func main(): i32 { let value = load_value() catch failure { fallback_for(failure.message()) } if value == 42 { return 0 } return 1 } func load_value(): i32! { return error.new("example.unavailable", "the primary value is unavailable") } func fallback_for(message: &str): i32 { return 42 }

use std/fmt.Format use std/io struct Point { x: i32 y: i32 } instance Point { impl Format method &self.try_format_into(output: &+String): void! { output.try_push_str("(")? self.x.try_format_into(output)? output.try_push_str(", ")? self.y.try_format_into(output)? output.try_push_str(")")? return } } func main(): i32! { let point = Point { x: 3, y: 4 } let message = "point = ${point}\n" io.print(&message)? return 0 }

use std/io use std/vec.Vec struct Point { x: i32 y: i32 } instance Point { operator (&self == other: &Self): bool { return self.x == other.x && self.y == other.y } } func main(): i32! { let first = Point { x: 3, y: 4 } let same = Point { x: 3, y: 4 } let other = Point { x: 5, y: 6 } if first != same || first == other { return 1 } let points = Vec [move first, move other] if points[0] != same { return 1 } var values = Vec [1, 2, 3] values[1] = 4 if values[0] + values[1] + values[2] != 8 { return 1 } io.print("equality found the point\n")? return 0 }

struct Buffer { values: [i32; 3] } instance Buffer { operator (&self[index: usize]): &i32 { return &self.values[index] } operator (&+self[index: usize]): &+i32 { return &+self.values[index] } } func at<C>(container: &C, index: usize): i32 where (&C[usize]): &i32 { return container[index] } func main(): i32 { var buffer = Buffer { values: [3, 4, 5] } buffer[1] = 9 if at(&buffer, 1) != 9 { return 1 } return 0 }

v0.31.0 Phase 4 Tooling and Practical Integration Review

Result: passed (2026-09-03). Phase 4 adds one ordinary public package and qualifies its authored source across formatter, editor, native, command, and installed-home boundaries. It adds no compiler exception or second subprocess implementation.

Public Package

examples/subprocess-output contains a short package root, one implementation source, and one repository-owned executable helper. capture.nct uses only public standard-library contracts:

1. Command.new validates and owns the helper path;
Command.arg copies a whitespace-bearing argument;
consuming Command.output returns one Output;
Output.status is checked as a typed nonzero exit;
Output.stdout and Output.stderr are converted through String.from_utf8 because this caller knows the helper's text contract;
both exact strings are validated before a deterministic report is written through std/io.

The example does not assume UTF-8 in the process API, merge stream order, invoke a shell API, search PATH, expose descriptors, or reproduce launch and drain policy.

Shared Execution Contract

PUBLIC_PACKAGE_EXAMPLES owns the executable helper bytes and exact process result. The same entry is consumed by complete native compilation and public command execution. The installed-home CLI test selects the same catalog entry, builds the authored package against a validated installed standard library, runs it beside its repository helper, and compares exact status, stdout, and stderr.

The formatter recursively discovers the authored example sources. Adding the package therefore extends the existing formatter authority without a second path list. The public examples catalog continues to assert that every directory containing a package index.nct has exactly one runtime contract.

Editor Evidence

The language-server reference-application test opens the real capture.nct. A complete generation has no diagnostic. Hover renders the public Command.output(): Output! signature, definition navigation selects std/process/index.nct, and implementation navigation selects the joined body in command_darwin.nct. An incomplete output.status. expression retains receiver semantics and offers the public code, signal, and success methods.

The test does not embed a copied process declaration or infer an implementation filename from syntax. All editor results come from the same compiler query authority used by other package sources.

Findings

No tooling-only source, duplicated process policy, private standard-library dependency, hidden text assumption, caller-owned cleanup step, or conflicting example contract was found. Phase 5 may run the final repository qualification and review directly on this integration boundary.