semantifold 0.3.0 → 0.5.0

package/README.md

@@ -1,8 +1,8 @@
 # Semantifold
 
-Task019 adds independent [C++20 source and target support](docs/cpp.md) (`cpp`): one deterministic `program.cpp`, owned UTF-8 `std::string` values, checked integer arithmetic, exact ordered-expression reparsing, and real Clang O0/O2 sanitizer acceptance. The official CPP grammar shares the existing private isolated parser runtime inside the single root distribution.
+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 current source tree proves a deliberately small ten-language end-to-end baseline: parse equivalent PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, strictly annotated Python, canonical C#, bounded Go, C17, and C++20 programs into one typed semantic representation, then generate and execute equivalent programs in every target language. The published package remains `semantifold@0.2.0`; Task019 does not publish a release.
+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.
 
 ## Current API
 
@@ -26,6 +26,12 @@ const javaSource = generate({language: "java", module})
 
 `parse` returns parser-independent discriminated semantic nodes with normalized types, source locations, a versioned source registry, and deterministic node/symbol provenance. `generate` accepts that shared module and returns an independently executable source program with its historical bytes unchanged. For each single-artifact target, `generateArtifact` adds an output filename, an authoritative range-based `SemantifoldMapping` v1, and a Source Map v3 sidecar:
 
+Task 034 adds the explicit `createCapabilityAuthority(input)` boundary and optional `parse({capabilityAuthority, ...})` field. The helper validates, detaches, and deeply freezes a `SemantifoldCapabilityAuthority` schema-version-1 payload. It is compilation authority, not a source declaration or Task 035 standard-library contract version: an ordinary same-named function wins source resolution and cannot forge an effect. The returned single-module semantic graph contains deterministic capability/resource/failure/operation identities plus complete effect-site resolutions; `parseProgram` accepts the same optional authority so program modules may also declare the Task 035 canonical standard-library contract descriptor that `generateProgramArtifactSet` links against a negotiated target host provider set. `createStdlibContractRegistry`, `listStdlibModules`, and `resolveStdlibModule` expose the versioned canonical contract registry; `createStdlibProviderRegistry` and `listStdlibProviders` expose the target host provider registry; and `negotiateStdlibProviders` selects one stable compatible provider set for the transitive capability closure.
+
+Task 036 adds `createStdlibFacadeRegistry`, `listStdlibFacades`, and `resolveStdlibFacade`. The built-in qualification corpus exposes one exact native-looking `compatibilityProbe(string): string` spelling per original-five source profile (snake case in PHP/Ruby), delegates through an internal executable facade module, and depends only on `semantifold.task034.resource-probe@1` operations `probeEffect` and `probeTrace`. `parseProgram` selects these definitions only from parser-proved native module plus symbol identity, records `SemantifoldStdlibFacadeResolution` evidence, and injects only the dependency-first reachable closure. `generateProgramArtifactSet` compiles those modules into collision-checked compatibility paths, marks them as support, preserves their source mappings, includes the complete `SemantifoldStdlibFacades` descriptor in link metadata, and validates the registry definition before returning any artifact. Dynamic or unresolved imports/requires, unsupported members, reflection, shadowing, reopening/monkey-patching, native extensions, caller authority, and compiler-owned name collisions fail with located diagnostics.
+
+Task 037 extends only Ruby-source-to-PHP-target program generation. An exact literal `require "socket"` profile gates genuine `TCPSocket.new(host, port)`, zero-argument receiver `gets`/`close`, and exactly one-string unqualified `puts` or `Kernel.puts`; outside that profile Ruby program-mode `puts` retains its legacy behavior. The two compiler-owned Ruby facade modules call the canonical `semantifold.socket-client@1.0.0`, `semantifold.text-stream@1.0.0`, `semantifold.output@1.0.0`, and `semantifold.resource@1.0.0` operations directly. PHP provider artifacts under `providers/php/semantifold/` own and hide native handles, retain LF/CRLF, return one final unterminated UTF-8 line before absence, normalize warnings/failures into declared errors, write stdout completely, and make the first close attempt terminal. Other source facades, targets, socket APIs, output forms, transports, timeouts, and async behavior remain unsupported.
+
 ```js
 import {generateArtifact, originalPositionFor} from "semantifold"
 
@@ -33,31 +39,63 @@ const artifact = generateArtifact({language: "java", module})
 const original = originalPositionFor(artifact.mapping, {offset: artifact.code.indexOf("label")})
 ```
 
-Generated 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, Python, C#, Go, C, and CPP use the same rich/v3 model without foreign comments. 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, 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.
+
+`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`.
+
+`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.
 
-`supportedLanguages` is the immutable registry-derived list `php`, `ruby`, `javascript`, `typescript`, `java`, `python`, `csharp`, `go`, `c`, and `cpp`. `languageCapabilities` exposes each ID's independent frontend, text-backend, binary-backend, application-backend, and interoperability roles together with 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`.
+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).
 
-`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`. Because C#, Go, and C are deliberately multi-artifact, `generate()` and `generateArtifact()` reject them with `UNSUPPORTED_ROLE`. Go accepts only an omitted filename or exact `main.go`, and C accepts only omitted or exact `program.c`; these multi-artifact backends reject 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; and exactly one artifact has role `entry`. 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 028 adds the target-only `android` application backend through the same artifact APIs. It lowers the Kotlin/JVM-supported semantic subset, including explicit Task 010 projects, into mapped namespaced Kotlin and a synthetic dependency-minimal Android Activity/native TextView project under fixed root `generated/android-app`. Configuration, manifests, SDK levels, resources/assets, output paths, checksums, and collisions are preflighted before rendering. The manifest has one exported launcher and no permissions or components beyond the Activity. The project carries exact Gradle 8.13, AGP 8.11.1, Kotlin 2.2.10, JDK 21.0.8, and API-35 metadata; its only Gradle library declarations are exact non-transitive test-implementation JUnit 4.13.2 and test-runtime Hamcrest Core 1.3. The implicit stdlib dependency is disabled, a checksum-pinned compiler stdlib is compile-input-only, and offline acceptance proves empty application runtime dependencies plus no JUnit/Hamcrest or Kotlin runtime implementation payload in the APK. No public materializer is exported. Real installation, labelled native-view assertion, activity recreation, emulator teardown, a second fresh boot/reinstall/relaunch, screenshots, UI XML, and failure diagnostics run only in the `/dev/kvm` TensorBuzz lane. See the [Android application target](docs/android.md).
+
+`parseProgram({entryModule, sources})` and `generateProgramArtifactSet({language, program})` are the opt-in Task 010 project APIs for PHP, Ruby, JavaScript/JSDoc, TypeScript, and Java. Callers supply every source explicitly; parsing resolves an acyclic dependency-first semantic program with stable module-qualified declaration identities, exports/import bindings, one selected entry, and complete provenance. Generation plans and validates the whole target layout before returning an immutable mapped artifact set. It performs no source discovery, package/load/classpath/network resolution, file writes, or package-manager work. Existing single-module APIs and bytes remain unchanged. See [multi-file modules and names](docs/multi-file-modules.md) for the public request/result contract, canonical source profiles, target layouts, diagnostics, and migration notes.
+
+Task 036 extends only this explicit program path with compiler-owned source-language facades. `createStdlibFacadeRegistry`, `listStdlibFacades`, and `resolveStdlibFacade` expose immutable versioned definitions and exact native module/symbol lookup. A parser-proved qualification import selects the dependency-only executable closure, records source identity evidence, and compiles those facade sources through the ordinary frontend/backend pipeline; generated facade files use the `support` role under a collision-safe `semantifold/facade/...` namespace. Application code cannot provide the facade's canonical authority, and malformed, dynamic, reflective, shadowed, reopened, native-extension, or forged inputs fail before artifacts are returned. Task 037 uses that route for its two Ruby facades, links only reachable canonical/provider modules, and retains mapped application/facade provenance plus protected synthetic provider provenance.
 
 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_PHP`, `SEMANTIFOLD_RUBY`, `SEMANTIFOLD_NODE`, `SEMANTIFOLD_TSC`, `SEMANTIFOLD_JAVAC`, `SEMANTIFOLD_JAVA`, `SEMANTIFOLD_PYTHON`, `SEMANTIFOLD_DOTNET`, `SEMANTIFOLD_GO`, `SEMANTIFOLD_CLANG`, and `SEMANTIFOLD_CLANGPP`; none of these APIs installs or downloads a tool. C# requires .NET SDK major 10, while Go requires Go 1.26.x on Linux/amd64 with matching-GOROOT `gofmt`.
+`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.
+
+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.
+
+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.
+
+Task 033 separately models closed nominal reference classes. Each class has deterministic declaration/member identities, ordered private fields, exactly one constructor that initializes every field once in declaration order, and exact instance methods. `ReferenceConstruction` allocates fresh identity; assignment and argument passage copy that reference, while private mutation remains available only through the semantic receiver in the declaring class. `MethodCallExpression` resolves nominally and evaluates its receiver before its left-to-right arguments. The original five accept one explicit parser-backed source profile and emit native class forms; every other registered role advertises `referenceClasses: false` and fails before artifact exposure. Inheritance, interfaces/traits/mixins, open classes or prototypes, overloads/virtual dispatch, reflection and lifecycle/protocol hooks, static members, public mutable fields, identity equality/hashing, finalizers, cloning/serialization, generic classes, and async methods remain excluded. Task 033 is single-module; both Task 010 program APIs reject class-bearing modules before resolution or output.
 
-This is not general-purpose support for any of the ten languages. The implemented subset is a two-parameter function using explicit integer, boolean, or string types; explicitly typed, initialized scalar locals; plain assignment to mutable locals; ordered lexical blocks; strictly boolean, nested `if` statements with optional `else`; explicit scalar returns; typed scalar operations; a two-argument function call; and sequenced printing. Operations cover integer add/subtract/multiply/negate and ordering, Boolean not/short-circuit and/or, same-type scalar value equality/inequality, and string concatenation. Non-void functions must return on every reachable path, and statements after an unconditional return are rejected. See [language support](docs/language-support.md) before using it on other code.
+Task 034 adds `EffectCapabilityDeclaration`, `EffectCallExpression`, `OwnedResourceType`, `OwnedReferenceType`, explicit move/borrow nodes, declared nominal capability failures, and deterministic `effect:N` identities. Owned values may be direct immutable locals, parameters, returns, or the sole private owned field of an owned-reference class; they cannot be copied, reassigned, compared, serialized, nested in containers/optionals, or exposed through a field. Transfers require a move, borrows are immediate and nonescaping, and every reachable normal or failure path must close or transfer the owner. A borrow/read failure leaves the owner open; a close attempt is terminal even when close fails; subsequent use becomes the declared terminal failure without a second native operation. Optional absence represents only clean absence such as EOF and cannot absorb a typed host failure.
 
-Semantic integers must be JavaScript-safe mathematical integers and have one unsigned zero. Generated JavaScript and TypeScript canonically render scalar output for modules containing negation or multiplication so IEEE-754 `-0` is observed as `0` without folding or rewriting the semantic operation tree. Java generation narrows literals and compile-time-known arithmetic trees further to signed 32-bit `int`. C# uses checked signed-64-bit arithmetic. Go uses exact decimal `int64` literals, rejects compile-time-known results outside signed 64-bit, and otherwise preserves native runtime wrap outside the portable guarantee. Strings are parser-decoded Unicode scalar values and are re-escaped for each target without preserving source quotes or escapes. Equality never coerces and never applies to objects or collections. Division, remainder, exponentiation, bitwise/shift/update/compound operations, ternary/nullish forms, casts/assertions, truthiness, implicit returns, loops, switches, exceptions, and constant folding are unsupported. JavaScript and TypeScript functions must be synchronous and non-generator; Ruby annotations must be immediately associated comment blocks; and PHP accepts only an optional exact `declare(strict_types=1)`. Python requires exact `int`/`bool`/`str` annotations and its exact adjacent immutable carrier. C# requires its exact generated namespace/class shell. Go requires `package main`, at most the exact `fmt` import, explicit `int64`/`bool`/`string` types, final zero-argument `func main()`, and direct `fmt.Println`; assignment occurrence determines source-local mutability, while generated immutable locals carry exact adjacent `// @semantifold-immutable`. Frontends reject syntax instead of dropping receivers, arguments, parameters, declarations, or statements. Before emission, each backend recursively validates blocks, flow, scalar types, typed operations, modeled bindings, mutability, target identifiers, and literal representability.
+Only the exact unversioned `semantifold.task034.resource-probe` authority has built-in conformance bindings, on the original five. It exists to prove real acquisition/read/close semantics and left-to-right exactly-once lowering, not to expose files or sockets as public APIs. Backends preflight the complete capability/effect/resource graph before writer allocation and reject unsupported targets or arbitrary authorities transactionally. Async/concurrency/cancellation, `finally`/`ensure`/`defer`, implicit cleanup, RAII/destructors/finalizers/GC close, retry, general effect polymorphism, unsafe handles, shared mutable resources, and distributed transactions remain absent. Task 035's delivered hub adds versioned canonical standard-library contracts, the target host provider registry and protected native binding, capability negotiation, and program-mode provider linking with tree-shaken provider artifacts. Task 036 adds only the bounded neutral qualification facades; public file, socket, console, and other host APIs remain outside its scope.
+
+Task 011 adds parser-neutral `ErrorDeclaration`/`ErrorType`, exact `ErrorConstruction` and `RaiseStatement`, one-handler `TryStatement`, immutable catch bindings, and `ErrorMessageRead`. A raise is abrupt completion; an exact matching handler consumes only that nominal identity, while every unmatched identity propagates. Internal fixed-point call-effect analysis establishes handler reachability without adding checked effects to public function signatures. Ruby uses empty `StandardError` subclasses and explicit typed `rescue`; JavaScript/TypeScript use empty `Error` subclasses plus an exact `instanceof` guard that rethrows unmatched values; PHP uses final `RuntimeException` subclasses and exact typed catches; Java uses final unchecked `RuntimeException` subclasses. Only the immutable string message is portable. Arbitrary values, broad/multiple catches, checked exceptions, causes/stacks, retry/rethrow, `finally`/`ensure`/`else`, resources, async rejection, result types, and non-original-five lowering remain unsupported. Generated single- and multi-file projects reparse to the same nominal identities; other targets advertise `typedErrors: false` and fail transactionally with `UNSUPPORTED_CAPABILITY`.
+
+Task 012 adds declaration-owned `TypeParameter` identities, `TypeVariableReference`, exact generic record applications, and inferred type arguments on resolved direct calls. Inference is deterministic first-order unification from arguments only: a present value for `Optional<T>` contributes its contained value type, while an optional argument supplied directly for `T` contributes the complete `Optional` type. Empty collections and absent optionals, including those nested recursively in list/map literals, are contextually checked only after another argument or evidence-bearing nested value has resolved the same variable, independent of argument order. Complete substitutions apply recursively to call returns, constructor fields, and member reads; parser-known argument and explicit-application types provide only conservative frontend classification context, with the semantic validator remaining authoritative. Conflicts, missing variables, recursive substitutions, raw record use, and wrong arity fail with stable diagnostics; caller-supplied resolved signatures also require dense inferred type-argument arrays recursively through record identities. A non-generic record has no `arguments` member at all, and Java construction must spell every generic application rather than borrowing its local declaration. TypeScript and Java use native declaration/application syntax. JavaScript, Ruby, and PHP preserve the same contract through exact parser-associated documentation, including optional type variables and optional applied records nested in collections and maps. PHP closes recursive constructor context from parser-known sibling call evidence, including a present scalar supplied for `Optional<T>`, while retaining an open variable only when its exact parameter identity belongs to the caller's lexical declaration. PHP omits a native type only for `Optional<T>` when `T` has no faithful native carrier; fixed optional scalar, record, list, and map documentation instead requires the exact matching nullable native carrier, while nonoptional documentation rejects that marker. Its documented generic getter is admitted only on the exact record receiver, including a presence-proven optional receiver through an explicit semantic unwrap, while ordinary property access remains rejected. PHP otherwise uses private promoted storage and documented accessors for generic records so a direct type variable remains immutable without inventing a top type. No target substitutes `any`, `mixed`, `Object`, a raw type, specialization copies, runtime tests, or wrappers. Bounds/defaults, variance/wildcards, higher-kinded and conditional/mapped/indexed types, explicit generic function application, casts, reflection, and expected-return-only inference remain excluded. All other registered roles advertise `typeParametersAndGenerics: false` and reject generic IR transactionally. PR #39 delivered Task 012 at `18e67d0de048259d3570c60e141c16a1d26719e2`; the post-merge PHP recursive-documentation correction is implemented locally with coordinator-owned CI and merge pending.
+
+Task 013 is the terminal source-tree acceptance gate for the historical original-five Tasks 001–008 profile, delivered through PR 32 with its packed-consumer lifecycle correction in PR 33 on current `master`. Five substantial parser-native fixtures normalize to one complete semantic module, all 25 source→target routes validate and reparse equivalently, and byte-identical target outputs execute through real PHP, Ruby, Node.js, TypeScript/Node.js, and Java toolchains with exact results. Its comparator is spec-only and removes only source coordinates/provenance plus regenerated declaration identities. This gate adds no Task 009 capability, stdlib mapping, pairwise rewrite, map iteration, or expanded-language claim.
+
+Semantic integers must be JavaScript-safe mathematical integers and have one unsigned zero. Generated JavaScript and TypeScript canonically render scalar output for modules containing negation or multiplication so IEEE-754 `-0` is observed as `0` without folding or rewriting the semantic operation tree. Java generation narrows literals and compile-time-known arithmetic trees further to signed 32-bit `int`. C# uses checked signed-64-bit arithmetic. Go uses exact decimal `int64` literals, rejects compile-time-known results outside signed 64-bit, and otherwise preserves native runtime wrap outside the portable guarantee. Strings are parser-decoded Unicode scalar values and are re-escaped for each target without preserving source quotes or escapes. Equality never coerces and never applies to objects or collections. Division, remainder, exponentiation, bitwise/shift/update/compound operations, ternary/nullish forms, general casts/assertions, truthiness, implicit returns, post-condition/basic/range/async loops, switches, exception behavior outside Task 011, and constant folding are unsupported. Task 006's exact TypeScript `Map#get(...)!` round-trip wrapper is the sole assertion exception and does not establish lookup totality. JavaScript and TypeScript functions must be synchronous and non-generator; Ruby annotations must be immediately associated comment blocks; and PHP accepts only an optional exact `declare(strict_types=1)`. Python requires exact `int`/`bool`/`str` annotations and its exact adjacent immutable carrier. C# requires its exact generated namespace/class shell. Go requires `package main`, at most the exact `fmt` import, explicit `int64`/`bool`/`string` types, final zero-argument `func main()`, and direct `fmt.Println`; assignment occurrence determines source-local mutability, while generated immutable locals carry exact adjacent `// @semantifold-immutable`. Frontends reject syntax instead of dropping receivers, arguments, parameters, declarations, or statements. Before emission, each backend recursively validates blocks, flow, scalar types, typed operations, modeled bindings, mutability, loop identities and control targets, target identifiers, literal representability, and expression acyclicity; malformed cycles fail with a located diagnostic before writer allocation.
 
 C17 support uses exact `int64_t`, `bool` and immutable UTF-8 byte slices. Its deterministic `program.c`/header pair preserves left-to-right and short-circuit effects through checked ordered-expression regions, uses checked signed-64-bit arithmetic, and owns concatenation storage until main cleanup. Reparse verifies the complete generated CST before collapsing temporary values. The qualified toolchain is Ubuntu Clang 21.1.8 on Linux x86-64 with mandatory O0/O2 ordinary and sanitizer execution. See the [C source/target profile](docs/c.md) and [portable toolchain commands](docs/testing.md).
 
-## Standard-library portability direction
+Rust accepts explicitly typed two-parameter free functions, `let`/`let mut`, scalar assignments, explicit returns and braced conditionals. Exact print, string, clone, borrow and overflow scaffolding collapses into existing semantic nodes. Source move validation rejects use-after-move and overlapping borrow/move expressions; generated clones preserve semantic copies at storage, call and print boundaries. Native operands retain left-to-right evaluation and short-circuiting. Dynamic integer overflow exits 70 with a fixed diagnostic in both Cargo modes. See the [complete Rust contract](docs/rust.md).
+
+Swift accepts explicitly typed two-parameter unlabeled functions, `let`/`var`, scalar assignments, explicit returns, braced conditionals, and top-level printing. It emits one mapped `program.swift`; ordinary Swift String `==`/`!=` reject because exact target-only helpers preserve Unicode-scalar equality instead of Swift's canonical-equivalence behavior. Generated mutable locals carry synthetic warning-clean scaffolding. Exact Swift 6.3.3 debug/optimized acceptance passed after the canonical-image rebuild. See the [complete Swift contract](docs/swift.md).
+
+Kotlin accepts top-level two-parameter functions with explicit `Long`, `Boolean`, or `String`, typed `val`/`var`, scalar assignments, explicit returns, braced conditionals, final `fun main()`, and direct `println`. It emits one mapped `Program.kt` plus immutable Kotlin 2.4/JVM 25 runnable-JAR metadata; private checked helpers preserve the semantic safe-integer range. Android, Gradle, Kotlin/Native, Kotlin/JS, and multiplatform projects remain excluded. See the [complete Kotlin/JVM contract](docs/kotlin.md).
+
+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).
+
+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
 
-Standard-library portability is planned and is not implemented in `semantifold@0.2.0`. The design is hub-and-spoke, with two integrations per language: a source-facing **language compatibility stdlib/facade** preserves that language's familiar supported API shape in portable executable definitions, while a **target host provider/native binding** implements versioned **canonical Semantifold stdlib contracts/capabilities** with the target's genuine native standard library.
+Standard-library portability is not released in `semantifold@0.3.0`. The source tree contains the delivered Task 035 canonical contract/provider hub, Task 036's bounded executable qualification facades, and Task 037's first concrete Ruby-to-PHP TCP candidate. The design is hub-and-spoke, with two integrations per language: a source-facing **language compatibility stdlib/facade** preserves that language's familiar supported API shape in portable executable definitions, while a **target host provider/native binding** implements versioned **canonical Semantifold stdlib contracts/capabilities** with the target's genuine native standard library.
 
-For example, planned Ruby-to-PHP compilation would compile a Ruby application with portable Ruby `TCPSocket` and bounded one-string `puts`/`Kernel.puts` compatibility facades through the semantic IR. The generated PHP could retain those source-compatible names in a collision-safe compatibility namespace, call canonical `SocketClient`, text-stream, output, and resource capabilities, and link only the required PHP provider modules. That provider would use native `fsockopen`, `fgets`, and `fclose` for socket operations and native stdout output without adding a duplicate LF. This requires no handwritten Ruby-on-PHP bridge, source-specific loop recognition, or whole-program intelligent refactor. See the [authoritative standard-library portability design](docs/standard-library-portability.md) and [dependency-ordered implementation plan](docs/plans/2026-09-05-standard-library-portability.md).
+Ruby-to-PHP program generation compiles a Ruby application with portable Ruby `TCPSocket` and bounded one-string `puts`/`Kernel.puts` compatibility facades through semantic IR. The generated PHP retains those source-compatible names in a collision-safe compatibility namespace, calls canonical SocketClient, TextStream, Output, and Resource operations, and links only the required PHP provider modules. That protected provider uses native `fsockopen`, `fgets`, `feof`, and `fclose` for socket operations plus native stdout without adding a duplicate LF. This requires no handwritten Ruby-on-PHP bridge, source-specific loop recognition, or whole-program intelligent refactor. See the [authoritative standard-library portability design](docs/standard-library-portability.md) and [dependency-ordered implementation plan](docs/plans/2026-09-05-standard-library-portability.md).
 
 ## Development
 
-Use Node.js 24 and install with `npm ci`. Specs use `@velocious/testing@0.0.0` and the standalone `velocious-test` runner. Run a focused spec with `npx velocious-test spec/repository-contract.spec.js`. Task 018 local validation runs explicitly named changed/affected spec files sequentially; aggregate `npm test` discovery runs only in TensorBuzz.
+Use Node.js 24 and install with `npm ci`. Specs use `@velocious/testing@0.0.0` and the standalone `velocious-test` runner. Run a focused spec with `npx velocious-test spec/repository-contract.spec.js`. Task021 local validation runs explicitly named changed/affected spec files sequentially; aggregate `npm test` discovery runs only in TensorBuzz.
 
 The aggregate suite includes direct real-toolchain specs that inherit the outer test process locale, so repository validation requires `LANG=C.UTF-8` and `LC_ALL=C.UTF-8`. The canonical container currently exports neither variable. This outer-suite requirement is separate from `runAcceptanceStages`, which normalizes the locale and timezone of every child it owns and does not depend on ambient locale.
 
@@ -78,13 +116,13 @@ npm pack --dry-run --json
 git diff --check
 ```
 
-The one `semantifold@0.2.0` distribution explicitly bundles root `tree-sitter@0.25.1` and a private internal package containing an isolated exact `tree-sitter@0.21.1` plus `tree-sitter-c@0.23.2` and `tree-sitter-cpp@0.23.4` dependency subtree. The private `packages/tree-sitter-legacy` workspace owns source checking and declaration generation, but has no export or publication identity. Its serializer returns only recursively frozen parser-neutral CST data; native parser, tree, node, and language handles stay inside the legacy runtime. The packed-consumer spec installs the real root tarball with a fresh npm cache and proves modern Go and legacy C parsing together without a workspace or registry fallback for the internal package.
+The root distribution explicitly bundles root `tree-sitter@0.25.1` and a private internal package containing an isolated exact `tree-sitter@0.21.1` plus `tree-sitter-c@0.23.2`, `tree-sitter-cpp@0.23.4`, and `tree-sitter-rust@0.23.1` dependency subtree. The immutable Kotlin grammar remains an ordinary full-SHA HTTPS source-archive dependency. The private `packages/tree-sitter-legacy` workspace owns source checking and declaration generation, but has no export or publication identity. Its serializer returns only recursively frozen parser-neutral CST data; native parser, tree, node, and language handles stay inside the legacy runtime. The packed-consumer spec installs the real root tarball with a fresh npm cache and proves modern Kotlin/Go and legacy C/CPP/Rust parsing together without a workspace, SSH route, or registry fallback for the internal package.
 
 Because `install-links=true` installs a copy of the private runtime, run `npm ci` again after editing its shipped files under `packages/tree-sitter-legacy/runtime/`. Tests, lint, and `npm pack` reject a stale installed payload with that recovery instruction. The gate compares npm's source file inventory and every file's bytes, including the manifest, serializer, README, and license; it never copies or repairs dependencies itself.
 
-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 the exact private `0.1.0` package already present in the bundle; npm still resolves new installations from the declared `file:` source, never from a registry release of the internal name. The cold-consumer proof isolates user/global configuration, verifies the public registry and ordinary default, and repeats dependency, parser, and TypeScript checks after both install and clean reinstall.
+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, .NET 10, Clang 21.1.8 with compiler-rt, and Go 1.26 with matching `gofmt` in addition to Node; missing tools are failures. The canonical container provides them: `docker compose up --build --detach`, followed by `docker compose exec dev npm ci` and the commands above.
+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.
 
 ## Documentation
 
@@ -92,9 +130,17 @@ The execution specs require PHP CLI, Ruby, Python 3, TypeScript, a Java JDK, .NE
 - [Architecture](docs/architecture.md)
 - [Coding standards](docs/coding-standards.md)
 - [Language support](docs/language-support.md)
+- [Rust source and Cargo target](docs/rust.md)
+- [Swift source and target](docs/swift.md)
+- [Kotlin/JVM source and target](docs/kotlin.md)
+- [Dart source and target](docs/dart.md)
+- [Browser WebAssembly target](docs/webassembly.md)
+- [iOS application target](docs/ios.md)
+- [Android application target](docs/android.md)
 - [Parser qualification](docs/parser-qualification.md)
 - [Testing](docs/testing.md)
 - [Source provenance and mappings](docs/source-maps.md)
+- [Multi-file modules and names](docs/multi-file-modules.md)
 - [Standard-library portability design](docs/standard-library-portability.md)
 - [Standard-library portability implementation plan](docs/plans/2026-09-05-standard-library-portability.md)
 - [Language feature roadmap](https://github.com/kaspernj/semantifold/blob/master/todo/README.md)

package/build/index.d.ts

@@ -1,7 +1,12 @@
 import { SemantifoldDiagnostic } from "./src/diagnostic.js";
 export { SemantifoldDiagnostic };
+export { createCapabilityAuthority } from "./src/semantic/capabilities.js";
 export { languageCapabilities, supportedLanguages } from "./src/language-registry.js";
 export { createGeneratedArtifactSet } from "./src/artifacts.js";
+export { createStdlibContractRegistry, listStdlibModules, resolveStdlibModule } from "./src/semantic/stdlib.js";
+export { createStdlibProviderRegistry, listStdlibProviders } from "./src/stdlib-providers.js";
+export { negotiateStdlibProviders } from "./src/stdlib-negotiation.js";
+export { createStdlibFacadeRegistry, listStdlibFacades, resolveStdlibFacade } from "./src/stdlib-facades.js";
 export { createByteMapping, parseByteMapping, stringifyByteMapping } from "./src/binary-mapping.js";
 export { canonicalToolchains, discoverCanonicalToolchain, discoverToolchain } from "./src/toolchains.js";
 export { runAcceptanceStages } from "./src/acceptance.js";
@@ -14,13 +19,33 @@ export { composeMappings, composeSourceMaps, generatedPositionFor, mappingFromSo
  * @param {string} input.filename - Source filename used in diagnostics.
  * @param {import("./src/semantic/types.js").SemanticLanguage} input.language - Source language.
  * @param {string} input.source - Source text.
+ * @param {Readonly<import("./src/semantic/types.js").CapabilityAuthority> | import("./src/semantic/types.js").CapabilityAuthorityInput} [input.capabilityAuthority] - Explicit compiler authority.
  * @returns {import("./src/semantic/types.js").SemanticModule} Semantic module.
  */
 export declare function parse(input: {
     filename: string;
     language: import("./src/semantic/types.js").SemanticLanguage;
     source: string;
+    capabilityAuthority?: Readonly<import("./src/semantic/types.js").CapabilityAuthority> | import("./src/semantic/types.js").CapabilityAuthorityInput;
 }): import("./src/semantic/types.js").SemanticModule;
+/**
+ * Parses a complete explicit multi-source project into one resolved semantic program.
+ * @param {object} input - Program parse request.
+ * @param {string} input.entryModule - Stable identity of the sole entry module.
+ * @param {{filename: string, id: string, language: import("./src/semantic/types.js").SemanticLanguage, source: string}[]} input.sources - Complete caller-supplied source set.
+ * @param {Readonly<import("./src/semantic/types.js").CapabilityAuthority> | import("./src/semantic/types.js").CapabilityAuthorityInput} [input.capabilityAuthority] - Explicit compiler authority shared by every program module.
+ * @returns {import("./src/semantic/types.js").SemanticProgram} Semantic program.
+ */
+export declare function parseProgram(input: {
+    entryModule: string;
+    sources: {
+        filename: string;
+        id: string;
+        language: import("./src/semantic/types.js").SemanticLanguage;
+        source: string;
+    }[];
+    capabilityAuthority?: Readonly<import("./src/semantic/types.js").CapabilityAuthority> | import("./src/semantic/types.js").CapabilityAuthorityInput;
+}): import("./src/semantic/types.js").SemanticProgram;
 /**
  * Generates target-language source from a shared semantic module.
  * @param {object} input - Generation request.
@@ -55,20 +80,42 @@ export declare function generateArtifact(input: {
         language?: import("./src/semantic/types.js").SemanticLanguage;
     }[];
 }): import("./src/semantic/types.js").GeneratedArtifact;
+/**
+ * Generates a deterministic mapped artifact set for a complete semantic program.
+ * @param {object} input - Program generation request.
+ * @param {import("./src/semantic/types.js").BackendLanguage} input.language - Registered program target.
+ * @param {import("./src/semantic/types.js").SemanticProgram} input.program - Complete resolved program.
+ * @param {"text" | "application"} [input.role] - Explicit role; omitted preserves text generation.
+ * @param {import("./src/semantic/types.js").IosApplicationConfigurationInput | import("./src/semantic/types.js").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.
+ * @param {import("./src/semantic/types.js").IosApplicationAssetInput[] | import("./src/semantic/types.js").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.
+ * @param {import("./src/semantic/types.js").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.
+ * @returns {import("./src/semantic/types.js").GeneratedArtifactSet} Complete generated set.
+ */
+export declare function generateProgramArtifactSet(input: {
+    language: import("./src/semantic/types.js").BackendLanguage;
+    program: import("./src/semantic/types.js").SemanticProgram;
+    role?: "text" | "application";
+    configuration?: import("./src/semantic/types.js").IosApplicationConfigurationInput | import("./src/semantic/types.js").AndroidApplicationConfigurationInput;
+    assets?: import("./src/semantic/types.js").IosApplicationAssetInput[] | import("./src/semantic/types.js").AndroidApplicationInputFile[];
+    resources?: import("./src/semantic/types.js").AndroidApplicationInputFile[];
+}): import("./src/semantic/types.js").GeneratedArtifactSet;
 /**
  * Generates a deterministic artifact set for one semantic module.
  * @param {object} input - Artifact-set generation request.
- * @param {string} input.language - Registered target language or platform ID.
+ * @param {import("./src/semantic/types.js").BackendLanguage} input.language - Registered target language or platform ID.
  * @param {import("./src/semantic/types.js").SemanticModule} input.module - Semantic module.
  * @param {"text" | "binary" | "application"} [input.role] - Requested backend artifact role.
  * @param {string} [input.filename] - Safe output path for a text target.
  * @param {"none" | "external" | "inline"} [input.mapDirective] - JavaScript-family map directive.
  * @param {string} [input.sourceMapFilename] - External map filename.
  * @param {{filename: string, content: string, language?: import("./src/semantic/types.js").SemanticLanguage}[]} [input.sources] - Original sources.
+ * @param {import("./src/semantic/types.js").IosApplicationConfigurationInput | import("./src/semantic/types.js").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.
+ * @param {import("./src/semantic/types.js").IosApplicationAssetInput[] | import("./src/semantic/types.js").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.
+ * @param {import("./src/semantic/types.js").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.
  * @returns {import("./src/semantic/types.js").GeneratedArtifactSet} Complete generated set.
  */
 export declare function generateArtifactSet(input: {
-    language: string;
+    language: import("./src/semantic/types.js").BackendLanguage;
     module: import("./src/semantic/types.js").SemanticModule;
     role?: "text" | "binary" | "application";
     filename?: string;
@@ -79,5 +126,8 @@ export declare function generateArtifactSet(input: {
         content: string;
         language?: import("./src/semantic/types.js").SemanticLanguage;
     }[];
+    configuration?: import("./src/semantic/types.js").IosApplicationConfigurationInput | import("./src/semantic/types.js").AndroidApplicationConfigurationInput;
+    assets?: import("./src/semantic/types.js").IosApplicationAssetInput[] | import("./src/semantic/types.js").AndroidApplicationInputFile[];
+    resources?: import("./src/semantic/types.js").AndroidApplicationInputFile[];
 }): import("./src/semantic/types.js").GeneratedArtifactSet;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"AAKA,OAAO,EAAC,qBAAqB,EAAC,MAAM,qBAAqB,CAAA;AAKzD,OAAO,EAAC,qBAAqB,EAAC,CAAA;AAC9B,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,4BAA4B,CAAA;AACnF,OAAO,EAAC,0BAA0B,EAAC,MAAM,oBAAoB,CAAA;AAC7D,OAAO,EAAC,iBAAiB,EAAE,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,yBAAyB,CAAA;AACjG,OAAO,EAAC,mBAAmB,EAAE,0BAA0B,EAAE,iBAAiB,EAAC,MAAM,qBAAqB,CAAA;AACtG,OAAO,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAA;AACnF,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EALxB;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAsB,MAAM,EAApB,MAAM,CACd;CAEwB,GAFd,OAAO,yBAAyB,EAAE,cAAc,CAI5D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAJ3B;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;CAE2B,GAFjB,MAAM,CAIlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EARnC;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAqH,OAAO,AAA5H,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAC5G;CAEmC,GAFzB,OAAO,yBAAyB,EAAE,iBAAiB,CAI/D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EATtC;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;IAAkD,IAAI,AAAtD,CACA,EADQ,MAAM,GAAG,QAAQ,GAAG,aAAa,CACzC;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAqH,OAAO,AAA5H,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAC5G;CAEsC,GAF5B,OAAO,yBAAyB,EAAE,oBAAoB,CAsFlE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"AAOA,OAAO,EAAC,qBAAqB,EAAwB,MAAM,qBAAqB,CAAA;AAOhF,OAAO,EAAC,qBAAqB,EAAC,CAAA;AAC9B,OAAO,EAAC,yBAAyB,EAAC,MAAM,gCAAgC,CAAA;AACxE,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,4BAA4B,CAAA;AACnF,OAAO,EAAC,0BAA0B,EAAC,MAAM,oBAAoB,CAAA;AAC7D,OAAO,EAAC,4BAA4B,EAAE,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,0BAA0B,CAAA;AAC7G,OAAO,EAAC,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,2BAA2B,CAAA;AAC3F,OAAO,EAAC,wBAAwB,EAAC,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAC,0BAA0B,EAAE,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,yBAAyB,CAAA;AAC1G,OAAO,EAAC,iBAAiB,EAAE,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,yBAAyB,CAAA;AACjG,OAAO,EAAC,mBAAmB,EAAE,0BAA0B,EAAE,iBAAiB,EAAC,MAAM,qBAAqB,CAAA;AACtG,OAAO,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAA;AACnF,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,KAAK,EANxB;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAsB,MAAM,EAApB,MAAM,CACd;IAA6I,mBAAmB,AAAhK,CACA,EADQ,QAAQ,CAAC,OAAO,yBAAyB,EAAE,mBAAmB,CAAC,GAAG,OAAO,yBAAyB,EAAE,wBAAwB,CACpI;CAEwB,GAFd,OAAO,yBAAyB,EAAE,cAAc,CAI5D;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAL/B;IAAsB,WAAW,EAAzB,MAAM,CACd;IAA8H,OAAO,EAA7H;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,EAAE,CACtH;IAA6I,mBAAmB,AAAhK,CACA,EADQ,QAAQ,CAAC,OAAO,yBAAyB,EAAE,mBAAmB,CAAC,GAAG,OAAO,yBAAyB,EAAE,wBAAwB,CACpI;CAE+B,GAFrB,OAAO,yBAAyB,EAAE,eAAe,CAI7D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAJ3B;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;CAE2B,GAFjB,MAAM,CAIlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EARnC;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAqH,OAAO,AAA5H,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAC5G;CAEmC,GAFzB,OAAO,yBAAyB,EAAE,iBAAiB,CAI/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAR7C;IAAiE,QAAQ,EAAjE,OAAO,yBAAyB,EAAE,eAAe,CACzD;IAAiE,OAAO,EAAhE,OAAO,yBAAyB,EAAE,eAAe,CACzD;IAAuC,IAAI,AAA3C,CACA,EADQ,MAAM,GAAG,aAAa,CAC9B;IAA4J,aAAa,AAAzK,CACA,EADQ,OAAO,yBAAyB,EAAE,gCAAgC,GAAG,OAAO,yBAAyB,EAAE,oCAAoC,CACnJ;IAA+I,MAAM,AAArJ,CACA,EADQ,OAAO,yBAAyB,EAAE,wBAAwB,EAAE,GAAG,OAAO,yBAAyB,EAAE,2BAA2B,EAAE,CACtI;IAAgF,SAAS,AAAzF,CACA,EADQ,OAAO,yBAAyB,EAAE,2BAA2B,EAAE,CACvE;CAE6C,GAFnC,OAAO,yBAAyB,EAAE,oBAAoB,CAIlE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAZtC;IAAiE,QAAQ,EAAjE,OAAO,yBAAyB,EAAE,eAAe,CACzD;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;IAAkD,IAAI,AAAtD,CACA,EADQ,MAAM,GAAG,QAAQ,GAAG,aAAa,CACzC;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAqH,OAAO,AAA5H,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAC5G;IAA4J,aAAa,AAAzK,CACA,EADQ,OAAO,yBAAyB,EAAE,gCAAgC,GAAG,OAAO,yBAAyB,EAAE,oCAAoC,CACnJ;IAA+I,MAAM,AAArJ,CACA,EADQ,OAAO,yBAAyB,EAAE,wBAAwB,EAAE,GAAG,OAAO,yBAAyB,EAAE,2BAA2B,EAAE,CACtI;IAAgF,SAAS,AAAzF,CACA,EADQ,OAAO,yBAAyB,EAAE,2BAA2B,EAAE,CACvE;CAEsC,GAF5B,OAAO,yBAAyB,EAAE,oBAAoB,CAwGlE"}

package/build/index.js

@@ -1,13 +1,22 @@
 // @ts-check
 import { parseSource } from "./src/frontends/index.js";
+import { parseProgramSource } from "./src/frontends/program.js";
 import { generateArtifactSource, generateSource } from "./src/backends/index.js";
+import { generateProgramArtifacts } from "./src/backends/program.js";
 import { createGeneratedArtifactSet as constructArtifactSet } from "./src/artifacts.js";
-import { SemantifoldDiagnostic } from "./src/diagnostic.js";
+import { SemantifoldDiagnostic, unsupportedCapability } from "./src/diagnostic.js";
 import { languageRegistry } from "./src/language-registry.js";
+import { kotlinArtifactMetadata } from "./src/backends/kotlin.js";
+import { preflightEffectCapabilities } from "./src/backends/effects.js";
 const artifactBackendRoles = new Set(["text", "binary", "application"]);
 export { SemantifoldDiagnostic };
+export { createCapabilityAuthority } from "./src/semantic/capabilities.js";
 export { languageCapabilities, supportedLanguages } from "./src/language-registry.js";
 export { createGeneratedArtifactSet } from "./src/artifacts.js";
+export { createStdlibContractRegistry, listStdlibModules, resolveStdlibModule } from "./src/semantic/stdlib.js";
+export { createStdlibProviderRegistry, listStdlibProviders } from "./src/stdlib-providers.js";
+export { negotiateStdlibProviders } from "./src/stdlib-negotiation.js";
+export { createStdlibFacadeRegistry, listStdlibFacades, resolveStdlibFacade } from "./src/stdlib-facades.js";
 export { createByteMapping, parseByteMapping, stringifyByteMapping } from "./src/binary-mapping.js";
 export { canonicalToolchains, discoverCanonicalToolchain, discoverToolchain } from "./src/toolchains.js";
 export { runAcceptanceStages } from "./src/acceptance.js";
@@ -20,11 +29,23 @@ export { composeMappings, composeSourceMaps, generatedPositionFor, mappingFromSo
  * @param {string} input.filename - Source filename used in diagnostics.
  * @param {import("./src/semantic/types.js").SemanticLanguage} input.language - Source language.
  * @param {string} input.source - Source text.
+ * @param {Readonly<import("./src/semantic/types.js").CapabilityAuthority> | import("./src/semantic/types.js").CapabilityAuthorityInput} [input.capabilityAuthority] - Explicit compiler authority.
  * @returns {import("./src/semantic/types.js").SemanticModule} Semantic module.
  */
 export function parse(input) {
     return parseSource(input);
 }
+/**
+ * Parses a complete explicit multi-source project into one resolved semantic program.
+ * @param {object} input - Program parse request.
+ * @param {string} input.entryModule - Stable identity of the sole entry module.
+ * @param {{filename: string, id: string, language: import("./src/semantic/types.js").SemanticLanguage, source: string}[]} input.sources - Complete caller-supplied source set.
+ * @param {Readonly<import("./src/semantic/types.js").CapabilityAuthority> | import("./src/semantic/types.js").CapabilityAuthorityInput} [input.capabilityAuthority] - Explicit compiler authority shared by every program module.
+ * @returns {import("./src/semantic/types.js").SemanticProgram} Semantic program.
+ */
+export function parseProgram(input) {
+    return parseProgramSource(input);
+}
 /**
  * Generates target-language source from a shared semantic module.
  * @param {object} input - Generation request.
@@ -49,16 +70,33 @@ export function generate(input) {
 export function generateArtifact(input) {
     return generateArtifactSource(input);
 }
+/**
+ * Generates a deterministic mapped artifact set for a complete semantic program.
+ * @param {object} input - Program generation request.
+ * @param {import("./src/semantic/types.js").BackendLanguage} input.language - Registered program target.
+ * @param {import("./src/semantic/types.js").SemanticProgram} input.program - Complete resolved program.
+ * @param {"text" | "application"} [input.role] - Explicit role; omitted preserves text generation.
+ * @param {import("./src/semantic/types.js").IosApplicationConfigurationInput | import("./src/semantic/types.js").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.
+ * @param {import("./src/semantic/types.js").IosApplicationAssetInput[] | import("./src/semantic/types.js").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.
+ * @param {import("./src/semantic/types.js").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.
+ * @returns {import("./src/semantic/types.js").GeneratedArtifactSet} Complete generated set.
+ */
+export function generateProgramArtifactSet(input) {
+    return generateProgramArtifacts(input);
+}
 /**
  * Generates a deterministic artifact set for one semantic module.
  * @param {object} input - Artifact-set generation request.
- * @param {string} input.language - Registered target language or platform ID.
+ * @param {import("./src/semantic/types.js").BackendLanguage} input.language - Registered target language or platform ID.
  * @param {import("./src/semantic/types.js").SemanticModule} input.module - Semantic module.
  * @param {"text" | "binary" | "application"} [input.role] - Requested backend artifact role.
  * @param {string} [input.filename] - Safe output path for a text target.
  * @param {"none" | "external" | "inline"} [input.mapDirective] - JavaScript-family map directive.
  * @param {string} [input.sourceMapFilename] - External map filename.
  * @param {{filename: string, content: string, language?: import("./src/semantic/types.js").SemanticLanguage}[]} [input.sources] - Original sources.
+ * @param {import("./src/semantic/types.js").IosApplicationConfigurationInput | import("./src/semantic/types.js").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.
+ * @param {import("./src/semantic/types.js").IosApplicationAssetInput[] | import("./src/semantic/types.js").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.
+ * @param {import("./src/semantic/types.js").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.
  * @returns {import("./src/semantic/types.js").GeneratedArtifactSet} Complete generated set.
  */
 export function generateArtifactSet(input) {
@@ -69,7 +107,7 @@ export function generateArtifactSet(input) {
             message: "Artifact-set generation requires a request object."
         });
     }
-    const { filename, language, mapDirective, module, role = "text", sourceMapFilename, sources } = input;
+    const { assets, configuration, filename, language, mapDirective, module, resources, role = "text", sourceMapFilename, sources } = input;
     if (typeof language != "string" || language.length == 0) {
         throw new SemantifoldDiagnostic({
             code: "INVALID_ARTIFACT_SET",
@@ -84,9 +122,21 @@ export function generateArtifactSet(input) {
             message: "Artifact backend role must be 'text', 'binary', or 'application'."
         });
     }
+    const target = languageRegistry.record(language);
+    preflightEffectCapabilities(module, /** @type {import("./src/semantic/types.js").BackendLanguage} */ (language));
+    const genericDeclaration = [...module?.records ?? [], ...module?.functions ?? []]
+        .find((declaration) => (declaration?.typeParameters?.length ?? 0) > 0);
+    if (genericDeclaration && !target.features.typeParametersAndGenerics) {
+        unsupportedCapability(/** @type {import("./src/semantic/types.js").BackendLanguage} */ (language), "Task 012 type parameters and generics", genericDeclaration.location ?? module.location);
+    }
+    if (Array.isArray(module?.records) && module.records.length > 0 && !target.features.closedRecords) {
+        unsupportedCapability(/** @type {import("./src/semantic/types.js").BackendLanguage} */ (language), "Task 009 closed records", module.records[0].location ?? module.location);
+    }
+    if (Array.isArray(module?.classes) && module.classes.length > 0 && !target.features.referenceClasses) {
+        unsupportedCapability(/** @type {import("./src/semantic/types.js").BackendLanguage} */ (language), "Task 033 reference classes", module.classes[0].location ?? module.location);
+    }
     if (role == "text") {
-        const record = languageRegistry.record(language);
-        if (record.artifactMultiplicity == "multiple") {
+        if (target.artifactMultiplicity == "multiple") {
             const backend = languageRegistry.resolve(language, "textBackend", module?.location);
             return constructArtifactSet(backend({ filename, language, mapDirective, module, sourceMapFilename, sources }));
         }
@@ -102,7 +152,7 @@ export function generateArtifactSet(input) {
         const artifacts = [{
                 content: artifact.code,
                 contentKind: "text",
-                mediaType: /** @type {string} */ (record.mediaType),
+                mediaType: /** @type {string} */ (target.mediaType),
                 ownership: "generated",
                 path: artifact.filename,
                 provenance: {
@@ -130,11 +180,13 @@ export function generateArtifactSet(input) {
         }
         return constructArtifactSet({
             artifacts,
+            ...(language == "kotlin" ? { metadata: kotlinArtifactMetadata } : {}),
             target: language
         });
     }
     const registryRole = role == "binary" ? "binaryBackend" : "applicationBackend";
     const backend = languageRegistry.resolve(language, registryRole, module?.location);
-    return constructArtifactSet(backend({ filename, language, module, sources }));
+    return constructArtifactSet(backend(language == "android" ? input :
+        { assets, configuration, filename, language, mapDirective, module, resources, sourceMapFilename, sources }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {parseSource} from \"./src/frontends/index.js\"\nimport {generateArtifactSource, generateSource} from \"./src/backends/index.js\"\nimport {createGeneratedArtifactSet as constructArtifactSet} from \"./src/artifacts.js\"\nimport {SemantifoldDiagnostic} from \"./src/diagnostic.js\"\nimport {languageRegistry} from \"./src/language-registry.js\"\n\nconst artifactBackendRoles = new Set([\"text\", \"binary\", \"application\"])\n\nexport {SemantifoldDiagnostic}\nexport {languageCapabilities, supportedLanguages} from \"./src/language-registry.js\"\nexport {createGeneratedArtifactSet} from \"./src/artifacts.js\"\nexport {createByteMapping, parseByteMapping, stringifyByteMapping} from \"./src/binary-mapping.js\"\nexport {canonicalToolchains, discoverCanonicalToolchain, discoverToolchain} from \"./src/toolchains.js\"\nexport {runAcceptanceStages} from \"./src/acceptance.js\"\nexport {getNodeProvenance, getSymbolProvenance} from \"./src/semantic/provenance.js\"\nexport {primaryLocation} from \"./src/semantic/provenance.js\"\nexport {\n  composeMappings,\n  composeSourceMaps,\n  generatedPositionFor,\n  mappingFromSourceMap,\n  originalPositionFor,\n  parseMapping,\n  remapDiagnostic,\n  remapLocation,\n  spansForNode,\n  spansForSymbol,\n  stringifyMapping,\n  toSourceMapV3\n} from \"./src/mapping.js\"\n\n/**\n * Parses source into Semantifold's shared semantic representation.\n * @param {object} input - Parse request.\n * @param {string} input.filename - Source filename used in diagnostics.\n * @param {import(\"./src/semantic/types.js\").SemanticLanguage} input.language - Source language.\n * @param {string} input.source - Source text.\n * @returns {import(\"./src/semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parse(input) {\n  return parseSource(input)\n}\n\n/**\n * Generates target-language source from a shared semantic module.\n * @param {object} input - Generation request.\n * @param {import(\"./src/semantic/types.js\").SemanticLanguage} input.language - Target language.\n * @param {import(\"./src/semantic/types.js\").SemanticModule} input.module - Semantic module.\n * @returns {string} Generated source.\n */\nexport function generate(input) {\n  return generateSource(input)\n}\n\n/**\n * Generates a reusable output artifact with rich and Source Map v3 mappings.\n * @param {object} input - Generation request.\n * @param {import(\"./src/semantic/types.js\").SemanticLanguage} input.language - Target language.\n * @param {import(\"./src/semantic/types.js\").SemanticModule} input.module - Semantic module.\n * @param {string} [input.filename] - Output filename.\n * @param {\"none\" | \"external\" | \"inline\"} [input.mapDirective] - JavaScript-family map directive.\n * @param {string} [input.sourceMapFilename] - External map filename.\n * @param {{filename: string, content: string, language?: import(\"./src/semantic/types.js\").SemanticLanguage}[]} [input.sources] - Sources for caller-authored modules.\n * @returns {import(\"./src/semantic/types.js\").GeneratedArtifact} Generated artifact.\n */\nexport function generateArtifact(input) {\n  return generateArtifactSource(input)\n}\n\n/**\n * Generates a deterministic artifact set for one semantic module.\n * @param {object} input - Artifact-set generation request.\n * @param {string} input.language - Registered target language or platform ID.\n * @param {import(\"./src/semantic/types.js\").SemanticModule} input.module - Semantic module.\n * @param {\"text\" | \"binary\" | \"application\"} [input.role] - Requested backend artifact role.\n * @param {string} [input.filename] - Safe output path for a text target.\n * @param {\"none\" | \"external\" | \"inline\"} [input.mapDirective] - JavaScript-family map directive.\n * @param {string} [input.sourceMapFilename] - External map filename.\n * @param {{filename: string, content: string, language?: import(\"./src/semantic/types.js\").SemanticLanguage}[]} [input.sources] - Original sources.\n * @returns {import(\"./src/semantic/types.js\").GeneratedArtifactSet} Complete generated set.\n */\nexport function generateArtifactSet(input) {\n  if (!input || typeof input != \"object\" || Array.isArray(input) || Object.getPrototypeOf(input) != Object.prototype) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_ARTIFACT_SET\",\n      language: \"artifact\",\n      message: \"Artifact-set generation requires a request object.\"\n    })\n  }\n  const {filename, language, mapDirective, module, role = \"text\", sourceMapFilename, sources} = input\n\n  if (typeof language != \"string\" || language.length == 0) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_ARTIFACT_SET\",\n      language: \"artifact\",\n      message: \"Artifact-set generation requires a non-empty string language or target ID.\"\n    })\n  }\n  if (typeof role != \"string\" || !artifactBackendRoles.has(role)) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_ARTIFACT_SET\",\n      language,\n      message: \"Artifact backend role must be 'text', 'binary', or 'application'.\"\n    })\n  }\n\n  if (role == \"text\") {\n    const record = languageRegistry.record(language)\n\n    if (record.artifactMultiplicity == \"multiple\") {\n      const backend = languageRegistry.resolve(language, \"textBackend\", module?.location)\n\n      return constructArtifactSet(backend({filename, language, mapDirective, module, sourceMapFilename, sources}))\n    }\n    const artifact = generateArtifactSource({\n      filename,\n      language: /** @type {import(\"./src/semantic/types.js\").SemanticLanguage} */ (language),\n      mapDirective,\n      module,\n      sourceMapFilename,\n      sources\n    })\n\n    /** @type {import(\"./src/semantic/types.js\").GeneratedSetArtifact[]} */\n    const artifacts = [{\n      content: artifact.code,\n      contentKind: \"text\",\n      mediaType: /** @type {string} */ (record.mediaType),\n      ownership: \"generated\",\n      path: artifact.filename,\n      provenance: {\n        kind: \"text\",\n        mapping: artifact.mapping,\n        sourceMap: artifact.sourceMap,\n        sourceMapFilename: artifact.sourceMapFilename\n      },\n      role: \"entry\"\n    }]\n\n    if (mapDirective == \"external\") {\n      artifacts.push({\n        content: `${JSON.stringify(artifact.sourceMap)}\\n`,\n        contentKind: \"text\",\n        mediaType: \"application/json\",\n        ownership: \"generated\",\n        path: artifact.sourceMapFilename,\n        provenance: {\n          kind: \"synthetic\",\n          reason: \"Serialized Source Map v3 projection for the generated entry artifact.\",\n          relatedOrigins: []\n        },\n        role: \"mapping\"\n      })\n    }\n\n    return constructArtifactSet({\n      artifacts,\n      target: language\n    })\n  }\n\n  const registryRole = role == \"binary\" ? \"binaryBackend\" : \"applicationBackend\"\n  const backend = languageRegistry.resolve(language, registryRole, module?.location)\n\n  return constructArtifactSet(backend({filename, language, module, sources}))\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {parseSource} from \"./src/frontends/index.js\"\nimport {parseProgramSource} from \"./src/frontends/program.js\"\nimport {generateArtifactSource, generateSource} from \"./src/backends/index.js\"\nimport {generateProgramArtifacts} from \"./src/backends/program.js\"\nimport {createGeneratedArtifactSet as constructArtifactSet} from \"./src/artifacts.js\"\nimport {SemantifoldDiagnostic, unsupportedCapability} from \"./src/diagnostic.js\"\nimport {languageRegistry} from \"./src/language-registry.js\"\nimport {kotlinArtifactMetadata} from \"./src/backends/kotlin.js\"\nimport {preflightEffectCapabilities} from \"./src/backends/effects.js\"\n\nconst artifactBackendRoles = new Set([\"text\", \"binary\", \"application\"])\n\nexport {SemantifoldDiagnostic}\nexport {createCapabilityAuthority} from \"./src/semantic/capabilities.js\"\nexport {languageCapabilities, supportedLanguages} from \"./src/language-registry.js\"\nexport {createGeneratedArtifactSet} from \"./src/artifacts.js\"\nexport {createStdlibContractRegistry, listStdlibModules, resolveStdlibModule} from \"./src/semantic/stdlib.js\"\nexport {createStdlibProviderRegistry, listStdlibProviders} from \"./src/stdlib-providers.js\"\nexport {negotiateStdlibProviders} from \"./src/stdlib-negotiation.js\"\nexport {createStdlibFacadeRegistry, listStdlibFacades, resolveStdlibFacade} from \"./src/stdlib-facades.js\"\nexport {createByteMapping, parseByteMapping, stringifyByteMapping} from \"./src/binary-mapping.js\"\nexport {canonicalToolchains, discoverCanonicalToolchain, discoverToolchain} from \"./src/toolchains.js\"\nexport {runAcceptanceStages} from \"./src/acceptance.js\"\nexport {getNodeProvenance, getSymbolProvenance} from \"./src/semantic/provenance.js\"\nexport {primaryLocation} from \"./src/semantic/provenance.js\"\nexport {\n  composeMappings,\n  composeSourceMaps,\n  generatedPositionFor,\n  mappingFromSourceMap,\n  originalPositionFor,\n  parseMapping,\n  remapDiagnostic,\n  remapLocation,\n  spansForNode,\n  spansForSymbol,\n  stringifyMapping,\n  toSourceMapV3\n} from \"./src/mapping.js\"\n\n/**\n * Parses source into Semantifold's shared semantic representation.\n * @param {object} input - Parse request.\n * @param {string} input.filename - Source filename used in diagnostics.\n * @param {import(\"./src/semantic/types.js\").SemanticLanguage} input.language - Source language.\n * @param {string} input.source - Source text.\n * @param {Readonly<import(\"./src/semantic/types.js\").CapabilityAuthority> | import(\"./src/semantic/types.js\").CapabilityAuthorityInput} [input.capabilityAuthority] - Explicit compiler authority.\n * @returns {import(\"./src/semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parse(input) {\n  return parseSource(input)\n}\n\n/**\n * Parses a complete explicit multi-source project into one resolved semantic program.\n * @param {object} input - Program parse request.\n * @param {string} input.entryModule - Stable identity of the sole entry module.\n * @param {{filename: string, id: string, language: import(\"./src/semantic/types.js\").SemanticLanguage, source: string}[]} input.sources - Complete caller-supplied source set.\n * @param {Readonly<import(\"./src/semantic/types.js\").CapabilityAuthority> | import(\"./src/semantic/types.js\").CapabilityAuthorityInput} [input.capabilityAuthority] - Explicit compiler authority shared by every program module.\n * @returns {import(\"./src/semantic/types.js\").SemanticProgram} Semantic program.\n */\nexport function parseProgram(input) {\n  return parseProgramSource(input)\n}\n\n/**\n * Generates target-language source from a shared semantic module.\n * @param {object} input - Generation request.\n * @param {import(\"./src/semantic/types.js\").SemanticLanguage} input.language - Target language.\n * @param {import(\"./src/semantic/types.js\").SemanticModule} input.module - Semantic module.\n * @returns {string} Generated source.\n */\nexport function generate(input) {\n  return generateSource(input)\n}\n\n/**\n * Generates a reusable output artifact with rich and Source Map v3 mappings.\n * @param {object} input - Generation request.\n * @param {import(\"./src/semantic/types.js\").SemanticLanguage} input.language - Target language.\n * @param {import(\"./src/semantic/types.js\").SemanticModule} input.module - Semantic module.\n * @param {string} [input.filename] - Output filename.\n * @param {\"none\" | \"external\" | \"inline\"} [input.mapDirective] - JavaScript-family map directive.\n * @param {string} [input.sourceMapFilename] - External map filename.\n * @param {{filename: string, content: string, language?: import(\"./src/semantic/types.js\").SemanticLanguage}[]} [input.sources] - Sources for caller-authored modules.\n * @returns {import(\"./src/semantic/types.js\").GeneratedArtifact} Generated artifact.\n */\nexport function generateArtifact(input) {\n  return generateArtifactSource(input)\n}\n\n/**\n * Generates a deterministic mapped artifact set for a complete semantic program.\n * @param {object} input - Program generation request.\n * @param {import(\"./src/semantic/types.js\").BackendLanguage} input.language - Registered program target.\n * @param {import(\"./src/semantic/types.js\").SemanticProgram} input.program - Complete resolved program.\n * @param {\"text\" | \"application\"} [input.role] - Explicit role; omitted preserves text generation.\n * @param {import(\"./src/semantic/types.js\").IosApplicationConfigurationInput | import(\"./src/semantic/types.js\").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.\n * @param {import(\"./src/semantic/types.js\").IosApplicationAssetInput[] | import(\"./src/semantic/types.js\").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.\n * @param {import(\"./src/semantic/types.js\").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.\n * @returns {import(\"./src/semantic/types.js\").GeneratedArtifactSet} Complete generated set.\n */\nexport function generateProgramArtifactSet(input) {\n  return generateProgramArtifacts(input)\n}\n\n/**\n * Generates a deterministic artifact set for one semantic module.\n * @param {object} input - Artifact-set generation request.\n * @param {import(\"./src/semantic/types.js\").BackendLanguage} input.language - Registered target language or platform ID.\n * @param {import(\"./src/semantic/types.js\").SemanticModule} input.module - Semantic module.\n * @param {\"text\" | \"binary\" | \"application\"} [input.role] - Requested backend artifact role.\n * @param {string} [input.filename] - Safe output path for a text target.\n * @param {\"none\" | \"external\" | \"inline\"} [input.mapDirective] - JavaScript-family map directive.\n * @param {string} [input.sourceMapFilename] - External map filename.\n * @param {{filename: string, content: string, language?: import(\"./src/semantic/types.js\").SemanticLanguage}[]} [input.sources] - Original sources.\n * @param {import(\"./src/semantic/types.js\").IosApplicationConfigurationInput | import(\"./src/semantic/types.js\").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.\n * @param {import(\"./src/semantic/types.js\").IosApplicationAssetInput[] | import(\"./src/semantic/types.js\").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.\n * @param {import(\"./src/semantic/types.js\").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.\n * @returns {import(\"./src/semantic/types.js\").GeneratedArtifactSet} Complete generated set.\n */\nexport function generateArtifactSet(input) {\n  if (!input || typeof input != \"object\" || Array.isArray(input) || Object.getPrototypeOf(input) != Object.prototype) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_ARTIFACT_SET\",\n      language: \"artifact\",\n      message: \"Artifact-set generation requires a request object.\"\n    })\n  }\n  const {assets, configuration, filename, language, mapDirective, module, resources, role = \"text\", sourceMapFilename, sources} = input\n\n  if (typeof language != \"string\" || language.length == 0) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_ARTIFACT_SET\",\n      language: \"artifact\",\n      message: \"Artifact-set generation requires a non-empty string language or target ID.\"\n    })\n  }\n  if (typeof role != \"string\" || !artifactBackendRoles.has(role)) {\n    throw new SemantifoldDiagnostic({\n      code: \"INVALID_ARTIFACT_SET\",\n      language,\n      message: \"Artifact backend role must be 'text', 'binary', or 'application'.\"\n    })\n  }\n  const target = languageRegistry.record(language)\n  preflightEffectCapabilities(module, /** @type {import(\"./src/semantic/types.js\").BackendLanguage} */ (language))\n  const genericDeclaration = [...module?.records ?? [], ...module?.functions ?? []]\n    .find((declaration) => (declaration?.typeParameters?.length ?? 0) > 0)\n\n  if (genericDeclaration && !target.features.typeParametersAndGenerics) {\n    unsupportedCapability(/** @type {import(\"./src/semantic/types.js\").BackendLanguage} */ (language),\n      \"Task 012 type parameters and generics\", genericDeclaration.location ?? module.location)\n  }\n\n  if (Array.isArray(module?.records) && module.records.length > 0 && !target.features.closedRecords) {\n    unsupportedCapability(/** @type {import(\"./src/semantic/types.js\").BackendLanguage} */ (language),\n      \"Task 009 closed records\", module.records[0].location ?? module.location)\n  }\n\n  if (Array.isArray(module?.classes) && module.classes.length > 0 && !target.features.referenceClasses) {\n    unsupportedCapability(/** @type {import(\"./src/semantic/types.js\").BackendLanguage} */ (language),\n      \"Task 033 reference classes\", module.classes[0].location ?? module.location)\n  }\n  if (role == \"text\") {\n    if (target.artifactMultiplicity == \"multiple\") {\n      const backend = languageRegistry.resolve(language, \"textBackend\", module?.location)\n\n      return constructArtifactSet(backend({filename, language, mapDirective, module, sourceMapFilename, sources}))\n    }\n    const artifact = generateArtifactSource({\n      filename,\n      language: /** @type {import(\"./src/semantic/types.js\").SemanticLanguage} */ (language),\n      mapDirective,\n      module,\n      sourceMapFilename,\n      sources\n    })\n\n    /** @type {import(\"./src/semantic/types.js\").GeneratedSetArtifact[]} */\n    const artifacts = [{\n      content: artifact.code,\n      contentKind: \"text\",\n      mediaType: /** @type {string} */ (target.mediaType),\n      ownership: \"generated\",\n      path: artifact.filename,\n      provenance: {\n        kind: \"text\",\n        mapping: artifact.mapping,\n        sourceMap: artifact.sourceMap,\n        sourceMapFilename: artifact.sourceMapFilename\n      },\n      role: \"entry\"\n    }]\n\n    if (mapDirective == \"external\") {\n      artifacts.push({\n        content: `${JSON.stringify(artifact.sourceMap)}\\n`,\n        contentKind: \"text\",\n        mediaType: \"application/json\",\n        ownership: \"generated\",\n        path: artifact.sourceMapFilename,\n        provenance: {\n          kind: \"synthetic\",\n          reason: \"Serialized Source Map v3 projection for the generated entry artifact.\",\n          relatedOrigins: []\n        },\n        role: \"mapping\"\n      })\n    }\n\n    return constructArtifactSet({\n      artifacts,\n      ...(language == \"kotlin\" ? {metadata: kotlinArtifactMetadata} : {}),\n      target: language\n    })\n  }\n\n  const registryRole = role == \"binary\" ? \"binaryBackend\" : \"applicationBackend\"\n  const backend = languageRegistry.resolve(language, registryRole, module?.location)\n\n  return constructArtifactSet(backend(language == \"android\" ? input :\n    {assets, configuration, filename, language, mapDirective, module, resources, sourceMapFilename, sources}))\n}\n"]}