@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/client/directClientRuntime.js

@@ -1,82 +1,133 @@
-import { directDataOwnership, directLimit } from '../compiler/directExecutionPolicy.js';
+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, checkDirectSourceCompatibility, DIRECT_CAPSULE_LIMITS } from '../compiler/directSourceCapsule.js';
-import { exchangeDirectSoap, directSoapOptionsShape } from '../compiler/directSoap.js';
-import { DIRECT_CLIENT_RUNTIME_VERSION } from './directClientVersion.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,
-    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)))
+    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();
-        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)))
+        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();
-        if (owned.budget !== undefined) {
-            const limits = owned.budget;
-            if (!limits || typeof limits !== 'object' || types.isProxy(limits)
-                || ![null, Object.prototype].includes(Object.getPrototypeOf(limits)))
+        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();
-            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);
+            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 = 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');
+        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');
             }
-            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 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;
@@ -85,28 +136,30 @@ export const directClientRuntime = Object.freeze({
                 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 });
+            result = await exchangeDirectSoap(fresh.contract, fresh.mappings[0], input, options.soap);
         }
-        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;
+        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

@@ -1,4 +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.";
-//# sourceMappingURL=directClientVersion.d.ts.map
+/** 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

@@ -1,3 +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

@@ -66,6 +66,18 @@ export function generateClient(outFile, compiled) {
     const soapOptions = soapImport("IOptions");
     const soapSecurity = soapImport("ISecurity");
     const soapFactory = soapImport("createClientAsync");
+    const soapHttpClient = soapImport("HttpClient");
+    const soapExOptions = soapImport("IExOptions");
+    const aliases = new Map(compiled.aliases.map(alias => [alias.name, alias.tsType]));
+    const scalarTypes = Object.fromEntries(compiled.aliases.flatMap(alias => {
+        let type = alias.tsType;
+        const visited = new Set([alias.name]);
+        while (aliases.has(type) && !visited.has(type)) {
+            visited.add(type);
+            type = aliases.get(type);
+        }
+        return ["string", "number", "boolean", "bigint"].includes(type) || type.endsWith("[]") ? [[alias.name, type]] : [];
+    }));
     // Track whether any operation opts into streaming, so we can emit the
     // supporting runtime helpers only when they're actually used.
     let anyStream = false;
@@ -97,12 +109,14 @@ export function generateClient(outFile, compiled) {
    * Streams records from the ${m} operation of the ${clientName}.${opDocStr}${secHintsStr}
    *
    * @param args - The request arguments for the ${m} operation.
+   * @param options - Optional cancellation signal and total stream deadline in milliseconds.
    * @returns A promise resolving to a streaming response whose \`records\` is an
    *          async iterable of ${recordTs} objects parsed from the SOAP body as
    *          chunks arrive. Iteration pulls bytes on demand.
    */
   async ${m}<HeadersType = Record<string, string>>(
-    args: ${inTs}
+    args: ${inTs},
+    options?: StreamCallOptions
   ): Promise<StreamOperationResponse<T.${recordTs}, HeadersType>> {
     return this.callStream<${inTs}, T.${recordTs}, HeadersType>(
       args,
@@ -112,7 +126,8 @@ export function generateClient(outFile, compiled) {
       ${JSON.stringify(inputElementLocal)},
       ${JSON.stringify(inputElementNs)},
       ${JSON.stringify(op.soapAction ?? "")},
-      ${JSON.stringify(op.stream.recordPath)}
+      ${JSON.stringify(op.stream.recordPath)},
+      options
     );
   }`;
             methods.push(methodTemplate);
@@ -144,7 +159,11 @@ export function generateClient(outFile, compiled) {
     // inside this template literal (which would flag `this`, `await`, `yield`
     // outside-of-function false positives).
     const streamMethodsBlock = anyStream
-        ? "\n" + loadRuntimeSource("clientStreamMethods.tpl.txt").replace("__SOAP_CLIENT_TYPE__", soapClient.local)
+        ? "\n" + loadRuntimeSource("clientStreamMethods.tpl.txt")
+            .replaceAll("__SOAP_CLIENT_TYPE__", soapClient.local)
+            .replaceAll("__SOAP_HTTP_CLIENT__", soapHttpClient.local)
+            .replaceAll("__SOAP_EX_OPTIONS__", soapExOptions.local)
+            .replaceAll("__SOAP_SECURITY__", soapSecurity.local)
         : "";
     // noinspection JSFileReferences,JSUnresolvedReference,CommaExpressionJS,JSDuplicatedDeclaration,ReservedWordAsName,JSCommentMatchesSignature,JSValidateTypes,JSIgnoredPromiseFromCall,BadExpressionStatementJS,ES6UnusedImports,JSUnnecessarySemicolon,UnreachableCodeJS,JSUnusedLocalSymbols
     const classTemplate = `// noinspection JSAnnotator
@@ -153,13 +172,14 @@ export function generateClient(outFile, compiled) {
  * Generated ${clientName} client class.
  * This class wraps the node-soap client and provides strongly-typed methods for each operation.
  */
-import {${soapFactory.specifier}} from "soap";
-import type {${soapClient.specifier}, ${soapOptions.specifier}, ${soapSecurity.specifier}} from "soap";
+import {${soapFactory.specifier}${anyStream ? `, ${soapHttpClient.specifier}` : ""}} from "soap";
+import type {${soapClient.specifier}, ${soapOptions.specifier}, ${soapSecurity.specifier}${anyStream ? `, ${soapExOptions.specifier}` : ""}} from "soap";
 import type * as T from "./types${suffix}";
 import type {${clientName}DataTypes} from "./utils${suffix}";
 import {${clientConstant}_DATA_TYPES} from "./utils${suffix}";${anyStream ? `
 import {parseRecords, type RecordParseSpec} from "./streamXml${suffix}";
-import type {StreamOperationResponse} from "./operations${suffix}";` : ""}
+import type {StreamOperationResponse, StreamCallOptions} from "./operations${suffix}";
+export type {StreamCallOptions} from "./operations${suffix}";` : ""}
 
 /**
  * Represents the response structure for ${clientName} operations.
@@ -214,6 +234,8 @@ export class ${clientName} {
   protected attributesKeyOut: string;
   protected client?: ${soapClient.local};
   protected dataTypes: ${clientName}DataTypes = ${clientConstant}_DATA_TYPES;
+  protected scalarTypes: Readonly<Record<string, string>> = ${JSON.stringify(scalarTypes)};
+${anyStream ? `  protected streamRequestOptions: ${soapExOptions.local};\n` : ""}
 
   /**
    * Creates a new ${clientName} instance.
@@ -224,17 +246,20 @@ export class ${clientName} {
    * @param [options.security] - Optional SOAP security settings to apply.
    * @param [options.attributesKeyIn] - Key name for input attribute bags (default: "$attributes").
    * @param [options.attributesKeyOut] - Key name for output attribute bags (default: "attributes").
-   */
+${anyStream ? `   * @param [options.streamRequestOptions] - Stream HTTP options such as verified HTTPS agents, separate from WSDL options.\n` : ""}   */
   constructor(options: {
     source: string,
     options?: ${soapOptions.local},
     security?: ${soapSecurity.local},
     attributesKeyIn?: string,
-    attributesKeyOut?: string
+    attributesKeyOut?: string${anyStream ? `,
+    /** HTTP request options for stream calls, including HTTPS agents and timeouts; WSDL options stay separate. */
+    streamRequestOptions?: ${soapExOptions.local}` : ""}
   }) {
     this.source = options.source;
     this.attributesKeyIn = options.attributesKeyIn ?? "$attributes";
     this.attributesKeyOut = options.attributesKeyOut ?? "attributes";
+${anyStream ? `    this.streamRequestOptions = options.streamRequestOptions ?? {};\n` : ""}
     if (options.options) {
       this.options = options.options;
     }
@@ -298,14 +323,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);
+          }
         }
       });
     });
@@ -398,16 +427,54 @@ ${methodsBody}
    *
    * @param node - The raw SOAP response node.
    * @param typeName - Optional metadata key to guide deserialization.
+   * @param nonNillable - Whether parent schema metadata rules out a nil child, permitting empty-object recovery.
    * @returns The deserialized object matching your DTO shape.
+   * @throws TypeError for invalid boolean, numeric, or bigint lexical values.
    */
-  protected fromSoapResult(node: any, typeName?: string): any {
-    // Pass through null/undefined unchanged
+  protected fromSoapResult(node: any, typeName?: string, nonNillable = false): any {
+    // @why node-soap collapses empty complex elements to null; only a declared non-nillable child permits recovering its object DTO.
+    // @constraints Nullable children and unknown/custom metadata retain null, including explicit xsi:nil responses.
+    if (node === null && nonNillable && typeName && Object.hasOwn(this.dataTypes.Attributes, typeName)
+      && Object.keys(this.dataTypes.ChildrenTypes[typeName] ?? {}).length === 0) return {};
     if (node == null) {
       return node;
     }
-    // Pass through primitives unchanged
+    if (typeName && Object.hasOwn(this.scalarTypes, typeName)) typeName = this.scalarTypes[typeName];
+    if (typeName?.endsWith("[]")) {
+      let itemType = typeName.slice(0, -2);
+      if (itemType.startsWith("(") && itemType.endsWith(")")) itemType = itemType.slice(1, -1);
+      if (typeof node === "string") {
+        const lexical = node.replace(/^[\\t\\r\\n ]+|[\\t\\r\\n ]+$/g, "");
+        return lexical === "" ? [] : lexical.split(/[\\t\\r\\n ]+/).map(item => this.fromSoapResult(item, itemType));
+      }
+      if (Array.isArray(node)) return node.map(item => this.fromSoapResult(item, itemType));
+    }
+    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");
+    }
+    if (typeof node === "string" && (typeName === "number" || typeName === "bigint")) {
+      const lexical = node.replace(/^[\\t\\r\\n ]+|[\\t\\r\\n ]+$/g, "");
+      if (typeName === "bigint") {
+        if (!/^[+-]?\\d+$/.test(lexical)) throw new TypeError("Invalid XML bigint response value");
+        return BigInt(lexical);
+      }
+      if (!/^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?$/.test(lexical)) {
+        throw new TypeError("Invalid XML numeric response value");
+      }
+      const number = Number(lexical);
+      if (!Number.isFinite(number)) throw new TypeError("Non-finite XML numeric response value");
+      return number;
+    }
+    // A simple-content complex type retains its object shape when no attributes are present on the wire.
     if (typeof node !== "object") {
-      return node;
+      if (node === "" && typeName && Object.hasOwn(this.dataTypes.Attributes, typeName) && Object.keys(childrenTypes).length === 0) return {};
+      return childrenTypes.$value ? {$value: this.fromSoapResult(node, childrenTypes.$value)} : node;
     }
     // Recursively process array elements
     if (Array.isArray(node)) {
@@ -415,13 +482,13 @@ ${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 nonNillableElements: readonly string[] = (typeName && this.dataTypes?.NonNillableElements?.[typeName]) || [];
     const result: any = {};
 
     // Preserve text content for mixed XML elements
-    if ("$value" in node) {
-      result.$value = (node as any).$value;
+    if ("$value" in node && (childrenTypes.$value || node.$value !== "")) {
+      result.$value = this.fromSoapResult(node.$value, childrenTypes.$value);
     }
 
     // Extract attributes from various node-soap attribute containers
@@ -429,7 +496,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
@@ -441,10 +510,11 @@ ${methodsBody}
       // Recursively convert child elements with their specific type info
       const childType: string | undefined = childrenTypes[k];
       // node-soap can return a scalar when repetition is declared on a wrapping sequence (#141).
-      const value = v != null && !Array.isArray(v) && repeatedElements.includes(k) ? [v] : v;
-      result[k] = Array.isArray(value)
-        ? value.map(node => this.fromSoapResult(node, childType))
-        : this.fromSoapResult(value, childType);
+      const repeated = repeatedElements.includes(k);
+      const value = v != null && !Array.isArray(v) && repeated ? [v] : v;
+      result[k] = repeated && Array.isArray(value)
+        ? value.map(node => this.fromSoapResult(node, childType, nonNillableElements.includes(k)))
+        : this.fromSoapResult(value, childType, nonNillableElements.includes(k));
     }
 
     return result;

package/dist/client/generateDirectClient.d.ts

@@ -1,4 +1,4 @@
-import type { ReconstructedDirectSource, DirectCapsuleFailure } from '../compiler/directSourceCapsule.js';
+import type { ReconstructedDirectSource, ReconstructedComponentSource, DirectCapsuleFailure } from '../compiler/directSourceCapsule.js';
 import type { ResolverUsage } from '../compiler/semanticBudget.js';
 export interface GeneratedDirectClient {
     readonly kind: 'generated-direct-client';
@@ -10,5 +10,23 @@ export interface GeneratedDirectClient {
 /** 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
+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>>>;