@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/directOperation.js

@@ -0,0 +1,282 @@
+import { directLimit, directLoadingLimits } from './directExecutionPolicy.js';
+/** Transient source-owned schema selection. This module grants no runtime admission. */
+import { loadSemanticSchemaInput } from '../loader/schemaInput.js';
+import { SchemaLoadingError, WSDL_NAMESPACE, syntaxAttribute, syntaxElements, isXmlNCName } from '../loader/orderedSyntax.js';
+import { globalId } from './canonicalGraph.js';
+import { createApplicationBudget, DEFAULT_MAX_NODES } from './semanticBudget.js';
+import { qualifyDirectSource } from './checkedSourcePreparation.js';
+const SOAP = 'http://schemas.xmlsoap.org/wsdl/soap/';
+const HTTP = 'http://schemas.xmlsoap.org/soap/http';
+const issued = new WeakMap();
+/** Object identity authenticates the exact issued roots; context IDs and digests do not. */
+export function inspectDirectOperation(contract, expectedContext) {
+    const owned = issued.get(contract);
+    if (!owned || expectedContext !== undefined && owned.context !== expectedContext)
+        throw new TypeError('Unauthenticated or foreign direct operation');
+    return owned;
+}
+class Refusal extends Error {
+    kind;
+    rule;
+    constructor(kind, rule) {
+        super(rule);
+        this.kind = kind;
+        this.rule = rule;
+    }
+}
+class Cancelled extends Error {
+}
+/** One load, whole-source qualification, explicit selection and publication on one sticky budget. */
+export async function selectDirectOperation(source, selector, options) {
+    return selectDirectOperationInRequest(source, selector, options, createApplicationBudget(options.limits));
+}
+/** Private-module composition seam: portable reading and selection share one request. */
+export async function selectDirectOperationInRequest(source, selector, options, budget) {
+    const check = () => { if (options.signal?.aborted)
+        throw new Cancelled(); budget.chargeWork(); };
+    const refuse = (kind, rule) => { throw new Refusal(kind, rule); };
+    const failure = (kind, rule) => Object.freeze({ kind, rule, usage: Object.freeze({ ...budget.usage() }) });
+    try {
+        // Fixed terminal envelope and issuance bookkeeping, before any source work.
+        budget.chargeWork(4096);
+        check();
+        const ownedSelector = budget.freeze(budget.snapshot(selector));
+        const name = (value) => value && typeof value.namespace === 'string' && typeof value.local === 'string' && isXmlNCName(value.local);
+        if (!name(ownedSelector.portType) || !name(ownedSelector.binding) || typeof ownedSelector.operation !== 'string' || !isXmlNCName(ownedSelector.operation))
+            return failure('selection-refused', 'explicit-selector');
+        const input = await loadSemanticSchemaInput(source, { ...options.loading, limits: directLoadingLimits(budget, options.loading.limits), signal: options.signal, chargeWork: amount => { check(); budget.chargeWork(amount); } });
+        check();
+        const result = budget.guard(() => {
+            const qualified = qualifyDirectSource(input, { budget, maxNodes: options.limits?.maxNodes ?? directLimit(budget, DEFAULT_MAX_NODES), check });
+            if (qualified.kind === 'resource-limit')
+                return failure('resource-limit', 'source-qualification');
+            if (qualified.kind === 'source-preparation-failed' && qualified.category === 'resource-limit')
+                return failure('resource-limit', 'source-preparation');
+            if (qualified.kind !== 'qualified-source')
+                return failure(qualified.kind === 'source-preparation-failed' && qualified.category === 'invalid-schema' ? 'invalid-schema' : 'inconclusive', 'source-preparation');
+            if (!qualified.eligible)
+                return failure(qualified.localDisproved || qualified.closure.kind === 'invalid-schema' ? 'invalid-schema' : 'inconclusive', 'whole-source-qualification');
+            const { request } = qualified;
+            const context = request.actual;
+            const children = (node) => {
+                check();
+                budget.chargeWork(128 + node.children.length * 16 + node.attributes.length * 32);
+                for (const a of node.attributes)
+                    budget.chargeWork(a.value.length * 8 + a.name.local.length * 8 + a.name.namespace.length * 8);
+                for (const child of node.children) {
+                    if (child.kind === 'element')
+                        budget.chargeWork(16 + child.name.namespace.length * 8 + child.name.local.length * 8);
+                }
+                return syntaxElements(node);
+            };
+            const attr = syntaxAttribute;
+            const exactly = (node, namespace, local) => {
+                const found = children(node).filter(c => c.name.namespace === namespace && c.name.local === local);
+                if (found.length !== 1)
+                    return refuse('selection-refused', `expected-one-${local}`);
+                return found[0];
+            };
+            const shape = (node, allowed) => {
+                for (const child of children(node))
+                    if (!allowed.includes(`${child.name.namespace}#${child.name.local}`))
+                        refuse('unsupported', 'binding-child-shape');
+                for (const child of node.children) {
+                    if (child.kind !== 'text')
+                        continue;
+                    budget.chargeWork(8 + child.value.length * 4);
+                    if (/[^\t\r\n ]/.test(child.value))
+                        refuse('unsupported', 'wsdl-text');
+                }
+            };
+            const ws = (local) => `${WSDL_NAMESPACE}#${local}`;
+            const soap = (local) => `${SOAP}#${local}`;
+            const attrs = (node, allowed) => {
+                children(node);
+                for (const a of node.attributes)
+                    if (a.name.namespace !== '' || !allowed.includes(a.name.local))
+                        refuse('unsupported', 'binding-attribute-shape');
+            };
+            // Conservative extension policy: only known WSDL 1.1/SOAP 1.1 syntax, even when optional.
+            // Documentation payload and XSD syntax are inert here and owned separately.
+            budget.chargeWork(64 + input.schemas.length * 32);
+            const qualifiedSchemas = new Set(input.schemas.map(schema => schema.syntax));
+            const attributes = {
+                definitions: ['name', 'targetNamespace'], import: ['namespace', 'location'], types: [], message: ['name'], part: ['name', 'element', 'type'],
+                portType: ['name'], operation: ['name', 'parameterOrder'], input: ['name', 'message'], output: ['name', 'message'], fault: ['name', 'message'],
+                binding: ['name', 'type'], service: ['name'], port: ['name', 'binding'],
+            };
+            const soapAttributes = { binding: ['style', 'transport'], operation: ['soapAction', 'style'], body: ['use', 'parts'], fault: ['name', 'use'], address: ['location'] };
+            for (const document of input.documents) {
+                const stack = [document.root];
+                while (stack.length) {
+                    const node = stack.pop();
+                    const nested = children(node);
+                    if (qualifiedSchemas.has(node))
+                        continue;
+                    if (node.name.namespace === WSDL_NAMESPACE && node.name.local === 'documentation')
+                        continue;
+                    const allowed = node.name.namespace === WSDL_NAMESPACE ? attributes[node.name.local] : node.name.namespace === SOAP ? soapAttributes[node.name.local] : undefined;
+                    if (!allowed)
+                        return refuse('unsupported', 'wsdl-extension');
+                    for (const a of node.attributes) {
+                        if (a.name.namespace === WSDL_NAMESPACE && a.name.local === 'required' && node.name.namespace === SOAP && ['true', '1', 'false', '0'].includes(a.value))
+                            continue;
+                        if (a.name.namespace !== '' || !allowed.includes(a.name.local))
+                            refuse('unsupported', 'wsdl-attribute');
+                        if (a.name.local === 'name' && !isXmlNCName(a.value))
+                            refuse('selection-refused', 'wsdl-name');
+                    }
+                    stack.push(...nested);
+                }
+            }
+            const lookup = (id) => {
+                check();
+                budget.chargeWork(32 + id.length * 4);
+                const found = context.lookup(id);
+                if (found.kind !== 'found')
+                    return refuse('selection-refused', 'missing-reference');
+                return found.node;
+            };
+            const wsdl = (role, qname) => {
+                budget.chargeWork(128 + qname.local.length * 8 + qname.namespace.length * 8);
+                const node = lookup(globalId(role, qname));
+                if (node.kind !== 'wsdl' || node.role !== role)
+                    return refuse('selection-refused', 'wrong-wsdl-role');
+                return node;
+            };
+            const reference = (owner, syntax, attribute) => {
+                budget.chargeWork(64 + owner.references.length * (32 + syntax.source.path.length * 4));
+                const path = syntax.source.path.slice(owner.syntax.source.path.length) || '/';
+                const refs = owner.references.filter(r => r.path === path && r.attribute === attribute);
+                if (refs.length !== 1 || refs[0].reference.kind !== 'symbol' || !refs[0].reference.target)
+                    return refuse('selection-refused', 'missing-reference');
+                return lookup(refs[0].reference.target);
+            };
+            const portType = wsdl('portType', ownedSelector.portType);
+            const binding = wsdl('binding', ownedSelector.binding);
+            shape(portType.syntax, [ws('operation'), ws('documentation')]);
+            if (reference(binding, binding.syntax, 'type') !== portType)
+                return refuse('selection-refused', 'binding-portType-mismatch');
+            const operation = (owner) => {
+                const matches = children(owner.syntax).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'operation' && attr(c, 'name') === ownedSelector.operation);
+                if (matches.length !== 1)
+                    return refuse('selection-refused', 'operation-missing-or-overloaded');
+                return matches[0];
+            };
+            const abstract = operation(portType), bound = operation(binding);
+            attrs(bound, ['name']);
+            shape(binding.syntax, [soap('binding'), ws('operation'), ws('documentation')]);
+            const soapBinding = exactly(binding.syntax, SOAP, 'binding');
+            const soapOperation = exactly(bound, SOAP, 'operation');
+            shape(soapBinding, []);
+            shape(soapOperation, []);
+            if (!['document', 'rpc'].includes(attr(soapBinding, 'style') ?? 'document'))
+                return refuse('unsupported', 'soap-binding-style');
+            if (attr(soapBinding, 'transport') !== HTTP)
+                return refuse('unsupported', 'soap-transport');
+            if ((attr(soapOperation, 'style') ?? attr(soapBinding, 'style') ?? 'document') !== 'document')
+                return refuse('unsupported', 'soap-style');
+            const action = attr(soapOperation, 'soapAction');
+            if (action === undefined)
+                return refuse('unsupported', 'soap-action-required');
+            shape(abstract, [ws('input'), ws('output'), ws('fault'), ws('documentation')]);
+            shape(bound, [soap('operation'), ws('input'), ws('output'), ws('fault'), ws('documentation')]);
+            const abstractInput = exactly(abstract, WSDL_NAMESPACE, 'input'), abstractOutput = exactly(abstract, WSDL_NAMESPACE, 'output');
+            const sequence = children(abstract).filter(c => c.name.namespace === WSDL_NAMESPACE && ['input', 'output'].includes(c.name.local));
+            if (sequence[0] !== abstractInput || sequence[1] !== abstractOutput)
+                return refuse('unsupported', 'request-response-required');
+            const messageOrder = (node) => {
+                const messages = children(node).filter(c => c.name.namespace === WSDL_NAMESPACE && ['input', 'output', 'fault'].includes(c.name.local));
+                if (messages[0]?.name.local !== 'input' || messages[1]?.name.local !== 'output' || messages.slice(2).some(c => c.name.local !== 'fault'))
+                    refuse('unsupported', 'request-response-order');
+            };
+            messageOrder(abstract);
+            messageOrder(bound);
+            if (attr(abstract, 'parameterOrder') !== undefined || attr(bound, 'parameterOrder') !== undefined)
+                return refuse('unsupported', 'parameter-order');
+            const root = (messageSyntax, boundSyntax, faultName) => {
+                attrs(messageSyntax, ['name', 'message']);
+                attrs(boundSyntax, ['name']);
+                shape(messageSyntax, [ws('documentation')]);
+                shape(boundSyntax, [soap(faultName === undefined ? 'body' : 'fault'), ws('documentation')]);
+                const body = exactly(boundSyntax, SOAP, faultName === undefined ? 'body' : 'fault');
+                shape(body, []);
+                if (attr(body, 'use') !== 'literal')
+                    return refuse('unsupported', 'literal-required');
+                if (faultName !== undefined && attr(body, 'name') !== faultName)
+                    return refuse('selection-refused', 'soap-fault-name');
+                const message = reference(portType, messageSyntax, 'message');
+                if (message.kind !== 'wsdl' || message.role !== 'message')
+                    return refuse('selection-refused', 'message-reference');
+                shape(message.syntax, [ws('part'), ws('documentation')]);
+                const parts = children(message.syntax).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'part');
+                if (parts.length !== 1)
+                    return refuse('unsupported', 'single-part-required');
+                const part = parts[0], partName = attr(part, 'name');
+                if (!partName || !isXmlNCName(partName))
+                    return refuse('selection-refused', 'part-name');
+                if (attr(body, 'parts') !== undefined && attr(body, 'parts').replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, '') !== partName)
+                    return refuse('selection-refused', 'body-parts');
+                if (attr(part, 'type') !== undefined || attr(part, 'element') === undefined)
+                    return refuse('unsupported', 'global-element-part-required');
+                shape(part, [ws('documentation')]);
+                const element = reference(message, part, 'element');
+                if (element.kind !== 'element' || element.identity.kind !== 'global')
+                    return refuse('selection-refused', 'global-element-root');
+                if (element.type.kind === 'symbol' && !element.type.target)
+                    return refuse('selection-refused', 'element-type');
+                return Object.freeze({ message: message.name, part: partName, element, type: element.type, source: part.source });
+            };
+            const io = (direction, declaration) => {
+                const boundIo = exactly(bound, WSDL_NAMESPACE, direction);
+                const boundName = attr(boundIo, 'name');
+                const expectedName = attr(declaration, 'name') ?? `${ownedSelector.operation}${direction === 'input' ? 'Request' : 'Response'}`;
+                if (boundName !== undefined && boundName !== expectedName)
+                    return refuse('selection-refused', 'binding-message-name');
+                return root(declaration, boundIo);
+            };
+            const requestRoot = io('input', abstractInput), responseRoot = io('output', abstractOutput);
+            const declaredFaults = children(abstract).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'fault');
+            const boundFaults = children(bound).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'fault');
+            if (declaredFaults.length !== boundFaults.length)
+                return refuse('selection-refused', 'fault-mapping');
+            const faultNames = new Set();
+            const faults = declaredFaults.map(f => {
+                check();
+                const faultName = attr(f, 'name');
+                if (!faultName || !isXmlNCName(faultName) || faultNames.has(faultName))
+                    return refuse('selection-refused', 'fault-name');
+                faultNames.add(faultName);
+                budget.chargeWork(64 + boundFaults.length * (64 + faultName.length * 4));
+                const matches = boundFaults.filter(b => attr(b, 'name') === faultName);
+                if (matches.length !== 1)
+                    return refuse('selection-refused', 'fault-mapping');
+                return Object.freeze({ name: faultName, root: root(f, matches[0], faultName) });
+            });
+            check();
+            // Charge publication traversal before retaining authority. Roots stay exact context objects.
+            const contract = { selector: ownedSelector, contextId: context.contextId, basis: 'native-direct-premises-v1', correspondence: 'dated-XSD-2004-direct-v1',
+                binding: { version: '1.1', style: 'document', use: 'literal', transport: HTTP, action, source: binding.context.source },
+                input: requestRoot, output: responseRoot, faults,
+                missingCapabilities: ['matcher', 'projection', 'scalar-payload', 'bundle', 'codec', 'buffered-transport', 'structured-generation'], admitted: false };
+            budget.freeze(contract);
+            check();
+            budget.chargeWork(256);
+            const selected = Object.freeze({ kind: 'selected', contract, usage: Object.freeze({ ...budget.usage() }) });
+            issued.set(contract, Object.freeze({ contract, context, source: input, evidence: qualified }));
+            return selected;
+        });
+        return result.kind === 'resource-limit' ? failure('resource-limit', 'request-budget') : result;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return failure('resource-limit', 'request-budget');
+        if (options.signal?.aborted || error instanceof Cancelled)
+            return failure('cancelled', 'cooperative-cancellation');
+        if (error instanceof Refusal)
+            return failure(error.kind, error.rule);
+        if (error instanceof SchemaLoadingError)
+            return failure(error.category === 'resource-limit' ? 'resource-limit' : 'loading-refused', error.category);
+        throw error;
+    }
+}

package/dist/compiler/directSoap.d.ts

@@ -0,0 +1,42 @@
+import type { DirectOperationContract } from './directOperation.js';
+import type { DirectCodecFailure, DirectDecodedXml, DirectXmlLimits } from './directCodec.js';
+import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+import type { ResolverUsage } from './semanticBudget.js';
+export interface DirectSoapOptions {
+    readonly service: ExpandedName;
+    readonly port: string;
+    readonly endpoint: string;
+    /** Explicit authorization; WSDL addresses never grant permission. */
+    readonly allowEndpoint: (endpoint: URL) => boolean;
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+    readonly limits?: DirectXmlLimits;
+    /** Every requested extension is refused by this first adapter. */
+    readonly capabilities?: readonly string[];
+}
+export interface DirectSoapFailure {
+    readonly kind: DirectCodecFailure['kind'] | 'transport' | 'protocol';
+    readonly rule: string;
+    readonly usage: ResolverUsage;
+}
+export type DirectSoapResult = DirectSoapFailure | Readonly<{
+    kind: 'soap-response' | 'soap-fault';
+    admitted: false;
+    decoded: DirectDecodedXml;
+    /** Actual bounded HTTP entity bytes, before any decoding; caller-owned data. */
+    responseBytes: Uint8Array;
+    status: number;
+    fault?: Readonly<{
+        name: string;
+        code: ExpandedName;
+        codeNode: SyntaxElement;
+        string: string;
+        actor?: string;
+    }>;
+    usage: ResolverUsage;
+}>;
+/** Shared entry guard: consumers must call before reading any SOAP option. */
+export declare function directSoapOptionsShape(options: unknown, check: () => void): string | undefined;
+/** Authentication and fresh-value validation precede dependency bootstrap and all HTTP I/O. */
+export declare function exchangeDirectSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: DirectSoapOptions): Promise<DirectSoapResult>;
+//# sourceMappingURL=directSoap.d.ts.map

package/dist/compiler/directSoap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directSoap.d.ts","sourceRoot":"","sources":["../../src/compiler/directSoap.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,sBAAsB,CAAC;AAIlE,OAAO,KAAK,EAAC,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAG5F,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAGvD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,OAAO,CAAC;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AACD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,WAAW,GAAG,UAAU,CAAC;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AACD,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,GAAG,QAAQ,CAAC;IAC1D,IAAI,EAAE,eAAe,GAAG,YAAY,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IACtD,OAAO,EAAE,gBAAgB,CAAC;IAC1B,gFAAgF;IAChF,aAAa,EAAE,UAAU,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAC;QAAC,QAAQ,EAAE,aAAa,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAC9G,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC,CAAC;AAMH,8EAA8E;AAC9E,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,IAAI,GAAG,MAAM,GAAG,SAAS,CAW9F;AAED,+FAA+F;AAC/F,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,uBAAuB,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EACrH,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAqMvD"}

package/dist/compiler/directSoap.js

@@ -0,0 +1,298 @@
+import { isApplicationUnmetered } from './semanticBudget.js';
+import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
+/** Internal, one-retained-operation, unauthenticated loopback SOAP 1.1 adapter. */
+import { checkSemanticBudget } from './semanticBudget.js';
+import { DataOwnershipLimitError } from './dataOwnership.js';
+import { Agent } from 'node:http';
+import { types } from 'node:util';
+import { WSDL } from 'soap/lib/wsdl/index.js';
+import { Client } from 'soap/lib/client.js';
+import { HttpClient } from 'soap/lib/http.js';
+import { inspectDirectOperation } from './directOperation.js';
+import { createDirectValueMapping, inspectDirectValueMapping } from './directValues.js';
+import { decodeDirectXml, encodeDirectXml, DIRECT_XML_LIMITS } from './directCodec.js';
+import { prepareDirectSoapSource, DirectSoapSourceError } from './directSoapSource.js';
+import { isXmlNCName, resolveLexicalQName, SchemaLoadingError } from '../loader/orderedSyntax.js';
+const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
+class Stop extends Error {
+    kind;
+    rule;
+    constructor(kind, rule) {
+        super(rule);
+        this.kind = kind;
+        this.rule = rule;
+    }
+}
+const same = (a, b) => a.namespace === b.namespace && a.local === b.local;
+/** Shared entry guard: consumers must call before reading any SOAP option. */
+export function directSoapOptionsShape(options, check) {
+    if (!options || typeof options !== 'object' || types.isProxy(options)
+        || ![null, Object.prototype].includes(Object.getPrototypeOf(options)))
+        return 'data-only SOAP options required';
+    const allowed = new Set(['service', 'port', 'endpoint', 'allowEndpoint', 'signal', 'timeoutMs', 'limits', 'capabilities']);
+    for (const key of Reflect.ownKeys(options)) {
+        check();
+        const descriptor = Object.getOwnPropertyDescriptor(options, key);
+        if (typeof key !== 'string' || !allowed.has(key) || !descriptor || !('value' in descriptor))
+            return 'SOAP option or capability';
+    }
+    return undefined;
+}
+/** Authentication and fresh-value validation precede dependency bootstrap and all HTTP I/O. */
+export async function exchangeDirectSoap(contract, inputMapping, application, options) {
+    const { context, source } = inspectDirectOperation(contract);
+    const input = inspectDirectValueMapping(inputMapping, contract);
+    if (input.direction.kind !== 'input')
+        throw new TypeError('SOAP request requires the exact input mapping');
+    const { budget } = context;
+    const fail = (kind, rule) => Object.freeze({ kind, rule, usage: Object.freeze({ ...budget.usage() }) });
+    let signal;
+    const check = () => { checkSemanticBudget(budget); if (signal?.aborted)
+        throw new Stop('cancelled', 'cooperative-cancellation'); };
+    const stop = (kind, rule) => { throw new Stop(kind, rule); };
+    let agent;
+    let controller;
+    let deadline;
+    const abort = () => controller?.abort();
+    try {
+        check();
+        // Options are a closed capability surface. Never silently discard security,
+        // headers, endpoint agents, redirects, streaming or other caller extensions.
+        const optionRule = directSoapOptionsShape(options, check);
+        if (optionRule)
+            return fail('unsupported', optionRule);
+        signal = options.signal;
+        if (signal !== undefined && !(signal instanceof AbortSignal))
+            return fail('unsupported', 'native AbortSignal required');
+        const allowEndpoint = options.allowEndpoint;
+        check();
+        const config = directDataOwnership(budget).freeze(directDataOwnership(budget).snapshot({ service: options.service, port: options.port, endpoint: options.endpoint,
+            timeoutMs: options.timeoutMs ?? (isApplicationUnmetered(budget) ? 0 : 15_000), limits: options.limits ?? {}, capabilities: options.capabilities ?? [] }));
+        if (!Array.isArray(config.capabilities) || config.capabilities.length)
+            return fail('unsupported', 'SOAP capability');
+        if (!Number.isSafeInteger(config.timeoutMs) || config.timeoutMs < 0 || config.timeoutMs > 2_147_483_647)
+            throw new RangeError('SOAP timeout must be a positive timer integer');
+        const limits = { maxBytes: directLimit(budget, DIRECT_XML_LIMITS.maxBytes), maxDepth: directLimit(budget, DIRECT_XML_LIMITS.maxDepth),
+            maxNodes: directLimit(budget, DIRECT_XML_LIMITS.maxNodes), maxText: directLimit(budget, DIRECT_XML_LIMITS.maxText), ...config.limits };
+        for (const [key, value] of Object.entries(limits)) {
+            if (!['maxBytes', 'maxDepth', 'maxNodes', 'maxText'].includes(key) || !Number.isSafeInteger(value) || value < 1)
+                throw new RangeError('Invalid SOAP XML limit');
+        }
+        if (typeof config.endpoint !== 'string' || typeof config.port !== 'string' || !isXmlNCName(config.port)
+            || !config.service || typeof config.service.namespace !== 'string' || !isXmlNCName(config.service.local))
+            return fail('unsupported', 'explicit SOAP selection');
+        const endpoint = new URL(config.endpoint);
+        if (endpoint.protocol !== 'http:' || endpoint.hostname !== '127.0.0.1' || !endpoint.port || endpoint.port === '1'
+            || endpoint.username || endpoint.password || endpoint.hash || endpoint.search)
+            return fail('unsupported', 'owned loopback HTTP endpoint required');
+        if (typeof allowEndpoint !== 'function' || allowEndpoint(new URL(endpoint.href)) !== true)
+            return fail('unsupported', 'endpoint authorization');
+        const action = contract.binding.action;
+        if (/[^\x20-\x21\x23-\x7e]|\\/.test(action))
+            return fail('unsupported', 'unsafe SOAPAction');
+        const { wsdlText } = prepareDirectSoapSource(contract, config, check);
+        const elements = (node) => {
+            check();
+            return node.children.filter((child) => child.kind === 'element');
+        };
+        const encoded = encodeDirectXml(contract, input, application, { signal, limits });
+        if (encoded.kind !== 'direct-encoded')
+            return fail(encoded.kind, encoded.rule);
+        const output = createDirectValueMapping(contract, { kind: 'output' }, { signal });
+        if (output.kind !== 'direct-mapping')
+            return fail(output.kind, output.rule);
+        const faults = new Map();
+        for (const fault of contract.faults) {
+            check();
+            const mapping = createDirectValueMapping(contract, { kind: 'fault', name: fault.name }, { signal });
+            if (mapping.kind !== 'direct-mapping')
+                return fail(mapping.kind, mapping.rule);
+            faults.set(fault.name, mapping);
+        }
+        const shape = (node) => {
+            const children = elements(node);
+            if (node.attributes.length || node.children.some(n => n.kind === 'text' && /[^\t\r\n ]/.test(n.value)))
+                stop('protocol', 'SOAP protocol attributes or text');
+            return children;
+        };
+        const bodyRoot = (root) => {
+            if (!same(root.name, { namespace: SOAP, local: 'Envelope' }))
+                stop('protocol', 'SOAP 1.1 Envelope required');
+            const children = shape(root);
+            if (children[0]?.name.namespace === SOAP && children[0].name.local === 'Header') {
+                if (shape(children[0]).length)
+                    stop('unsupported', 'incoming SOAP headers');
+                children.shift();
+            }
+            if (children.length !== 1 || !same(children[0].name, { namespace: SOAP, local: 'Body' }))
+                stop('protocol', 'one SOAP Body required');
+            const body = shape(children[0]);
+            if (body.length !== 1)
+                stop('protocol', 'one SOAP Body payload required');
+            return body[0];
+        };
+        // The native dependency receives only the explicitly byte-bounded source.
+        const wsdl = new WSDL(wsdlText, source.root.uri, { wsdl_options: { overrideImportLocation: () => { throw new Stop('unsupported', 'dependency import forbidden'); } } });
+        await new Promise((resolve, reject) => wsdl.onReady(error => error ? reject(error) : resolve()));
+        check();
+        // HTTP and codec byte limits bound buffering and output copies directly.
+        agent = new Agent({ keepAlive: false, maxSockets: 1 });
+        controller = new AbortController();
+        signal?.addEventListener('abort', abort, { once: true });
+        let timedOut = false;
+        if (config.timeoutMs > 0)
+            deadline = setTimeout(() => { timedOut = true; controller.abort(); }, config.timeoutMs);
+        const complete = new Error('direct raw response captured');
+        let response;
+        let hookFailure;
+        class BufferedHttp extends HttpClient {
+            request(url, data, callback, headers, _options) {
+                try {
+                    check();
+                    if (url !== endpoint.href || headers.SOAPAction !== `"${action}"` || headers['Content-Type'] !== 'text/xml; charset=utf-8')
+                        stop('protocol', 'dependency dispatch mismatch');
+                    if (Buffer.byteLength(data) > limits.maxBytes)
+                        stop('resource-limit', 'SOAP request byte limit');
+                    const outgoing = decodeDirectXml(contract, input, Buffer.from(data), { signal, limits,
+                        uri: 'urn:typescript-wsdl-client:outgoing-soap', selectPayload: root => ({ payload: bodyRoot(root), mapping: input }) });
+                    if (outgoing.kind !== 'direct-decoded')
+                        stop(outgoing.kind, outgoing.rule);
+                    check();
+                }
+                catch (error) {
+                    hookFailure = error;
+                    callback(complete);
+                    // The dependency ignores this return value; no HTTP request is made.
+                    const rejected = Promise.reject(complete);
+                    void rejected.catch(() => { });
+                    return rejected;
+                }
+                return super.request(url, data, (error, res, bytes) => {
+                    // Never throw through HttpClient's detached then-handler.
+                    try {
+                        check();
+                        if (error)
+                            hookFailure = error;
+                        else if (!res || !Buffer.isBuffer(bytes))
+                            stop('transport', 'raw response bytes unavailable');
+                        else
+                            response = { bytes, status: res.status, contentType: String(res.headers['content-type'] ?? ''), encoding: String(res.headers['content-encoding'] ?? '') };
+                    }
+                    catch (failure) {
+                        hookFailure = failure;
+                    }
+                    // No response object/data on this sentinel: node-soap cannot enter
+                    // xmlToObject, including its special err.response parsing path.
+                    callback(complete);
+                }, headers, { responseType: 'arraybuffer', decompress: false, maxRedirects: 0, maxContentLength: limits.maxBytes,
+                    maxBodyLength: limits.maxBytes, proxy: false, httpAgent: agent, signal: controller.signal, timeout: config.timeoutMs });
+            }
+        }
+        const client = new Client(wsdl, endpoint.href, { httpClient: new BufferedHttp() });
+        // Every lookup is own and explicit; the dependency's first-port shortcut is
+        // never consulted. Source checks above bind these names to the native handle.
+        const own = (object, key) => Object.getOwnPropertyDescriptor(object, key)?.value;
+        const service = own(client, config.service.local);
+        const port = service && typeof service === 'object' ? own(service, config.port) : undefined;
+        const method = port && typeof port === 'object' ? own(port, contract.selector.operation) : undefined;
+        if (typeof method !== 'function')
+            return fail('unsupported', 'dependency selected method unavailable');
+        check();
+        await new Promise((resolve, reject) => method({ _xml: Buffer.from(encoded.bytes).toString('utf8') }, (error) => error === complete ? resolve() : reject(error), {}, { SOAPAction: `"${action}"` }));
+        check();
+        if (timedOut)
+            return fail('transport', 'SOAP deadline exceeded');
+        if (hookFailure)
+            throw hookFailure;
+        if (!response)
+            return fail('transport', 'incomplete HTTP response');
+        const observed = response;
+        if (observed.encoding && observed.encoding.toLowerCase() !== 'identity')
+            return fail('unsupported', 'HTTP compression');
+        const media = /^text\/xml(?:\s*;\s*charset\s*=\s*(?:"(utf-8|utf-16|utf-16le|utf-16be)"|(utf-8|utf-16|utf-16le|utf-16be)))?\s*$/i.exec(observed.contentType);
+        if (!media)
+            return fail('protocol', 'SOAP response Content-Type');
+        if (observed.status !== 200 && observed.status !== 500)
+            return fail('transport', 'SOAP HTTP status');
+        // Header charset is a protocol assertion, checked against actual BOM bytes.
+        const charset = (media[1] ?? media[2])?.toLowerCase();
+        const bom = observed.bytes[0] === 0xff && observed.bytes[1] === 0xfe ? 'utf-16le'
+            : observed.bytes[0] === 0xfe && observed.bytes[1] === 0xff ? 'utf-16be' : 'utf-8';
+        if (charset && charset !== bom && !(charset === 'utf-16' && bom.startsWith('utf-16')))
+            return fail('protocol', 'SOAP charset disagrees with bytes');
+        let faultInfo;
+        const decoded = decodeDirectXml(contract, output, observed.bytes, { signal, limits, uri: endpoint.href,
+            selectPayload: root => {
+                const payload = bodyRoot(root);
+                if (!same(payload.name, { namespace: SOAP, local: 'Fault' })) {
+                    if (observed.status !== 200)
+                        stop('protocol', 'HTTP 500 requires SOAP Fault');
+                    return { payload, mapping: output };
+                }
+                const children = shape(payload);
+                const names = children.map(n => n.name.namespace === '' ? n.name.local : '');
+                if (names.join(',') !== 'faultcode,faultstring,detail' && names.join(',') !== 'faultcode,faultstring,faultactor,detail')
+                    stop('protocol', 'SOAP Fault children');
+                const text = (node) => {
+                    if (node.attributes.some(a => !(node.name.local === 'faultstring' && a.name.namespace === 'http://www.w3.org/XML/1998/namespace' && a.name.local === 'lang')) || elements(node).length)
+                        stop('protocol', 'SOAP Fault scalar child');
+                    return node.children.map(n => n.kind === 'text' ? n.value : '').join('');
+                };
+                let code;
+                try {
+                    code = resolveLexicalQName(text(children[0]), children[0]);
+                }
+                catch (error) {
+                    if (error instanceof SchemaLoadingError)
+                        return stop('protocol', 'SOAP Fault code QName');
+                    throw error;
+                }
+                if (!code.namespace)
+                    stop('protocol', 'SOAP Fault code namespace required');
+                const string = text(children[1]);
+                const actor = names[2] === 'faultactor' ? text(children[2]) : undefined;
+                const detail = shape(children.at(-1));
+                if (detail.length !== 1)
+                    stop('protocol', 'one declared SOAP Fault detail required');
+                const matches = contract.faults.filter(f => same(f.root.element.name, detail[0].name));
+                if (matches.length !== 1)
+                    stop('protocol', 'unknown or ambiguous SOAP Fault detail');
+                faultInfo = { name: matches[0].name, code, codeNode: children[0], string, ...(actor === undefined ? {} : { actor }) };
+                directDataOwnership(budget).freeze(faultInfo);
+                return { payload: detail[0], mapping: faults.get(faultInfo.name) };
+            } });
+        if (decoded.kind !== 'direct-decoded')
+            return fail(decoded.kind, decoded.rule);
+        check();
+        check();
+        return Object.freeze({ kind: faultInfo ? 'soap-fault' : 'soap-response', admitted: false, decoded,
+            responseBytes: new Uint8Array(observed.bytes), status: observed.status, ...(faultInfo ? { fault: faultInfo } : {}), usage: Object.freeze({ ...budget.usage() }) });
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return fail('resource-limit', 'request-budget');
+        if (error instanceof DataOwnershipLimitError)
+            return fail('resource-limit', error.message);
+        if (signal?.aborted)
+            return fail('cancelled', 'cooperative-cancellation');
+        if (error instanceof DirectSoapSourceError)
+            return fail(error.kind, error.message);
+        if (error instanceof Stop)
+            return fail(error.kind, error.rule);
+        if (error instanceof SchemaLoadingError)
+            return fail(error.category === 'resource-limit' ? 'resource-limit' : error.category === 'invalid-schema' ? 'protocol' : 'unsupported', 'SOAP protocol XML');
+        if (error instanceof Error && 'code' in error) {
+            if (error.code === 'ERR_BAD_RESPONSE' && error.message.startsWith('maxContentLength size of '))
+                return fail('resource-limit', 'HTTP response byte limit');
+            return fail('transport', error.code === 'ERR_CANCELED' ? 'SOAP deadline exceeded' : 'HTTP exchange failed');
+        }
+        throw error;
+    }
+    finally {
+        if (deadline)
+            clearTimeout(deadline);
+        signal?.removeEventListener('abort', abort);
+        controller?.abort();
+        agent?.destroy();
+    }
+}

package/dist/compiler/directSoapSource.d.ts

@@ -0,0 +1,15 @@
+import type { DirectOperationContract } from './directOperation.js';
+import type { ExpandedName } from '../loader/orderedSyntax.js';
+export declare const DIRECT_SOAP_SOURCE_MAX_BYTES: number;
+export declare class DirectSoapSourceError extends Error {
+    readonly kind: 'unsupported' | 'resource-limit';
+    constructor(message: string, kind?: 'unsupported' | 'resource-limit');
+}
+export declare function prepareDirectSoapSource(contract: DirectOperationContract, config: {
+    service: ExpandedName;
+    port: string;
+}, check: () => void): {
+    original: Uint8Array<ArrayBufferLike>;
+    wsdlText: string;
+};
+//# sourceMappingURL=directSoapSource.d.ts.map