@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/README.md

@@ -19,6 +19,9 @@ Created from production integration work at [TechSpokes](https://www.techspokes.
 
 See [Start Here](docs/start-here.md) for detailed guidance on choosing a path.
 
+Unreleased checked direct artifacts can use the [versioned package-root runtime binding](docs/direct-values.md#package-root-binding-for-generated-direct-clients).
+Its restricted grammar and owned-loopback transport are separate from the existing generation commands.
+
 ## Why Choose This
 
 Most tools in this space stop at one layer: a SOAP runtime, type generation, or spec conversion. This package generates the full stack from a single WSDL source.
@@ -208,12 +211,38 @@ See [CLI Reference](docs/cli-reference.md) for all flags and examples.
 |-------|-------------|
 | [Start Here](docs/start-here.md) | What this is, who it is for, choose your path |
 | [Supported Patterns](docs/supported-patterns.md) | WSDL/XSD features handled and current limitations |
+| [Content Model Baseline](docs/content-model-baseline.md) | Reproducible S01 reference evidence and current semantic limits |
+| [Shipped Fix Reconciliation](docs/content-model-shipped-fix.md) | Contributor attribution, delivered occurrence behavior and S02 handoff |
+| [Content Model Contracts (ADR-003)](docs/decisions/003-content-model-contracts.md) | Fidelity, profile, compatibility and integration contracts for S02 |
+| [Content Model Decision Register](docs/content-model-decisions.md) | Stable S02 decisions, evidence, owners and prerequisite gates |
+| [SOAP Feasibility Evidence](docs/content-model-soap-feasibility.md) | Local ordered SOAP exchanges, raw transport seams and capability limits |
+| [Gateway Feasibility Evidence](docs/content-model-gateway-feasibility.md) | Non-mutating route validation, dialect boundaries and serialized HTTP bytes |
+| [S02 Handoff](docs/content-model-s02-handoff.md) | Delivery checkpoints, validation, provisional limits and S03 continuation |
+| [Ordered Schema Loading](docs/content-model-loading.md) | Internal ordered syntax, provenance and controlled resolution contracts |
+| [Canonical Schema Graph](docs/content-model-graph.md) | Immutable declarations, use-site particles, references and lexical context |
+| [Canonical Reference Resolution](docs/content-model-resolution.md) | Namespace visibility, complete targets, legal recursion and component-cycle diagnostics |
+| [Canonical Derivation Composition](docs/content-model-composition.md) | Distinct extension/restriction views, attributes, wildcards and legality obligations |
+| [Structural Companion Catalogs](docs/content-model-companions.md) | Required closures, actual structural equality, provenance and shared semantic dispatch |
+| [Exact Particle Analysis](docs/content-model-analysis.md) | Exact contributions, particle emptiness and bounded immutable summaries |
+| [S06 Attribute Research](docs/content-model-s06-au-01.md) | Repeated attribute-use identities, constraints and interpretation alternatives |
+| [S06 Reordered Derivation Research](docs/content-model-s06-re-01.md) | Constructive witnesses, counterexamples and decision-procedure proof obligations |
+| [S06 RE01 Support Reconstruction](docs/content-model-s06-re-01-support-reconstruction.md) | Conditional member/copy/bundle reductions, value/name palettes and open support bounds |
+| [S06 RE01 Scalar Witness Construction](docs/content-model-s06-re-01-scalar-witnesses.md) | Shared endpoint tuple construction, scalar counterexamples and open materialization gates |
+| [S06 Hypothetical Resolver Specification](docs/content-model-s06-re-01-resolver.md) | Candidate contexts, component identity, validation ownership and implementation tasks |
+| [S06 Research Resolver Implementation](docs/content-model-s06-re-01-resolver-implementation.md) | Resolver guarantees, abstract wildcard properties, verification and the future production seam |
+| [S06 Wildcard Research](docs/content-model-s06-pw-01.md) | Member and whole-group cardinality, original namespace context and authority |
+| [S06 Calendar Research](docs/content-model-s06-dt-01.md) | Exact negative-year calendar alternatives and corrected reference observations |
+| [S06 Research Handoff](docs/content-model-s06-research-handoff.md) | Joint contracts, reproducible evidence, unresolved gates and production ownership |
+| [Semantic Catalog Format 2](docs/content-model-catalog.md) | Deterministic persistence, typed validation and early compatibility routing |
 | [Output Anatomy](docs/output-anatomy.md) | What gets generated and how to use it |
 
 ### Adopt
 
 | Guide | Description |
 |-------|-------------|
+| [Checked WSDL readiness](docs/content-model-readiness.md) | Measured assessment corpus and bounded P3 implementation packet |
+| [Direct Scalar Values](docs/direct-values.md) | Internal scalar mapping, fresh inverse and bounded bare-root XML codec |
+| [Direct Structural Matching](docs/content-model-matching.md) | Internal structure-only matcher, evidence and scalar handoff |
 | [CLI Reference](docs/cli-reference.md) | All commands with flags and examples |
 | [Working With Generated Code](docs/generated-code.md) | Using clients, types, and operations |
 | [Configuration](docs/configuration.md) | Gateway security, upstream SOAP security, tags, operation overrides |
@@ -228,6 +257,7 @@ See [CLI Reference](docs/cli-reference.md) for all flags and examples.
 | [Production Guide](docs/production.md) | CI/CD, validation, logging |
 | [Troubleshooting](docs/troubleshooting.md) | Common issues and debugging |
 | [Release Notes](docs/releases/README.md) | Per-version GitHub release notes used by the draft release workflow |
+| [v1.1.5 Release Notes](docs/releases/v1.1.5.md) | Restricted checked-direct runtime binding, safe local SOAP evidence and explicit caller controls |
 | [v1.1.4 Release Notes](docs/releases/v1.1.4.md) | Named SOAP imports and compiled-client coverage on Node 24 and 26 |
 | [v1.1.3 Release Notes](docs/releases/v1.1.3.md) | Dependency security updates and Node 24 development alignment |
 | [v1.1.2 Release Notes](docs/releases/v1.1.2.md) | Sequence occurrence bounds and singleton SOAP response normalization |
@@ -241,9 +271,11 @@ See [CLI Reference](docs/cli-reference.md) for all flags and examples.
 | [Programmatic API](docs/api-reference.md) | TypeScript functions for build tools |
 | [Core Concepts](docs/concepts.md) | Flattening, $value, primitives, determinism |
 | [Architecture](docs/architecture.md) | Internal pipeline for contributors |
+| [Reference Validation](docs/reference-validation.md) | Internal evidence contract and Node tooling migration inventory |
 | [File Naming And Path Organization](docs/file-naming-and-path-organization.md) | Contributor convention for taxonomy paths and fixture retrieval |
 | [Agent Skill Artifact](docs/agent-skill.md) | Release ZIP for consumer-project AI agents |
-| [Version 1.0 Roadmap Plan](docs/roadmap/README.md) | Conformance framework, implementation slices, and release gates for 1.0 |
+| [Current Roadmap](ROADMAP.md) | Published baseline, active content-model backlog, and delivery milestones |
+| [Version 1.0 Roadmap Plan](docs/roadmap/README.md) | Historical completed implementation slices and qualification gates for 1.0 |
 | [Streamable Responses (ADR-002)](docs/decisions/002-streamable-responses.md) | Opt-in streaming: client `AsyncIterable`, gateway NDJSON or JSON array, `x-wsdl-tsc-stream` |
 | [Version Migration](docs/migration.md) | Upgrading between package versions |
 
@@ -276,3 +308,19 @@ Built and maintained by [TechSpokes](https://www.techspokes.com). Created by [Se
 - Community help: [GitHub Discussions](https://github.com/techspokes/typescript-wsdl-client/discussions)
 - Bug reports: [GitHub Issues](https://github.com/techspokes/typescript-wsdl-client/issues)
 - Commercial support and integration consulting: [techspokes.com/contact](https://www.techspokes.com/contact/)
+
+## Schema assessment diagnostics
+
+`assess` is an additive diagnostic command. It writes a versioned JSON report without generating artifacts or dispatching SOAP.
+
+```bash
+npx wsdl-tsc assess --wsdl-source examples/minimal/weather.wsdl --report .generated/assessment.json
+```
+
+Create the report directory first. Local loading defaults to the source directory; use repeated `--schema-root` values for additional authorized roots and `--schema-origin` for exact HTTP(S) origins. Network access has no implicit authorization. `--assessment-max-work` and `--assessment-max-nodes` configure the inclusive shared request limits.
+
+The programmatic `assessSchemaSource(source, {loading: {policy: {fileRoots: [...]}}})` entry returns the same report; `serializeAssessmentReport` publishes its precharged JSON. `parseAssessmentReport` checks diagnostic compatibility and consistency, but does not authenticate proof. Reports expose opaque source/context identifiers and exact resource digests rather than source URLs or payloads.
+
+The report separates native schema premises, dated-XSD correspondence, execution and per-operation runtime capabilities. Exit 0 requires established native scope and qualified correspondence; 2 means inconclusive, 3 native scope disproved, 4 resource-limit, 5 cancelled and 1 operational failure. Execution failure takes precedence over retained schema facts. An assessment never admits structured generation; legacy defaults and existing commands are unchanged.
+
+See the [checked-product assurance contract](docs/decisions/003-content-model-contracts.md#checked-product-assessment-amendment-p1-d01) for the sufficient direct correspondence route and remaining downstream obligations.

package/dist/app/generateApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateApp.d.ts","sourceRoot":"","sources":["../../src/app/generateApp.ts"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IACnC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAuqBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmDzE"}
+{"version":3,"file":"generateApp.d.ts","sourceRoot":"","sources":["../../src/app/generateApp.ts"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IACnC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAuqBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmDzE"}

package/dist/app/generateApp.js

@@ -22,6 +22,7 @@
  * - Skip-if-exists protection for scaffold files (override with force option)
  */
 import fs from "node:fs";
+import { readLegacyCatalogFile, CatalogError } from "../compiler/semanticCatalog.js";
 import { writeGeneratedSource } from "../generation/writeGeneratedSource.js";
 import path from "node:path";
 import { deriveClientName } from "../util/tools.js";
@@ -147,10 +148,11 @@ function shouldWriteScaffoldFile(filePath, force) {
  */
 function readCatalog(catalogPath) {
     try {
-        const content = fs.readFileSync(catalogPath, "utf-8");
-        return JSON.parse(content);
+        return readLegacyCatalogFile(catalogPath);
     }
     catch (err) {
+        if (err instanceof CatalogError)
+            throw err;
         throw new Error(`Failed to read or parse catalog file: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
@@ -526,13 +528,13 @@ function generatePackageJson(appDir, force) {
             dev: "tsx watch server.ts",
         },
         dependencies: {
-            fastify: "^5.12.5",
-            "fastify-plugin": "^6.0.0",
+            fastify: "^5.12.7",
+            "fastify-plugin": "^6.0.1",
             saxes: "^6.0.0",
-            soap: "^1.13.3",
+            soap: "^1.14.0",
         },
         devDependencies: {
-            "@types/node": "^26.6.4",
+            "@types/node": "^26.6.6",
             tsx: "^4.23.15",
             typescript: "^6.0.3",
         },

package/dist/cli.js

@@ -9,15 +9,19 @@
  * invocation (no subcommand) is kept for backward compatibility and behaves like the client
  * command with legacy flags.
  */
+import { assessSchemaSource, serializeAssessmentReport, assessmentExitCode } from "./compiler/checkedAssessment.js";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveResourceUri } from "./loader/schemaResources.js";
 import { loadWsdl } from "./loader/wsdlLoader.js";
 import { compileCatalog } from "./compiler/schemaCompiler.js";
 import { generateTypes } from "./client/generateTypes.js";
 import { generateUtils } from "./client/generateUtils.js";
 import { generateCatalog } from "./compiler/generateCatalog.js";
+import { readLegacyCatalogFile, CatalogError } from "./compiler/semanticCatalog.js";
 import { generateClient } from "./client/generateClient.js";
 import { generateOperations } from "./client/generateOperations.js";
 import { generateOpenAPI } from "./openapi/generateOpenAPI.js";
@@ -47,7 +51,7 @@ function loadStreamConfigOrExit(filePath) {
 // Process command line arguments, removing the first two elements (node executable and script path)
 const rawArgs = hideBin(process.argv);
 // Available commands
-const COMMANDS = ["compile", "client", "openapi", "gateway", "app", "pipeline"];
+const COMMANDS = ["compile", "client", "openapi", "gateway", "app", "pipeline", "assess"];
 // ---------------------------------------------------------------------------
 // Show help if no subcommand provided
 // ---------------------------------------------------------------------------
@@ -56,6 +60,7 @@ if (!rawArgs[0] || !COMMANDS.includes(rawArgs[0])) {
         .version(false)
         .scriptName("wsdl-tsc")
         .usage("$0 <command> [options]")
+        .command("assess", "Assess schema obligations without generating artifacts")
         .command("compile", "Compile WSDL to catalog.json")
         .command("client", "Generate TypeScript SOAP client from WSDL or catalog")
         .command("openapi", "Generate OpenAPI specification from WSDL or catalog")
@@ -68,6 +73,45 @@ if (!rawArgs[0] || !COMMANDS.includes(rawArgs[0])) {
         .parse();
     process.exit(1);
 }
+// Assessment is deliberately independent of every generation command.
+if (rawArgs[0] === "assess") {
+    const argv = await yargs(rawArgs.slice(1)).version(false).scriptName("wsdl-tsc assess")
+        .option("wsdl-source", { type: "string", demandOption: true, desc: "Authorized local WSDL/XSD source" })
+        .option("report", { type: "string", demandOption: true, desc: "Diagnostic JSON report path" })
+        .option("schema-root", { type: "array", string: true, desc: "Authorized schema root; defaults to source directory" })
+        .option("schema-origin", { type: "array", string: true, desc: "Explicitly authorized HTTP(S) origin" })
+        .option("assessment-max-work", { type: "number", desc: "Inclusive shared request work limit" })
+        .option("assessment-max-nodes", { type: "number", desc: "Inclusive shared request node limit" })
+        .strict().help().parse();
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    process.on("SIGINT", cancel);
+    try {
+        const source = argv["wsdl-source"];
+        let localFile;
+        try {
+            const uri = resolveResourceUri(source);
+            localFile = uri.startsWith("file:") ? fileURLToPath(uri) : undefined;
+        }
+        catch {
+            // Root inference grants nothing on failure; the API still publishes its loading diagnostic.
+        }
+        const report = await assessSchemaSource(source, { signal: controller.signal, loading: { policy: {
+                    fileRoots: argv["schema-root"] ?? (localFile ? [path.dirname(localFile)] : []),
+                    allowedOrigins: argv["schema-origin"] ?? [],
+                } }, limits: { maxWork: argv["assessment-max-work"], maxNodes: argv["assessment-max-nodes"] } });
+        fs.writeFileSync(argv.report, serializeAssessmentReport(report), { encoding: "utf8" });
+        console.error(`Schema: ${report.schema}; correspondence: ${report.correspondence}; execution: ${report.execution}; generation: not admitted`);
+        process.exitCode = assessmentExitCode(report);
+    }
+    catch {
+        console.error("Assessment or report publication failed; source details redacted");
+        process.exitCode = 1;
+    }
+    finally {
+        process.off("SIGINT", cancel);
+    }
+}
 // ---------------------------------------------------------------------------
 // Compile subcommand - Parse WSDL and generate catalog
 // ---------------------------------------------------------------------------
@@ -191,8 +235,7 @@ if (rawArgs[0] === "client") {
     else {
         // Only catalog-file provided: it's an input, load it
         const catalogPath = path.resolve(String(clientArgv["catalog-file"]));
-        const catalogContent = fs.readFileSync(catalogPath, "utf-8");
-        compiled = JSON.parse(catalogContent);
+        compiled = readLegacyCatalogFile(catalogPath);
         success(`Loaded catalog from ${catalogPath}`);
     }
     // If we need to compile from WSDL
@@ -540,11 +583,12 @@ if (rawArgs[0] === "app") {
     let imports = appArgv["import-extensions"];
     if (!imports && fs.existsSync(catalogFile)) {
         try {
-            const catalogContent = fs.readFileSync(catalogFile, "utf-8");
-            const catalog = JSON.parse(catalogContent);
+            const catalog = readLegacyCatalogFile(catalogFile);
             imports = catalog?.options?.imports || "js";
         }
         catch (err) {
+            if (err instanceof CatalogError && err.category === "incompatible-artifact")
+                throw err;
             // If catalog read fails, fall back to "js"
             imports = "js";
         }

package/dist/client/checkedDirectRuntime.d.ts

@@ -0,0 +1,59 @@
+import { DIRECT_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+interface Name {
+    readonly namespace: string;
+    readonly local: string;
+}
+interface Usage {
+    readonly nodes: number;
+    readonly work: number;
+}
+interface Options {
+    readonly localSource: string;
+    readonly fileRoots: readonly string[];
+    readonly capsule: Uint8Array;
+    readonly soap: {
+        readonly service: Name;
+        readonly port: string;
+        readonly endpoint: string;
+        readonly allowEndpoint: (endpoint: URL) => boolean;
+        readonly signal?: AbortSignal;
+        readonly timeoutMs?: number;
+        readonly capabilities?: readonly string[];
+        readonly limits?: {
+            readonly maxBytes?: number;
+            readonly maxDepth?: number;
+            readonly maxNodes?: number;
+            readonly maxText?: number;
+        };
+    };
+}
+interface Failure {
+    readonly kind: 'incompatible-artifact' | 'unsupported' | 'missing-authority' | 'resource-limit' | 'cancelled' | 'inconclusive' | 'invalid-schema' | 'scalar-invalid' | 'value-invalid' | 'xml-invalid' | 'mismatch' | 'transport' | 'protocol';
+    readonly rule: string;
+    readonly usage: Usage;
+    readonly repair?: string;
+}
+type Success = {
+    readonly value: unknown;
+    readonly admitted: false;
+    readonly status: number;
+    readonly usage: Usage;
+    readonly responseBytes: Uint8Array;
+} & ({
+    readonly kind: 'soap-response';
+} | {
+    readonly kind: 'soap-fault';
+    readonly fault: {
+        readonly name: string;
+        readonly code: Name;
+        readonly string: string;
+        readonly actor?: string;
+    };
+});
+/** Unreleased direct-grammar binding. Generation and broader SOAP capabilities remain internal. */
+export declare const checkedDirectRuntimeV1: Readonly<{
+    version: typeof DIRECT_CLIENT_RUNTIME_VERSION;
+    execute(expectedBase64: string, input: unknown, options: Options, version: typeof DIRECT_CLIENT_RUNTIME_VERSION): Promise<Failure | Success>;
+}>;
+export {};
+//# sourceMappingURL=checkedDirectRuntime.d.ts.map

package/dist/client/checkedDirectRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkedDirectRuntime.d.ts","sourceRoot":"","sources":["../../src/client/checkedDirectRuntime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,6BAA6B,EAA+B,MAAM,0BAA0B,CAAC;AAErG,UAAU,IAAI;IAAG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACrE,UAAU,KAAK;IAAG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AACjE,UAAU,OAAO;IACf,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE;QACb,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QACzE,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,OAAO,CAAC;QACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC3D,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE;YAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;KACnI,CAAC;CACH;AACD,UAAU,OAAO;IACf,QAAQ,CAAC,IAAI,EAAE,uBAAuB,GAAG,aAAa,GAAG,mBAAmB,GAAG,gBAAgB,GAAG,WAAW,GACzG,cAAc,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,eAAe,GAAG,aAAa,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC;IACnI,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACxE;AACD,KAAK,OAAO,GAAG;IACb,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,aAAa,EAAE,UAAU,CAAC;CAC9G,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAC,GAAG;IAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IACnE,QAAQ,CAAC,KAAK,EAAE;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAAA;CAAC,CAAC,CAAC;AAEnH,mGAAmG;AACnG,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC;IAC5C,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAC9C,OAAO,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,6BAA6B,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,CAAC;CAC9I,CAiBC,CAAC"}

package/dist/client/checkedDirectRuntime.js

@@ -0,0 +1,23 @@
+import { types } from 'node:util';
+import { directClientRuntime } from './directClientRuntime.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR } from './directClientVersion.js';
+/** Unreleased direct-grammar binding. Generation and broader SOAP capabilities remain internal. */
+export const checkedDirectRuntimeV1 = Object.freeze({
+    version: DIRECT_CLIENT_RUNTIME_VERSION,
+    async execute(expectedBase64, input, options, version) {
+        if (version !== DIRECT_CLIENT_RUNTIME_VERSION)
+            return Object.freeze({ kind: 'incompatible-artifact',
+                rule: 'generated-runtime-version', repair: DIRECT_CLIENT_RUNTIME_REPAIR,
+                usage: Object.freeze({ nodes: 0, work: 0 }) });
+        // The public entry never accepts the private profiling hook, even from JavaScript.
+        // Inspect descriptors before forwarding so getters/proxies cannot supply it.
+        if (!options || typeof options !== 'object' || types.isProxy(options)
+            || ![null, Object.prototype].includes(Object.getPrototypeOf(options))
+            || Reflect.ownKeys(options).some(key => typeof key !== 'string'
+                || !['localSource', 'fileRoots', 'capsule', 'soap'].includes(key)
+                || !Object.hasOwn(Object.getOwnPropertyDescriptor(options, key), 'value'))) {
+            return Object.freeze({ kind: 'unsupported', rule: 'data-only checked direct options required', usage: Object.freeze({ nodes: 0, work: 0 }) });
+        }
+        return directClientRuntime.execute(expectedBase64, input, options);
+    },
+});

package/dist/client/directClientRuntime.d.ts

@@ -0,0 +1,49 @@
+import type { SemanticBudgetLimits, ResolverUsage } from '../compiler/semanticBudget.js';
+import type { DirectCapsuleFailure } from '../compiler/directSourceCapsule.js';
+import type { DirectSoapOptions, DirectSoapFailure } from '../compiler/directSoap.js';
+import type { DirectApplicationValue } from '../compiler/directValues.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+export interface DirectClientOptions {
+    readonly localSource: string;
+    readonly fileRoots: readonly string[];
+    readonly capsule: Uint8Array;
+    readonly budget?: SemanticBudgetLimits;
+    readonly soap: DirectSoapOptions;
+}
+export interface DirectClientFailure {
+    readonly kind: DirectCapsuleFailure['kind'] | DirectSoapFailure['kind'];
+    readonly rule: string;
+    readonly usage: ResolverUsage;
+    readonly repair?: string;
+}
+export type DirectClientResult = DirectClientFailure | Readonly<{
+    kind: 'soap-response';
+    value: DirectApplicationValue;
+    status: number;
+    admitted: false;
+    responseBytes: Uint8Array;
+    usage: ResolverUsage;
+}> | Readonly<{
+    kind: 'soap-fault';
+    value: DirectApplicationValue;
+    status: number;
+    admitted: false;
+    fault: Readonly<{
+        name: string;
+        code: Readonly<{
+            namespace: string;
+            local: string;
+        }>;
+        string: string;
+        actor?: string;
+    }>;
+    responseBytes: Uint8Array;
+    usage: ResolverUsage;
+}>;
+export interface DirectClientRuntime {
+    readonly version: typeof DIRECT_CLIENT_RUNTIME_VERSION;
+    execute(expectedBase64: string, input: unknown, options: DirectClientOptions): Promise<DirectClientResult>;
+}
+/** The generated literal is the expected artifact; caller bytes never choose its static contract. */
+export declare const directClientRuntime: DirectClientRuntime;
+//# sourceMappingURL=directClientRuntime.d.ts.map

package/dist/client/directClientRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directClientRuntime.d.ts","sourceRoot":"","sources":["../../src/client/directClientRuntime.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,oBAAoB,EAAE,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAEvF,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,oCAAoC,CAAC;AAE7E,OAAO,KAAK,EAAC,iBAAiB,EAAE,iBAAiB,EAAC,MAAM,2BAA2B,CAAC;AACpF,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAC,6BAA6B,EAAC,MAAM,0BAA0B,CAAC;AAEvE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;CAClC;AACD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAChF;AACD,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,GAAG,QAAQ,CAAC;IAC9D,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,sBAAsB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IACtF,aAAa,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,aAAa,CAAC;CACjD,CAAC,GAAG,QAAQ,CAAC;IACZ,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,sBAAsB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IACnF,KAAK,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IACpH,aAAa,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,aAAa,CAAC;CACjD,CAAC,CAAC;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IACvD,OAAO,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAC5G;AACD,qGAAqG;AACrG,eAAO,MAAM,mBAAmB,EAAE,mBAmFhC,CAAC"}

package/dist/client/directClientRuntime.js

@@ -0,0 +1,112 @@
+import { directDataOwnership, directLimit } from '../compiler/directExecutionPolicy.js';
+/** Private P3.7 binding. No public package entry or alternate SOAP implementation. */
+import { checkSemanticBudget } from '../compiler/semanticBudget.js';
+import { DataOwnershipLimitError } from '../compiler/dataOwnership.js';
+import { types } from 'node:util';
+import { createApplicationBudget } from '../compiler/semanticBudget.js';
+import { reconstructDirectSourceCapsuleInRequest, checkDirectSourceCompatibility, DIRECT_CAPSULE_LIMITS } from '../compiler/directSourceCapsule.js';
+import { exchangeDirectSoap, directSoapOptionsShape } from '../compiler/directSoap.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+/** The generated literal is the expected artifact; caller bytes never choose its static contract. */
+export const directClientRuntime = Object.freeze({
+    version: DIRECT_CLIENT_RUNTIME_VERSION,
+    async execute(expectedBase64, input, options) {
+        // Constant-sized entry introspection precedes budget configuration and all reads.
+        const entryFailure = () => ({ kind: 'unsupported', rule: 'data-only client options required', usage: { nodes: 0, work: 0 } });
+        if (!options || typeof options !== 'object' || types.isProxy(options)
+            || ![null, Object.prototype].includes(Object.getPrototypeOf(options)))
+            return entryFailure();
+        const allowed = ['localSource', 'fileRoots', 'capsule', 'budget', 'soap'];
+        const owned = Object.create(null);
+        for (const key of Reflect.ownKeys(options)) {
+            const descriptor = Object.getOwnPropertyDescriptor(options, key);
+            if (typeof key !== 'string' || !allowed.includes(key) || !descriptor || !('value' in descriptor))
+                return entryFailure();
+            owned[key] = descriptor.value;
+        }
+        if (!['localSource', 'fileRoots', 'capsule', 'soap'].every(key => Object.hasOwn(owned, key)))
+            return entryFailure();
+        if (owned.budget !== undefined) {
+            const limits = owned.budget;
+            if (!limits || typeof limits !== 'object' || types.isProxy(limits)
+                || ![null, Object.prototype].includes(Object.getPrototypeOf(limits)))
+                return entryFailure();
+            const copied = Object.create(null);
+            for (const key of Reflect.ownKeys(limits)) {
+                const descriptor = Object.getOwnPropertyDescriptor(limits, key);
+                if (typeof key !== 'string' || !['maxNodes', 'maxWork'].includes(key) || !descriptor || !('value' in descriptor))
+                    return entryFailure();
+                copied[key] = descriptor.value;
+            }
+            owned.budget = Object.freeze(copied);
+        }
+        options = owned;
+        const budget = createApplicationBudget(options.budget);
+        const fail = (kind, rule) => Object.freeze({ kind, rule, usage: Object.freeze({ ...budget.usage() }) });
+        try {
+            const optionRule = directSoapOptionsShape(options.soap, () => checkSemanticBudget(budget));
+            if (optionRule)
+                return fail('unsupported', optionRule);
+            if (options.soap.signal !== undefined && !(options.soap.signal instanceof AbortSignal))
+                return fail('unsupported', 'native AbortSignal required');
+            if (options.soap.signal?.aborted)
+                return fail('cancelled', 'cooperative-cancellation');
+            const signal = options.soap.signal;
+            const check = () => { checkSemanticBudget(budget); if (signal?.aborted)
+                throw new Error('cancelled'); };
+            const soap = Object.create(null);
+            for (const key of Reflect.ownKeys(options.soap))
+                soap[key] = Object.getOwnPropertyDescriptor(options.soap, key).value;
+            for (const key of ['service', 'port', 'endpoint', 'timeoutMs', 'limits', 'capabilities']) {
+                if (Object.hasOwn(soap, key))
+                    soap[key] = directDataOwnership(budget).freeze(directDataOwnership(budget).snapshot(soap[key], check));
+            }
+            options = Object.freeze({ ...options, fileRoots: directDataOwnership(budget).freeze(directDataOwnership(budget).snapshot(options.fileRoots, check)), soap: Object.freeze(soap) });
+            if (typeof expectedBase64 !== 'string' || expectedBase64.length > Math.ceil(directLimit(budget, DIRECT_CAPSULE_LIMITS.maxBytes) / 3) * 4)
+                return fail('incompatible-artifact', 'generated-capsule-limit');
+            // The exact embedded artifact pins the emitted types. Check actual byte extent
+            // before copying; do not invoke caller byte getters.
+            if (!types.isUint8Array(options.capsule) || types.isProxy(options.capsule))
+                return fail('incompatible-artifact', 'capsule-bytes-required');
+            const typed = Object.getPrototypeOf(Uint8Array.prototype);
+            const backing = Object.getOwnPropertyDescriptor(typed, 'buffer').get.call(options.capsule);
+            const length = Object.getOwnPropertyDescriptor(typed, 'byteLength').get.call(options.capsule);
+            if (types.isSharedArrayBuffer(backing) || length > directLimit(budget, DIRECT_CAPSULE_LIMITS.maxBytes))
+                return fail('incompatible-artifact', 'capsule-bytes-required');
+            const bytes = new Uint8Array(length);
+            Uint8Array.prototype.set.call(bytes, options.capsule);
+            if (Buffer.from(bytes).toString('base64') !== expectedBase64)
+                return fail('incompatible-artifact', 'generated-capsule-mismatch');
+            const fresh = await reconstructDirectSourceCapsuleInRequest(bytes, options.localSource, { policy: { fileRoots: options.fileRoots }, limits: options.budget, signal: options.soap.signal }, budget);
+            if (fresh.kind !== 'reconstructed-direct')
+                return fresh;
+            const compatible = checkDirectSourceCompatibility(fresh, fresh.contract, { service: options.soap.service, port: options.soap.port }, options.soap.signal);
+            if (compatible.kind !== 'compatible-direct')
+                return compatible;
+            // Value and byte provenance stay owned
+            // by the original adapter; no catch-and-cast turns a failure into typed success.
+            const result = await exchangeDirectSoap(fresh.contract, fresh.mappings[0], input, options.soap);
+            if (!('decoded' in result))
+                return result;
+            if (options.soap.signal?.aborted)
+                return fail('cancelled', 'cooperative-cancellation');
+            const common = { value: result.decoded.validated.value, status: result.status, admitted: false,
+                responseBytes: result.responseBytes, usage: Object.freeze({ ...budget.usage() }) };
+            if (result.kind === 'soap-fault') {
+                if (!result.fault)
+                    throw new TypeError('Missing native declared fault');
+                return Object.freeze({ kind: 'soap-fault', ...common, fault: result.fault });
+            }
+            return Object.freeze({ kind: 'soap-response', ...common });
+        }
+        catch (error) {
+            if (budget.exhausted())
+                return fail('resource-limit', 'request-budget');
+            if (error instanceof DataOwnershipLimitError)
+                return fail('resource-limit', error.message);
+            if (options.soap.signal?.aborted)
+                return fail('cancelled', 'cooperative-cancellation');
+            throw error;
+        }
+    },
+});

package/dist/client/directClientVersion.d.ts

@@ -0,0 +1,4 @@
+/** Generated injection protocol; independent of package, capsule and scalar-policy versions. */
+export declare const DIRECT_CLIENT_RUNTIME_VERSION: "checked-direct-runtime-v1";
+export declare const DIRECT_CLIENT_RUNTIME_REPAIR = "Regenerate matched direct client and capsule with the installed runtime.";
+//# sourceMappingURL=directClientVersion.d.ts.map

package/dist/client/directClientVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directClientVersion.d.ts","sourceRoot":"","sources":["../../src/client/directClientVersion.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,eAAO,MAAM,6BAA6B,EAAG,2BAAoC,CAAC;AAClF,eAAO,MAAM,4BAA4B,6EAA6E,CAAC"}

package/dist/client/directClientVersion.js

@@ -0,0 +1,3 @@
+/** Generated injection protocol; independent of package, capsule and scalar-policy versions. */
+export const DIRECT_CLIENT_RUNTIME_VERSION = 'checked-direct-runtime-v1';
+export const DIRECT_CLIENT_RUNTIME_REPAIR = 'Regenerate matched direct client and capsule with the installed runtime.';

package/dist/client/generateDirectClient.d.ts

@@ -0,0 +1,14 @@
+import type { ReconstructedDirectSource, DirectCapsuleFailure } from '../compiler/directSourceCapsule.js';
+import type { ResolverUsage } from '../compiler/semanticBudget.js';
+export interface GeneratedDirectClient {
+    readonly kind: 'generated-direct-client';
+    readonly source: string;
+    readonly capsule: Uint8Array;
+    readonly admitted: false;
+    readonly usage: ResolverUsage;
+}
+/** Roles are separate declarations, so equal local names never merge namespace identities. */
+export declare function generateDirectClient(expected: ReconstructedDirectSource, signal?: AbortSignal): GeneratedDirectClient | DirectCapsuleFailure;
+/** Only authentic bounded artifacts may be written; prior semantic failure remains terminal. */
+export declare function writeDirectClient(file: string, generated: GeneratedDirectClient): void;
+//# sourceMappingURL=generateDirectClient.d.ts.map

package/dist/client/generateDirectClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateDirectClient.d.ts","sourceRoot":"","sources":["../../src/client/generateDirectClient.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAC,yBAAyB,EAAE,oBAAoB,EAAC,MAAM,oCAAoC,CAAC;AACxG,OAAO,KAAK,EAAC,aAAa,EAAiB,MAAM,+BAA+B,CAAC;AAKjF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAChG,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CACzD;AACD,8FAA8F;AAC9F,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,yBAAyB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,qBAAqB,GAAG,oBAAoB,CAsG5I;AACD,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,qBAAqB,GAAG,IAAI,CAKtF"}