semantifold 0.5.0 → 0.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 Task037 adds the first concrete standard-library portability slice: exact parser-proved Ruby `require "socket"`, genuine `TCPSocket.new(host, port)`, receiver `gets`/`close`, and one-string `puts`/`Kernel.puts` compile through executable Ruby facades and canonical v1 contracts to protected PHP providers using native `fsockopen`, `fgets`, `feof`, `fclose`, and stdout. Task036's neutral versioned facade foundation was delivered through PR #46 and merge `9aba48f9d48bcef4fd4c9275aec14bfcc4f0904c`; Task035's canonical contract/provider hub was delivered through PR #45 and merge `a2aad9d4932bfc6087adc4ff8bca43678c92413c`. Task034 supplies explicit compiler-authorized host effects, linear owned resources/references, typed host failures, exactly-once lowering, and path-complete explicit close. Task033 adds bounded nominal reference classes, Task032 adds strict-Boolean condition-controlled loops, and Task021 adds a [browser-oriented WebAssembly target](docs/webassembly.md).
 
-Semantifold is an early language-neutral semantic code toolkit. The source tree supports a deliberately small fourteen-language baseline: PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, Kotlin/JVM, strictly annotated Python, canonical C#, bounded Go, C17, C++20, Rust edition 2021, strict Swift, and strict Dart VM/native source share one typed semantic representation. Browser WebAssembly is an additional target-only ID, not a fifteenth source language. The published baseline is `semantifold@0.4.0`. Android application generation is implemented on the Task 028 topic branch; exact-head TensorBuzz offline-build/KVM-emulator acceptance and merge remain coordinator-owned delivery gates.
+Semantifold is an early language-neutral semantic code toolkit. The source tree supports a deliberately small fifteen-language baseline: PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, Kotlin/JVM, strictly annotated Python, canonical C#, bounded Go, C17, C++20, Rust edition 2021, strict Swift, strict Dart VM/native, and strict Zig 0.15.2 source share one typed semantic representation. Browser WebAssembly is an additional target-only ID, not a sixteenth source language. The published baseline is `semantifold@0.5.0`. Android application generation is implemented on the Task 028 topic branch; exact-head TensorBuzz offline-build/KVM-emulator acceptance and merge remain coordinator-owned delivery gates.
 
 ## Current API
 
@@ -39,11 +39,11 @@ const artifact = generateArtifact({language: "java", module})
 const original = originalPositionFor(artifact.mapping, {offset: artifact.code.indexOf("label")})
 ```
 
-Generated text output always uses LF. Exact original content, including LF, CRLF, lone CR, and astral UTF-16 coordinates, remains in the source registry and `sourcesContent`. Optional inline/external `sourceMappingURL` directives apply only to JavaScript and TypeScript; PHP, Ruby, Java, Kotlin, Python, C#, Go, C, CPP, Rust, Swift, and Dart use the same rich/v3 model without foreign comments. Wasm instead uses rich byte ranges, a line-zero/byte-column Source Map v3 sidecar, and a relative `sourceMappingURL` custom section. See [source provenance and mappings](docs/source-maps.md) for schemas, lookups, composition, diagnostics, directives, and compatibility.
+Generated text output always uses LF. Exact original content, including LF, CRLF, lone CR, and astral UTF-16 coordinates, remains in the source registry and `sourcesContent`. Optional inline/external `sourceMappingURL` directives apply only to JavaScript and TypeScript; PHP, Ruby, Java, Kotlin, Python, C#, Go, C, CPP, Rust, Swift, Dart, and Zig use the same rich/v3 model without foreign comments. Wasm instead uses rich byte ranges, a line-zero/byte-column Source Map v3 sidecar, and a relative `sourceMappingURL` custom section. See [source provenance and mappings](docs/source-maps.md) for schemas, lookups, composition, diagnostics, directives, and compatibility.
 
-`supportedLanguages` is the immutable registry-derived list `php`, `ruby`, `javascript`, `typescript`, `java`, `kotlin`, `python`, `csharp`, `go`, `c`, `cpp`, `rust`, `swift`, and `dart`. `languageCapabilities` additionally includes target-only `wasm`, `ios`, and `android` records and exposes all seventeen IDs' independent frontend, text-backend, binary-backend, application-backend, and interoperability roles together with `generalFunctionsAndCalls`, `immutableCollections`, `optionalValues`, `orderedListIteration`, `orderedMapIteration`, `conditionControlledLoops`, `referenceClasses`, `effectfulCapabilitiesAndResources`, `closedRecords`, `typedErrors`, and `typeParametersAndGenerics` feature flags, artifact multiplicity, round-trip, mapping, acceptance-stage, and toolchain declarations. Unknown IDs use `UNSUPPORTED_LANGUAGE`; a registered ID missing a requested role uses `UNSUPPORTED_ROLE`; an existing backend that cannot represent a semantic module uses `UNSUPPORTED_CAPABILITY`.
+`supportedLanguages` is the immutable registry-derived list `php`, `ruby`, `javascript`, `typescript`, `java`, `kotlin`, `python`, `csharp`, `go`, `c`, `cpp`, `rust`, `swift`, `dart`, and `zig`. `languageCapabilities` additionally includes target-only `wasm`, `ios`, and `android` records and exposes all eighteen IDs' independent frontend, text-backend, binary-backend, application-backend, and interoperability roles together with `generalFunctionsAndCalls`, `immutableCollections`, `optionalValues`, `orderedListIteration`, `orderedMapIteration`, `conditionControlledLoops`, `referenceClasses`, `effectfulCapabilitiesAndResources`, `closedRecords`, `typedErrors`, and `typeParametersAndGenerics` feature flags, artifact multiplicity, round-trip, mapping, acceptance-stage, and toolchain declarations. Unknown IDs use `UNSUPPORTED_LANGUAGE`; a registered ID missing a requested role uses `UNSUPPORTED_ROLE`; an existing backend that cannot represent a semantic module uses `UNSUPPORTED_CAPABILITY`.
 
-`generateArtifactSet` is the additive single-module artifact API. Original text targets return an entry artifact with the exact legacy bytes and rich/v3 mappings; an external JavaScript-family map directive also returns the referenced serialized mapping sidecar. C# returns mapped `Program.cs` then synthetic-provenance `Semantifold.csproj`. Go returns exactly two ordered artifacts: fixed synthetic-provenance `go.mod` first, then mapped `main.go`; the fixed module is `example.com/semantifold/generated` with `go 1.26.0` and creates no `go.sum`. C returns mapped `program.c` followed by synthetic `semantifold_runtime.h`. Rust returns synthetic `Cargo.toml`, synthetic Cargo-generated `Cargo.lock`, then mapped `src/main.rs`, with fixed edition 2021 and Rust/Cargo 1.98.1. Dart returns synthetic `pubspec.yaml`, synthetic deterministic `pubspec.lock`, then mapped sole-entry `bin/program.dart`. Wasm binary/application generation returns `program.wasm`, `program.wasm.map`, `semantifold-loader.mjs`, then sole entry `index.html`, plus frozen `semantifold.browser.v1` ABI metadata. Because C#, Go, C, Rust, Dart, and Wasm are deliberately multi-artifact, `generate()` and `generateArtifact()` reject them with `UNSUPPORTED_ROLE`. Go accepts only an omitted filename or exact `main.go`, C accepts only omitted or exact `program.c`, Rust only omitted or exact `src/main.rs`, Dart only omitted or exact `bin/program.dart`, and Wasm only omitted or exact `program.wasm`; these multi-artifact backends reject unsupported mapping options rather than ignoring them. `createGeneratedArtifactSet` validates multi-file text, binary, mixed loader/binary, and application shapes transactionally: paths are ordered, unique, safe relative POSIX paths with no file/directory prefix collisions; content is explicitly text or bytes; media type, role, generated ownership, and provenance are required; exactly one artifact has role `entry`; and optional metadata is detached deeply frozen JSON. Binary content is held privately and returned as a fresh detached byte view on every read, so caller mutation cannot change validated bytes or their provenance. Generated helper files do not create semantic modules and are not Task 010 projects.
+`generateArtifactSet` is the additive single-module artifact API. Original text targets return an entry artifact with the exact legacy bytes and rich/v3 mappings; an external JavaScript-family map directive also returns the referenced serialized mapping sidecar. C# returns mapped `Program.cs` then synthetic-provenance `Semantifold.csproj`. Go returns exactly two ordered artifacts: fixed synthetic-provenance `go.mod` first, then mapped `main.go`; the fixed module is `example.com/semantifold/generated` with `go 1.26.0` and creates no `go.sum`. C returns mapped `program.c` followed by synthetic `semantifold_runtime.h`. Rust returns synthetic `Cargo.toml`, synthetic Cargo-generated `Cargo.lock`, then mapped `src/main.rs`, with fixed edition 2021 and Rust/Cargo 1.98.1. Dart returns synthetic `pubspec.yaml`, synthetic deterministic `pubspec.lock`, then mapped sole-entry `bin/program.dart`. Zig returns synthetic `build.zig` then mapped sole-entry `src/main.zig`; Zig 0.15.2 needs no `build.zig.zon` for this dependency-free native-host project. Wasm binary/application generation returns `program.wasm`, `program.wasm.map`, `semantifold-loader.mjs`, then sole entry `index.html`, plus frozen `semantifold.browser.v1` ABI metadata. Because C#, Go, C, Rust, Dart, Zig, and Wasm are deliberately multi-artifact, `generate()` and `generateArtifact()` reject them with `UNSUPPORTED_ROLE`. Go accepts only an omitted filename or exact `main.go`, C accepts only omitted or exact `program.c`, Rust and Zig only omitted or exact `src/main.rs` and `src/main.zig` respectively, Dart only omitted or exact `bin/program.dart`, and Wasm only omitted or exact `program.wasm`; these multi-artifact backends reject unsupported mapping options rather than ignoring them. `createGeneratedArtifactSet` validates multi-file text, binary, mixed loader/binary, and application shapes transactionally: paths are ordered, unique, safe relative POSIX paths with no file/directory prefix collisions; content is explicitly text or bytes; media type, role, generated ownership, and provenance are required; exactly one artifact has role `entry`; and optional metadata is detached deeply frozen JSON. Binary content is held privately and returned as a fresh detached byte view on every read, so caller mutation cannot change validated bytes or their provenance. Generated helper files do not create semantic modules and are not Task 010 projects.
 
 Task 026 adds the target-only `ios` application backend through `generateArtifactSet({language: "ios", role: "application", ...})` and `generateProgramArtifactSet`. It lowers only the Task 022 Tasks 001–004 Swift subset, including Ruby-originating Task 010 projects, into deterministic captured semantic Swift, a synthetic SwiftUI shell, an unsigned Xcode project model, tests, exact assets, and a versioned ownership/provenance manifest with causal configuration spans and stable semantic-program identities. Artifact/resource paths use a closed portable ASCII alphabet while Unicode semantic source and generated text remain intact. Transactional create-only directory materialization remains deferred because Node's public filesystem API cannot provide both atomic no-replace directory publication and descriptor-relative no-follow operations without a separately authorized native boundary. Linux semantic execution and credential-free packed generation are implemented; real macOS/Xcode/Apple SDK/XCTest/XCUIAutomation/iOS Simulator acceptance is also deferred, so Task 026 is not delivered. See the [iOS application target](docs/ios.md).
 
@@ -55,9 +55,9 @@ Task 036 extends only this explicit program path with compiler-owned source-lang
 
 Binary/resource provenance uses `SemantifoldByteMapping` v1 through `createByteMapping`, `parseByteMapping`, and `stringifyByteMapping`. Generated ranges are ordered, non-overlapping, half-open byte offsets with semantic identities or explicit synthetic reasons. They are never interpreted as UTF-16 positions.
 
-`discoverCanonicalToolchain` and `discoverToolchain` resolve an exact executable from a configured absolute override or one unambiguous canonical PATH command and capture its version. `runAcceptanceStages` materializes a validated artifact set in a unique temporary directory and runs applicable `parse`, `generate`, `restore`, `compile`, `link`, `validate`, `instantiate`, and `execute` stages with exact argument arrays, a deterministic locale/timezone, bounded per-stage timeouts, captured output, no shell, and normalized stage diagnostics. The canonical overrides are `SEMANTIFOLD_DART`, `SEMANTIFOLD_PHP`, `SEMANTIFOLD_RUBY`, `SEMANTIFOLD_NODE`, `SEMANTIFOLD_TSC`, `SEMANTIFOLD_JAVAC`, `SEMANTIFOLD_JAVA`, `SEMANTIFOLD_KOTLINC`, `SEMANTIFOLD_PYTHON`, `SEMANTIFOLD_DOTNET`, `SEMANTIFOLD_GO`, `SEMANTIFOLD_CLANG`, `SEMANTIFOLD_CLANGPP`, `SEMANTIFOLD_RUSTC`, `SEMANTIFOLD_CARGO`, `SEMANTIFOLD_SWIFTC`, `SEMANTIFOLD_WASM_VALIDATE`, and `SEMANTIFOLD_CHROMIUM`; none of these APIs installs or downloads a tool. The generic `php` profile accepts PHP 8.x, while closed-record execution and the Task 037 PHP provider use the canonical `php82` profile (through the same `SEMANTIFOLD_PHP` override) to require PHP 8.2 or newer with core stream functions. Dart requires exact SDK 3.13.3 stable on Linux x64, Kotlin exact 2.4.20 on pinned OpenJDK 25.0.4+7, and Swift exact 6.3.3 on Linux x86-64. Browser Wasm requires WABT 1.0.36 and Chrome/Chromium 152.0.7977.82 in addition to Node 24.
+`discoverCanonicalToolchain` and `discoverToolchain` resolve an exact executable from a configured absolute override or one unambiguous canonical PATH command and capture its version. `runAcceptanceStages` materializes a validated artifact set in a unique temporary directory and runs applicable `parse`, `generate`, `restore`, `compile`, `link`, `validate`, `instantiate`, and `execute` stages with exact argument arrays, a deterministic locale/timezone, bounded per-stage timeouts, captured output, no shell, and normalized stage diagnostics. The canonical overrides are `SEMANTIFOLD_DART`, `SEMANTIFOLD_ZIG`, `SEMANTIFOLD_PHP`, `SEMANTIFOLD_RUBY`, `SEMANTIFOLD_NODE`, `SEMANTIFOLD_TSC`, `SEMANTIFOLD_JAVAC`, `SEMANTIFOLD_JAVA`, `SEMANTIFOLD_KOTLINC`, `SEMANTIFOLD_PYTHON`, `SEMANTIFOLD_DOTNET`, `SEMANTIFOLD_GO`, `SEMANTIFOLD_CLANG`, `SEMANTIFOLD_CLANGPP`, `SEMANTIFOLD_RUSTC`, `SEMANTIFOLD_CARGO`, `SEMANTIFOLD_SWIFTC`, `SEMANTIFOLD_WASM_VALIDATE`, and `SEMANTIFOLD_CHROMIUM`; none of these APIs installs or downloads a tool. The generic `php` profile accepts PHP 8.x, while closed-record execution and the Task 037 PHP provider use the canonical `php82` profile (through the same `SEMANTIFOLD_PHP` override) to require PHP 8.2 or newer with core stream functions. Zig requires exact 0.15.2 on Linux x86-64; Dart requires exact SDK 3.13.3 stable on Linux x64, Kotlin exact 2.4.20 on pinned OpenJDK 25.0.4+7, and Swift exact 6.3.3 on Linux x86-64. Browser Wasm requires WABT 1.0.36 and Chrome/Chromium 152.0.7977.82 in addition to Node 24.
 
-This is not general-purpose support for any of the fourteen languages. PHP, Ruby, JavaScript with JSDoc, TypeScript, and Java implement Task 005 general required functions/calls, Task 006 recursive immutable lists/maps, Task 007 explicit optional values, Task 008 ordered list iteration, Task 009 closed records, Task 010 explicit semantic projects, Task 011 typed unchecked errors, Task 012 invariant unbounded type parameters and generic declarations/applications, Task 014 insertion-ordered immutable map iteration, Task 032 strict-Boolean condition-controlled loops, Task 033 bounded reference classes, and Task 034's bounded effect/resource profile. Dart implements Task 005 general required functions/calls but none of those later profiles. `OptionalType {valueType}` contains only semantic presence or absence; it composes recursively as a declared list element or map value, and access preserves that optional result. A strict presence test can prove one simple binding present inside exactly the corresponding branch. Ruby uses exact `T?` metadata and `nil?`, JavaScript/JSDoc uses exact `T|null`, TypeScript uses exact `T | null`, PHP uses canonical `?T`, and Java uses exact `java.util.Optional<T>`/`Optional<T>` operations. Arbitrary unions, nested optionals, implicit nullable/default parameters, `undefined`, truthiness, nullish defaults/navigation, Java bare `null`, and unchecked unwrap remain unsupported. Collection support covers homogeneous literals, zero-based list indexing, total string-key map lookup, size, recursive typing, function passage, exact ordered list `for-each`, and the separate `OrderedMapType` pair-iteration profile. Ordinary `MapType` remains unordered and non-iterable. Ordered maps accept unique nonnumeric string keys, evaluate entries left-to-right, and visit key/value pairs in first-insertion order; aliases, mutation, key-only/value-only loops, and unordered conversions fail loudly. Java lowers only safe local ordered literals through a private `LinkedHashMap` insertion sequence and a non-escaping `Collections.unmodifiableSequencedMap` boundary. Every list, ordered-map, and condition-controlled loop has a deterministic semantic identity; each `break` or `continue` resolves to the nearest enclosing identity and cannot cross a function boundary. Collection loops evaluate their operand once and bind values immutably in body-local scope. A condition-controlled loop evaluates an exact Boolean condition before every iteration and may execute zero times; no loop body by itself proves a non-void function complete. Any outer mutable binding assigned on a nested loop path loses its known-value and optional-presence facts before the relevant repeated condition or body validation and after loop exit, including assignment paths ending in `break`, `continue`, or `return`; unaffected bindings keep stable facts. Task 007 does not turn an unchecked missing-key lookup into an optional operation. PHPDoc distinguishes `list<T>` from `array<string,T>`; JavaScript objects are never maps. Immutability is the accepted semantic operation boundary, not a deep-freezing promise. The other eight source languages and browser Wasm remain on the Tasks 001–004 two-parameter/scalar-return profile and reject later-feature modules transactionally. See [language support](docs/language-support.md) before using it on other code.
+This is not general-purpose support for any of the fifteen languages. PHP, Ruby, JavaScript with JSDoc, TypeScript, and Java implement Task 005 general required functions/calls, Task 006 recursive immutable lists/maps, Task 007 explicit optional values, Task 008 ordered list iteration, Task 009 closed records, Task 010 explicit semantic projects, Task 011 typed unchecked errors, Task 012 invariant unbounded type parameters and generic declarations/applications, Task 014 insertion-ordered immutable map iteration, Task 032 strict-Boolean condition-controlled loops, Task 033 bounded reference classes, and Task 034's bounded effect/resource profile. Dart and Zig implement Task 005 general required functions/calls but none of those later profiles. `OptionalType {valueType}` contains only semantic presence or absence; it composes recursively as a declared list element or map value, and access preserves that optional result. A strict presence test can prove one simple binding present inside exactly the corresponding branch. Ruby uses exact `T?` metadata and `nil?`, JavaScript/JSDoc uses exact `T|null`, TypeScript uses exact `T | null`, PHP uses canonical `?T`, and Java uses exact `java.util.Optional<T>`/`Optional<T>` operations. Arbitrary unions, nested optionals, implicit nullable/default parameters, `undefined`, truthiness, nullish defaults/navigation, Java bare `null`, and unchecked unwrap remain unsupported. Collection support covers homogeneous literals, zero-based list indexing, total string-key map lookup, size, recursive typing, function passage, exact ordered list `for-each`, and the separate `OrderedMapType` pair-iteration profile. Ordinary `MapType` remains unordered and non-iterable. Ordered maps accept unique nonnumeric string keys, evaluate entries left-to-right, and visit key/value pairs in first-insertion order; aliases, mutation, key-only/value-only loops, and unordered conversions fail loudly. Java lowers only safe local ordered literals through a private `LinkedHashMap` insertion sequence and a non-escaping `Collections.unmodifiableSequencedMap` boundary. Every list, ordered-map, and condition-controlled loop has a deterministic semantic identity; each `break` or `continue` resolves to the nearest enclosing identity and cannot cross a function boundary. Collection loops evaluate their operand once and bind values immutably in body-local scope. A condition-controlled loop evaluates an exact Boolean condition before every iteration and may execute zero times; no loop body by itself proves a non-void function complete. Any outer mutable binding assigned on a nested loop path loses its known-value and optional-presence facts before the relevant repeated condition or body validation and after loop exit, including assignment paths ending in `break`, `continue`, or `return`; unaffected bindings keep stable facts. Task 007 does not turn an unchecked missing-key lookup into an optional operation. PHPDoc distinguishes `list<T>` from `array<string,T>`; JavaScript objects are never maps. Immutability is the accepted semantic operation boundary, not a deep-freezing promise. The other eight source languages and browser Wasm remain on the Tasks 001–004 two-parameter/scalar-return profile and reject later-feature modules transactionally. See [language support](docs/language-support.md) before using it on other code.
 
 Task 009 models nominal product values as ordered `RecordDeclaration`/`RecordField` definitions, identity-bound `RecordType`, exact `RecordConstruction`, and resolved `MemberRead`. Records are closed and immutable: construction supplies every field once in declaration order, member access resolves to stable field identity, and structurally similar objects or maps are not records. Record declaration names cannot be captured by lexical parameters, locals, or iteration bindings. Presence-proven optional record receivers retain nominal field dispatch even when a field is named `length` or `size`, and Java zero-argument `equals()` record access remains distinct from one-argument string equality. Fields may recursively contain supported scalars, optionals, lists, maps, and records; an unmediated value cycle is rejected, while optional- or container-mediated recursion is accepted and compiled by every original-five target. Each frontend accepts only its documented canonical class shape. Backend preflight rejects target-reserved identifiers, including the deterministic PHP 8.2+ core/date/SPL/JSON type baseline and Ruby built-in type names, before emission; generated JavaScript and Ruby bind record freezing independently from user field and function names. Omitted or `undefined` external-IR `records` remains the legacy empty-record shape, while explicit `null` is malformed. Java uses a conventional final class with private-final storage, one constructor, and canonical accessors because pinned `@lezer/java@1.1.3` cannot faithfully represent Java `record` declarations. General classes, inheritance, interfaces/traits/mixins, extra methods, mutation, reflection, computed/dynamic members, decorators, equality/hashing, and copy/destructuring remain outside the profile. PR #34 delivered Task 009 after green TensorBuzz CI. This follow-up hardens JavaScript/Ruby record freezing and Java `equals()` member dispatch; its review and merge remain coordinator-owned.
 
@@ -85,6 +85,8 @@ Kotlin accepts top-level two-parameter functions with explicit `Long`, `Boolean`
 
 Dart accepts explicitly typed synchronous top-level functions through Task 005, required positional parameters, typed initialized locals, assignment, scalar operators, strict Boolean branches, direct calls, explicit returns, and exact `void main()`/`print`. `generateArtifactSet({language: "dart"})` returns dependency-free `pubspec.yaml`, deterministic `pubspec.lock`, and mapped `bin/program.dart`; private canonical support keeps arithmetic inside the semantic safe-integer range and prevents analyzer constant folding from invalidating short-circuit acceptance. Exact Dart SDK 3.13.3 format/analyze/VM/native acceptance passes offline in isolated state. Flutter, browser Dart, imports/packages, dynamic/nullability, collections/classes, async/isolates, and exceptions remain excluded. See the [complete Dart VM/native contract](docs/dart.md).
 
+Zig accepts explicitly typed top-level functions through Task 005, required positional parameters, exact `i64`/`bool`/immutable UTF-8 `[]const u8` values, typed `const`/`var` locals, assignment, scalar operators, strict Boolean branches, direct calls, explicit returns, and the exact generated `main`/output shell. `generateArtifactSet({language: "zig"})` returns dependency-free `build.zig` and mapped `src/main.zig`; a whole-program arena keeps concatenated slices alive through execution and checked arithmetic exits 70 identically in Debug, ReleaseSafe, and ReleaseFast. Exact Zig 0.15.2 format/build/test/run acceptance is offline with isolated caches. User allocators, pointers/slices/containers, `comptime`, error unions, FFI, reflection, concurrency, package fetching, and undefined behavior remain excluded. See the [complete Zig source and target contract](docs/zig.md).
+
 Browser Wasm lowers the unchanged subset to signed `i64`, canonical Boolean `i32`, and UTF-8 pointer/length strings in one fixed exported memory. A private 1 MiB scratch arena supports checked runtime concatenation, and generation rejects unprovable allocation, more than 64 active semantic calls, or compile-time-known i64 overflow before returning bytes. The strict loader has no DOM/WASI allocator imports or semantic JavaScript fallback. See the [complete browser Wasm contract](docs/webassembly.md).
 
 ## Bounded standard-library portability
@@ -122,7 +124,7 @@ Because `install-links=true` installs a copy of the private runtime, run `npm ci
 
 Consumers need no Semantifold-specific npm settings: default `npm install`, `npm ls --all`, and subsequent `npm ci` work with `install-links=false`. The repository alone uses `install-links=true` to materialize the local source. Root `acceptDependencies` accepts only the exact private `0.1.0` package already present in the bundle; npm resolves the Kotlin grammar from its integrity-locked full-SHA HTTPS source archive. The cold-consumer proof isolates user/global configuration, verifies the public registry and ordinary default, rejects SSH lock entries, and repeats dependency, parser, TypeScript, Rust, and Kotlin/JVM checks after both install and clean reinstall.
 
-The execution specs require PHP CLI, Ruby, Python 3, TypeScript, a Java JDK, Kotlin/JVM 2.4.20, .NET 10, Clang 21.1.8 with compiler-rt, Go 1.26 with matching `gofmt`, the exact qualified Rust/Cargo 1.98.1 pair, Swift 6.3.3, Dart SDK 3.13.3, WABT 1.0.36, and headless Chrome/Chromium 152.0.7977.82 in addition to Node; missing tools are failures. The canonical container contract installs Kotlin, Java, and Dart during image construction; runtime tests never download a compiler or dependency.
+The execution specs require PHP CLI, Ruby, Python 3, TypeScript, a Java JDK, Kotlin/JVM 2.4.20, .NET 10, Clang 21.1.8 with compiler-rt, Go 1.26 with matching `gofmt`, the exact qualified Rust/Cargo 1.98.1 pair, Swift 6.3.3, Dart SDK 3.13.3, Zig 0.15.2, WABT 1.0.36, and headless Chrome/Chromium 152.0.7977.82 in addition to Node; missing tools are failures. The canonical container contract installs Kotlin, Java, Dart, and Zig during image construction; runtime tests never download a compiler or dependency.
 
 ## Documentation
 
@@ -134,6 +136,7 @@ The execution specs require PHP CLI, Ruby, Python 3, TypeScript, a Java JDK, Kot
 - [Swift source and target](docs/swift.md)
 - [Kotlin/JVM source and target](docs/kotlin.md)
 - [Dart source and target](docs/dart.md)
+- [Zig source and target](docs/zig.md)
 - [Browser WebAssembly target](docs/webassembly.md)
 - [iOS application target](docs/ios.md)
 - [Android application target](docs/android.md)