semantifold 0.1.1 → 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, and Java 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,31 +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, and Java 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`, `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. 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`, `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.
 
-`supportedLanguages` lists the five exact language identifiers, and `SemantifoldDiagnostic` exposes stable error codes for unsupported syntax, missing types, parse failures, binding/type failures, and backend capabilities.
+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.
 
-This is not general-purpose support for any of the five 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.
+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).
 
-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)`. Ruby and PHP local carriers default to mutable and use the exact `@semantifold-immutable` profile tag for immutable locals. 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.
+## Standard-library portability direction
+
+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.
+
+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 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 complete local gate is:
+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, 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
 
@@ -63,8 +92,11 @@ The execution specs require PHP CLI, Ruby, TypeScript, and a Java JDK in additio
 - [Architecture](docs/architecture.md)
 - [Coding standards](docs/coding-standards.md)
 - [Language support](docs/language-support.md)
+- [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.d.ts

@@ -1,9 +1,13 @@
-export { SemantifoldDiagnostic } from "./src/diagnostic.js";
+import { SemantifoldDiagnostic } from "./src/diagnostic.js";
+export { SemantifoldDiagnostic };
+export { languageCapabilities, supportedLanguages } from "./src/language-registry.js";
+export { createGeneratedArtifactSet } from "./src/artifacts.js";
+export { createByteMapping, parseByteMapping, stringifyByteMapping } from "./src/binary-mapping.js";
+export { canonicalToolchains, discoverCanonicalToolchain, discoverToolchain } from "./src/toolchains.js";
+export { runAcceptanceStages } from "./src/acceptance.js";
 export { getNodeProvenance, getSymbolProvenance } from "./src/semantic/provenance.js";
 export { primaryLocation } from "./src/semantic/provenance.js";
 export { composeMappings, composeSourceMaps, generatedPositionFor, mappingFromSourceMap, originalPositionFor, parseMapping, remapDiagnostic, remapLocation, spansForNode, spansForSymbol, stringifyMapping, toSourceMapV3 } from "./src/mapping.js";
-/** @type {readonly import("./src/semantic/types.js").SemanticLanguage[]} */
-export declare const supportedLanguages: readonly import("./src/semantic/types.js").SemanticLanguage[];
 /**
  * Parses source into Semantifold's shared semantic representation.
  * @param {object} input - Parse request.
@@ -51,4 +55,29 @@ export declare function generateArtifact(input: {
         language?: import("./src/semantic/types.js").SemanticLanguage;
     }[];
 }): import("./src/semantic/types.js").GeneratedArtifact;
+/**
+ * Generates a deterministic artifact set for one semantic module.
+ * @param {object} input - Artifact-set generation request.
+ * @param {string} input.language - Registered target language or platform ID.
+ * @param {import("./src/semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @param {"text" | "binary" | "application"} [input.role] - Requested backend artifact role.
+ * @param {string} [input.filename] - Safe output path for a text target.
+ * @param {"none" | "external" | "inline"} [input.mapDirective] - JavaScript-family map directive.
+ * @param {string} [input.sourceMapFilename] - External map filename.
+ * @param {{filename: string, content: string, language?: import("./src/semantic/types.js").SemanticLanguage}[]} [input.sources] - Original sources.
+ * @returns {import("./src/semantic/types.js").GeneratedArtifactSet} Complete generated set.
+ */
+export declare function generateArtifactSet(input: {
+    language: string;
+    module: import("./src/semantic/types.js").SemanticModule;
+    role?: "text" | "binary" | "application";
+    filename?: string;
+    mapDirective?: "none" | "external" | "inline";
+    sourceMapFilename?: string;
+    sources?: {
+        filename: string;
+        content: string;
+        language?: import("./src/semantic/types.js").SemanticLanguage;
+    }[];
+}): import("./src/semantic/types.js").GeneratedArtifactSet;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"AAKA,OAAO,EAAC,qBAAqB,EAAC,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAA;AACnF,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACd,MAAM,kBAAkB,CAAA;AAEzB,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,EADpB,SAAS,OAAO,yBAAyB,EAAE,gBAAgB,EAC8B,CAAA;AAEpG;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EALxB;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAsB,MAAM,EAApB,MAAM,CACd;CAEwB,GAFd,OAAO,yBAAyB,EAAE,cAAc,CAI5D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAJ3B;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;CAE2B,GAFjB,MAAM,CAIlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EARnC;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAqH,OAAO,AAA5H,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAC5G;CAEmC,GAFzB,OAAO,yBAAyB,EAAE,iBAAiB,CAI/D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"AAKA,OAAO,EAAC,qBAAqB,EAAC,MAAM,qBAAqB,CAAA;AAKzD,OAAO,EAAC,qBAAqB,EAAC,CAAA;AAC9B,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,4BAA4B,CAAA;AACnF,OAAO,EAAC,0BAA0B,EAAC,MAAM,oBAAoB,CAAA;AAC7D,OAAO,EAAC,iBAAiB,EAAE,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,yBAAyB,CAAA;AACjG,OAAO,EAAC,mBAAmB,EAAE,0BAA0B,EAAE,iBAAiB,EAAC,MAAM,qBAAqB,CAAA;AACtG,OAAO,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAA;AACnF,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EALxB;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAsB,MAAM,EAApB,MAAM,CACd;CAEwB,GAFd,OAAO,yBAAyB,EAAE,cAAc,CAI5D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAJ3B;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;CAE2B,GAFjB,MAAM,CAIlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EARnC;IAAkE,QAAQ,EAAlE,OAAO,yBAAyB,EAAE,gBAAgB,CAC1D;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAqH,OAAO,AAA5H,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAC5G;CAEmC,GAFzB,OAAO,yBAAyB,EAAE,iBAAiB,CAI/D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EATtC;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAAgE,MAAM,EAA9D,OAAO,yBAAyB,EAAE,cAAc,CACxD;IAAkD,IAAI,AAAtD,CACA,EADQ,MAAM,GAAG,QAAQ,GAAG,aAAa,CACzC;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAA+C,YAAY,AAA3D,CACA,EADQ,MAAM,GAAG,UAAU,GAAG,QAAQ,CACtC;IAAuB,iBAAiB,AAAxC,CACA,EADQ,MAAM,CACd;IAAqH,OAAO,AAA5H,CACA,EADQ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,yBAAyB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAC5G;CAEsC,GAF5B,OAAO,yBAAyB,EAAE,oBAAoB,CAsFlE"}

package/build/index.js

@@ -1,12 +1,19 @@
 // @ts-check
 import { parseSource } from "./src/frontends/index.js";
 import { generateArtifactSource, generateSource } from "./src/backends/index.js";
-export { SemantifoldDiagnostic } from "./src/diagnostic.js";
+import { createGeneratedArtifactSet as constructArtifactSet } from "./src/artifacts.js";
+import { SemantifoldDiagnostic } from "./src/diagnostic.js";
+import { languageRegistry } from "./src/language-registry.js";
+const artifactBackendRoles = new Set(["text", "binary", "application"]);
+export { SemantifoldDiagnostic };
+export { languageCapabilities, supportedLanguages } from "./src/language-registry.js";
+export { createGeneratedArtifactSet } from "./src/artifacts.js";
+export { createByteMapping, parseByteMapping, stringifyByteMapping } from "./src/binary-mapping.js";
+export { canonicalToolchains, discoverCanonicalToolchain, discoverToolchain } from "./src/toolchains.js";
+export { runAcceptanceStages } from "./src/acceptance.js";
 export { getNodeProvenance, getSymbolProvenance } from "./src/semantic/provenance.js";
 export { primaryLocation } from "./src/semantic/provenance.js";
 export { composeMappings, composeSourceMaps, generatedPositionFor, mappingFromSourceMap, originalPositionFor, parseMapping, remapDiagnostic, remapLocation, spansForNode, spansForSymbol, stringifyMapping, toSourceMapV3 } from "./src/mapping.js";
-/** @type {readonly import("./src/semantic/types.js").SemanticLanguage[]} */
-export const supportedLanguages = Object.freeze(["php", "ruby", "javascript", "typescript", "java"]);
 /**
  * Parses source into Semantifold's shared semantic representation.
  * @param {object} input - Parse request.
@@ -42,4 +49,92 @@ export function generate(input) {
 export function generateArtifact(input) {
     return generateArtifactSource(input);
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Generates a deterministic artifact set for one semantic module.
+ * @param {object} input - Artifact-set generation request.
+ * @param {string} input.language - Registered target language or platform ID.
+ * @param {import("./src/semantic/types.js").SemanticModule} input.module - Semantic module.
+ * @param {"text" | "binary" | "application"} [input.role] - Requested backend artifact role.
+ * @param {string} [input.filename] - Safe output path for a text target.
+ * @param {"none" | "external" | "inline"} [input.mapDirective] - JavaScript-family map directive.
+ * @param {string} [input.sourceMapFilename] - External map filename.
+ * @param {{filename: string, content: string, language?: import("./src/semantic/types.js").SemanticLanguage}[]} [input.sources] - Original sources.
+ * @returns {import("./src/semantic/types.js").GeneratedArtifactSet} Complete generated set.
+ */
+export function generateArtifactSet(input) {
+    if (!input || typeof input != "object" || Array.isArray(input) || Object.getPrototypeOf(input) != Object.prototype) {
+        throw new SemantifoldDiagnostic({
+            code: "INVALID_ARTIFACT_SET",
+            language: "artifact",
+            message: "Artifact-set generation requires a request object."
+        });
+    }
+    const { filename, language, mapDirective, module, role = "text", sourceMapFilename, sources } = input;
+    if (typeof language != "string" || language.length == 0) {
+        throw new SemantifoldDiagnostic({
+            code: "INVALID_ARTIFACT_SET",
+            language: "artifact",
+            message: "Artifact-set generation requires a non-empty string language or target ID."
+        });
+    }
+    if (typeof role != "string" || !artifactBackendRoles.has(role)) {
+        throw new SemantifoldDiagnostic({
+            code: "INVALID_ARTIFACT_SET",
+            language,
+            message: "Artifact backend role must be 'text', 'binary', or 'application'."
+        });
+    }
+    if (role == "text") {
+        const record = languageRegistry.record(language);
+        if (record.artifactMultiplicity == "multiple") {
+            const backend = languageRegistry.resolve(language, "textBackend", module?.location);
+            return constructArtifactSet(backend({ filename, language, mapDirective, module, sourceMapFilename, sources }));
+        }
+        const artifact = generateArtifactSource({
+            filename,
+            language: /** @type {import("./src/semantic/types.js").SemanticLanguage} */ (language),
+            mapDirective,
+            module,
+            sourceMapFilename,
+            sources
+        });
+        /** @type {import("./src/semantic/types.js").GeneratedSetArtifact[]} */
+        const artifacts = [{
+                content: artifact.code,
+                contentKind: "text",
+                mediaType: /** @type {string} */ (record.mediaType),
+                ownership: "generated",
+                path: artifact.filename,
+                provenance: {
+                    kind: "text",
+                    mapping: artifact.mapping,
+                    sourceMap: artifact.sourceMap,
+                    sourceMapFilename: artifact.sourceMapFilename
+                },
+                role: "entry"
+            }];
+        if (mapDirective == "external") {
+            artifacts.push({
+                content: `${JSON.stringify(artifact.sourceMap)}\n`,
+                contentKind: "text",
+                mediaType: "application/json",
+                ownership: "generated",
+                path: artifact.sourceMapFilename,
+                provenance: {
+                    kind: "synthetic",
+                    reason: "Serialized Source Map v3 projection for the generated entry artifact.",
+                    relatedOrigins: []
+                },
+                role: "mapping"
+            });
+        }
+        return constructArtifactSet({
+            artifacts,
+            target: language
+        });
+    }
+    const registryRole = role == "binary" ? "binaryBackend" : "applicationBackend";
+    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":"AAAA,YAAY;AAEZ,OAAO,EAAC,WAAW,EAAC,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAC,sBAAsB,EAAE,cAAc,EAAC,MAAM,yBAAyB,CAAA;AAC9E,OAAO,EAAC,0BAA0B,IAAI,oBAAoB,EAAC,MAAM,oBAAoB,CAAA;AACrF,OAAO,EAAC,qBAAqB,EAAC,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAA;AAE3D,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAA;AAEvE,OAAO,EAAC,qBAAqB,EAAC,CAAA;AAC9B,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,4BAA4B,CAAA;AACnF,OAAO,EAAC,0BAA0B,EAAC,MAAM,oBAAoB,CAAA;AAC7D,OAAO,EAAC,iBAAiB,EAAE,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,yBAAyB,CAAA;AACjG,OAAO,EAAC,mBAAmB,EAAE,0BAA0B,EAAE,iBAAiB,EAAC,MAAM,qBAAqB,CAAA;AACtG,OAAO,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAA;AACnF,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAC,KAAK;IACzB,OAAO,WAAW,CAAC,KAAK,CAAC,CAAA;AAC3B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAK;IAC5B,OAAO,cAAc,CAAC,KAAK,CAAC,CAAA;AAC9B,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAK;IACpC,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAA;AACtC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAK;IACvC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;QACnH,MAAM,IAAI,qBAAqB,CAAC;YAC9B,IAAI,EAAE,sBAAsB;YAC5B,QAAQ,EAAE,UAAU;YACpB,OAAO,EAAE,oDAAoD;SAC9D,CAAC,CAAA;IACJ,CAAC;IACD,MAAM,EAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,GAAG,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,GAAG,KAAK,CAAA;IAEnG,IAAI,OAAO,QAAQ,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,qBAAqB,CAAC;YAC9B,IAAI,EAAE,sBAAsB;YAC5B,QAAQ,EAAE,UAAU;YACpB,OAAO,EAAE,4EAA4E;SACtF,CAAC,CAAA;IACJ,CAAC;IACD,IAAI,OAAO,IAAI,IAAI,QAAQ,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/D,MAAM,IAAI,qBAAqB,CAAC;YAC9B,IAAI,EAAE,sBAAsB;YAC5B,QAAQ;YACR,OAAO,EAAE,mEAAmE;SAC7E,CAAC,CAAA;IACJ,CAAC;IAED,IAAI,IAAI,IAAI,MAAM,EAAE,CAAC;QACnB,MAAM,MAAM,GAAG,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QAEhD,IAAI,MAAM,CAAC,oBAAoB,IAAI,UAAU,EAAE,CAAC;YAC9C,MAAM,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAA;YAEnF,OAAO,oBAAoB,CAAC,OAAO,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,CAAC,CAAC,CAAA;QAC9G,CAAC;QACD,MAAM,QAAQ,GAAG,sBAAsB,CAAC;YACtC,QAAQ;YACR,QAAQ,EAAE,iEAAiE,CAAC,CAAC,QAAQ,CAAC;YACtF,YAAY;YACZ,MAAM;YACN,iBAAiB;YACjB,OAAO;SACR,CAAC,CAAA;QAEF,uEAAuE;QACvE,MAAM,SAAS,GAAG,CAAC;gBACjB,OAAO,EAAE,QAAQ,CAAC,IAAI;gBACtB,WAAW,EAAE,MAAM;gBACnB,SAAS,EAAE,qBAAqB,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC;gBACnD,SAAS,EAAE,WAAW;gBACtB,IAAI,EAAE,QAAQ,CAAC,QAAQ;gBACvB,UAAU,EAAE;oBACV,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE,QAAQ,CAAC,OAAO;oBACzB,SAAS,EAAE,QAAQ,CAAC,SAAS;oBAC7B,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;iBAC9C;gBACD,IAAI,EAAE,OAAO;aACd,CAAC,CAAA;QAEF,IAAI,YAAY,IAAI,UAAU,EAAE,CAAC;YAC/B,SAAS,CAAC,IAAI,CAAC;gBACb,OAAO,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI;gBAClD,WAAW,EAAE,MAAM;gBACnB,SAAS,EAAE,kBAAkB;gBAC7B,SAAS,EAAE,WAAW;gBACtB,IAAI,EAAE,QAAQ,CAAC,iBAAiB;gBAChC,UAAU,EAAE;oBACV,IAAI,EAAE,WAAW;oBACjB,MAAM,EAAE,uEAAuE;oBAC/E,cAAc,EAAE,EAAE;iBACnB;gBACD,IAAI,EAAE,SAAS;aAChB,CAAC,CAAA;QACJ,CAAC;QAED,OAAO,oBAAoB,CAAC;YAC1B,SAAS;YACT,MAAM,EAAE,QAAQ;SACjB,CAAC,CAAA;IACJ,CAAC;IAED,MAAM,YAAY,GAAG,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,oBAAoB,CAAA;IAC9E,MAAM,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAA;IAElF,OAAO,oBAAoB,CAAC,OAAO,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAC,CAAC,CAAC,CAAA;AAC7E,CAAC","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

@@ -0,0 +1,32 @@
+import { rm } from "node:fs/promises";
+/**
+ * Materializes one artifact set and runs ordered acceptance stages without a shell.
+ * @param {object} input - Acceptance request.
+ * @param {import("./semantic/types.js").GeneratedArtifactSet} input.artifacts - Complete input artifacts.
+ * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit process environment.
+ * @param {{arguments: string[], stage: import("./semantic/types.js").AcceptanceStage, tool: import("./semantic/types.js").DiscoveredToolchain}[]} input.stages - Ordered stages.
+ * @param {string} input.target - Target identity.
+ * @param {number} [input.timeoutMs] - Per-stage timeout.
+ * @returns {Promise<import("./semantic/types.js").AcceptanceResult>} Captured results after cleanup.
+ */
+export declare function runAcceptanceStages(input: {
+    artifacts: import("./semantic/types.js").GeneratedArtifactSet;
+    environment?: Readonly<Record<string, string | undefined>>;
+    stages: {
+        arguments: string[];
+        stage: import("./semantic/types.js").AcceptanceStage;
+        tool: import("./semantic/types.js").DiscoveredToolchain;
+    }[];
+    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

@@ -0,0 +1 @@
+{"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"}