semantifold 0.8.0 → 0.10.0

package/README.md

@@ -1,8 +1,8 @@
 # Semantifold
 
-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).
+Task 044 proves the first packed JavaScript/JSDoc-to-Java watch workflow through Task 043's deterministic coordinator and Task 040's registry-driven check boundary. A credential-free consumer can keep `semantifold watch --check` running while edits regenerate Java and real `javac` commits coherent source/classes through one active pointer. Frontend or compiler failure retains the last good generation, a later valid edit recovers in the same process, and generated programs run only when acceptance code explicitly invokes real `java`. The package ships a [copy-ready watched project](examples/jsdoc-java-watch/).
 
-Semantifold is an early language-neutral semantic code toolkit. The source tree supports a deliberately small fifteen-language baseline: PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, Kotlin/JVM, strictly annotated Python, canonical C#, bounded Go, C17, C++20, Rust edition 2021, strict Swift, strict Dart VM/native, and strict Zig 0.15.2 source share one typed semantic representation. Browser WebAssembly is an additional target-only ID, not a sixteenth source language. The published baseline is `semantifold@0.7.0` / annotated `v0.7.0` at exact `gitHead` `8cd70c5a6c7de98df2d4a183d6555ad4f3d5ba5a`; it includes Task 028 Android, Task 030's bounded Android-qualified Flutter application target, and Task 031 Zig while retaining explicit iOS/macOS deferral. The planned [watch/build/check pipeline](docs/watch-build-pipeline.md) starts from this exact baseline; no product watch CLI exists yet.
+Semantifold is an early language-neutral semantic code toolkit. The source tree supports a deliberately small fifteen-language baseline: PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, Kotlin/JVM, strictly annotated Python, canonical C#, bounded Go, C17, C++20, Rust edition 2021, strict Swift, strict Dart VM/native, and strict Zig 0.15.2 source share one typed semantic representation. Browser WebAssembly is an additional target-only ID, not a sixteenth source language. Task 043 shipped through PR #58 at `40dcc86372929fb4747da08cd8e9d8226a32d88d`. The strict project manifest, one-shot and watched generation/publication CLI, generic non-executing check-plan contract, all fifteen text-target plans, deterministic watch coordinator, and packed JavaScript/JSDoc-to-Java vertical slice are implemented; only the terminal all-text-language matrix remains later watch/check work.
 
 ## Current API
 
@@ -45,9 +45,13 @@ Generated text output always uses LF. Exact original content, including LF, CRLF
 
 `generateArtifactSet` is the additive single-module artifact API. Original text targets return an entry artifact with the exact legacy bytes and rich/v3 mappings; an external JavaScript-family map directive also returns the referenced serialized mapping sidecar. C# returns mapped `Program.cs` then synthetic-provenance `Semantifold.csproj`. Go returns exactly two ordered artifacts: fixed synthetic-provenance `go.mod` first, then mapped `main.go`; the fixed module is `example.com/semantifold/generated` with `go 1.26.0` and creates no `go.sum`. C returns mapped `program.c` followed by synthetic `semantifold_runtime.h`. Rust returns synthetic `Cargo.toml`, synthetic Cargo-generated `Cargo.lock`, then mapped `src/main.rs`, with fixed edition 2021 and Rust/Cargo 1.98.1. Dart returns synthetic `pubspec.yaml`, synthetic deterministic `pubspec.lock`, then mapped sole-entry `bin/program.dart`. Zig returns synthetic `build.zig` then mapped sole-entry `src/main.zig`; Zig 0.15.2 needs no `build.zig.zon` for this dependency-free native-host project. Wasm binary/application generation returns `program.wasm`, `program.wasm.map`, `semantifold-loader.mjs`, then sole entry `index.html`, plus frozen `semantifold.browser.v1` ABI metadata. Because C#, Go, C, Rust, Dart, Zig, and Wasm are deliberately multi-artifact, `generate()` and `generateArtifact()` reject them with `UNSUPPORTED_ROLE`. Go accepts only an omitted filename or exact `main.go`, C accepts only omitted or exact `program.c`, Rust and Zig only omitted or exact `src/main.rs` and `src/main.zig` respectively, Dart only omitted or exact `bin/program.dart`, and Wasm only omitted or exact `program.wasm`; these multi-artifact backends reject unsupported mapping options rather than ignoring them. `createGeneratedArtifactSet` validates multi-file text, binary, mixed loader/binary, and application shapes transactionally: paths are ordered, unique, safe relative POSIX paths with no file/directory prefix collisions; content is explicitly text or bytes; media type, role, generated ownership, and provenance are required; exactly one artifact has role `entry`; and optional metadata is detached deeply frozen JSON. Binary content is held privately and returned as a fresh detached byte view on every read, so caller mutation cannot change validated bytes or their provenance. Generated helper files do not create semantic modules and are not Task 010 projects.
 
-Task 026 adds the target-only `ios` application backend through `generateArtifactSet({language: "ios", role: "application", ...})` and `generateProgramArtifactSet`. It lowers only the Task 022 Tasks 001–004 Swift subset, including Ruby-originating Task 010 projects, into deterministic captured semantic Swift, a synthetic SwiftUI shell, an unsigned Xcode project model, tests, exact assets, and a versioned ownership/provenance manifest with causal configuration spans and stable semantic-program identities. Artifact/resource paths use a closed portable ASCII alphabet while Unicode semantic source and generated text remain intact. Transactional create-only directory materialization remains deferred because Node's public filesystem API cannot provide both atomic no-replace directory publication and descriptor-relative no-follow operations without a separately authorized native boundary. Linux semantic execution and credential-free packed generation are implemented; real macOS/Xcode/Apple SDK/XCTest/XCUIAutomation/iOS Simulator acceptance is also deferred, so Task 026 is not delivered. See the [iOS application target](docs/ios.md).
+`GeneratedArtifactPublisher` persists a complete ordered set of those already-validated artifact sets beneath a dedicated publication directory inside one canonical project root. Every target declares a language-neutral role. The publisher stages immutable generation directories, validator/compiler outputs, complete provenance, SHA-256 hashes, a complete filesystem inventory, and a deterministic versioned manifest, then commits the project through one synchronized same-directory regular-file replacement of `active-generation.json`. `resolveActive()` reads that pointer once and returns generation-scoped source/build paths plus truthful pending-cleanup state; stale files disappear only when a new immutable generation is selected, while old committed generations and caller-owned files remain untouched. See [transactional generated-artifact publication](docs/generated-artifact-publication.md) for path constraints, validators, the manifest and pointer schemas, interruption recovery, reader obligations, diagnostics, and the explicit single-writer/retention boundaries.
 
-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 shared Gradle 8.14, 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).
+`semantifold build` and `semantifold watch` load `./semantifold.json` by default; `--project <path>` selects another manifest, `--ndjson` selects the machine protocol, and `--check` requires every selected target to own a registered non-executing developer-check plan. The strict manifest declares a project ID, one publisher-owned relative root, explicit ordered source modules with one entry, and explicit ordered target roles/projections. Ordinary operation still performs generation only. Registered plans cover all fifteen text targets: the interpreted/managed checks plus cgo-disabled Go build/vet, strict C/C++ compile/link, locked offline Cargo build/check, Swift type-check/compile, Dart offline package/format/analyze/native compile, and isolated Zig project build/format. Expensive native sanitizer/optimization and Zig multi-mode test profiles remain explicit CI acceptance rather than every-edit branches. Every command is an exact shell-free argv against a configured canonical tool; output, homes, caches, and intermediates stay within the candidate generation, transient state is removed after close, and only a fully successful candidate switches the single active pointer. Dart's absolute-source-URI-bearing native check binary is transient rather than published. The version-1 complete-program manifest still admits PHP, Ruby, JavaScript, TypeScript, and Java text targets; other plans apply to existing single-module artifact sets without expanding semantic program generation. Watch adds a real initial build, complete-graph content reconciliation, burst coalescing, native-file-event fallback polling, failure recovery, and owned signal shutdown without runtime execution. See [project manifest and one-shot build CLI](docs/project-build-cli.md) for the schema and check boundary, and [deterministic project watch](docs/project-watch.md) for watch lifecycle, events, reporting, and tuning.
+
+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. Task 026's independent create-only directory materializer 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; Task 038 can instead persist the already-validated set inside its generic immutable-generation/pointer contract. 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).
+
+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 shared Gradle 8.14, 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. Task 038 can persist the already-validated artifact set generically but adds no Android-specific build, emulator, or deployment policy. 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).
 
 Task 030 adds the application-only `flutter` target without making Flutter a source language. Any Task 010 project accepted by the Dart backend lowers to mapped namespaced Dart, an exact SDK-only stateless Material shell, and an owned Android Flutter project under `generated/flutter-app`. Flutter stable 3.47.4/Dart 3.13.3, the exact SDK-preloaded lockfile, assets, identities, versions, all paths/hashes, and rich provenance are deterministic; no `flutter create`, plugin, platform channel, permission, network/storage/background work, or external pub download participates. Offline real Flutter format/analyze/widget tests and Android build/UI acceptance reuse Task 028's one shared cache and two KVM boots. iOS artifacts and all macOS/Xcode/Apple SDK/CocoaPods/signing/Simulator claims remain explicitly deferred. See the [Flutter application target](docs/flutter.md).
 
@@ -57,7 +61,7 @@ Task 036 extends only this explicit program path with compiler-owned source-lang
 
 Binary/resource provenance uses `SemantifoldByteMapping` v1 through `createByteMapping`, `parseByteMapping`, and `stringifyByteMapping`. Generated ranges are ordered, non-overlapping, half-open byte offsets with semantic identities or explicit synthetic reasons. They are never interpreted as UTF-16 positions.
 
-`discoverCanonicalToolchain` and `discoverToolchain` resolve an exact executable from a configured absolute override or one unambiguous canonical PATH command and capture its version. `runAcceptanceStages` materializes a validated artifact set in a unique temporary directory and runs applicable `parse`, `generate`, `restore`, `compile`, `link`, `validate`, `instantiate`, and `execute` stages with exact argument arrays, a deterministic locale/timezone, bounded per-stage timeouts, captured output, no shell, and normalized stage diagnostics. The canonical overrides are `SEMANTIFOLD_DART`, `SEMANTIFOLD_ZIG`, `SEMANTIFOLD_PHP`, `SEMANTIFOLD_RUBY`, `SEMANTIFOLD_NODE`, `SEMANTIFOLD_TSC`, `SEMANTIFOLD_JAVAC`, `SEMANTIFOLD_JAVA`, `SEMANTIFOLD_KOTLINC`, `SEMANTIFOLD_PYTHON`, `SEMANTIFOLD_DOTNET`, `SEMANTIFOLD_GO`, `SEMANTIFOLD_CLANG`, `SEMANTIFOLD_CLANGPP`, `SEMANTIFOLD_RUSTC`, `SEMANTIFOLD_CARGO`, `SEMANTIFOLD_SWIFTC`, `SEMANTIFOLD_WASM_VALIDATE`, and `SEMANTIFOLD_CHROMIUM`; none of these APIs installs or downloads a tool. The generic `php` profile accepts PHP 8.x, while closed-record execution and the Task 037 PHP provider use the canonical `php82` profile (through the same `SEMANTIFOLD_PHP` override) to require PHP 8.2 or newer with core stream functions. Zig requires exact 0.15.2 on Linux x86-64; Dart requires exact SDK 3.13.3 stable on Linux x64, Kotlin exact 2.4.20 on pinned OpenJDK 25.0.4+7, and Swift exact 6.3.3 on Linux x86-64. Browser Wasm requires WABT 1.0.36 and Chrome/Chromium 152.0.7977.82 in addition to Node 24.
+`discoverCanonicalToolchain` and `discoverToolchain` resolve an exact executable from a configured absolute override or one unambiguous canonical PATH command and capture its version. `runAcceptanceStages` materializes a validated artifact set in a unique temporary directory and runs applicable `parse`, `generate`, `restore`, `compile`, `link`, `validate`, `instantiate`, and `execute` stages with exact argument arrays, a deterministic locale/timezone, bounded per-stage timeouts, captured output, no shell, and normalized stage diagnostics. The canonical overrides are `SEMANTIFOLD_DART`, `SEMANTIFOLD_ZIG`, `SEMANTIFOLD_PHP`, `SEMANTIFOLD_RUBY`, `SEMANTIFOLD_NODE`, `SEMANTIFOLD_TSC`, `SEMANTIFOLD_JAVAC`, `SEMANTIFOLD_JAVA`, `SEMANTIFOLD_KOTLINC`, `SEMANTIFOLD_PYTHON`, `SEMANTIFOLD_DOTNET`, `SEMANTIFOLD_GO`, `SEMANTIFOLD_CLANG`, `SEMANTIFOLD_CLANGPP`, `SEMANTIFOLD_RUSTC`, `SEMANTIFOLD_CARGO`, `SEMANTIFOLD_SWIFTC`, `SEMANTIFOLD_WASM_VALIDATE`, and `SEMANTIFOLD_CHROMIUM`; none of these APIs installs or downloads a tool. The generic `php` profile accepts PHP 8.x, while closed-record execution and the Task 037 PHP provider use the canonical `php82` profile (through the same `SEMANTIFOLD_PHP` override) to require PHP 8.2 or newer with core stream functions. Zig requires exact 0.15.2 on Linux x86-64; Dart requires exact SDK 3.13.3 stable on Linux x64, Kotlin exact 2.4.20 on pinned OpenJDK 25.0.4.1+1 development or 25.0.4+7 TensorBuzz profiles, 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 fifteen languages. PHP, Ruby, JavaScript with JSDoc, TypeScript, and Java implement Task 005 general required functions/calls, Task 006 recursive immutable lists/maps, Task 007 explicit optional values, Task 008 ordered list iteration, Task 009 closed records, Task 010 explicit semantic projects, Task 011 typed unchecked errors, Task 012 invariant unbounded type parameters and generic declarations/applications, Task 014 insertion-ordered immutable map iteration, Task 032 strict-Boolean condition-controlled loops, Task 033 bounded reference classes, and Task 034's bounded effect/resource profile. Dart and Zig implement Task 005 general required functions/calls but none of those later profiles. `OptionalType {valueType}` contains only semantic presence or absence; it composes recursively as a declared list element or map value, and access preserves that optional result. A strict presence test can prove one simple binding present inside exactly the corresponding branch. Ruby uses exact `T?` metadata and `nil?`, JavaScript/JSDoc uses exact `T|null`, TypeScript uses exact `T | null`, PHP uses canonical `?T`, and Java uses exact `java.util.Optional<T>`/`Optional<T>` operations. Arbitrary unions, nested optionals, implicit nullable/default parameters, `undefined`, truthiness, nullish defaults/navigation, Java bare `null`, and unchecked unwrap remain unsupported. Collection support covers homogeneous literals, zero-based list indexing, total string-key map lookup, size, recursive typing, function passage, exact ordered list `for-each`, and the separate `OrderedMapType` pair-iteration profile. Ordinary `MapType` remains unordered and non-iterable. Ordered maps accept unique nonnumeric string keys, evaluate entries left-to-right, and visit key/value pairs in first-insertion order; aliases, mutation, key-only/value-only loops, and unordered conversions fail loudly. Java lowers only safe local ordered literals through a private `LinkedHashMap` insertion sequence and a non-escaping `Collections.unmodifiableSequencedMap` boundary. Every list, ordered-map, and condition-controlled loop has a deterministic semantic identity; each `break` or `continue` resolves to the nearest enclosing identity and cannot cross a function boundary. Collection loops evaluate their operand once and bind values immutably in body-local scope. A condition-controlled loop evaluates an exact Boolean condition before every iteration and may execute zero times; no loop body by itself proves a non-void function complete. Any outer mutable binding assigned on a nested loop path loses its known-value and optional-presence facts before the relevant repeated condition or body validation and after loop exit, including assignment paths ending in `break`, `continue`, or `return`; unaffected bindings keep stable facts. Task 007 does not turn an unchecked missing-key lookup into an optional operation. PHPDoc distinguishes `list<T>` from `array<string,T>`; JavaScript objects are never maps. Immutability is the accepted semantic operation boundary, not a deep-freezing promise. The other eight source languages and browser Wasm remain on the Tasks 001–004 two-parameter/scalar-return profile and reject later-feature modules transactionally. See [language support](docs/language-support.md) before using it on other code.
 
@@ -133,6 +137,7 @@ The execution specs require PHP CLI, Ruby, Python 3, TypeScript, a Java JDK, Kot
 - [Goals](docs/goals.md)
 - [Architecture](docs/architecture.md)
 - [Watch, build, and target-check pipeline](docs/watch-build-pipeline.md)
+- [Deterministic project watch](docs/project-watch.md)
 - [Coding standards](docs/coding-standards.md)
 - [Language support](docs/language-support.md)
 - [Rust source and Cargo target](docs/rust.md)
@@ -147,6 +152,7 @@ The execution specs require PHP CLI, Ruby, Python 3, TypeScript, a Java JDK, Kot
 - [Parser qualification](docs/parser-qualification.md)
 - [Testing](docs/testing.md)
 - [Source provenance and mappings](docs/source-maps.md)
+- [Transactional generated-artifact publication](docs/generated-artifact-publication.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)

package/bin/semantifold.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// @ts-check
+
+import {SemantifoldCli} from "../index.js"
+
+process.exitCode = await new SemantifoldCli().run(process.argv.slice(2))

package/build/bin/semantifold.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=semantifold.d.ts.map

package/build/bin/semantifold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantifold.d.ts","sourceRoot":"","sources":["../../bin/semantifold.js"],"names":[],"mappings":""}

package/build/bin/semantifold.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-check
+import { SemantifoldCli } from "../index.js";
+process.exitCode = await new SemantifoldCli().run(process.argv.slice(2));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VtYW50aWZvbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9iaW4vc2VtYW50aWZvbGQuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLFlBQVk7QUFFWixPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sYUFBYSxDQUFBO0FBRTFDLE9BQU8sQ0FBQyxRQUFRLEdBQUcsTUFBTSxJQUFJLGNBQWMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiIyEvdXNyL2Jpbi9lbnYgbm9kZVxuLy8gQHRzLWNoZWNrXG5cbmltcG9ydCB7U2VtYW50aWZvbGRDbGl9IGZyb20gXCIuLi9pbmRleC5qc1wiXG5cbnByb2Nlc3MuZXhpdENvZGUgPSBhd2FpdCBuZXcgU2VtYW50aWZvbGRDbGkoKS5ydW4ocHJvY2Vzcy5hcmd2LnNsaWNlKDIpKVxuIl19

package/build/index.d.ts

@@ -3,6 +3,15 @@ export { SemantifoldDiagnostic };
 export { createCapabilityAuthority } from "./src/semantic/capabilities.js";
 export { languageCapabilities, supportedLanguages } from "./src/language-registry.js";
 export { createGeneratedArtifactSet } from "./src/artifacts.js";
+export { GeneratedArtifactPublisher } from "./src/publication.js";
+export { ProjectManifestLoader, SemantifoldProject } from "./src/project-manifest.js";
+export { ProjectSnapshot, ProjectSnapshotBuilder } from "./src/project-snapshot.js";
+export { ProjectBuilder } from "./src/project-build.js";
+export { parseSemantifoldCliArguments, SemantifoldCli } from "./src/project-cli.js";
+export { ProjectBuildReporter } from "./src/project-reporter.js";
+export { ProjectWatchCoordinator } from "./src/project-watch.js";
+export { ProjectWatchReporter } from "./src/project-watch-reporter.js";
+export { createTargetCheckPlan, TargetCheckRunner } from "./src/target-check.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";

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"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"}

package/build/index.js

@@ -13,6 +13,15 @@ export { SemantifoldDiagnostic };
 export { createCapabilityAuthority } from "./src/semantic/capabilities.js";
 export { languageCapabilities, supportedLanguages } from "./src/language-registry.js";
 export { createGeneratedArtifactSet } from "./src/artifacts.js";
+export { GeneratedArtifactPublisher } from "./src/publication.js";
+export { ProjectManifestLoader, SemantifoldProject } from "./src/project-manifest.js";
+export { ProjectSnapshot, ProjectSnapshotBuilder } from "./src/project-snapshot.js";
+export { ProjectBuilder } from "./src/project-build.js";
+export { parseSemantifoldCliArguments, SemantifoldCli } from "./src/project-cli.js";
+export { ProjectBuildReporter } from "./src/project-reporter.js";
+export { ProjectWatchCoordinator } from "./src/project-watch.js";
+export { ProjectWatchReporter } from "./src/project-watch-reporter.js";
+export { createTargetCheckPlan, TargetCheckRunner } from "./src/target-check.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";
@@ -189,4 +198,4 @@ export function generateArtifactSet(input) {
     return constructArtifactSet(backend(language == "android" || language == "flutter" ? 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 {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 | import(\"./src/semantic/types.js\").FlutterApplicationConfigurationInput} [input.configuration] - Application configuration.\n * @param {import(\"./src/semantic/types.js\").IosApplicationAssetInput[] | import(\"./src/semantic/types.js\").AndroidApplicationInputFile[] | import(\"./src/semantic/types.js\").FlutterApplicationAssetInput[]} [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 | import(\"./src/semantic/types.js\").FlutterApplicationConfigurationInput} [input.configuration] - Application configuration.\n * @param {import(\"./src/semantic/types.js\").IosApplicationAssetInput[] | import(\"./src/semantic/types.js\").AndroidApplicationInputFile[] | import(\"./src/semantic/types.js\").FlutterApplicationAssetInput[]} [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\" || language == \"flutter\" ? input :\n    {assets, configuration, filename, language, mapDirective, module, resources, sourceMapFilename, 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 {GeneratedArtifactPublisher} from \"./src/publication.js\"\nexport {ProjectManifestLoader, SemantifoldProject} from \"./src/project-manifest.js\"\nexport {ProjectSnapshot, ProjectSnapshotBuilder} from \"./src/project-snapshot.js\"\nexport {ProjectBuilder} from \"./src/project-build.js\"\nexport {parseSemantifoldCliArguments, SemantifoldCli} from \"./src/project-cli.js\"\nexport {ProjectBuildReporter} from \"./src/project-reporter.js\"\nexport {ProjectWatchCoordinator} from \"./src/project-watch.js\"\nexport {ProjectWatchReporter} from \"./src/project-watch-reporter.js\"\nexport {createTargetCheckPlan, TargetCheckRunner} from \"./src/target-check.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 | import(\"./src/semantic/types.js\").FlutterApplicationConfigurationInput} [input.configuration] - Application configuration.\n * @param {import(\"./src/semantic/types.js\").IosApplicationAssetInput[] | import(\"./src/semantic/types.js\").AndroidApplicationInputFile[] | import(\"./src/semantic/types.js\").FlutterApplicationAssetInput[]} [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 | import(\"./src/semantic/types.js\").FlutterApplicationConfigurationInput} [input.configuration] - Application configuration.\n * @param {import(\"./src/semantic/types.js\").IosApplicationAssetInput[] | import(\"./src/semantic/types.js\").AndroidApplicationInputFile[] | import(\"./src/semantic/types.js\").FlutterApplicationAssetInput[]} [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\" || language == \"flutter\" ? input :\n    {assets, configuration, filename, language, mapDirective, module, resources, sourceMapFilename, sources}))\n}\n"]}

package/build/src/artifact-path.d.ts

@@ -22,6 +22,12 @@ export declare function isSafeArtifactPath(value: unknown): value is string;
  * @returns {string} Complete ASCII case-fold key.
  */
 export declare function portableArtifactPathKey(value: string): string;
+/**
+ * Produces a deterministic case-fold comparison key for a validated source path.
+ * @param {string} value - Safe relative POSIX source path.
+ * @returns {string} Unicode case-fold comparison key.
+ */
+export declare function portableSourcePathKey(value: string): string;
 /**
  * Finds the first unsafe, duplicate, portable case-fold, or file/directory-prefix conflict.
  * @param {readonly string[]} paths - Ordered candidate artifact paths.
@@ -32,4 +38,14 @@ export declare function findPortableArtifactPathConflict(paths: readonly string[
     path: string;
     other?: string;
 } | null;
+/**
+ * Finds the first unsafe, duplicate, portable case-fold, or file/directory-prefix source conflict.
+ * @param {readonly string[]} paths - Ordered candidate source paths.
+ * @returns {{kind: "case-fold" | "duplicate" | "prefix" | "unsafe", path: string, other?: string} | null} First conflict.
+ */
+export declare function findPortableSourcePathConflict(paths: readonly string[]): {
+    kind: "case-fold" | "duplicate" | "prefix" | "unsafe";
+    path: string;
+    other?: string;
+} | null;
 //# sourceMappingURL=artifact-path.d.ts.map

package/build/src/artifact-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifact-path.d.ts","sourceRoot":"","sources":["../../src/artifact-path.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAHlC,OAGkC,GAFhC,KAAK,IAAI,MAAM,CAI3B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAH3B,OAG2B,GAFzB,KAAK,IAAI,MAAM,CAe3B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAH7B,OAG6B,GAF3B,KAAK,IAAI,MAAM,CAI3B;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAHlC,MAGkC,GAFhC,MAAM,CAIlB;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAH3C,SAAS,MAAM,EAG4B,GAFzC;IAAC,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAqBxG"}
+{"version":3,"file":"artifact-path.d.ts","sourceRoot":"","sources":["../../src/artifact-path.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAHlC,OAGkC,GAFhC,KAAK,IAAI,MAAM,CAI3B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAH3B,OAG2B,GAFzB,KAAK,IAAI,MAAM,CAe3B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAH7B,OAG6B,GAF3B,KAAK,IAAI,MAAM,CAI3B;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAHlC,MAGkC,GAFhC,MAAM,CAIlB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAHhC,MAGgC,GAF9B,MAAM,CAIlB;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAH3C,SAAS,MAAM,EAG4B,GAFzC;IAAC,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAIxG;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAHzC,SAAS,MAAM,EAG0B,GAFvC;IAAC,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAIxG"}

package/build/src/artifact-path.js

@@ -44,18 +44,44 @@ export function isSafeArtifactPath(value) {
 export function portableArtifactPathKey(value) {
     return value.toLowerCase();
 }
+/**
+ * Produces a deterministic case-fold comparison key for a validated source path.
+ * @param {string} value - Safe relative POSIX source path.
+ * @returns {string} Unicode case-fold comparison key.
+ */
+export function portableSourcePathKey(value) {
+    return value.toLowerCase();
+}
 /**
  * Finds the first unsafe, duplicate, portable case-fold, or file/directory-prefix conflict.
  * @param {readonly string[]} paths - Ordered candidate artifact paths.
  * @returns {{kind: "case-fold" | "duplicate" | "prefix" | "unsafe", path: string, other?: string} | null} First conflict.
  */
 export function findPortableArtifactPathConflict(paths) {
+    return findPortablePathConflict(paths, isSafeArtifactPath, portableArtifactPathKey);
+}
+/**
+ * Finds the first unsafe, duplicate, portable case-fold, or file/directory-prefix source conflict.
+ * @param {readonly string[]} paths - Ordered candidate source paths.
+ * @returns {{kind: "case-fold" | "duplicate" | "prefix" | "unsafe", path: string, other?: string} | null} First conflict.
+ */
+export function findPortableSourcePathConflict(paths) {
+    return findPortablePathConflict(paths, isSafeSourcePath, portableSourcePathKey);
+}
+/**
+ * Compares paths inside one explicitly selected validation domain.
+ * @param {readonly string[]} paths - Ordered candidate paths.
+ * @param {(value: unknown) => boolean} isSafe - Domain-specific path validator.
+ * @param {(value: string) => string} comparisonKey - Domain-specific portable comparison key.
+ * @returns {{kind: "case-fold" | "duplicate" | "prefix" | "unsafe", path: string, other?: string} | null} First conflict.
+ */
+function findPortablePathConflict(paths, isSafe, comparisonKey) {
     /** @type {{key: string, path: string}[]} */
     const accepted = [];
     for (const path of paths) {
-        if (!isSafeArtifactPath(path))
+        if (!isSafe(path))
             return { kind: "unsafe", path: String(path) };
-        const key = portableArtifactPathKey(path);
+        const key = comparisonKey(path);
         for (const previous of accepted) {
             if (path == previous.path)
                 return { kind: "duplicate", other: previous.path, path };
@@ -69,4 +95,4 @@ export function findPortableArtifactPathConflict(paths) {
     }
     return null;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"artifact-path.js","sourceRoot":"","sources":["../../src/artifact-path.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {hasOnlyUnicodeScalars} from \"./semantic/scalars.js\"\n\nconst lineTerminatorPattern = /[\\n\\r\\u2028\\u2029]/u\nconst portableArtifactComponentPattern = /^[A-Za-z0-9._-]+$/u\n\n/**\n * Validates filename metadata without imposing artifact-set path semantics.\n * @param {unknown} value - Candidate filename.\n * @returns {value is string} Whether the value is a non-empty single-line string.\n */\nexport function isValidFilenameMetadata(value) {\n  return typeof value == \"string\" && value.length > 0 && !lineTerminatorPattern.test(value)\n}\n\n/**\n * Validates a safe relative POSIX source path while retaining Unicode filename metadata.\n * @param {unknown} value - Candidate path.\n * @returns {value is string} Whether the value is safe.\n */\nexport function isSafeSourcePath(value) {\n  if (typeof value != \"string\" || value.length == 0 || value.includes(\"\\\\\") || value.includes(\"\\0\") ||\n    !hasOnlyUnicodeScalars(value)) return false\n  if (value.startsWith(\"/\") || /^[A-Za-z]:/u.test(value)) return false\n\n  const parts = value.split(\"/\")\n\n  return parts.every((part) => part.length > 0 && part != \".\" && part != \"..\" &&\n    [...part].every((character) => {\n      const codePoint = character.codePointAt(0)\n\n      return codePoint != undefined && codePoint > 31 && codePoint != 127\n    }))\n}\n\n/**\n * Validates a safe portable artifact/resource path in the closed ASCII comparison domain.\n * @param {unknown} value - Candidate path.\n * @returns {value is string} Whether the value is safe and portably comparable.\n */\nexport function isSafeArtifactPath(value) {\n  return isSafeSourcePath(value) && value.split(\"/\").every(part => portableArtifactComponentPattern.test(part))\n}\n\n/**\n * Produces a conservative portable comparison key for a validated artifact path.\n * @param {string} value - Safe relative POSIX path.\n * @returns {string} Complete ASCII case-fold key.\n */\nexport function portableArtifactPathKey(value) {\n  return value.toLowerCase()\n}\n\n/**\n * Produces a deterministic case-fold comparison key for a validated source path.\n * @param {string} value - Safe relative POSIX source path.\n * @returns {string} Unicode case-fold comparison key.\n */\nexport function portableSourcePathKey(value) {\n  return value.toLowerCase()\n}\n\n/**\n * Finds the first unsafe, duplicate, portable case-fold, or file/directory-prefix conflict.\n * @param {readonly string[]} paths - Ordered candidate artifact paths.\n * @returns {{kind: \"case-fold\" | \"duplicate\" | \"prefix\" | \"unsafe\", path: string, other?: string} | null} First conflict.\n */\nexport function findPortableArtifactPathConflict(paths) {\n  return findPortablePathConflict(paths, isSafeArtifactPath, portableArtifactPathKey)\n}\n\n/**\n * Finds the first unsafe, duplicate, portable case-fold, or file/directory-prefix source conflict.\n * @param {readonly string[]} paths - Ordered candidate source paths.\n * @returns {{kind: \"case-fold\" | \"duplicate\" | \"prefix\" | \"unsafe\", path: string, other?: string} | null} First conflict.\n */\nexport function findPortableSourcePathConflict(paths) {\n  return findPortablePathConflict(paths, isSafeSourcePath, portableSourcePathKey)\n}\n\n/**\n * Compares paths inside one explicitly selected validation domain.\n * @param {readonly string[]} paths - Ordered candidate paths.\n * @param {(value: unknown) => boolean} isSafe - Domain-specific path validator.\n * @param {(value: string) => string} comparisonKey - Domain-specific portable comparison key.\n * @returns {{kind: \"case-fold\" | \"duplicate\" | \"prefix\" | \"unsafe\", path: string, other?: string} | null} First conflict.\n */\nfunction findPortablePathConflict(paths, isSafe, comparisonKey) {\n  /** @type {{key: string, path: string}[]} */\n  const accepted = []\n\n  for (const path of paths) {\n    if (!isSafe(path)) return {kind: \"unsafe\", path: String(path)}\n    const key = comparisonKey(path)\n\n    for (const previous of accepted) {\n      if (path == previous.path) return {kind: \"duplicate\", other: previous.path, path}\n      if (key == previous.key) return {kind: \"case-fold\", other: previous.path, path}\n      if (key.startsWith(`${previous.key}/`) || previous.key.startsWith(`${key}/`)) {\n        return {kind: \"prefix\", other: previous.path, path}\n      }\n    }\n    accepted.push({key, path})\n  }\n\n  return null\n}\n"]}

package/build/src/backends/c-check.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Constructs C's strict Clang C17 compile/link plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable C plan.
+ */
+export declare function createCCheckPlan(context: import("../language-registry.js").TargetCheckPlanContext): import("../semantic/types.js").TargetCheckPlan;
+//# sourceMappingURL=c-check.d.ts.map

package/build/src/backends/c-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c-check.d.ts","sourceRoot":"","sources":["../../../src/backends/c-check.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAH7B,OAAO,yBAAyB,EAAE,sBAGL,GAF3B,OAAO,sBAAsB,EAAE,eAAe,CAuD1D"}

package/build/src/backends/c-check.js

@@ -0,0 +1,65 @@
+// @ts-check
+import path from "node:path";
+import { SemantifoldDiagnostic } from "../diagnostic.js";
+import { checkArtifacts, checkOutput, checkPlan, checkStage, checkTool, environmentPath, pathArgument } from "./check-plan.js";
+import { cRuntimeHeader } from "./c-runtime.js";
+const compilerFlags = Object.freeze([
+    "--no-default-config", "-std=c17", "-Wall", "-Wextra", "-Werror", "-pedantic-errors", "-Wconversion",
+    "-Wsign-conversion", "-Wshadow", "-Wstrict-prototypes", "-Wmissing-prototypes", "-Wformat=2", "-ftrapv",
+    "-finput-charset=UTF-8", "-fexec-charset=UTF-8", "-fno-color-diagnostics", "-O0"
+]);
+/**
+ * Constructs C's strict Clang C17 compile/link plan.
+ * @param {import("../language-registry.js").TargetCheckPlanContext} context - Validated candidate context.
+ * @returns {import("../semantic/types.js").TargetCheckPlan} Immutable C plan.
+ */
+export function createCCheckPlan(context) {
+    const tool = checkTool(context, "clang", "c");
+    const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(".c") || artifact.path.endsWith(".h"), "c", "only staged C translation units and headers");
+    const sources = artifacts.filter(artifact => artifact.endsWith(".c"));
+    const headers = artifacts.filter(artifact => artifact.endsWith(".h"));
+    const support = context.artifacts.artifacts.filter(artifact => artifact.path == "semantifold_runtime.h");
+    if (artifacts.length != 2 || sources.length != 1 || sources[0] != path.join(context.sourcePath, "program.c") ||
+        headers.length != 1 || support.length != 1 || support[0].contentKind != "text" || support[0].role != "support" ||
+        support[0].content != cRuntimeHeader) {
+        throw new SemantifoldDiagnostic({ code: "INVALID_TARGET_CHECK_PLAN", language: "c",
+            message: "C developer checks require the exact producer-owned translation unit and support header." });
+    }
+    const objects = path.join(context.buildPath, "objects");
+    const temporary = path.join(context.buildPath, "tmp");
+    const environment = { TMPDIR: temporary };
+    const environmentPaths = [environmentPath("TMPDIR", "build")];
+    const objectPaths = sources.map((_, index) => path.join(objects, `${String(index).padStart(6, "0")}.o`));
+    const stages = sources.map((source, index) => {
+        const argv = [...compilerFlags, "-c", source, "-o", objectPaths[index]];
+        return checkStage({
+            argv,
+            cwd: context.sourcePath,
+            environment,
+            environmentPaths,
+            inputs: [source, ...headers],
+            output: null,
+            pathArguments: [pathArgument(argv.length - 3, "source"), pathArgument(argv.length - 1, "build")],
+            stage: /** @type {const} */ ("compile"),
+            tool,
+            transientPaths: [objects]
+        });
+    });
+    const binary = path.join(context.buildPath, "semantifold-c");
+    const linkArgv = ["--no-default-config", "-O0", ...objectPaths, "-o", binary];
+    stages.push(checkStage({
+        argv: linkArgv,
+        cwd: context.sourcePath,
+        environment,
+        environmentPaths,
+        inputs: objectPaths,
+        output: checkOutput(context.buildPath, "application/x-executable", "linker-output"),
+        pathArguments: [...objectPaths.map((_, index) => pathArgument(index + 2, "build")),
+            pathArgument(linkArgv.length - 1, "build")],
+        stage: "link",
+        tool,
+        transientPaths: [objects]
+    }));
+    return checkPlan(context, "c", artifacts, stages);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"c-check.js","sourceRoot":"","sources":["../../../src/backends/c-check.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"node:path\"\nimport {SemantifoldDiagnostic} from \"../diagnostic.js\"\nimport {\n  checkArtifacts,\n  checkOutput,\n  checkPlan,\n  checkStage,\n  checkTool,\n  environmentPath,\n  pathArgument\n} from \"./check-plan.js\"\nimport {cRuntimeHeader} from \"./c-runtime.js\"\n\nconst compilerFlags = Object.freeze([\n  \"--no-default-config\", \"-std=c17\", \"-Wall\", \"-Wextra\", \"-Werror\", \"-pedantic-errors\", \"-Wconversion\",\n  \"-Wsign-conversion\", \"-Wshadow\", \"-Wstrict-prototypes\", \"-Wmissing-prototypes\", \"-Wformat=2\", \"-ftrapv\",\n  \"-finput-charset=UTF-8\", \"-fexec-charset=UTF-8\", \"-fno-color-diagnostics\", \"-O0\"\n])\n\n/**\n * Constructs C's strict Clang C17 compile/link plan.\n * @param {import(\"../language-registry.js\").TargetCheckPlanContext} context - Validated candidate context.\n * @returns {import(\"../semantic/types.js\").TargetCheckPlan} Immutable C plan.\n */\nexport function createCCheckPlan(context) {\n  const tool = checkTool(context, \"clang\", \"c\")\n  const artifacts = checkArtifacts(context, artifact => artifact.path.endsWith(\".c\") || artifact.path.endsWith(\".h\"),\n    \"c\", \"only staged C translation units and headers\")\n  const sources = artifacts.filter(artifact => artifact.endsWith(\".c\"))\n  const headers = artifacts.filter(artifact => artifact.endsWith(\".h\"))\n  const support = context.artifacts.artifacts.filter(artifact => artifact.path == \"semantifold_runtime.h\")\n\n  if (artifacts.length != 2 || sources.length != 1 || sources[0] != path.join(context.sourcePath, \"program.c\") ||\n    headers.length != 1 || support.length != 1 || support[0].contentKind != \"text\" || support[0].role != \"support\" ||\n    support[0].content != cRuntimeHeader) {\n    throw new SemantifoldDiagnostic({code: \"INVALID_TARGET_CHECK_PLAN\", language: \"c\",\n      message: \"C developer checks require the exact producer-owned translation unit and support header.\"})\n  }\n  const objects = path.join(context.buildPath, \"objects\")\n  const temporary = path.join(context.buildPath, \"tmp\")\n  const environment = {TMPDIR: temporary}\n  const environmentPaths = [environmentPath(\"TMPDIR\", \"build\")]\n  const objectPaths = sources.map((_, index) => path.join(objects, `${String(index).padStart(6, \"0\")}.o`))\n  const stages = sources.map((source, index) => {\n    const argv = [...compilerFlags, \"-c\", source, \"-o\", objectPaths[index]]\n\n    return checkStage({\n      argv,\n      cwd: context.sourcePath,\n      environment,\n      environmentPaths,\n      inputs: [source, ...headers],\n      output: null,\n      pathArguments: [pathArgument(argv.length - 3, \"source\"), pathArgument(argv.length - 1, \"build\")],\n      stage: /** @type {const} */ (\"compile\"),\n      tool,\n      transientPaths: [objects]\n    })\n  })\n  const binary = path.join(context.buildPath, \"semantifold-c\")\n  const linkArgv = [\"--no-default-config\", \"-O0\", ...objectPaths, \"-o\", binary]\n\n  stages.push(checkStage({\n    argv: linkArgv,\n    cwd: context.sourcePath,\n    environment,\n    environmentPaths,\n    inputs: objectPaths,\n    output: checkOutput(context.buildPath, \"application/x-executable\", \"linker-output\"),\n    pathArguments: [...objectPaths.map((_, index) => pathArgument(index + 2, \"build\")),\n      pathArgument(linkArgv.length - 1, \"build\")],\n    stage: \"link\",\n    tool,\n    transientPaths: [objects]\n  }))\n\n  return checkPlan(context, \"c\", artifacts, stages)\n}\n"]}