semantifold 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,8 @@
 # Semantifold
 
-Semantifold is an early language-neutral semantic code toolkit. This first release candidate proves a deliberately small end-to-end slice: parse equivalent PHP, Ruby, JavaScript with JSDoc, TypeScript, Java, and strictly annotated Python programs into one typed semantic representation, then generate and genuinely execute equivalent programs in every target language.
+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.
+
+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.
 
 ## Current API
 
@@ -22,7 +24,7 @@ const module = parse({
 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. `generateArtifact` adds an output filename, an authoritative range-based `SemantifoldMapping` v1, and a Source Map v3 sidecar for every target:
+`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:
 
 ```js
 import {generateArtifact, originalPositionFor} from "semantifold"
@@ -31,37 +33,58 @@ 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, and Python use the same rich/v3 sidecars without foreign comments. See [source provenance and mappings](docs/source-maps.md) for schemas, lookups, composition, diagnostics, directives, and compatibility.
+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.
 
-`supportedLanguages` is the immutable registry-derived list `php`, `ruby`, `javascript`, `typescript`, `java`, and `python`. `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`.
+`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`.
 
-`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. `createGeneratedArtifactSet` validates future 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.
+`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.
 
 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`, `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`, and `SEMANTIFOLD_PYTHON`; none of these APIs installs or downloads a tool.
+`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`.
+
+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.
+
+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.
+
+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
 
-This is not general-purpose support for any of the six 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.
+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.
 
-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`; general runtime-overflow equivalence remains outside the portable contract. 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 on parameters, returns, and initialized locals, treats `bool` and `int` as distinct, and rejects dynamic forms; its exact adjacent `# @semantifold-immutable` carrier preserves immutable-local intent. 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.
+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).
 
 ## 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`; run the framework-native `spec` directory discovery with `npm test`.
+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.
 
-The complete local gate is:
+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.
+
+The local quality/package gate follows the named focused specs documented in [testing](docs/testing.md):
 
 ```sh
-npm test
+export LANG=C.UTF-8
+export LC_ALL=C.UTF-8
+npm run verify:legacy-runtime
+npx velocious-test spec/repository-contract.spec.js
 npm run lint
 npm run typecheck
 npm run build
 npm audit --audit-level=high
 npm ls --omit=dev --all
+npm ls --all
 npm pack --dry-run --json
+git diff --check
 ```
 
-The execution specs require PHP CLI, Ruby, Python 3, TypeScript, and a Java JDK 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 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.
+
+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.
+
+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.
 
 ## Documentation
 
@@ -72,6 +95,8 @@ The execution specs require PHP CLI, Ruby, Python 3, TypeScript, and a Java JDK
 - [Parser qualification](docs/parser-qualification.md)
 - [Testing](docs/testing.md)
 - [Source provenance and mappings](docs/source-maps.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)
 - [Initial toolchain plan](docs/plans/2026-09-02-initial-toolchain.md)
 

package/build/index.js

@@ -88,7 +88,7 @@ export function generateArtifactSet(input) {
         const record = languageRegistry.record(language);
         if (record.artifactMultiplicity == "multiple") {
             const backend = languageRegistry.resolve(language, "textBackend", module?.location);
-            return constructArtifactSet(backend({ filename, language, module, sources }));
+            return constructArtifactSet(backend({ filename, language, mapDirective, module, sourceMapFilename, sources }));
         }
         const artifact = generateArtifactSource({
             filename,
@@ -137,4 +137,4 @@ export function generateArtifactSet(input) {
     const backend = languageRegistry.resolve(language, registryRole, module?.location);
     return constructArtifactSet(backend({ filename, language, module, 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, module, 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 {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"]}

package/build/src/acceptance.d.ts

@@ -1,3 +1,4 @@
+import { rm } from "node:fs/promises";
 /**
  * Materializes one artifact set and runs ordered acceptance stages without a shell.
  * @param {object} input - Acceptance request.
@@ -19,4 +20,13 @@ export declare function runAcceptanceStages(input: {
     target: string;
     timeoutMs?: number;
 }): Promise<import("./semantic/types.js").AcceptanceResult>;
+/**
+ * Creates an acceptance runner with instance-owned cleanup behavior.
+ * @param {object} dependencies - Internal runner dependencies.
+ * @param {typeof rm} dependencies.removeDirectory - Isolated-directory removal operation.
+ * @returns {typeof runAcceptanceStages} Acceptance runner.
+ */
+export declare function createAcceptanceRunner({ removeDirectory }: {
+    removeDirectory: typeof rm;
+}): typeof runAcceptanceStages;
 //# sourceMappingURL=acceptance.d.ts.map

package/build/src/acceptance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../../src/acceptance.js"],"names":[],"mappings":"AAmBA;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAP5C;IAAkE,SAAS,EAAnE,OAAO,qBAAqB,EAAE,oBAAoB,CAC1D;IAA6D,WAAW,AAAxE,CACA,EADQ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CACpD;IAAsJ,MAAM,EAApJ;QAAC,SAAS,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,OAAO,qBAAqB,EAAE,eAAe,CAAC;QAAC,IAAI,EAAE,OAAO,qBAAqB,EAAE,mBAAmB,CAAA;KAAC,EAAE,CAC9I;IAAsB,MAAM,EAApB,MAAM,CACd;IAAuB,SAAS,AAAhC,CACA,EADQ,MAAM,CACd;CAE4C,GAFlC,OAAO,CAAC,OAAO,qBAAqB,EAAE,gBAAgB,CAAC,CAwEnE"}
+{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../../src/acceptance.js"],"names":[],"mappings":"AAEA,OAAO,EAAiB,EAAE,EAAY,MAAM,kBAAkB,CAAA;AAiB9D;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAP5C;IAAkE,SAAS,EAAnE,OAAO,qBAAqB,EAAE,oBAAoB,CAC1D;IAA6D,WAAW,AAAxE,CACA,EADQ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CACpD;IAAsJ,MAAM,EAApJ;QAAC,SAAS,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,OAAO,qBAAqB,EAAE,eAAe,CAAC;QAAC,IAAI,EAAE,OAAO,qBAAqB,EAAE,mBAAmB,CAAA;KAAC,EAAE,CAC9I;IAAsB,MAAM,EAApB,MAAM,CACd;IAAuB,SAAS,AAAhC,CACA,EADQ,MAAM,CACd;CAE4C,GAFlC,OAAO,CAAC,OAAO,qBAAqB,EAAE,gBAAgB,CAAC,CAInE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,EAAC,eAAe,EAAC,EAHrD;IAAgC,eAAe,EAAvC,OAAO,EAAE,CACjB;CAEqD,GAF3C,OAAO,mBAAmB,CAItC"}

package/build/src/acceptance.js

@@ -12,7 +12,7 @@ const acceptanceMaxBuffer = 16 * 1024 * 1024;
 const launchErrorCodes = new Set([
     "E2BIG", "EACCES", "EAGAIN", "ELOOP", "EMFILE", "ENAMETOOLONG", "ENFILE", "ENOENT", "ENOEXEC", "ENOMEM", "ENOTDIR", "ENOTSUP", "EPERM", "ETXTBSY"
 ]);
-const orderedStages = Object.freeze(["parse", "generate", "compile", "link", "validate", "instantiate", "execute"]);
+const orderedStages = Object.freeze(["parse", "generate", "restore", "compile", "link", "validate", "instantiate", "execute"]);
 const stageIndexes = new Map(orderedStages.map((stage, index) => [stage, index]));
 /**
  * Materializes one artifact set and runs ordered acceptance stages without a shell.
@@ -25,6 +25,24 @@ const stageIndexes = new Map(orderedStages.map((stage, index) => [stage, index])
  * @returns {Promise<import("./semantic/types.js").AcceptanceResult>} Captured results after cleanup.
  */
 export async function runAcceptanceStages(input) {
+    return await runAcceptanceStagesWithDependencies(input, rm);
+}
+/**
+ * Creates an acceptance runner with instance-owned cleanup behavior.
+ * @param {object} dependencies - Internal runner dependencies.
+ * @param {typeof rm} dependencies.removeDirectory - Isolated-directory removal operation.
+ * @returns {typeof runAcceptanceStages} Acceptance runner.
+ */
+export function createAcceptanceRunner({ removeDirectory }) {
+    return async (input) => await runAcceptanceStagesWithDependencies(input, removeDirectory);
+}
+/**
+ * Runs acceptance with exact instance-owned dependencies.
+ * @param {Parameters<typeof runAcceptanceStages>[0]} input - Acceptance request.
+ * @param {typeof rm} removeDirectory - Isolated-directory removal operation.
+ * @returns {ReturnType<typeof runAcceptanceStages>} Captured results after cleanup.
+ */
+async function runAcceptanceStagesWithDependencies(input, removeDirectory) {
     if (!isPlainObject(input))
         invalidRunner("Acceptance requires a request object.", "acceptance");
     const artifacts = /** @type {import("./semantic/types.js").GeneratedArtifactSet} */ (input.artifacts);
@@ -76,7 +94,7 @@ export async function runAcceptanceStages(input) {
     let cleanupFailure;
     let cleanupFailed = false;
     try {
-        await removeAcceptanceDirectory(directory, request.target);
+        await removeAcceptanceDirectory(directory, request.target, removeDirectory);
     }
     catch (error) {
         cleanupFailed = true;
@@ -279,11 +297,12 @@ function isPlainObject(value) {
  * Removes the isolated acceptance directory with a normalized failure.
  * @param {string} directory - Exact temporary directory.
  * @param {string} target - Acceptance target.
+ * @param {typeof rm} removeDirectory - Instance-owned removal operation.
  * @returns {Promise<void>} Cleanup completion.
  */
-async function removeAcceptanceDirectory(directory, target) {
+async function removeAcceptanceDirectory(directory, target, removeDirectory) {
     try {
-        await rm(directory, { force: true, recursive: true });
+        await removeDirectory(directory, { force: true, recursive: true });
     }
     catch (error) {
         throw new SemantifoldDiagnostic({
@@ -336,4 +355,4 @@ async function materializeArtifacts(artifacts, directory, target) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"acceptance.js","sourceRoot":"","sources":["../../src/acceptance.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {mkdir, mkdtemp, rm, writeFile} from \"node:fs/promises\"\nimport os from \"node:os\"\nimport path from \"node:path\"\nimport {isDenseArray} from \"./array.js\"\nimport {createGeneratedArtifactSet} from \"./artifacts.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {exceededOwnedDeadline, executeFileWithDeadline} from \"./subprocess.js\"\nimport {isSupportedTimeoutMs, maximumTimeoutMs} from \"./timeout.js\"\nimport {deterministicEnvironment} from \"./toolchains.js\"\n\nconst acceptanceMaxBuffer = 16 * 1024 * 1024\nconst launchErrorCodes = new Set([\n  \"E2BIG\", \"EACCES\", \"EAGAIN\", \"ELOOP\", \"EMFILE\", \"ENAMETOOLONG\", \"ENFILE\", \"ENOENT\", \"ENOEXEC\", \"ENOMEM\", \"ENOTDIR\", \"ENOTSUP\", \"EPERM\", \"ETXTBSY\"\n])\nconst orderedStages = Object.freeze([\"parse\", \"generate\", \"compile\", \"link\", \"validate\", \"instantiate\", \"execute\"])\nconst stageIndexes = new Map(orderedStages.map((stage, index) => [stage, index]))\n\n/**\n * Materializes one artifact set and runs ordered acceptance stages without a shell.\n * @param {object} input - Acceptance request.\n * @param {import(\"./semantic/types.js\").GeneratedArtifactSet} input.artifacts - Complete input artifacts.\n * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit process environment.\n * @param {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[]} input.stages - Ordered stages.\n * @param {string} input.target - Target identity.\n * @param {number} [input.timeoutMs] - Per-stage timeout.\n * @returns {Promise<import(\"./semantic/types.js\").AcceptanceResult>} Captured results after cleanup.\n */\nexport async function runAcceptanceStages(input) {\n  if (!isPlainObject(input)) invalidRunner(\"Acceptance requires a request object.\", \"acceptance\")\n  const artifacts = /** @type {import(\"./semantic/types.js\").GeneratedArtifactSet} */ (input.artifacts)\n  const environment = /** @type {Readonly<Record<string, string | undefined>>} */ (\n    input.environment === undefined ? {PATH: process.env.PATH} : input.environment)\n  const stages = /** @type {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[]} */ (input.stages)\n  const target = /** @type {string} */ (input.target)\n  const timeoutMs = /** @type {number} */ (input.timeoutMs === undefined ? 10_000 : input.timeoutMs)\n  const request = validateRequest({artifacts, environment, stages, target, timeoutMs})\n  const directory = await createAcceptanceDirectory(request.target)\n  /** @type {unknown} */\n  let primaryFailure\n  /** @type {import(\"./semantic/types.js\").AcceptanceResult | undefined} */\n  let result\n  let primaryFailed = false\n\n  try {\n    await materializeArtifacts(request.artifacts, directory, request.target)\n\n    /** @type {import(\"./semantic/types.js\").AcceptanceStageResult[]} */\n    const results = []\n\n    for (const stage of request.stages) {\n      try {\n        const result = await executeFileWithDeadline({\n          arguments: stage.arguments,\n          cwd: directory,\n          environment: request.environment,\n          executable: stage.tool.executable,\n          maxBuffer: acceptanceMaxBuffer,\n          timeoutMs: request.timeoutMs\n        })\n\n        results.push(Object.freeze({\n          arguments: Object.freeze([...stage.arguments]),\n          executable: stage.tool.executable,\n          stage: stage.stage,\n          stderr: result.stderr,\n          stdout: result.stdout,\n          version: stage.tool.version\n        }))\n      } catch (error) {\n        throw processDiagnostic(error, stage, request.target, request.timeoutMs)\n      }\n    }\n\n    result = Object.freeze({directory, stages: Object.freeze(results), target: request.target})\n  } catch (error) {\n    primaryFailed = true\n    primaryFailure = error\n  }\n\n  /** @type {unknown} */\n  let cleanupFailure\n  let cleanupFailed = false\n\n  try {\n    await removeAcceptanceDirectory(directory, request.target)\n  } catch (error) {\n    cleanupFailed = true\n    cleanupFailure = error\n  }\n\n  if (primaryFailed && cleanupFailed && primaryFailure instanceof Error) {\n    throw preservePrimaryFailure(primaryFailure, cleanupFailure, request.target)\n  }\n  if (primaryFailed) throw primaryFailure\n  if (cleanupFailed) throw cleanupFailure\n\n  return /** @type {import(\"./semantic/types.js\").AcceptanceResult} */ (result)\n}\n\n/**\n * Validates and detaches a staged acceptance request before filesystem mutation.\n * @param {{\n *   artifacts: import(\"./semantic/types.js\").GeneratedArtifactSet,\n *   environment: Readonly<Record<string, string | undefined>>,\n *   stages: {arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[],\n *   target: string,\n *   timeoutMs: number\n * }} input - Candidate request.\n * @returns {{\n *   artifacts: import(\"./semantic/types.js\").GeneratedArtifactSet,\n *   environment: Readonly<Record<string, string>>,\n *   stages: {arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: Readonly<{executable: string, version: string}>}[],\n *   target: string,\n *   timeoutMs: number\n * }} Validated request.\n */\nfunction validateRequest(input) {\n  try {\n    if (typeof input.target != \"string\" || input.target.length == 0 || !isSupportedTimeoutMs(input.timeoutMs) ||\n      !isDenseArray(input.stages) || input.stages.length == 0) {\n      invalidRunner(`Acceptance requires a target, timeout from 1 through ${maximumTimeoutMs}ms, and non-empty ordered stages.`, input.target)\n    }\n    const artifacts = createGeneratedArtifactSet(input.artifacts)\n\n    if (artifacts.target != input.target) invalidRunner(\"Acceptance target must match the generated artifact-set target.\", input.target)\n    const environment = deterministicEnvironment(input.environment)\n    let previousIndex = -1\n    const seen = new Set()\n    /** @type {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: Readonly<{executable: string, version: string}>}[]} */\n    const stages = []\n\n    for (let stagePosition = 0; stagePosition < input.stages.length; stagePosition += 1) {\n      const stage = input.stages[stagePosition]\n\n      if (!isPlainObject(stage)) invalidRunner(\"Acceptance stages must be distinct known stage records.\", input.target)\n      const stageName = stage.stage\n\n      if (typeof stageName != \"string\" || !stageIndexes.has(stageName) || seen.has(stageName)) {\n        invalidRunner(\"Acceptance stages must be distinct known stage records.\", input.target)\n      }\n      const index = /** @type {number} */ (stageIndexes.get(stageName))\n\n      if (index < previousIndex) invalidRunner(\"Acceptance stages must follow parse-to-execute order.\", input.target)\n      previousIndex = index\n      seen.add(stageName)\n      const argumentCandidate = stage.arguments\n      const stageArguments = isDenseArray(argumentCandidate) ? [...argumentCandidate] : undefined\n      const toolCandidate = stage.tool\n      const tool = isPlainObject(toolCandidate) ? Object.freeze({\n        executable: toolCandidate.executable,\n        id: toolCandidate.id,\n        source: toolCandidate.source,\n        version: toolCandidate.version\n      }) : undefined\n\n      if (stageArguments == undefined || !stageArguments.every((argument) => typeof argument == \"string\" && !argument.includes(\"\\0\")) ||\n        !isTool(tool)) invalidRunner(`Acceptance stage '${stageName}' has an invalid tool or argument array.`, input.target)\n\n      stages.push(Object.freeze({arguments: stageArguments, stage: stageName, tool}))\n    }\n\n    return {artifacts, environment, stages, target: input.target, timeoutMs: input.timeoutMs}\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic && error.code == \"INVALID_ACCEPTANCE_RUNNER\") throw error\n    if (error instanceof SemantifoldDiagnostic) {\n      throw new SemantifoldDiagnostic({\n        cause: error,\n        code: \"INVALID_ACCEPTANCE_RUNNER\",\n        language: typeof input.target == \"string\" ? input.target : \"acceptance\",\n        message: `Acceptance runner input is invalid: ${error.detail}`\n      })\n    }\n\n    return invalidRunner(\"Acceptance runner input is invalid.\", typeof input.target == \"string\" ? input.target : \"acceptance\", error)\n  }\n}\n\n/**\n * Normalizes a subprocess failure with exact stage and toolchain context.\n * @param {unknown} error - Subprocess rejection.\n * @param {{arguments: string[], stage: string, tool: Readonly<{executable: string, version: string}>}} stage - Failed stage.\n * @param {string} target - Acceptance target.\n * @param {number} timeoutMs - Configured stage timeout.\n * @returns {SemantifoldDiagnostic} Normalized failure.\n */\nfunction processDiagnostic(error, stage, target, timeoutMs) {\n  const fields = processErrorFields(error)\n  const outputLimited = fields.nativeCode == \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\"\n  const timedOut = !outputLimited && exceededOwnedDeadline(error)\n  const launchFailure = fields.nativeCode != undefined && launchErrorCodes.has(fields.nativeCode)\n  const signaled = !outputLimited && !timedOut && fields.signal != undefined\n  const code = outputLimited ? \"ACCEPTANCE_OUTPUT_LIMIT\" : timedOut ? \"ACCEPTANCE_TIMEOUT\" : launchFailure ? \"ACCEPTANCE_LAUNCH_FAILURE\" : signaled\n    ? \"ACCEPTANCE_SIGNAL\"\n    : \"ACCEPTANCE_NONZERO_EXIT\"\n  const reason = outputLimited ? `exceeded the ${acceptanceMaxBuffer}-byte output capture limit (${fields.nativeCode})` : timedOut\n    ? `timed out after ${timeoutMs}ms` : launchFailure\n    ? `could not launch (${fields.nativeCode})`\n    : signaled ? `terminated by signal ${fields.signal}`\n    : fields.exitCode != undefined ? `exited nonzero (${fields.exitCode})`\n    : `failed after launch (${fields.nativeCode ?? \"unknown\"})`\n\n  return new SemantifoldDiagnostic({\n    cause: outputLimited ? undefined : error instanceof Error ? error : undefined,\n    code,\n    executable: stage.tool.executable,\n    exitCode: fields.exitCode,\n    language: target,\n    message: `Acceptance stage '${stage.stage}' ${reason} using '${stage.tool.executable}' (${stage.tool.version}).`,\n    signal: fields.signal,\n    stage: stage.stage,\n    stderr: fields.stderr,\n    stdout: fields.stdout,\n    version: stage.tool.version\n  })\n}\n\n/**\n * Narrows the stable fields of an opaque child-process failure.\n * @param {unknown} error - Process rejection.\n * @returns {{exitCode: number | undefined, nativeCode: string | undefined, signal: string | undefined, stderr: string, stdout: string}} Stable fields.\n */\nfunction processErrorFields(error) {\n  if (!error || typeof error != \"object\") return {exitCode: undefined, nativeCode: undefined, signal: undefined, stderr: \"\", stdout: \"\"}\n  const value = /** @type {Record<string, unknown>} */ (error)\n  const nativeCode = typeof value.code == \"string\" ? value.code : undefined\n  const outputLimited = nativeCode == \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\"\n\n  return {\n    exitCode: typeof value.code == \"number\" ? value.code : undefined,\n    nativeCode,\n    signal: typeof value.signal == \"string\" ? value.signal : undefined,\n    stderr: !outputLimited && typeof value.stderr == \"string\" ? value.stderr : \"\",\n    stdout: !outputLimited && typeof value.stdout == \"string\" ? value.stdout : \"\"\n  }\n}\n\n/**\n * Checks the discovered-tool fields consumed by the runner.\n * @param {unknown} value - Candidate tool.\n * @returns {value is import(\"./semantic/types.js\").DiscoveredToolchain} Whether the tool contract is present.\n */\nfunction isTool(value) {\n  return isPlainObject(value) && typeof value.id == \"string\" && typeof value.executable == \"string\" && path.isAbsolute(value.executable) &&\n    !value.executable.includes(\"\\0\") && typeof value.version == \"string\" && value.version.length > 0 &&\n    (value.source == \"canonical\" || value.source == \"override\")\n}\n\n/**\n * Keeps the primary acceptance error while recording bounded cleanup evidence in its cause chain.\n * @param {Error} primaryFailure - Original materialization or stage failure.\n * @param {unknown} cleanupFailure - Cleanup rejection.\n * @param {string} target - Acceptance target.\n * @returns {Error} The original primary error with structured cleanup evidence.\n */\nfunction preservePrimaryFailure(primaryFailure, cleanupFailure, target) {\n  const cleanupEvidence = new SemantifoldDiagnostic({\n    code: \"ACCEPTANCE_CLEANUP_FAILURE\",\n    language: cleanupFailure instanceof SemantifoldDiagnostic ? cleanupFailure.language : target,\n    message: \"Isolated acceptance-directory cleanup failed after the primary acceptance failure.\"\n  })\n  const causes = primaryFailure.cause instanceof Error ? [primaryFailure.cause, cleanupEvidence] : [cleanupEvidence]\n\n  Object.defineProperty(primaryFailure, \"cause\", {\n    configurable: true,\n    value: new AggregateError(causes, \"Acceptance failed and isolated-directory cleanup also failed.\"),\n    writable: true\n  })\n\n  return primaryFailure\n}\n\n/**\n * Throws a normalized runner-configuration diagnostic.\n * @param {string} message - Failure detail.\n * @param {unknown} target - Candidate target identity.\n * @param {unknown} [error] - Preserved cause.\n * @returns {never} Always throws.\n */\nfunction invalidRunner(message, target, error) {\n  throw new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code: \"INVALID_ACCEPTANCE_RUNNER\",\n    language: typeof target == \"string\" && target.length > 0 ? target : \"acceptance\",\n    message\n  })\n}\n\n/**\n * Checks for an ordinary string-keyed object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return typeof value == \"object\" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Removes the isolated acceptance directory with a normalized failure.\n * @param {string} directory - Exact temporary directory.\n * @param {string} target - Acceptance target.\n * @returns {Promise<void>} Cleanup completion.\n */\nasync function removeAcceptanceDirectory(directory, target) {\n  try {\n    await rm(directory, {force: true, recursive: true})\n  } catch (error) {\n    throw new SemantifoldDiagnostic({\n      cause: error instanceof Error ? error : undefined,\n      code: \"ACCEPTANCE_CLEANUP_FAILURE\",\n      language: target,\n      message: `Failed to remove isolated acceptance directory '${directory}'.`\n    })\n  }\n}\n\n/**\n * Creates one isolated acceptance directory with a normalized setup failure.\n * @param {string} target - Acceptance target.\n * @returns {Promise<string>} Exact temporary directory.\n */\nasync function createAcceptanceDirectory(target) {\n  try {\n    return await mkdtemp(path.join(os.tmpdir(), \"semantifold-acceptance-\"))\n  } catch (error) {\n    throw new SemantifoldDiagnostic({\n      cause: error instanceof Error ? error : undefined,\n      code: \"ACCEPTANCE_SETUP_FAILURE\",\n      language: target,\n      message: \"Failed to create an isolated acceptance directory.\"\n    })\n  }\n}\n\n/**\n * Writes only the already-validated generated artifacts into the isolated directory.\n * @param {import(\"./semantic/types.js\").GeneratedArtifactSet} artifacts - Complete validated set.\n * @param {string} directory - Exact temporary directory.\n * @param {string} target - Acceptance target.\n * @returns {Promise<void>} Materialization completion.\n */\nasync function materializeArtifacts(artifacts, directory, target) {\n  for (const artifact of artifacts.artifacts) {\n    const filename = path.join(directory, ...artifact.path.split(\"/\"))\n\n    try {\n      await mkdir(path.dirname(filename), {recursive: true})\n      await writeFile(filename, artifact.content)\n    } catch (error) {\n      throw new SemantifoldDiagnostic({\n        cause: error instanceof Error ? error : undefined,\n        code: \"ACCEPTANCE_MATERIALIZATION_FAILURE\",\n        language: target,\n        message: `Failed to materialize generated artifact '${artifact.path}'.`\n      })\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"acceptance.js","sourceRoot":"","sources":["../../src/acceptance.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {mkdir, mkdtemp, rm, writeFile} from \"node:fs/promises\"\nimport os from \"node:os\"\nimport path from \"node:path\"\nimport {isDenseArray} from \"./array.js\"\nimport {createGeneratedArtifactSet} from \"./artifacts.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {exceededOwnedDeadline, executeFileWithDeadline} from \"./subprocess.js\"\nimport {isSupportedTimeoutMs, maximumTimeoutMs} from \"./timeout.js\"\nimport {deterministicEnvironment} from \"./toolchains.js\"\n\nconst acceptanceMaxBuffer = 16 * 1024 * 1024\nconst launchErrorCodes = new Set([\n  \"E2BIG\", \"EACCES\", \"EAGAIN\", \"ELOOP\", \"EMFILE\", \"ENAMETOOLONG\", \"ENFILE\", \"ENOENT\", \"ENOEXEC\", \"ENOMEM\", \"ENOTDIR\", \"ENOTSUP\", \"EPERM\", \"ETXTBSY\"\n])\nconst orderedStages = Object.freeze([\"parse\", \"generate\", \"restore\", \"compile\", \"link\", \"validate\", \"instantiate\", \"execute\"])\nconst stageIndexes = new Map(orderedStages.map((stage, index) => [stage, index]))\n\n/**\n * Materializes one artifact set and runs ordered acceptance stages without a shell.\n * @param {object} input - Acceptance request.\n * @param {import(\"./semantic/types.js\").GeneratedArtifactSet} input.artifacts - Complete input artifacts.\n * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit process environment.\n * @param {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[]} input.stages - Ordered stages.\n * @param {string} input.target - Target identity.\n * @param {number} [input.timeoutMs] - Per-stage timeout.\n * @returns {Promise<import(\"./semantic/types.js\").AcceptanceResult>} Captured results after cleanup.\n */\nexport async function runAcceptanceStages(input) {\n  return await runAcceptanceStagesWithDependencies(input, rm)\n}\n\n/**\n * Creates an acceptance runner with instance-owned cleanup behavior.\n * @param {object} dependencies - Internal runner dependencies.\n * @param {typeof rm} dependencies.removeDirectory - Isolated-directory removal operation.\n * @returns {typeof runAcceptanceStages} Acceptance runner.\n */\nexport function createAcceptanceRunner({removeDirectory}) {\n  return async (input) => await runAcceptanceStagesWithDependencies(input, removeDirectory)\n}\n\n/**\n * Runs acceptance with exact instance-owned dependencies.\n * @param {Parameters<typeof runAcceptanceStages>[0]} input - Acceptance request.\n * @param {typeof rm} removeDirectory - Isolated-directory removal operation.\n * @returns {ReturnType<typeof runAcceptanceStages>} Captured results after cleanup.\n */\nasync function runAcceptanceStagesWithDependencies(input, removeDirectory) {\n  if (!isPlainObject(input)) invalidRunner(\"Acceptance requires a request object.\", \"acceptance\")\n  const artifacts = /** @type {import(\"./semantic/types.js\").GeneratedArtifactSet} */ (input.artifacts)\n  const environment = /** @type {Readonly<Record<string, string | undefined>>} */ (\n    input.environment === undefined ? {PATH: process.env.PATH} : input.environment)\n  const stages = /** @type {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[]} */ (input.stages)\n  const target = /** @type {string} */ (input.target)\n  const timeoutMs = /** @type {number} */ (input.timeoutMs === undefined ? 10_000 : input.timeoutMs)\n  const request = validateRequest({artifacts, environment, stages, target, timeoutMs})\n  const directory = await createAcceptanceDirectory(request.target)\n  /** @type {unknown} */\n  let primaryFailure\n  /** @type {import(\"./semantic/types.js\").AcceptanceResult | undefined} */\n  let result\n  let primaryFailed = false\n\n  try {\n    await materializeArtifacts(request.artifacts, directory, request.target)\n\n    /** @type {import(\"./semantic/types.js\").AcceptanceStageResult[]} */\n    const results = []\n\n    for (const stage of request.stages) {\n      try {\n        const result = await executeFileWithDeadline({\n          arguments: stage.arguments,\n          cwd: directory,\n          environment: request.environment,\n          executable: stage.tool.executable,\n          maxBuffer: acceptanceMaxBuffer,\n          timeoutMs: request.timeoutMs\n        })\n\n        results.push(Object.freeze({\n          arguments: Object.freeze([...stage.arguments]),\n          executable: stage.tool.executable,\n          stage: stage.stage,\n          stderr: result.stderr,\n          stdout: result.stdout,\n          version: stage.tool.version\n        }))\n      } catch (error) {\n        throw processDiagnostic(error, stage, request.target, request.timeoutMs)\n      }\n    }\n\n    result = Object.freeze({directory, stages: Object.freeze(results), target: request.target})\n  } catch (error) {\n    primaryFailed = true\n    primaryFailure = error\n  }\n\n  /** @type {unknown} */\n  let cleanupFailure\n  let cleanupFailed = false\n\n  try {\n    await removeAcceptanceDirectory(directory, request.target, removeDirectory)\n  } catch (error) {\n    cleanupFailed = true\n    cleanupFailure = error\n  }\n\n  if (primaryFailed && cleanupFailed && primaryFailure instanceof Error) {\n    throw preservePrimaryFailure(primaryFailure, cleanupFailure, request.target)\n  }\n  if (primaryFailed) throw primaryFailure\n  if (cleanupFailed) throw cleanupFailure\n\n  return /** @type {import(\"./semantic/types.js\").AcceptanceResult} */ (result)\n}\n\n/**\n * Validates and detaches a staged acceptance request before filesystem mutation.\n * @param {{\n *   artifacts: import(\"./semantic/types.js\").GeneratedArtifactSet,\n *   environment: Readonly<Record<string, string | undefined>>,\n *   stages: {arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: import(\"./semantic/types.js\").DiscoveredToolchain}[],\n *   target: string,\n *   timeoutMs: number\n * }} input - Candidate request.\n * @returns {{\n *   artifacts: import(\"./semantic/types.js\").GeneratedArtifactSet,\n *   environment: Readonly<Record<string, string>>,\n *   stages: {arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: Readonly<{executable: string, version: string}>}[],\n *   target: string,\n *   timeoutMs: number\n * }} Validated request.\n */\nfunction validateRequest(input) {\n  try {\n    if (typeof input.target != \"string\" || input.target.length == 0 || !isSupportedTimeoutMs(input.timeoutMs) ||\n      !isDenseArray(input.stages) || input.stages.length == 0) {\n      invalidRunner(`Acceptance requires a target, timeout from 1 through ${maximumTimeoutMs}ms, and non-empty ordered stages.`, input.target)\n    }\n    const artifacts = createGeneratedArtifactSet(input.artifacts)\n\n    if (artifacts.target != input.target) invalidRunner(\"Acceptance target must match the generated artifact-set target.\", input.target)\n    const environment = deterministicEnvironment(input.environment)\n    let previousIndex = -1\n    const seen = new Set()\n    /** @type {{arguments: string[], stage: import(\"./semantic/types.js\").AcceptanceStage, tool: Readonly<{executable: string, version: string}>}[]} */\n    const stages = []\n\n    for (let stagePosition = 0; stagePosition < input.stages.length; stagePosition += 1) {\n      const stage = input.stages[stagePosition]\n\n      if (!isPlainObject(stage)) invalidRunner(\"Acceptance stages must be distinct known stage records.\", input.target)\n      const stageName = stage.stage\n\n      if (typeof stageName != \"string\" || !stageIndexes.has(stageName) || seen.has(stageName)) {\n        invalidRunner(\"Acceptance stages must be distinct known stage records.\", input.target)\n      }\n      const index = /** @type {number} */ (stageIndexes.get(stageName))\n\n      if (index < previousIndex) invalidRunner(\"Acceptance stages must follow parse-to-execute order.\", input.target)\n      previousIndex = index\n      seen.add(stageName)\n      const argumentCandidate = stage.arguments\n      const stageArguments = isDenseArray(argumentCandidate) ? [...argumentCandidate] : undefined\n      const toolCandidate = stage.tool\n      const tool = isPlainObject(toolCandidate) ? Object.freeze({\n        executable: toolCandidate.executable,\n        id: toolCandidate.id,\n        source: toolCandidate.source,\n        version: toolCandidate.version\n      }) : undefined\n\n      if (stageArguments == undefined || !stageArguments.every((argument) => typeof argument == \"string\" && !argument.includes(\"\\0\")) ||\n        !isTool(tool)) invalidRunner(`Acceptance stage '${stageName}' has an invalid tool or argument array.`, input.target)\n\n      stages.push(Object.freeze({arguments: stageArguments, stage: stageName, tool}))\n    }\n\n    return {artifacts, environment, stages, target: input.target, timeoutMs: input.timeoutMs}\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic && error.code == \"INVALID_ACCEPTANCE_RUNNER\") throw error\n    if (error instanceof SemantifoldDiagnostic) {\n      throw new SemantifoldDiagnostic({\n        cause: error,\n        code: \"INVALID_ACCEPTANCE_RUNNER\",\n        language: typeof input.target == \"string\" ? input.target : \"acceptance\",\n        message: `Acceptance runner input is invalid: ${error.detail}`\n      })\n    }\n\n    return invalidRunner(\"Acceptance runner input is invalid.\", typeof input.target == \"string\" ? input.target : \"acceptance\", error)\n  }\n}\n\n/**\n * Normalizes a subprocess failure with exact stage and toolchain context.\n * @param {unknown} error - Subprocess rejection.\n * @param {{arguments: string[], stage: string, tool: Readonly<{executable: string, version: string}>}} stage - Failed stage.\n * @param {string} target - Acceptance target.\n * @param {number} timeoutMs - Configured stage timeout.\n * @returns {SemantifoldDiagnostic} Normalized failure.\n */\nfunction processDiagnostic(error, stage, target, timeoutMs) {\n  const fields = processErrorFields(error)\n  const outputLimited = fields.nativeCode == \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\"\n  const timedOut = !outputLimited && exceededOwnedDeadline(error)\n  const launchFailure = fields.nativeCode != undefined && launchErrorCodes.has(fields.nativeCode)\n  const signaled = !outputLimited && !timedOut && fields.signal != undefined\n  const code = outputLimited ? \"ACCEPTANCE_OUTPUT_LIMIT\" : timedOut ? \"ACCEPTANCE_TIMEOUT\" : launchFailure ? \"ACCEPTANCE_LAUNCH_FAILURE\" : signaled\n    ? \"ACCEPTANCE_SIGNAL\"\n    : \"ACCEPTANCE_NONZERO_EXIT\"\n  const reason = outputLimited ? `exceeded the ${acceptanceMaxBuffer}-byte output capture limit (${fields.nativeCode})` : timedOut\n    ? `timed out after ${timeoutMs}ms` : launchFailure\n    ? `could not launch (${fields.nativeCode})`\n    : signaled ? `terminated by signal ${fields.signal}`\n    : fields.exitCode != undefined ? `exited nonzero (${fields.exitCode})`\n    : `failed after launch (${fields.nativeCode ?? \"unknown\"})`\n\n  return new SemantifoldDiagnostic({\n    cause: outputLimited ? undefined : error instanceof Error ? error : undefined,\n    code,\n    executable: stage.tool.executable,\n    exitCode: fields.exitCode,\n    language: target,\n    message: `Acceptance stage '${stage.stage}' ${reason} using '${stage.tool.executable}' (${stage.tool.version}).`,\n    signal: fields.signal,\n    stage: stage.stage,\n    stderr: fields.stderr,\n    stdout: fields.stdout,\n    version: stage.tool.version\n  })\n}\n\n/**\n * Narrows the stable fields of an opaque child-process failure.\n * @param {unknown} error - Process rejection.\n * @returns {{exitCode: number | undefined, nativeCode: string | undefined, signal: string | undefined, stderr: string, stdout: string}} Stable fields.\n */\nfunction processErrorFields(error) {\n  if (!error || typeof error != \"object\") return {exitCode: undefined, nativeCode: undefined, signal: undefined, stderr: \"\", stdout: \"\"}\n  const value = /** @type {Record<string, unknown>} */ (error)\n  const nativeCode = typeof value.code == \"string\" ? value.code : undefined\n  const outputLimited = nativeCode == \"ERR_CHILD_PROCESS_STDIO_MAXBUFFER\"\n\n  return {\n    exitCode: typeof value.code == \"number\" ? value.code : undefined,\n    nativeCode,\n    signal: typeof value.signal == \"string\" ? value.signal : undefined,\n    stderr: !outputLimited && typeof value.stderr == \"string\" ? value.stderr : \"\",\n    stdout: !outputLimited && typeof value.stdout == \"string\" ? value.stdout : \"\"\n  }\n}\n\n/**\n * Checks the discovered-tool fields consumed by the runner.\n * @param {unknown} value - Candidate tool.\n * @returns {value is import(\"./semantic/types.js\").DiscoveredToolchain} Whether the tool contract is present.\n */\nfunction isTool(value) {\n  return isPlainObject(value) && typeof value.id == \"string\" && typeof value.executable == \"string\" && path.isAbsolute(value.executable) &&\n    !value.executable.includes(\"\\0\") && typeof value.version == \"string\" && value.version.length > 0 &&\n    (value.source == \"canonical\" || value.source == \"override\")\n}\n\n/**\n * Keeps the primary acceptance error while recording bounded cleanup evidence in its cause chain.\n * @param {Error} primaryFailure - Original materialization or stage failure.\n * @param {unknown} cleanupFailure - Cleanup rejection.\n * @param {string} target - Acceptance target.\n * @returns {Error} The original primary error with structured cleanup evidence.\n */\nfunction preservePrimaryFailure(primaryFailure, cleanupFailure, target) {\n  const cleanupEvidence = new SemantifoldDiagnostic({\n    code: \"ACCEPTANCE_CLEANUP_FAILURE\",\n    language: cleanupFailure instanceof SemantifoldDiagnostic ? cleanupFailure.language : target,\n    message: \"Isolated acceptance-directory cleanup failed after the primary acceptance failure.\"\n  })\n  const causes = primaryFailure.cause instanceof Error ? [primaryFailure.cause, cleanupEvidence] : [cleanupEvidence]\n\n  Object.defineProperty(primaryFailure, \"cause\", {\n    configurable: true,\n    value: new AggregateError(causes, \"Acceptance failed and isolated-directory cleanup also failed.\"),\n    writable: true\n  })\n\n  return primaryFailure\n}\n\n/**\n * Throws a normalized runner-configuration diagnostic.\n * @param {string} message - Failure detail.\n * @param {unknown} target - Candidate target identity.\n * @param {unknown} [error] - Preserved cause.\n * @returns {never} Always throws.\n */\nfunction invalidRunner(message, target, error) {\n  throw new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code: \"INVALID_ACCEPTANCE_RUNNER\",\n    language: typeof target == \"string\" && target.length > 0 ? target : \"acceptance\",\n    message\n  })\n}\n\n/**\n * Checks for an ordinary string-keyed object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return typeof value == \"object\" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Removes the isolated acceptance directory with a normalized failure.\n * @param {string} directory - Exact temporary directory.\n * @param {string} target - Acceptance target.\n * @param {typeof rm} removeDirectory - Instance-owned removal operation.\n * @returns {Promise<void>} Cleanup completion.\n */\nasync function removeAcceptanceDirectory(directory, target, removeDirectory) {\n  try {\n    await removeDirectory(directory, {force: true, recursive: true})\n  } catch (error) {\n    throw new SemantifoldDiagnostic({\n      cause: error instanceof Error ? error : undefined,\n      code: \"ACCEPTANCE_CLEANUP_FAILURE\",\n      language: target,\n      message: `Failed to remove isolated acceptance directory '${directory}'.`\n    })\n  }\n}\n\n/**\n * Creates one isolated acceptance directory with a normalized setup failure.\n * @param {string} target - Acceptance target.\n * @returns {Promise<string>} Exact temporary directory.\n */\nasync function createAcceptanceDirectory(target) {\n  try {\n    return await mkdtemp(path.join(os.tmpdir(), \"semantifold-acceptance-\"))\n  } catch (error) {\n    throw new SemantifoldDiagnostic({\n      cause: error instanceof Error ? error : undefined,\n      code: \"ACCEPTANCE_SETUP_FAILURE\",\n      language: target,\n      message: \"Failed to create an isolated acceptance directory.\"\n    })\n  }\n}\n\n/**\n * Writes only the already-validated generated artifacts into the isolated directory.\n * @param {import(\"./semantic/types.js\").GeneratedArtifactSet} artifacts - Complete validated set.\n * @param {string} directory - Exact temporary directory.\n * @param {string} target - Acceptance target.\n * @returns {Promise<void>} Materialization completion.\n */\nasync function materializeArtifacts(artifacts, directory, target) {\n  for (const artifact of artifacts.artifacts) {\n    const filename = path.join(directory, ...artifact.path.split(\"/\"))\n\n    try {\n      await mkdir(path.dirname(filename), {recursive: true})\n      await writeFile(filename, artifact.content)\n    } catch (error) {\n      throw new SemantifoldDiagnostic({\n        cause: error instanceof Error ? error : undefined,\n        code: \"ACCEPTANCE_MATERIALIZATION_FAILURE\",\n        language: target,\n        message: `Failed to materialize generated artifact '${artifact.path}'.`\n      })\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,3 @@
+/** Canonical C17 support header; native ownership never enters semantic IR. */
+export declare const cRuntimeHeader = "#ifndef SEMANTIFOLD_RUNTIME_H\n#define SEMANTIFOLD_RUNTIME_H\n\n#include <stdbool.h>\n#include <stddef.h>\n#include <stdint.h>\n#include <limits.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n_Static_assert(CHAR_BIT == 8, \"Semantifold requires eight-bit bytes\");\n_Static_assert(sizeof(int64_t) == 8, \"Semantifold requires exact int64_t\");\n_Static_assert(sizeof(size_t) == 8 && PTRDIFF_MAX == INT64_MAX, \"Semantifold requires the qualified 64-bit ABI\");\n\ntypedef struct {\n    const unsigned char *data;\n    size_t length;\n} SemantifoldString;\n\n#define SEMANTIFOLD_STRING(literal) ((SemantifoldString){(const unsigned char *)(literal), sizeof(literal) - 1})\n\ntypedef struct SemantifoldAllocation {\n    struct SemantifoldAllocation *next;\n    unsigned char data[];\n} SemantifoldAllocation;\n\n_Static_assert(sizeof(SemantifoldAllocation) == 8, \"Semantifold requires the qualified arena metadata size\");\n\nstatic SemantifoldAllocation *semantifold_arena = NULL;\nstatic size_t semantifold_arena_bytes = 0;\n\nstatic inline void semantifold_cleanup(void) {\n    while (semantifold_arena != NULL) {\n        SemantifoldAllocation *allocation = semantifold_arena;\n        semantifold_arena = allocation->next;\n        free(allocation);\n    }\n    semantifold_arena_bytes = 0;\n}\n\n_Noreturn static inline void semantifold_fatal(const char *message, size_t length) {\n    semantifold_cleanup();\n    (void)fwrite(message, 1, length, stderr);\n    exit(70);\n}\n\nstatic inline int64_t semantifold_integer_add(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_add_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_subtract(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_sub_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_multiply(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_mul_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_negate(int64_t value) {\n    return semantifold_integer_subtract(INT64_C(0), value);\n}\n\nstatic inline size_t semantifold_allocation_size(size_t left, size_t right) {\n    const size_t maximum = (size_t)PTRDIFF_MAX;\n    if (left > maximum || right > maximum - left ||\n        left + right > maximum - sizeof(SemantifoldAllocation)) {\n        semantifold_fatal(\"semantifold: allocation size\\n\", sizeof(\"semantifold: allocation size\\n\") - 1);\n    }\n    const size_t size = sizeof(SemantifoldAllocation) + left + right;\n    if (semantifold_arena_bytes > maximum - size) {\n        semantifold_fatal(\"semantifold: allocation size\\n\", sizeof(\"semantifold: allocation size\\n\") - 1);\n    }\n    return size;\n}\n\nstatic inline SemantifoldString semantifold_string_concat(SemantifoldString left, SemantifoldString right) {\n    const size_t size = semantifold_allocation_size(left.length, right.length);\n    SemantifoldAllocation *allocation = malloc(size);\n    if (allocation == NULL) {\n        semantifold_fatal(\"semantifold: allocation failure\\n\", sizeof(\"semantifold: allocation failure\\n\") - 1);\n    }\n    allocation->next = semantifold_arena;\n    semantifold_arena = allocation;\n    semantifold_arena_bytes += size;\n    if (left.length != 0) (void)memcpy(allocation->data, left.data, left.length);\n    if (right.length != 0) (void)memcpy(allocation->data + left.length, right.data, right.length);\n    return (SemantifoldString){allocation->data, left.length + right.length};\n}\n\nstatic inline bool semantifold_string_equal(SemantifoldString left, SemantifoldString right) {\n    return left.length == right.length && (left.length == 0 || memcmp(left.data, right.data, left.length) == 0);\n}\n\nstatic inline bool semantifold_string_not_equal(SemantifoldString left, SemantifoldString right) {\n    return !semantifold_string_equal(left, right);\n}\n\nstatic inline void semantifold_write(const unsigned char *data, size_t length) {\n    if (length != 0 && fwrite(data, 1, length, stdout) != length) {\n        semantifold_fatal(\"semantifold: output failure\\n\", sizeof(\"semantifold: output failure\\n\") - 1);\n    }\n}\n\nstatic inline void semantifold_newline(void) {\n    semantifold_write((const unsigned char *)\"\\n\", 1);\n    if (fflush(stdout) != 0) semantifold_fatal(\"semantifold: output failure\\n\", sizeof(\"semantifold: output failure\\n\") - 1);\n}\n\nstatic inline void semantifold_print_string(SemantifoldString value) {\n    semantifold_write(value.data, value.length);\n    semantifold_newline();\n}\n\nstatic inline void semantifold_print_boolean(bool value) {\n    if (value) semantifold_write((const unsigned char *)\"true\", 4);\n    else semantifold_write((const unsigned char *)\"false\", 5);\n    semantifold_newline();\n}\n\nstatic inline void semantifold_print_integer(int64_t value) {\n    unsigned char digits[20];\n    size_t position = sizeof(digits);\n    uint64_t magnitude = (uint64_t)value;\n    if (value < 0) magnitude = UINT64_C(0) - magnitude;\n    do {\n        digits[--position] = (unsigned char)(UINT64_C(48) + magnitude % UINT64_C(10));\n        magnitude /= UINT64_C(10);\n    } while (magnitude != 0);\n    if (value < 0) digits[--position] = (unsigned char)45;\n    semantifold_write(digits + position, sizeof(digits) - position);\n    semantifold_newline();\n}\n\n#endif\n";
+//# sourceMappingURL=c-runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"c-runtime.d.ts","sourceRoot":"","sources":["../../../src/backends/c-runtime.js"],"names":[],"mappings":"AAEA,+EAA+E;AAC/E,eAAO,MAAM,cAAc,2sLAmJ1B,CAAA"}