Nocter v0.12.0

Status: Phase 3 complete; v0.12.0 published and audited.

v0.12.0 returns development to practical standard-library APIs. Phase 0 replaces the closed, compiler-enumerated interpolation formatter table with one source-defined Format interface and static conformance dispatch. It also establishes the general built-in conformance authority needed by later equality, hashing, and collection contracts.

The published v0.11.0 language, tag, archive, and qualification record are immutable. v0.12.0 work must not alter or relabel that release.

Phase 0: Extensible Formatting

Problem

Interpolation currently accepts only &str, String, bool, and built-in integers selected by a compiler-owned type-to-function table. The standard library contains one append_* function for each accepted type, and lowering repeats the input-kind split. A user-defined struct or enum cannot participate even when it can append a textual representation through ordinary Nocter code.

This boundary has three structural defects:

formatting capability is encoded as a closed Rust enum instead of a source contract;
compiler-built-in types cannot use the same explicit conformance model as nominal types;
type checking, buildability, specialization, and lowering transport formatter identity through interpolation-specific representations rather than the common method-dispatch model.

Adding another accepted type to the current table would deepen all three defects. Phase 0 removes the table rather than extending it.

Public Contract

std/fmt owns the ordinary source interface:

pub interface Format {
    pub method &self.format_into(output: &+String): void
}

The method uses the normal aborting allocation policy of String. It does not add an implicit fallible edge to interpolation. Explicit try_append_* functions remain the recoverable builder surface; Phase 0 does not introduce recoverable interpolation or a second formatting interface.

The distributed standard library provides exact conformances for str, String, bool, and all ten built-in integer types. User-owned nominal types opt in with an ordinary conformance:

use std/fmt.{Format, append_i32, append_str}

struct Point {
    x: i32
    y: i32
}

conform Format for Point {
    method &self.format_into(output: &+String): void {
        append_str(output, "(")
        append_i32(output, self.x)
        append_str(output, ", ")
        append_i32(output, self.y)
        append_str(output, ")")
        return
    }
}

${point} is accepted because Point conforms to the exact selected standard-library Format declaration. A project interface with the same spelling has no compiler-defined role.

Interpolation retains its existing result, evaluation, storage, and failure rules:

the result is an owned String in the current allocation context;
text and expression parts are processed left to right;
every expression is evaluated exactly once;
formatting borrows the value and does not consume it;
temporaries stay live through the formatting call and are then destroyed exactly once;
allocation failure aborts without unwinding;
explicit failure or absence inside an interpolation expression follows the surrounding source operation rather than the formatting interface.

Built-in Conformance Authority

Compiler-built-in types remain syntax identities rather than synthetic nominal declarations. The resolver extends its existing source-backed built-in surface model so a built-in identity can own explicit interface conformances without entering the ordinary type symbol table.

Only sources belonging to the exact implicit standard-library package may declare a conformance whose target is a compiler-built-in type. A project package cannot conform i32, bool, str, or a slice to an interface. This is an authority check based on package identity, not a module-name or filesystem-name convention.

The built-in registry owns canonical identities for string data, slice data, bool, and every integer type. Inherent method authorities remain restricted to their existing std/str and std/slice modules. Conformance authority is package-wide because independent standard modules will later own contracts such as formatting, equality, and hashing.

Resolver collection, signature qualification, duplicate detection, conformance selection, method lookup, associated-type normalization, specialization, editor occurrences, and native lowering must consume the same source-backed conformance records. No synthetic struct declaration or name-only capability path may be introduced.

Compiler Runtime Binding

The trusted interpolation capability validates only the declarations that make interpolation an atomic language operation:

the owned String type;
zero-capacity construction in the current allocation context;
the exact std/fmt.Format interface and its public borrowed format_into method.

It no longer validates or stores one formatter function per input type. Type checking selects the conformance method for each part from resolved semantic identities. Static text uses the same str: Format conformance as an interpolated &str expression.

A reusable planned protocol-method record carries the contract declaration, selected implementation declaration, concrete Self type, receiver mode, specialized target name, and free type parameters. Collection iteration and interpolation must share this representation or a common lower-level service; Phase 0 must not create a second conformance-specialization algorithm.

Type Checking and Diagnostics

For every interpolation expression part, type checking:

1. determines the ordinary expression type;
derives the method Self type using normal receiver rules;
selects the conformance to the exact trusted Format interface;
records the selected implementation or interface default identity;
rejects a missing or ambiguous conformance before buildability or IR lowering.

The diagnostic names the concrete type and required std/fmt.Format contract and points at the interpolation expression. It suggests importing and conforming to Format only for user-owned nominal types. Built-in, optional, fallible, pointer, callable, array, and opaque values are not silently formatted unless they have a legal explicit conformance.

Native Lowering and Cleanup

IR receives the resolved method plan and emits an ordinary static call. It does not inspect a formatting input-kind enum, rediscover a conformance, or search for format_into by spelling.

Readonly receiver lowering covers:

UTF-8 views using their ordinary two-word representation;
scalar locals, parameters, literals, calls, and computed expressions through temporary readonly storage when required by the borrowed receiver ABI;
nominal aggregate locals, parameters, fields, and temporary results;
generic conformances specialized to a concrete Self type.

Temporary aggregate initialization and cleanup reuse the common pending-drop model. A formatting call cannot leak, double-drop, consume, or extend the lifetime of its receiver.

Editor Contract

Hover on an interpolation part reports the accepted value type and Format conformance without inventing source syntax. Definition and references for named interface, conformance, and method occurrences use their actual declaration identities. Completion and signature help inside ${...} remain ordinary expression analysis. Semantic tokens do not color string text as source declarations.

The LSP must not independently look up Format, format_into, built-in types, or standard-library paths. All editor results derive from compiler analysis facts and immutable compile-unit snapshots.

Implementation Sequence

1. Generalize source-backed built-in surfaces to retain package-authorized conformances for str, bool, and every integer type, with focused authority and identity tests.
Add std/fmt.Format, standard conformances, and a package-private copy-from-borrow helper built from existing trusted pointer operations.
Replace InterpolationInputKind and the formatter table with the trusted interface identity and resolved protocol-method plans.
Route specialization and buildability traversal through the selected method plans.
Lower readonly format receivers and cleanup through ordinary static call and aggregate lifetime services.
Add command-line, native, distributed-home, and framed-LSP coverage for nominal, generic, imported, built-in, temporary, missing-conformance, and spoofed-interface cases.
Update the public specification, implementation documents, standard-library reference, and generated website only after behavior and tests agree.

Completion Gates

Phase 0 is complete only when all of the following hold:

${value} accepts a user-owned nominal type solely through explicit conformance to the exact standard Format interface;
all previously supported string, boolean, and integer values preserve exact native output;
every supported built-in uses a source conformance rather than an interpolation type table;
project-owned built-in conformances and same-spelling fake interfaces are rejected or ignored without acquiring trusted behavior;
generic and imported conformances specialize and execute through normal static dispatch;
existing values remain usable after interpolation, and temporary move-only values are destroyed exactly once after formatting;
missing conformance is diagnosed during type checking with an exact source range;
hover, definition, references, completion, semantic tokens, and signature help remain consistent with the semantic plan;
no InterpolationInputKind, per-type trusted formatter map, name-based fallback, compatibility grammar, or required Phase 0 TODO remains;
cargo fmt --check, warnings-denied Clippy, git diff --check, documentation generation, public examples, source corpus, distributed-home tests, and the complete verification matrix pass.

Non-goals

Phase 0 does not add format specifiers, width, precision, radix selection, locale behavior, debug formatting, automatic derived conformance, runtime interface objects, dynamic dispatch, reflection, float or Unicode scalar types, recoverable interpolation syntax, specialization ranking, negative requirements, or a new native target.

Phase 0 Completion Record

Phase 0 completed on 2026-08-11. The compiler no longer contains InterpolationInputKind or a trusted per-type formatter map. The selected std/fmt.Format identity and resolved TypecheckProtocolMethod plans now drive type checking, specialization, buildability, IR, and editor presentation. Built-in and standard nominal conformance collectors preserve exact package and declaration authority without synthetic type declarations or spelling-based fallback.

The distributed standard library defines Format and source conformances for str, String, bool, and every integer. Native installed-home coverage proves exact legacy output, nominal and generic user conformances, imported conformance dispatch, continued use of borrowed values, exactly-once temporary destruction, missing-conformance diagnostics, spoof resistance, allocation abort, region escape rejection, and framed-LSP behavior.

The completed verification matrix contains 3,533 tests: 2,463 library tests, 296 CLI build tests, 7 formatter tests, 28 LSP tests, 20 package tests, 467 CLI run tests, 11 native-test tests, 232 distributed-home tests, 2 public-example tests, and 7 source-corpus tests. The initial complete run found only canonical formatting drift in the new public example; applying nocter fmt and rerunning that gate produced 2/2 passes. Warnings-denied Clippy, cargo fmt --check, git diff --check, all public example checks/builds/runs, and the 125-page documentation build pass. No Phase 1 work was started.

Phase 1: Instance-Owned Equality

Goal

Phase 1 replaces the remaining closed nominal equality behavior with one statically resolved operator declaration owned by an instance. Equality remains a fixed language operation rather than an open-ended operator-overloading facility. Generic APIs state the operation they use directly, without a marker interface or a hidden standard-library protocol.

The declaration form is:

instance Text {
    pub operator (&self == other: &Self): bool {
        ...
    }
}

The corresponding generic requirement is:

where (&T == &T): bool

operator belongs only in an instance. Phase 1 accepts only the readonly homogeneous equality shape shown above: the left operand is &self, the right operand is a named &Self binding, and the result is bool. The right binding name is local to the body and is not part of operator identity. Ordinary visibility applies. != cannot be declared and is always the logical negation of the selected == operation.

Equality Selection

Operator selection is deterministic and preserves the existing one-step borrow-coercion model:

1. Select an accessible equality operator on the original left owner before considering a left coercion.
If none exists, consider each accessible one-step readonly borrow coercion of the left operand and select equality on the exact coercion target.
Check the right operand against the selected operator's concrete right type. Ordinary exact compatibility wins; otherwise one accessible readonly borrow coercion may satisfy that expected type.
Each operand may use at most one declared coercion. Coercions never chain, infer an unconstrained generic argument, or compete through implicit ranking.
Multiple remaining candidates are an ambiguity. An original-owner declaration is the explicit disambiguation boundary.

An operator requirement describes expression capability, not the physical presence of a declaration on the concrete type. A concrete String therefore satisfies where (&T == &T): bool through its public &String as &str coercion and the equality declared by str.

The standard library defines text equality once:

instance str {
    pub operator (&self == other: &Self): bool {
        ...
    }
}

Together with the existing String coercion, that one declaration supports &str == &str, &str == &String, &String == &str, and &String == &String. String does not duplicate the algorithm or introduce an asymmetric heterogeneous operator.

Compiler Architecture

The authored models are EqualityOperatorDecl and OperatorRequirementPredicate. Resolution represents the callable under one compiler-private method identity so visibility, qualification, cross-source bodies, and static call targets reuse ordinary infrastructure. Type checking records one immutable TypecheckEqualityPlan containing the declaration identity, concrete operand types, operand borrow adjustments, and zero or one coercion plan per operand. Specialization, ownership, provenance, buildability, IR, and editor analysis consume it and never repeat lookup from token spelling.

The resolved call shares the ordinary static-call lowering boundary used by methods and interface methods. It is not rewritten to a synthetic interface, trusted function name, or hidden formatter table. Exact compiler primitive equality for booleans, integers, and payloadless runtime tags remains the leaf operation used to implement source operators; nominal equality is source-owned.

Instance ownership, declaration-pattern overlap, visibility, selected-package authority for built-in owners, and duplicate diagnostics apply unchanged. Generic operator requirements are substituted and proven alongside existing copy, callable, interface, and associated-type requirements. Cyclic conditional operator selection must fail deterministically.

Standard-Library Completion Surface

str owns the public source equality operator and a narrow package-authorized byte comparison primitive where ordinary source cannot inspect the runtime view efficiently.
[T] owns homogeneous equality when where (&T == &T): bool; Vec<T> receives it through its existing readonly slice coercion.
[T].contains and [T].position use the same structural requirement. Vec<T> receives these readonly APIs through receiver coercion.
Iterator.contains and Iterator.position consume the iterator, borrow each yielded item only for comparison, and destroy every yielded value exactly once.

Tooling and Diagnostics

formatting and AST JSON preserve the exact declaration and requirement syntax;
hover renders operator (&Text == other: &Text): bool for a concrete owner and shows selected coercion paths separately from the authored contract;
definition, references, and rename use the operator token identity and the right binding's own declaration identity;
completion inside an instance offers the fixed equality declaration only where it is absent;
missing, inaccessible, duplicate, ambiguous, malformed, and unsatisfied generic operators have focused diagnostics on the exact operand or operator span.

Non-goals

Phase 1 does not add heterogeneous operators, user declarations for !=, arithmetic or ordering operators, operator precedence declarations, automatic equality derivation, hashing, sorting, floating-point types, transitive coercion, coercion-driven generic inference, runtime dispatch, or a named equality interface.

Completion Definition

Phase 1 is complete when source, generic, imported, and coercion-derived equality execute through the resolved operator plan; all four str/String borrow combinations work; slice, Vec, and iterator equality APIs work for user-defined types; ownership tests prove borrowed operands remain usable and move-only iterator items are destroyed exactly once; malformed and unavailable cases produce stable diagnostics; LSP presentation and navigation use exact semantic identities; public specification and examples describe only implemented behavior; and the complete repository, distributed-home, source-corpus, documentation, formatting, Clippy, and diff verification gates pass.

Phase 1 Completion Record

Phase 1 completed on 2026-08-11. EqualityOperatorDecl and OperatorRequirementPredicate preserve the fixed authored forms through parsing, formatting, AST JSON, qualification, resolution, type checking, specialization, and presentation. A compiler-private callable identity reuses ordinary static method infrastructure without exposing a synthetic method name to source or editor clients. TypecheckEqualityPlan is the single handoff for selected declaration identity, concrete operands, implicit readonly borrows, and per-operand coercions.

Direct, imported, generic, primitive, and one-step coercion-derived equality execute natively. Owned operands are borrowed without consumption, != negates the selected operation, inaccessible operators stay inaccessible, and competing readonly targets produce E0474 with both coercion paths. str owns the standard text algorithm; all four str/String combinations select it. [T] supplies equality, contains, and position; Vec<T> reaches those APIs through slice coercion; iterator defaults consume their source while destroying every move-only yielded owner exactly once.

Hover, completion, semantic tokens, definition, references, rename validation, and framed LSP transport preserve authored syntax, exact == ranges, declaration identity, and readonly parameter roles. The public specification, implementation documentation, generated website, and runnable equality example describe the implemented surface.

The complete verification matrix contains 3,555 tests: 2,477 library tests, 296 CLI build tests, 7 formatter tests, 29 LSP tests, 20 package tests, 472 CLI run tests, 11 native-test tests, 234 distributed-home tests, 2 public-example tests, and 7 source-corpus tests. Warnings-denied Clippy, cargo fmt --check, documentation generation, and git diff --check pass. No Phase 2 work was started.

Phase 2: Uniform Operator Requirements and Coercion-Driven Indexing

Goal

Phase 2 removes equality's exceptional requirement grammar and establishes one structural signature form for every fixed language operation that can appear in a generic contract:

where (&T == &T): bool
where (&C[K]): &V
where (&+C[K]): &+V

The parenthesized portion describes operand types and capabilities. The required result follows the same : Type spelling as an authored operator declaration. Requirement operands never introduce value bindings. Parentheses and the result are mandatory, so the parser does not infer an operation kind or output from context.

Phase 2 supports the already authored equality operation and the built-in index projection. It does not add source-defined index declarations or arithmetic, ordering, unary, assignment, call, or custom-precedence operators. The representation must be extensible to those fixed operation kinds without accepting unknown tokens or a free-form overload grammar.

Grammar Migration

The exceptional Phase 1 equality-requirement spelling is removed before v0.12.0 publication. No compatibility AST, warning period, formatter rewrite, or dual presentation remains. Equality declarations retain their existing source form:

pub operator (&self == other: &Self): bool

Every equality requirement becomes:

where (&T == &T): bool

The equality shape remains readonly, homogeneous, and boolean. A result other than bool, missing parentheses, different operand parameters, or an unsupported operation receives a focused parser or type diagnostic at the exact offending component.

The AST owns one OperatorRequirementPredicate with an operation-specific shape enum, result type, and exact punctuation spans. AST JSON, formatting, qualification, hover, semantic tokens, completion recovery, signature help, and diagnostics consume that node. They do not reparse a formatted label or infer the result from the operator token.

Coercion-Driven Indexing

Existing arrays, slices, mutable slices, and str remain compiler-known index projections. Index selection becomes deterministic:

1. Use the original target when it is directly indexable.
Otherwise consider accessible one-step receiver coercions whose exact target is indexable.
Read contexts accept readonly or readwrite targets and select the minimum capability when both equivalent coercions reach the same projection.
Writable assignment and &+target[index] require a readwrite target.
Multiple non-equivalent remaining targets are ambiguous and require explicit as.
Coercions never chain, consume the owner, infer an unconstrained generic argument, or change the index operand type.

This makes the existing Vec<T> coercions sufficient for ordinary indexing:

let item = values[index]
let borrowed = &values[index]
values[index] = replacement

Vec<T> does not duplicate slice bounds checks, projection semantics, or an index declaration. The selected coercion result retains the original owner loan through the projected place.

Generic Index Requirements

A readonly index contract is:

where (&C[K]): &V

A readwrite index contract is:

where (&+C[K]): &+V

C, K, and V are ordinary visible generic parameters or concrete types. The index operand uses ordinary exact assignability after specialization; it is not an overload selector. The result must be a borrow whose capability matches the target capability. Its provenance is structurally fixed to the indexed target, so the requirement does not carry or infer a separate from clause.

Inside a generic body, indexing is accepted only from a matching lexical requirement. A concrete call must prove the specialized requirement through direct indexability or one selected receiver coercion. The generic body and every specialization share the same index-plan representation; no unchecked generic indexing reaches buildability or IR.

Compiler Architecture

One immutable TypecheckIndexPlan records the target and index spans, concrete or parameterized target/index/element types, required access capability, direct projection kind, and optional receiver conversion plan. It is collected during type checking and specialized once concrete type arguments are known.

Place checking, ownership, borrow conflicts, provenance, region escape analysis, buildability, fixed-array and slice lowering, assignment lowering, call-argument lowering, and editor analysis consume that plan. No consumer independently asks whether a spelling is Vec, rediscovers a coercion, or treats an unresolved generic target as a slice.

Direct arrays and views still lower through their existing checked projection leaves. A coerced projection first invokes the recorded coercion exactly once, then supplies its result to the same leaf. Evaluation order remains target expression, then index expression, then bounds check and access. Failure or a trap cannot duplicate either expression.

Tooling and Diagnostics

formatting and presentation preserve where (&T == &T): bool and where (&C[K]): &V exactly;
completion after where ( offers visible types and fixed operation punctuation without inventing unsupported operators;
hover on a requirement reports its normalized structural signature;
semantic tokens classify operand and result types by resolved identity;
definition, references, and rename for those types use normal type occurrences;
hover on coerced indexing reports the source type, selected view, element type, and readonly or readwrite access without presenting an implicit source contract;
missing, malformed, capability-mismatched, inaccessible, and ambiguous index requirements have distinct diagnostics and exact spans.

Implementation Sequence

1. Replace the Phase 1 equality predicate grammar and every source, fixture, test, presentation, and document with the uniform structural signature.
Generalize the authored and resolved operator-requirement model to carry equality and index shapes plus an explicit result type.
Add direct and one-step-coerced index candidate selection and record one TypecheckIndexPlan.
Add generic index requirement validation, entailment, substitution, and specialization.
Route place, ownership, provenance, buildability, and all native index lowering through the plan, preserving the existing direct array/view leaves.
Add focused unit, CLI, native, installed-home, public-example, and framed-LSP coverage.
Update the public specification, implementation documents, generated website, handoff, and completion record only after behavior and tests agree.

Completion Definition

Phase 2 is complete when the old equality requirement syntax no longer parses and remains only in a focused rejection test; direct and generic equality use the uniform structural signature; readonly and readwrite Vec<T> indexing execute through recorded slice coercions without a Vec-specific path; generic indexing specializes through direct arrays/views and coerced user-owned containers; borrowed index results retain their owner loan; mutable, move-only, bounds, evaluation-order, inaccessible, and ambiguity cases are covered; LSP presentation and navigation derive from semantic nodes and plans; no source-defined index declaration or unsupported operator grammar was introduced; and the complete repository, distributed-home, examples, source corpus, documentation, formatting, warnings-denied Clippy, and diff gates pass.

Phase 2 Completion Record

Phase 2 completed on 2026-08-11. Equality and index requirements now share one parenthesized operator-requirement AST with an explicit result type. The removed unparenthesized equality spelling survives only in its focused parser rejection test; source, standard-library contracts, formatting, AST JSON, qualification, diagnostics, and editor presentation use the structural form.

One selector chooses direct arrays and views, lexical generic index requirements, or an accessible one-step receiver coercion. Its immutable TypecheckIndexPlan carries access capability, projection, substituted types, requirement identity, and the selected conversion through place checking, ownership, specialization, IR, and editor analysis. Vec<T> readonly and readwrite indexing consequently execute through the existing slice coercions and checked slice leaves; the compiler has no Vec-specific indexing case. Generic containers use the same selector when a concrete call proves where (&C[K]): &V or where (&+C[K]): &+V.

Installed-home native coverage proves direct and generic Vec indexing, writable replacement, bounds behavior, owner-loan retention, and multiple indexed operands. The last case also corrected the common integer lowering boundary: deferred memory projections are snapshotted before the next operand can reuse backend scratch registers, while constants and stable locations remain direct. LSP hover and completion consume semantic index plans and structural requirement nodes rather than re-parsing source labels.

The complete verification matrix contains 3,565 tests: 2,485 library tests, 296 CLI build tests, 7 formatter tests, 29 LSP tests, 20 package tests, 472 CLI run tests, 11 native-test tests, 236 distributed-home tests, 2 public-example tests, and 7 source-corpus tests. Warnings-denied Clippy, cargo fmt --check, documentation generation, and git diff --check pass. Phase 2 did not add source-defined index declarations, unsupported operator grammar, transitive coercion, or a Vec-specific path.

Phase 3: Stabilization and Release Qualification

Goal

Phase 3 freezes the completed formatting, equality, and indexing contracts as one v0.12.0 release candidate. It may correct defects, remove duplicate semantic authority, improve diagnostics, and add focused regression coverage. It does not add another operator, coercion form, standard-library feature, compatibility grammar, host, target, or runtime abstraction.

The published v0.11.0 tag, archive, documentation, and audit remain immutable until v0.12.0 is separately authorized and published.

Contract Audit

The audit must establish all of the following from implementation and tests:

interpolation reaches the exact selected std/fmt.Format declaration through an ordinary conformance and one TypecheckProtocolMethod; lowering does not select a formatter by value type or public spelling;
equality and indexing each have one immutable typecheck plan consumed by ownership, specialization, IR, diagnostics, and editor analysis;
generic operator requirements use only where (operation): Result, and the removed equality spelling remains only in a focused rejection fixture;
one-step borrow coercion is the common receiver adaptation boundary for String/str, Vec<T>/[T], nominal user containers, equality, indexing, and member lookup;
no Vec-specific equality or index execution path, textual capability test, compatibility parser, silent semantic fallback, or unfinished production marker remains;
hover, completion, signature help, semantic tokens, definition, references, and rename project resolved declaration identities and normalized source contracts rather than slicing source text;
formatting, equality, indexing, bounds failures, coercion ambiguity, owner loans, readwrite mutation, evaluation order, and exactly-once cleanup retain focused native and installed-home coverage.

Exact toolchain declarations under target/trusted may validate names and shapes only inside the selected implicit standard-library package. This is primitive authority validation, not permission for typecheck, analysis, IR, or backend code to dispatch by public standard-library spelling.

Candidate Identity

The candidate commit updates the Cargo package and lockfile, installed VERSION, distribution manifest and archive name, distributed std/nocter.nct, CLI and LSP versions, specification status, public English release notes, contributor release index, and generated website to v0.12.0. The root README and public release index continue to identify v0.11.0 as the latest downloadable release until publication.

Qualification

The exact release-content commit must pass:

1. the complete repository verification script incrementally;
a second complete verification after removing only reproducible compiler build artifacts;
public documentation generation, formatting, warnings-denied Clippy, and diff checks;
two independently packaged archives whose extracted .nocter/ trees compare recursively;
a fresh extraction without inherited NOCTER_HOME covering version, doctor, help, package initialization, locked/offline check and test, deterministic graph output, run, explicit build, direct Mach-O execution, and a framed LSP lifecycle reporting 0.12.0.

The retained candidate record includes the release-content commit, archive byte size, SHA-256, standard-library file count, exact test matrix, generated page count, and qualification commands.

Completion Definition

Phase 3 is complete when the contract audit finds no unresolved production defect; all candidate identity sources agree on 0.12.0; incremental and clean repository qualification pass; the local archive passes the two-build and fresh-extraction matrix; the release record contains exact evidence; and the worktree is clean. The loop stops before tagging, pushing, creating a GitHub Release, uploading an asset, changing the root download link, or claiming publication.

Phase 3 Completion Record

Phase 3 completed on 2026-08-11. The audit removed an LSP interpolation fallback that invented String and Format labels when declaration spans did not match. Trusted declarations now retain complete semantic identities, and editor presentation resolves those identities through the owning module analysis and shared type presentation service. Public example coverage now exercises readonly and readwrite Vec indexing through ordinary slice coercions.

Release-content commit 7accfd5a21182b6904d6e2213a18a5c7e80647c3 passed incremental and clean repository verification. Each run covered 3,520 tests, Rust formatting, and warnings-denied Clippy. The clean run followed removal of 421 files totaling 687.4 MiB. Documentation generation produced 131 pages, and diff checks passed.

The local archive was built twice and its extracted trees matched recursively. The retained 3,783,354-byte ARM64 Darwin archive has SHA-256 65514f5b5f5bddbbcd883b72026566109302e96203d3702503615ca26f2f4e60 and contains all 28 standard-library files. Its fresh extraction passed version, doctor, help, package initialization, locked/offline check and test, deterministic graph output, run, explicit build, direct Mach-O execution, and framed LSP lifecycle checks without NOCTER_HOME. Publication and the independent public-asset audit are preserved in the release record.