@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/client/directClientRuntime.d.ts

@@ -0,0 +1,74 @@
+import type { SemanticBudgetLimits, ResolverUsage } from '../compiler/semanticBudget.js';
+import type { DirectCapsuleFailure } from '../compiler/directSourceCapsule.js';
+import type { DirectSoapOptions, ComponentSoapOptions, DirectSoapFailure } from '../compiler/directSoap.js';
+import type { DirectOperationSelector } from '../compiler/directOperation.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 ComponentClientOptions extends Omit<DirectClientOptions, 'soap'> {
+    readonly sourceResources: readonly {
+        readonly uri: string;
+        readonly file: string;
+        readonly canonicalUri?: string;
+    }[];
+    readonly sourceUri?: string;
+    readonly sourceOrigins: readonly string[];
+    readonly namespaceLocations?: readonly {
+        readonly namespace: string;
+        readonly location: string;
+    }[];
+    readonly standardLibraries?: readonly string[];
+    readonly recordSources?: readonly {
+        readonly selector: DirectOperationSelector;
+        readonly source: string;
+    }[];
+    readonly soap: ComponentSoapOptions;
+}
+export interface DirectClientFailure {
+    readonly kind: DirectCapsuleFailure['kind'] | DirectSoapFailure['kind'];
+    readonly rule: string;
+    readonly usage: ResolverUsage;
+    readonly repair?: string;
+    readonly phase?: 'input' | 'response';
+}
+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;
+/** Same artifact/execution chain, with explicit physical dependency snapshots and component-profile reconstruction. */
+export declare const componentClientRuntime: Readonly<{
+    version: "checked-component-runtime-v2";
+    execute: (expectedBase64: string, input: unknown, options: ComponentClientOptions) => Promise<DirectClientResult>;
+}>;

package/dist/client/directClientRuntime.js

@@ -0,0 +1,165 @@
+import { directDataOwnership, directLimit, directLoadingLimits } 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, reconstructComponentSourceCapsuleInRequest, checkDirectSourceCompatibility, DIRECT_CAPSULE_LIMITS } from '../compiler/directSourceCapsule.js';
+import { exchangeDirectSoap, exchangeComponentSoap, directSoapOptionsShape } from '../compiler/directSoap.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+import { prepareSchemaSnapshotFiles } from '../loader/schemaInput.js';
+import { SchemaLoadingError } from '../loader/orderedSyntax.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,
+    execute: (expectedBase64, input, options) => executeClient(expectedBase64, input, options, false),
+});
+/** Same artifact/execution chain, with explicit physical dependency snapshots and component-profile reconstruction. */
+export const componentClientRuntime = Object.freeze({
+    version: COMPONENT_CLIENT_RUNTIME_VERSION,
+    execute: (expectedBase64, input, options) => executeClient(expectedBase64, input, options, true),
+});
+async function executeClient(expectedBase64, input, options, component) {
+    // 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', ...(component ? ['sourceResources', 'sourceOrigins', 'sourceUri', 'namespaceLocations', 'standardLibraries', 'recordSources'] : [])];
+    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', ...(component ? ['sourceResources', 'sourceOrigins'] : [])].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), component ? ['ca'] : []);
+        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', ...(component ? ['ca'] : [])]) {
+            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');
+        let result;
+        if (component) {
+            if (typeof options.localSource !== 'string')
+                return fail('unsupported', 'explicit local source required');
+            const supplied = options;
+            const sources = directDataOwnership(budget).freeze(directDataOwnership(budget).snapshot({ resources: supplied.sourceResources,
+                origins: supplied.sourceOrigins, locations: supplied.namespaceLocations ?? [], standards: supplied.standardLibraries ?? [],
+                records: supplied.recordSources ?? [] }, check));
+            if (!Array.isArray(sources.resources) || !Array.isArray(sources.origins) || !sources.origins.every(origin => typeof origin === 'string')
+                || !Array.isArray(sources.locations) || !Array.isArray(sources.standards) || !sources.standards.every(id => typeof id === 'string')
+                || !Array.isArray(sources.records))
+                return fail('unsupported', 'explicit source snapshots required');
+            for (const resource of sources.resources) {
+                check();
+                if (!resource || typeof resource.uri !== 'string' || typeof resource.file !== 'string'
+                    || Object.keys(resource).some(k => !['uri', 'file', 'canonicalUri'].includes(k))
+                    || resource.canonicalUri !== undefined && typeof resource.canonicalUri !== 'string')
+                    return fail('unsupported', 'explicit source resource required');
+            }
+            const namespaceLocations = new Map();
+            for (const location of sources.locations) {
+                check();
+                if (!location || typeof location.namespace !== 'string' || typeof location.location !== 'string'
+                    || Object.keys(location).length !== 2 || namespaceLocations.has(location.namespace))
+                    return fail('unsupported', 'explicit namespace location required');
+                namespaceLocations.set(location.namespace, location.location);
+            }
+            const prepared = await prepareSchemaSnapshotFiles(options.localSource, sources.resources, { policy: {
+                    fileRoots: options.fileRoots, allowedOrigins: sources.origins
+                }, limits: directLoadingLimits(budget), namespaceLocations, signal, sourceUri: supplied.sourceUri,
+                chargeWork: amount => { check(); budget.chargeWork(amount); } });
+            const fresh = await reconstructComponentSourceCapsuleInRequest(bytes, prepared.source, { loading: prepared.loading, signal,
+                standardLibraries: sources.standards, recordSources: sources.records }, budget);
+            if (fresh.kind !== 'reconstructed-component')
+                return fresh;
+            if (fresh.selection.port !== options.soap.port || fresh.selection.service.namespace !== options.soap.service.namespace
+                || fresh.selection.service.local !== options.soap.service.local)
+                return fail('incompatible-artifact', 'explicit source selection mismatch');
+            result = fresh.responseProjection ? await exchangeComponentSoap(fresh.contract, fresh.mappings[0], input, supplied.soap, fresh.responseProjection)
+                : await exchangeComponentSoap(fresh.contract, fresh.mappings[0], input, supplied.soap);
+        }
+        else {
+            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.
+            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');
+        if (error instanceof SchemaLoadingError)
+            return fail(error.category === 'resource-limit' ? 'resource-limit' : 'missing-authority', 'authorized-local-source-required');
+        throw error;
+    }
+}

package/dist/client/directClientVersion.d.ts

@@ -0,0 +1,6 @@
+/** 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.";
+/** Component profile never impersonates the supported direct preview protocol. */
+export declare const COMPONENT_CLIENT_RUNTIME_VERSION: "checked-component-runtime-v2";
+export declare const COMPONENT_CLIENT_RUNTIME_REPAIR = "Regenerate matched component client and source artifacts with the installed runtime.";

package/dist/client/directClientVersion.js

@@ -0,0 +1,6 @@
+/** 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.';
+/** Component profile never impersonates the supported direct preview protocol. */
+export const COMPONENT_CLIENT_RUNTIME_VERSION = 'checked-component-runtime-v2';
+export const COMPONENT_CLIENT_RUNTIME_REPAIR = 'Regenerate matched component client and source artifacts with the installed runtime.';

package/dist/client/generateClient.d.ts

@@ -18,4 +18,3 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * @throws {Error} If a packaged preamble cannot be loaded or a TypeScript file cannot be written.
  */
 export declare function generateClient(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=generateClient.d.ts.map

package/dist/client/generateClient.js

@@ -298,14 +298,18 @@ ${methodsBody}
         if (err) {
           reject(err);
         } else {
-          // Convert the SOAP response back to TypeScript object
-          const response = this.fromSoapResult(result, responseType);
-          resolve({
-            response,
-            headers: soapHeader || {},
-            responseRaw: rawResponse,
-            requestRaw: rawRequest
-          });
+          // @why Response conversion failures must reject the call rather than escape the asynchronous SOAP callback.
+          try {
+            const response = this.fromSoapResult(result, responseType);
+            resolve({
+              response,
+              headers: soapHeader || {},
+              responseRaw: rawResponse,
+              requestRaw: rawRequest
+            });
+          } catch (error) {
+            reject(error);
+          }
         }
       });
     });
@@ -405,9 +409,18 @@ ${methodsBody}
     if (node == null) {
       return node;
     }
-    // Pass through primitives unchanged
+    const childrenTypes: Readonly<Record<string, string>> = (typeName && this.dataTypes?.ChildrenTypes?.[typeName]) || {};
+    const attributeTypes: Readonly<Record<string, string>> = (typeName && this.dataTypes?.AttributeTypes?.[typeName]) || {};
+    // XML boolean attributes arrive as lexical strings even when element booleans are parsed by node-soap.
+    if (typeof node === "string" && typeName === "boolean") {
+      const lexical = node.replace(/^[\\t\\r\\n ]+|[\\t\\r\\n ]+$/g, "");
+      if (lexical === "true" || lexical === "1") return true;
+      if (lexical === "false" || lexical === "0") return false;
+      throw new TypeError("Invalid XML boolean response value");
+    }
+    // A simple-content complex type retains its object shape when no attributes are present on the wire.
     if (typeof node !== "object") {
-      return node;
+      return childrenTypes.$value ? {$value: this.fromSoapResult(node, childrenTypes.$value)} : node;
     }
     // Recursively process array elements
     if (Array.isArray(node)) {
@@ -415,7 +428,6 @@ ${methodsBody}
     }
 
     // Get child type mapping for recursive processing with correct types
-    const childrenTypes: Readonly<Record<string, string>> = (typeName && this.dataTypes?.ChildrenTypes?.[typeName]) || {};
     const repeatedElements: readonly string[] = (typeName && this.dataTypes?.RepeatedElements?.[typeName]) || [];
     const result: any = {};
 
@@ -429,7 +441,9 @@ ${methodsBody}
     const inAttrNode = (node as any)[this.attributesKeyOut] || (node as any)["attributes"] || (node as any)["$"];
     if (inAttrNode && typeof inAttrNode === "object") {
       // Promote all attributes to top-level properties for easier TS access
-      Object.assign(result, inAttrNode);
+      for (const [name, value] of Object.entries(inAttrNode)) {
+        result[name] = this.fromSoapResult(value, attributeTypes[name]);
+      }
     }
 
     // Process remaining properties as child elements

package/dist/client/generateDirectClient.d.ts

@@ -0,0 +1,32 @@
+import type { ReconstructedDirectSource, ReconstructedComponentSource, 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 | GeneratedComponentClient): void;
+export interface GeneratedComponentClient {
+    readonly kind: 'generated-component-client';
+    readonly source: string;
+    readonly capsule: Uint8Array;
+    readonly admitted: false;
+    readonly usage: ResolverUsage;
+}
+/** Emit recursive component types and the existing checked runtime injection protocol.
+ * @remarks Native reconstruction and mappings remain authoritative; generated TypeScript is a static description.
+ * @returns An authentic writable artifact, or explicit refusal. No legacy catalog or saved report is consumed.
+ * @throws TypeError For copied/foreign reconstruction handles. Caller cancellation returns a refusal.
+ */
+export declare function generateComponentClient(expected: ReconstructedComponentSource, signal?: AbortSignal): Promise<GeneratedComponentClient | DirectCapsuleFailure>;
+/** Emit a service client index and per-operation native artifacts using the existing component emitter.
+ * @remarks All operation artifacts are prepared before writing. The index contains no source authority.
+ * @returns Generator-owned relative capsule paths, keyed by exact operation name.
+ * @throws For foreign/mixed native operations, refused generation, cancellation or filesystem failure.
+ */
+export declare function writeComponentServiceClient(expected: readonly ReconstructedComponentSource[], directory: string, signal?: AbortSignal, prepared?: readonly GeneratedComponentClient[]): Promise<Readonly<Record<string, string>>>;

package/dist/client/generateDirectClient.js

@@ -0,0 +1,268 @@
+import { directLimit } from '../compiler/directExecutionPolicy.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR } from './directClientVersion.js';
+/** Native-plan generator consumed by the opt-in checked pipeline. */
+import { checkSemanticBudget } from '../compiler/semanticBudget.js';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { inspectDirectOperation } from '../compiler/directOperation.js';
+import { inspectDirectValueMapping, inspectComponentValueMapping } from '../compiler/directValues.js';
+import { checkDirectSourceCompatibility, createDirectSourceCapsule, componentSourceCapsuleBytes, inspectReconstructedComponentSource, inspectComponentSourceService } from '../compiler/directSourceCapsule.js';
+import { lowerComponentShape } from '../generation/componentShape.js';
+import { composeGeneratedSource, resolvePreamble } from '../generation/preamble.js';
+const MAX_SOURCE_BYTES = 512 * 1024;
+const generatedArtifacts = new WeakMap();
+const componentArtifactOwners = new WeakMap();
+/** Roles are separate declarations, so equal local names never merge namespace identities. */
+export function generateDirectClient(expected, signal) {
+    const { budget } = inspectDirectOperation(expected.contract).context;
+    const failure = (kind, rule) => ({ kind, rule,
+        repair: 'Regenerate matched internal direct artifacts from an explicitly authorized source.', usage: Object.freeze({ ...budget.usage() }) });
+    try {
+        const compatible = checkDirectSourceCompatibility(expected, expected.contract, expected.selection, signal);
+        if (compatible.kind !== 'compatible-direct')
+            return compatible;
+        const capsule = createDirectSourceCapsule(expected.contract, expected.selection, signal);
+        if (capsule.kind !== 'direct-capsule')
+            return capsule;
+        // Bound every variable emission before building strings. Six bytes per UTF-16
+        // unit covers JSON escapes; fixed per-slot/role costs cover TypeScript syntax.
+        let bound = 16_384 + Math.ceil(capsule.bytes.byteLength / 3) * 4;
+        for (const mapping of expected.mappings) {
+            inspectDirectValueMapping(mapping, expected.contract);
+            if (mapping.direction.kind === 'fault')
+                bound += mapping.direction.name.length * 6 + 512;
+            for (const slot of mapping.slots)
+                bound += 256 + slot.element.name.local.length * 6;
+        }
+        const selector = expected.contract.selector;
+        bound += 6 * (selector.operation.length * 2 + selector.portType.namespace.length + selector.portType.local.length
+            + selector.binding.namespace.length + selector.binding.local.length + expected.selection.service.namespace.length
+            + expected.selection.service.local.length + expected.selection.port.length);
+        if (bound > directLimit(budget, MAX_SOURCE_BYTES))
+            return failure('resource-limit', 'generated-source-byte-limit');
+        const literal = (text) => JSON.stringify(text).replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+        const primitive = (name) => {
+            if (name === 'string')
+                return 'string';
+            if (name === 'boolean')
+                return 'boolean';
+            if (name === 'int')
+                return 'number';
+            throw new TypeError('Unsupported native scalar plan');
+        };
+        const shape = (supplied) => {
+            const mapping = inspectDirectValueMapping(supplied, expected.contract);
+            if (mapping.rootBuiltin)
+                return primitive(mapping.rootBuiltin.local);
+            if (!mapping.slots.length)
+                return 'Readonly<Record<string, never>>';
+            return '{\n' + mapping.slots.map(slot => {
+                if (signal?.aborted)
+                    throw new Error('cancelled');
+                const item = primitive(slot.builtin.local), { min, max } = slot.particle.occurs;
+                const type = max === 'unbounded' ? min === '1' ? `readonly [${item}, ...${item}[]]` : `readonly ${item}[]` : item;
+                return `  readonly ${literal(slot.element.name.local)}${max === '1' && min === '0' ? '?' : ''}: ${type};`;
+            }).join('\n') + '\n}';
+        };
+        const mappings = expected.mappings;
+        const input = mappings.find(m => m.direction.kind === 'input');
+        const output = mappings.find(m => m.direction.kind === 'output');
+        const faults = mappings.filter(m => m.direction.kind === 'fault');
+        const lines = [
+            '// Checked direct client; inject checkedDirectRuntimeV1 from the package root.',
+            '// Opt-in preview binding supports only the documented direct grammar.',
+            '// Static number types require native int32 validation; native checks enforce exact shapes.',
+            `export type Request = ${shape(input)};`,
+            `export type Response = ${shape(output)};`,
+            ...faults.map((m, i) => `export type Fault_${i} = ${shape(m)};`),
+            'export interface Usage { readonly nodes: number; readonly work: number }',
+            'export interface Name { readonly namespace: string; readonly local: string }',
+            'export 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 } };',
+            '}',
+            'export 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 repair?: string; readonly usage: Usage;',
+            '}',
+            'export interface NativeSuccess { readonly kind: "soap-response" | "soap-fault"; readonly value: unknown;',
+            '  readonly admitted: false; readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array;',
+            '  readonly fault?: { readonly name: string; readonly code: Name; readonly string: string; readonly actor?: string }; }',
+            `export interface Runtime { readonly version: ${literal(DIRECT_CLIENT_RUNTIME_VERSION)}; execute(expectedBase64: string, input: unknown, options: Options, version: ${literal(DIRECT_CLIENT_RUNTIME_VERSION)}): Promise<Failure | NativeSuccess> }`,
+            'type Common = { readonly admitted: false; readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array };',
+            'export type DeclaredFault = ' + (faults.length ? faults.map((m, i) => {
+                if (m.direction.kind !== 'fault')
+                    throw new TypeError('fault direction');
+                return `(Common & { readonly kind: "soap-fault"; readonly value: Fault_${i}; readonly fault: { readonly name: ${literal(m.direction.name)}; readonly code: Name; readonly string: string; readonly actor?: string } })`;
+            }).join(' | ') : 'never') + ';',
+            'export type Result = Failure | (Common & { readonly kind: "soap-response"; readonly value: Response }) | DeclaredFault;',
+            `const capsule = ${literal(Buffer.from(capsule.bytes).toString('base64'))};`,
+            'export const expectedCapsuleBase64 = capsule;',
+            `export const selection = ${literal(JSON.stringify({ selector: expected.contract.selector, ...expected.selection }))};`,
+            'export function createClient(runtime: Runtime) {',
+            '  return Object.freeze({',
+            `    [${literal(expected.contract.selector.operation)}]: async (input: Request, options: Options): Promise<Result> => {`,
+            `      if (runtime.version !== ${literal(DIRECT_CLIENT_RUNTIME_VERSION)}) return {kind: "incompatible-artifact", rule: "generated-runtime-version", repair: ${literal(DIRECT_CLIENT_RUNTIME_REPAIR)}, usage: {nodes: 0, work: 0}};`,
+            '      // The installed native binding pins the literal capsule before issuing fresh authority.',
+            `      return await runtime.execute(capsule, input, options, ${literal(DIRECT_CLIENT_RUNTIME_VERSION)}) as Result;`,
+            '    },',
+            '  });',
+            '}',
+            '',
+        ];
+        const source = composeGeneratedSource(lines.join('\n'), resolvePreamble('direct-client'));
+        if (Buffer.byteLength(source) > directLimit(budget, MAX_SOURCE_BYTES))
+            return failure('resource-limit', 'generated-source-byte-limit');
+        if (signal?.aborted)
+            return failure('cancelled', 'cooperative-cancellation');
+        const result = Object.freeze({ kind: 'generated-direct-client', source, capsule: capsule.bytes, admitted: false, usage: Object.freeze({ ...budget.usage() }) });
+        generatedArtifacts.set(result, budget);
+        return result;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return failure('resource-limit', 'request-budget');
+        if (signal?.aborted)
+            return failure('cancelled', 'cooperative-cancellation');
+        throw error;
+    }
+}
+/** Only authentic bounded artifacts may be written; prior semantic failure remains terminal. */
+export function writeDirectClient(file, generated) {
+    const budget = generatedArtifacts.get(generated);
+    if (!budget)
+        throw new TypeError('Authentic generated artifact required');
+    checkSemanticBudget(budget);
+    writeFileSync(file, generated.source, 'utf8');
+}
+/** Emit recursive component types and the existing checked runtime injection protocol.
+ * @remarks Native reconstruction and mappings remain authoritative; generated TypeScript is a static description.
+ * @returns An authentic writable artifact, or explicit refusal. No legacy catalog or saved report is consumed.
+ * @throws TypeError For copied/foreign reconstruction handles. Caller cancellation returns a refusal.
+ */
+export async function generateComponentClient(expected, signal) {
+    inspectReconstructedComponentSource(expected);
+    const { budget } = inspectDirectOperation(expected.contract).context;
+    const failure = (kind, rule) => ({ kind, rule,
+        repair: COMPONENT_CLIENT_RUNTIME_REPAIR, usage: Object.freeze({ ...budget.usage() }) });
+    const check = () => { checkSemanticBudget(budget); if (signal?.aborted)
+        throw new Error('cancelled'); };
+    try {
+        check();
+        const capsule = { bytes: componentSourceCapsuleBytes(expected, signal) };
+        const literal = (value) => JSON.stringify(value).replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+        const mappings = expected.mappings;
+        const input = mappings.find(mapping => mapping.direction.kind === 'input');
+        const output = mappings.find(mapping => mapping.direction.kind === 'output');
+        const request = lowerComponentShape(expected.contract, input, 'Request', check);
+        const response = lowerComponentShape(expected.contract, output, 'Response', check);
+        const faults = mappings.filter(mapping => mapping.direction.kind === 'fault').map((mapping, index) => ({ mapping,
+            shape: lowerComponentShape(expected.contract, mapping, `Fault_${index}`, check) }));
+        const grouped = mappings.some(mapping => mapping.kind === 'component-mapping'
+            && inspectComponentValueMapping(mapping, expected.contract).applicationGroups);
+        const declarations = grouped ? [...new Set([...request.declarations, ...response.declarations, ...faults.flatMap(({ shape }) => shape.declarations)]),
+            `export type Request = ${request.type};`, `export type Response = ${response.type};`,
+            ...faults.map(({ shape }, index) => `export type Fault_${index} = ${shape.type};`)] : [
+            ...request.declarations, `export type Request = ${request.type};`,
+            ...response.declarations, `export type Response = ${response.type};`,
+            ...faults.flatMap(({ shape }, index) => [...shape.declarations, `export type Fault_${index} = ${shape.type};`])
+        ];
+        const lines = [
+            '// Checked component client; inject checkedComponentRuntimeV1 from the package root.',
+            '// Scalar facets, ordered occurrence correlation and wildcard membership remain native runtime duties.',
+            ...declarations,
+            'export interface Usage {readonly nodes: number; readonly work: number}',
+            'export interface Name {readonly namespace: string; readonly local: string}',
+            'export interface Options {',
+            '  readonly localSource: string; readonly fileRoots: readonly string[]; readonly capsule: Uint8Array;',
+            '  readonly sourceResources: readonly {readonly uri: string; readonly file: string; readonly canonicalUri?: string}[]; readonly sourceOrigins: readonly string[];',
+            '  readonly sourceUri?: string;',
+            '  readonly namespaceLocations?: readonly {readonly namespace: string; readonly location: string}[];',
+            '  readonly standardLibraries?: readonly string[];',
+            '  readonly recordSources?: readonly {readonly selector: {readonly portType: Name; readonly binding: Name; readonly operation: string}; readonly source: string}[];',
+            '  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 ca?: string;',
+            '    readonly limits?: {readonly maxBytes?: number; readonly maxDepth?: number; readonly maxNodes?: number; readonly maxText?: number}};',
+            '}',
+            'export 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 repair?: string; readonly phase?: "input" | "response"; readonly usage: Usage}',
+            'export interface NativeSuccess {readonly kind: "soap-response" | "soap-fault"; readonly value: unknown; readonly admitted: false;',
+            '  readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array;',
+            '  readonly fault?: {readonly name: string; readonly code: Name; readonly string: string; readonly actor?: string}}',
+            `export interface Runtime {readonly version: ${literal(COMPONENT_CLIENT_RUNTIME_VERSION)}; execute(expectedBase64: string, input: unknown, options: Options, version: ${literal(COMPONENT_CLIENT_RUNTIME_VERSION)}): Promise<Failure | NativeSuccess>}`,
+            'type Common = {readonly admitted: false; readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array};',
+            'export type Result = Failure | (Common & {readonly kind: "soap-response"; readonly value: Response})',
+            ...faults.map(({ mapping }, index) => {
+                if (mapping.direction.kind !== 'fault')
+                    throw new TypeError('Native fault mapping required');
+                return `  | (Common & {readonly kind: "soap-fault"; readonly value: Fault_${index}; readonly fault: {readonly name: ${literal(mapping.direction.name)}; readonly code: Name; readonly string: string; readonly actor?: string}})`;
+            }),
+            ...(faults.length ? [] : ['  | (Common & {readonly kind: "soap-fault"; readonly value: never; readonly fault: {readonly name: never; readonly code: Name; readonly string: string; readonly actor?: string}})']),
+            ';',
+            `export const expectedCapsuleBase64 = ${literal(Buffer.from(capsule.bytes).toString('base64'))};`,
+            `export const selection = ${literal(JSON.stringify({ selector: expected.contract.selector, ...expected.selection }))};`,
+            'export function createClient(runtime: Runtime) {',
+            '  return Object.freeze({',
+            `    [${literal(expected.contract.selector.operation)}]: async (input: Request, options: Options): Promise<Result> => {`,
+            `      if (runtime.version !== ${literal(COMPONENT_CLIENT_RUNTIME_VERSION)}) return {kind: "incompatible-artifact", rule: "generated-runtime-version", repair: ${literal(COMPONENT_CLIENT_RUNTIME_REPAIR)}, usage: {nodes: 0, work: 0}};`,
+            `      return await runtime.execute(expectedCapsuleBase64, input, options, ${literal(COMPONENT_CLIENT_RUNTIME_VERSION)}) as Result;`,
+            '    },', '  });', '}', '',
+        ];
+        const source = composeGeneratedSource(lines.join('\n'), resolvePreamble('direct-client'));
+        if (Buffer.byteLength(source) > directLimit(budget, MAX_SOURCE_BYTES))
+            return failure('resource-limit', 'generated-source-byte-limit');
+        check();
+        const artifact = Object.freeze({ kind: 'generated-component-client', source, capsule: capsule.bytes,
+            admitted: false, usage: Object.freeze({ ...budget.usage() }) });
+        generatedArtifacts.set(artifact, budget);
+        componentArtifactOwners.set(artifact, expected);
+        return artifact;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return failure('resource-limit', 'request-budget');
+        if (signal?.aborted)
+            return failure('cancelled', 'cooperative-cancellation');
+        throw error;
+    }
+}
+/** Emit a service client index and per-operation native artifacts using the existing component emitter.
+ * @remarks All operation artifacts are prepared before writing. The index contains no source authority.
+ * @returns Generator-owned relative capsule paths, keyed by exact operation name.
+ * @throws For foreign/mixed native operations, refused generation, cancellation or filesystem failure.
+ */
+export async function writeComponentServiceClient(expected, directory, signal, prepared) {
+    const operations = inspectComponentSourceService(expected);
+    const generated = [];
+    if (prepared && prepared.length !== operations.length)
+        throw new TypeError('Prepared operation artifacts must match the service');
+    for (const [index, operation] of operations.entries()) {
+        const artifact = prepared?.[index] ?? await generateComponentClient(operation, signal);
+        if (artifact.kind !== 'generated-component-client')
+            throw new Error(`Checked client refused: ${artifact.kind}: ${artifact.rule}`);
+        if (componentArtifactOwners.get(artifact) !== operation)
+            throw new TypeError('Prepared client belongs to another native operation');
+        generated.push(artifact);
+    }
+    const files = Object.create(null);
+    const lines = operations.flatMap((_, index) => [
+        `import {createClient as operation_${index}} from './operations/${index}/client.js';`,
+        `export * as Operation_${index} from './operations/${index}/client.js';`,
+    ]);
+    lines.push("import type {Runtime, Options as OperationOptions} from './operations/0/client.js';", "export type Options = Omit<OperationOptions, 'capsule'>;", `export const selection = ${JSON.stringify(JSON.stringify(operations[0].selection))};`, 'export function createClient(runtime: Runtime) {', '  return Object.freeze({', ...operations.map((_, index) => `    ...operation_${index}(runtime),`), '  });', '}', '');
+    for (const [index, operation] of operations.entries()) {
+        const dir = path.join(directory, 'operations', String(index));
+        mkdirSync(dir, { recursive: true });
+        writeDirectClient(path.join(dir, 'client.ts'), generated[index]);
+        writeFileSync(path.join(dir, 'contract.json'), generated[index].capsule);
+        files[operation.contract.selector.operation] = `operations/${index}/contract.json`;
+    }
+    const { budget } = inspectDirectOperation(operations[0].contract).context;
+    checkSemanticBudget(budget);
+    writeFileSync(path.join(directory, 'client.ts'), composeGeneratedSource(lines.join('\n'), resolvePreamble('direct-client')), 'utf8');
+    return Object.freeze(files);
+}