@techspokes/typescript-wsdl-client 1.2.0 → 1.4.0

package/dist/compiler/directSoap.js

@@ -1,11 +1,11 @@
 import { isApplicationUnmetered } from './semanticBudget.js';
 import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
-/** Shared retained-operation SOAP 1.1 exchange; profile-specific authority stays explicit. */
+/** Shared retained-operation SOAP exchange; profile-specific authority stays explicit. */
 import { checkSemanticBudget } from './semanticBudget.js';
 import { DataOwnershipLimitError } from './dataOwnership.js';
 import { Agent } from 'node:http';
 import { Agent as HttpsAgent } from 'node:https';
-import { types } from 'node:util';
+import { types, MIMEType } 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';
@@ -16,7 +16,7 @@ import { prepareDirectSoapSource, prepareComponentSoapWsdl, DirectSoapSourceErro
 import { isXmlNCName, resolveLexicalQName, SchemaLoadingError, syntaxElements, syntaxAttribute, WSDL_NAMESPACE } from '../loader/orderedSyntax.js';
 import { decodeComponentRecordXml, inspectComponentRecordProjection } from './componentRecordProjection.js';
 import { assessComponentSoapHeader } from './soapHeaders.js';
-const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
+const SOAP11 = 'http://schemas.xmlsoap.org/soap/envelope/';
 class Stop extends Error {
     kind;
     rule;
@@ -44,7 +44,7 @@ export function directSoapOptionsShape(options, check, additional = []) {
 /** Authentication and fresh-value validation precede dependency bootstrap and all HTTP I/O. */
 export async function exchangeDirectSoap(contract, inputMapping, application, options) {
     const input = inspectDirectValueMapping(inputMapping, contract);
-    return exchangeSoap(contract, input, application, options, {
+    const result = await exchangeSoap(contract, input, application, options, {
         component: false, encode: encodeDirectXml, decode: decodeDirectXml, create: createDirectValueMapping,
         prepare: async (selection, check) => {
             const { source } = inspectDirectOperation(contract);
@@ -54,13 +54,16 @@ export async function exchangeDirectSoap(contract, inputMapping, application, op
             return wsdl;
         },
     });
+    if (result.kind === 'soap-fault' && !('decoded' in result))
+        throw new TypeError('Component fault on direct profile');
+    return result;
 }
-export async function exchangeComponentSoap(contract, inputMapping, application, options, responseProjection) {
+export async function exchangeComponentSoap(contract, inputMapping, application, options, responseProjection, soap11ProtocolFaults = true) {
     const { mapping: input } = inspectComponentValueMapping(inputMapping, contract);
     if (responseProjection !== undefined) {
         inspectComponentRecordProjection(responseProjection, contract);
         return exchangeSoap(contract, input, application, options, {
-            component: true,
+            component: true, soap11ProtocolFaults,
             encode(owner, mapping, value, controls) {
                 if (mapping.kind !== 'component-mapping')
                     throw new TypeError('SOAP input requires the native input mapping');
@@ -83,12 +86,13 @@ export async function exchangeComponentSoap(contract, inputMapping, application,
         });
     }
     return exchangeSoap(contract, input, application, options, {
-        component: true, encode: encodeComponentXml, decode: decodeComponentXml,
+        component: true, soap11ProtocolFaults, encode: encodeComponentXml, decode: decodeComponentXml,
         create: (owner, direction, controls) => createComponentDirectionalMapping(owner, input, direction, controls),
         prepare: (selection, check) => prepareComponentSoapWsdl(contract, selection, check),
     });
 }
 async function exchangeSoap(contract, input, application, options, profile) {
+    const soap12 = profile.component && contract.binding.version === '1.2';
     const { context } = inspectDirectOperation(contract);
     if (input.direction.kind !== 'input')
         throw new TypeError('SOAP request requires the exact input mapping');
@@ -120,7 +124,7 @@ async function exchangeSoap(contract, input, application, options, profile) {
             const { source } = inspectDirectOperation(contract);
             const services = source.documents.flatMap(d => syntaxElements(d.root, WSDL_NAMESPACE, 'service').filter(n => syntaxAttribute(d.root, 'targetNamespace') === options.service?.namespace && syntaxAttribute(n, 'name') === options.service?.local));
             const ports = services.flatMap(n => syntaxElements(n, WSDL_NAMESPACE, 'port').filter(p => syntaxAttribute(p, 'name') === options.port));
-            const addresses = ports.flatMap(p => syntaxElements(p, 'http://schemas.xmlsoap.org/wsdl/soap/', 'address'));
+            const addresses = ports.flatMap(p => syntaxElements(p, soap12 ? 'http://schemas.xmlsoap.org/wsdl/soap12/' : 'http://schemas.xmlsoap.org/wsdl/soap/', 'address'));
             if (services.length !== 1 || ports.length !== 1 || addresses.length !== 1 || !syntaxAttribute(addresses[0], 'location')) {
                 return fail('unsupported', 'Select one SOAP service/port address or supply an endpoint override');
             }
@@ -174,10 +178,6 @@ async function exchangeSoap(contract, input, application, options, profile) {
         const rpc = contract.binding.style === 'rpc';
         if (/[^\x20-\x21\x23-\x7e]|\\/.test(action))
             return fail('unsupported', 'unsafe SOAPAction');
-        const elements = (node) => {
-            check();
-            return node.children.filter((child) => child.kind === 'element');
-        };
         const encoded = profile.encode(contract, input, application, { signal, limits });
         if (!('bytes' in encoded))
             return fail(encoded.kind, encoded.rule, 'input');
@@ -192,42 +192,7 @@ async function exchangeSoap(contract, input, application, options, profile) {
                 return fail(mapping.kind, mapping.rule);
             faults.set(fault.name, mapping);
         }
-        const shape = (node, encodedScope = false) => {
-            const children = elements(node);
-            if (node.attributes.some(a => !(encodedScope && a.name.namespace === SOAP && a.name.local === 'encodingStyle'
-                && a.value === 'http://schemas.xmlsoap.org/soap/encoding/')) || node.children.some(n => n.kind === 'text' && /[^\t\r\n ]/.test(n.value)))
-                stop('protocol', 'SOAP protocol attributes or text');
-            return children;
-        };
-        const ignoredHeaders = [];
-        const bodyRoot = (root, incoming = false) => {
-            if (!same(root.name, { namespace: SOAP, local: 'Envelope' }))
-                stop('protocol', 'SOAP 1.1 Envelope required');
-            const children = shape(root, rpc);
-            if (children[0]?.name.namespace === SOAP && children[0].name.local === 'Header') {
-                if (profile.component && incoming) {
-                    const assessed = assessComponentSoapHeader(children[0], check);
-                    if (assessed.kind !== 'ignored-optional-headers')
-                        stop(assessed.kind, assessed.rule);
-                    else
-                        for (const name of assessed.headers) {
-                            check();
-                            ignoredHeaders.push(name);
-                        }
-                }
-                else 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], rpc);
-            if (rpc && !body.some(n => same(n.name, { namespace: SOAP, local: 'Fault' })))
-                return children[0];
-            if (body.length !== 1)
-                stop('protocol', 'one SOAP Body payload required');
-            return body[0];
-        };
+        const { bodyRoot } = soapProtocolSelection(contract, profile.component, check, stop);
         const wsdl = await profile.prepare(config, check);
         check();
         // @why node-soap's RPC writer would wrap `_xml` as a parameter. This private
@@ -255,7 +220,8 @@ async function exchangeSoap(contract, input, application, options, profile) {
             request(url, data, callback, headers, _options) {
                 try {
                     check();
-                    if (url !== endpoint.href || headers.SOAPAction !== `"${action}"` || headers['Content-Type'] !== 'text/xml; charset=utf-8')
+                    if (url !== endpoint.href || (soap12 ? headers.SOAPAction !== undefined || headers['Content-Type'] !== requestContentType
+                        : 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');
@@ -294,7 +260,8 @@ async function exchangeSoap(contract, input, application, options, profile) {
                     maxBodyLength: limits.maxBytes, proxy: false, httpAgent: agent, httpsAgent: agent, signal: controller.signal, timeout: config.timeoutMs });
             }
         }
-        const client = new Client(wsdl, endpoint.href, { httpClient: new BufferedHttp() });
+        const requestContentType = soap12 ? 'application/soap+xml; charset=utf-8' + (action ? `; action="${action}"` : '') : 'text/xml; charset=utf-8';
+        const client = new Client(wsdl, endpoint.href, { httpClient: new BufferedHttp(), ...(soap12 ? { forceSoap12Headers: true } : {}) });
         // 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;
@@ -304,7 +271,7 @@ async function exchangeSoap(contract, input, application, options, profile) {
         if (typeof method !== 'function')
             return fail('unsupported', 'dependency selected method unavailable');
         check();
-        await new Promise((resolve, reject) => method(rpc ? rpcArguments : { _xml: Buffer.from(encoded.bytes).toString('utf8') }, (error) => error === complete ? resolve() : reject(error), {}, { SOAPAction: `"${action}"` }));
+        await new Promise((resolve, reject) => method(rpc ? rpcArguments : { _xml: Buffer.from(encoded.bytes).toString('utf8') }, (error) => error === complete ? resolve() : reject(error), {}, soap12 ? { 'Content-Type': requestContentType } : { SOAPAction: `"${action}"` }));
         check();
         if (timedOut)
             return fail('transport', 'SOAP deadline exceeded');
@@ -313,35 +280,238 @@ async function exchangeSoap(contract, input, application, options, profile) {
         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|iso-8859-1)"|(utf-8|utf-16|utf-16le|utf-16be|iso-8859-1)))?\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();
-        if (!profile.component && charset === 'iso-8859-1')
-            return fail('protocol', 'SOAP response Content-Type');
-        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 (!profile.component && charset && charset !== bom && !(charset === 'utf-16' && bom.startsWith('utf-16')))
-            return fail('protocol', 'SOAP charset disagrees with bytes');
+        const assessed = assessSoapResponse(contract, output, faults, observed.bytes, profile, { signal, limits, uri: endpoint.href,
+            responseMetadata: { status: observed.status, contentType: observed.contentType, contentEncoding: observed.encoding } });
+        if (!('admitted' in assessed))
+            return assessed;
+        if (assessed.decoded === undefined) {
+            if (!profile.component || !assessed.fault || 'name' in assessed.fault)
+                throw new TypeError('Missing decoded SOAP response');
+            return Object.freeze({ kind: 'soap-fault', admitted: false, fault: assessed.fault,
+                responseBytes: new Uint8Array(observed.bytes), status: observed.status, usage: assessed.usage,
+                ...(assessed.ignoredHeaders ? { ignoredHeaders: assessed.ignoredHeaders } : {}) });
+        }
+        if (assessed.fault && !('name' in assessed.fault))
+            throw new TypeError('Decoded fault requires its declared application mapping');
+        return Object.freeze({ kind: assessed.kind, admitted: false, decoded: assessed.decoded,
+            responseBytes: new Uint8Array(observed.bytes), status: observed.status, usage: assessed.usage,
+            ...(assessed.fault && 'name' in assessed.fault ? { fault: assessed.fault } : {}),
+            ...(assessed.ignoredHeaders ? { ignoredHeaders: assessed.ignoredHeaders } : {}) });
+    }
+    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();
+    }
+}
+/** Assess caller-observed response bytes through the same protocol and native decoder used by real exchanges.
+ * @param contract Authenticated selected component operation.
+ * @param inputMapping Exact operation input mapping, used only to derive response/fault mappings.
+ * @param bytes Actual observed SOAP entity bytes; no request or transport is constructed.
+ * @param options XML controls, optional actual HTTP metadata and exact response projection.
+ * @returns Native response/fault assessment or semantic failure; HTTP remains unassessed when metadata is absent.
+ * @throws TypeError For foreign native handles; RangeError for invalid explicit XML limits.
+ * @constraints This response-only helper performs no transport, endpoint authorization or request-value assessment.
+ */
+export function inspectComponentSoapResponse(contract, inputMapping, bytes, options = {}) {
+    const { mapping: input } = inspectComponentValueMapping(inputMapping, contract);
+    const { context } = inspectDirectOperation(contract);
+    const failure = (kind, rule) => Object.freeze({ kind, rule, phase: 'response', usage: context.budget.usage() });
+    if (options.signal?.aborted)
+        return failure('cancelled', 'cooperative-cancellation');
+    const limits = { ...DIRECT_XML_LIMITS, ...options.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 (options.responseProjection)
+        inspectComponentRecordProjection(options.responseProjection, contract);
+    const output = options.responseProjection ?? createComponentDirectionalMapping(contract, input, { kind: 'output' }, { signal: options.signal });
+    if (!('direction' in output))
+        return output;
+    const faults = new Map();
+    for (const fault of contract.faults) {
+        const mapping = createComponentDirectionalMapping(contract, input, { kind: 'fault', name: fault.name }, { signal: options.signal });
+        if (mapping.kind !== 'component-mapping')
+            return mapping;
+        faults.set(fault.name, mapping);
+    }
+    return assessSoapResponse(contract, output, faults, bytes, { component: true, soap11ProtocolFaults: true,
+        decode(owner, mapping, observed, controls) {
+            if (mapping.kind === 'component-record-projection')
+                return decodeComponentRecordXml(owner, mapping, observed, controls);
+            return decodeComponentXml(owner, mapping, observed, { ...controls, selectPayload(root) {
+                    const selected = controls.selectPayload(root);
+                    if (selected.mapping.kind !== 'component-mapping')
+                        throw new TypeError('Normal component decoding requires its exact mapping');
+                    return { payload: selected.payload, mapping: selected.mapping };
+                } });
+        },
+    }, { ...options, limits });
+}
+/** Shared response episode for offline inspection and actual HTTP exchanges. */
+function assessSoapResponse(contract, output, faults, bytes, profile, options) {
+    const { context } = inspectDirectOperation(contract), { budget } = context;
+    const signal = options.signal, limits = options.limits;
+    const soap12 = profile.component && contract.binding.version === '1.2';
+    const SOAP = soap12 ? 'http://www.w3.org/2003/05/soap-envelope' : SOAP11;
+    const fail = (kind, rule, phase) => Object.freeze({ kind, rule, ...(phase ? { phase } : {}), usage: Object.freeze({ ...budget.usage() }) });
+    const check = () => { checkSemanticBudget(budget); if (signal?.aborted)
+        throw new Stop('cancelled', 'cooperative-cancellation'); };
+    const stop = (kind, rule) => { throw new Stop(kind, rule); };
+    try {
+        check();
+        const { elements, shape, bodyRoot, ignoredHeaders } = soapProtocolSelection(contract, profile.component, check, stop);
+        let charset;
+        const metadata = options.responseMetadata;
+        if (metadata) {
+            if ((metadata.contentEncoding ?? '') && (metadata.contentEncoding ?? '').toLowerCase() !== 'identity')
+                return fail('unsupported', 'HTTP compression');
+            let soap12Charset;
+            let validSoap12Media = false;
+            if (soap12) {
+                try {
+                    const mime = new MIMEType(metadata.contentType);
+                    soap12Charset = mime.params.get('charset')?.toLowerCase();
+                    validSoap12Media = mime.essence === 'application/soap+xml' && (!soap12Charset || ['utf-8', 'utf-16', 'utf-16le', 'utf-16be', 'iso-8859-1'].includes(soap12Charset));
+                }
+                catch { /* Invalid media types are refused below. */ }
+            }
+            const media = soap12 ? validSoap12Media ? ['', soap12Charset] : null : /^text\/xml(?:\s*;\s*charset\s*=\s*(?:"(utf-8|utf-16|utf-16le|utf-16be|iso-8859-1)"|(utf-8|utf-16|utf-16le|utf-16be|iso-8859-1)))?\s*$/i.exec(metadata.contentType);
+            if (!media)
+                return fail('protocol', 'SOAP response Content-Type');
+            if (metadata.status !== 200 && metadata.status !== 500 && !(soap12 && metadata.status === 400))
+                return fail('transport', 'SOAP HTTP status');
+            // Header charset is a protocol assertion, checked against actual BOM bytes.
+            charset = (media[1] ?? media[2])?.toLowerCase();
+            if (!profile.component && charset === 'iso-8859-1')
+                return fail('protocol', 'SOAP response Content-Type');
+            const bom = bytes[0] === 0xff && bytes[1] === 0xfe ? 'utf-16le'
+                : bytes[0] === 0xfe && bytes[1] === 0xff ? 'utf-16be' : 'utf-8';
+            if (!profile.component && charset && charset !== bom && !(charset === 'utf-16' && bom.startsWith('utf-16')))
+                return fail('protocol', 'SOAP charset disagrees with bytes');
+        }
         let faultInfo;
-        const decoded = profile.decode(contract, output, observed.bytes, { signal, limits, uri: endpoint.href,
+        let protocolFault;
+        const protocolFaultSignal = new Error('SOAP protocol fault assessed');
+        const decodeResponse = () => profile.decode(contract, output, bytes, { signal, limits, uri: options.uri ?? 'urn:typescript-wsdl-client:observed-soap-response',
             ...(profile.component ? { componentResponseEncoding: { charset } } : {}),
             selectPayload: root => {
                 const payload = bodyRoot(root, true);
                 if (!same(payload.name, { namespace: SOAP, local: 'Fault' })) {
-                    if (observed.status !== 200)
+                    if (options.responseMetadata && options.responseMetadata.status !== 200)
                         stop('protocol', 'HTTP 500 requires SOAP Fault');
                     return { payload, mapping: output };
                 }
+                if (soap12) {
+                    const children = shape(payload);
+                    const names = children.map(n => n.name.namespace === SOAP ? n.name.local : '');
+                    if (!/^Code,Reason(?:,Node)?(?:,Role)?(?:,Detail)?$/.test(names.join(',')))
+                        stop('protocol', 'SOAP 1.2 Fault children');
+                    const scalar = (node, language = false) => {
+                        check();
+                        if (elements(node).length || node.attributes.some(a => !(language && a.name.namespace === 'http://www.w3.org/XML/1998/namespace' && a.name.local === 'lang')))
+                            stop('protocol', 'SOAP 1.2 Fault scalar child');
+                        return node.children.map(n => n.kind === 'text' ? n.value : '').join('');
+                    };
+                    const qname = (node) => {
+                        const lexical = scalar(node);
+                        try {
+                            const name = resolveLexicalQName(lexical, node);
+                            return name;
+                        }
+                        catch (error) {
+                            if (error instanceof SchemaLoadingError)
+                                return stop('protocol', 'SOAP Fault code QName');
+                            throw error;
+                        }
+                    };
+                    const codes = [];
+                    let codeNode;
+                    let codeContainer = children[0];
+                    while (codeContainer) {
+                        check();
+                        const nested = shape(codeContainer);
+                        if (nested.length < 1 || nested.length > 2 || !same(nested[0].name, { namespace: SOAP, local: 'Value' })
+                            || nested[1] && !same(nested[1].name, { namespace: SOAP, local: 'Subcode' }))
+                            stop('protocol', 'SOAP 1.2 Fault Code');
+                        codeNode ??= nested[0];
+                        codes.push(qname(nested[0]));
+                        codeContainer = nested[1];
+                    }
+                    const code = codes[0];
+                    if (code.namespace !== SOAP || !['VersionMismatch', 'MustUnderstand', 'DataEncodingUnknown', 'Sender', 'Receiver'].includes(code.local))
+                        stop('protocol', 'SOAP 1.2 Fault code');
+                    if (options.responseMetadata?.status === 400 && code.local !== 'Sender')
+                        stop('protocol', 'HTTP 400 requires SOAP Sender Fault');
+                    const reasonChildren = shape(children[1]);
+                    if (!reasonChildren.length)
+                        stop('protocol', 'SOAP 1.2 Fault Reason');
+                    const reasons = reasonChildren.map(node => {
+                        check();
+                        if (!same(node.name, { namespace: SOAP, local: 'Text' }))
+                            stop('protocol', 'SOAP 1.2 Fault Reason Text');
+                        const text = scalar(node, true), lang = syntaxAttribute(node, 'lang', 'http://www.w3.org/XML/1998/namespace');
+                        if (lang === undefined || !/^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*$/.test(lang))
+                            stop('protocol', 'SOAP 1.2 Fault language');
+                        return { lang: lang, text };
+                    });
+                    const uriField = (local) => {
+                        const node = children.find(n => n.name.local === local);
+                        if (!node)
+                            return undefined;
+                        const value = scalar(node).trim();
+                        if (!/^[A-Za-z][A-Za-z0-9+.-]*:[^\s]*$/.test(value))
+                            stop('protocol', 'SOAP 1.2 Fault URI');
+                        return value;
+                    };
+                    const node = uriField('Node'), role = uriField('Role');
+                    const metadata = { version: '1.2', code, subcodes: codes.slice(1), reasons, string: reasons[0].text,
+                        ...(node === undefined ? {} : { node }), ...(role === undefined ? {} : { role }) };
+                    const detailNode = children.find(n => n.name.local === 'Detail');
+                    // @see SOAP 1.2 section 5.4.5 permits attributes on Detail; these protocol-wrapper attributes stay in the original bytes.
+                    if (detailNode?.children.some(n => n.kind === 'text' && /[^\t\r\n ]/.test(n.value)))
+                        stop('protocol', 'SOAP 1.2 Fault Detail text');
+                    const detail = detailNode ? elements(detailNode) : [];
+                    const matches = contract.faults.filter(f => detail.some(n => same(f.root.element.name, n.name)));
+                    if (matches.length) {
+                        if (matches.length !== 1 || detail.length !== 1)
+                            stop('protocol', 'ambiguous SOAP Fault detail');
+                        faultInfo = directDataOwnership(budget).freeze({ ...metadata, name: matches[0].name, codeNode: codeNode });
+                        return { payload: detail[0], mapping: faults.get(faultInfo.name) };
+                    }
+                    protocolFault = directDataOwnership(budget).freeze(metadata);
+                    // @constraints Only protocol grammar was assessed; no fabricated application receipt is published.
+                    throw protocolFaultSignal;
+                }
                 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')
+                const hasDetail = names.at(-1) === 'detail';
+                if (!/^faultcode,faultstring(?:,faultactor)?(?:,detail)?$/.test(names.join(',')) || !hasDetail && !profile.soap11ProtocolFaults) {
                     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');
@@ -360,49 +530,101 @@ async function exchangeSoap(contract, input, application, options, profile) {
                     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)
+                const detail = hasDetail ? shape(children.at(-1)) : [];
+                if (!profile.soap11ProtocolFaults && 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)
+                const matches = contract.faults.filter(f => detail.some(node => same(f.root.element.name, node.name)));
+                if (!matches.length && profile.soap11ProtocolFaults) {
+                    protocolFault = directDataOwnership(budget).freeze({ version: '1.1', code, string, ...(actor === undefined ? {} : { actor }) });
+                    throw protocolFaultSignal;
+                }
+                if (detail.length !== 1 || 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) };
             } });
+        let decoded;
+        try {
+            decoded = decodeResponse();
+        }
+        catch (error) {
+            if (error !== protocolFaultSignal)
+                throw error;
+        }
+        if (protocolFault && decoded === undefined) {
+            check();
+            return Object.freeze({ kind: 'soap-fault', admitted: false, fault: protocolFault,
+                ...(ignoredHeaders.length ? { ignoredHeaders: Object.freeze(ignoredHeaders) } : {}), usage: Object.freeze({ ...budget.usage() }) });
+        }
+        if (!decoded)
+            throw new TypeError('Missing decoded SOAP response');
         if (!('validated' in decoded))
-            return fail(decoded.kind, decoded.rule, 'response');
+            return profile.component ? Object.freeze({ ...decoded, phase: 'response' }) : 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 } : {}),
+            ...(faultInfo ? { fault: faultInfo } : {}),
             ...(ignoredHeaders.length ? { ignoredHeaders: Object.freeze(ignoredHeaders) } : {}), usage: Object.freeze({ ...budget.usage() }) });
     }
     catch (error) {
         if (budget.exhausted())
-            return fail('resource-limit', 'request-budget');
+            return fail('resource-limit', 'response-budget', 'response');
         if (error instanceof DataOwnershipLimitError)
-            return fail('resource-limit', error.message);
+            return fail('resource-limit', error.message, 'response');
         if (signal?.aborted)
-            return fail('cancelled', 'cooperative-cancellation');
-        if (error instanceof DirectSoapSourceError)
-            return fail(error.kind, error.message);
+            return fail('cancelled', 'cooperative-cancellation', 'response');
         if (error instanceof Stop)
-            return fail(error.kind, error.rule);
+            return fail(error.kind, error.rule, 'response');
         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');
-        }
+            return fail(error.category === 'resource-limit' ? 'resource-limit' : error.category === 'invalid-schema' ? 'protocol' : 'unsupported', 'SOAP protocol XML', 'response');
         throw error;
     }
-    finally {
-        if (deadline)
-            clearTimeout(deadline);
-        signal?.removeEventListener('abort', abort);
-        controller?.abort();
-        agent?.destroy();
-    }
+}
+/** Select protocol-owned nodes without relabeling observed XML or granting value authority. */
+function soapProtocolSelection(contract, component, check, stop) {
+    const soap12 = component && contract.binding.version === '1.2';
+    const SOAP = soap12 ? 'http://www.w3.org/2003/05/soap-envelope' : SOAP11;
+    const rpc = contract.binding.style === 'rpc';
+    const elements = (node) => {
+        check();
+        return node.children.filter((child) => child.kind === 'element');
+    };
+    const shape = (node, encodedScope = false) => {
+        const children = elements(node);
+        if (node.attributes.some(a => !(encodedScope && a.name.namespace === SOAP && a.name.local === 'encodingStyle'
+            && a.value === 'http://schemas.xmlsoap.org/soap/encoding/')) || node.children.some(n => n.kind === 'text' && /[^\t\r\n ]/.test(n.value)))
+            stop('protocol', 'SOAP protocol attributes or text');
+        return children;
+    };
+    const ignoredHeaders = [];
+    const bodyRoot = (root, incoming = false) => {
+        if (!same(root.name, { namespace: SOAP, local: 'Envelope' }))
+            stop('protocol', `SOAP ${contract.binding.version} Envelope required`);
+        const children = shape(root, rpc);
+        if (children[0]?.name.namespace === SOAP && children[0].name.local === 'Header') {
+            if (component && incoming) {
+                const assessed = assessComponentSoapHeader(children[0], check, contract.binding.version);
+                if (assessed.kind !== 'ignored-optional-headers')
+                    stop(assessed.kind, assessed.rule);
+                else
+                    for (const name of assessed.headers) {
+                        check();
+                        ignoredHeaders.push(name);
+                    }
+            }
+            else 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], rpc);
+        if (rpc && !body.some(n => same(n.name, { namespace: SOAP, local: 'Fault' })))
+            return children[0];
+        if (body.length !== 1)
+            stop('protocol', 'one SOAP Body payload required');
+        return body[0];
+    };
+    return { elements, shape, bodyRoot, ignoredHeaders };
 }

package/dist/compiler/directSoapSource.js

@@ -16,6 +16,7 @@ export class DirectSoapSourceError extends Error {
     }
 }
 function validateSoapSelection(source, contract, config, check) {
+    const addressNamespace = contract.binding.version === '1.2' ? 'http://schemas.xmlsoap.org/wsdl/soap12/' : WSDL_SOAP;
     const elements = (node) => { check(); return node.children.filter((child) => child.kind === 'element'); };
     const definitions = source.root.root;
     if (definitions.name.namespace !== WSDL_NAMESPACE || definitions.name.local !== 'definitions')
@@ -30,8 +31,8 @@ function validateSoapSelection(source, contract, config, check) {
     const binding = syntaxAttribute(ports[0], 'binding');
     if (!binding || !same(resolveLexicalQName(binding, ports[0]), contract.selector.binding))
         throw new DirectSoapSourceError('SOAP binding mismatch');
-    const addresses = elements(ports[0]).filter(n => n.name.namespace === WSDL_SOAP && n.name.local === 'address');
-    if (addresses.length !== 1 || elements(ports[0]).some(n => !(n.name.namespace === WSDL_SOAP && n.name.local === 'address')
+    const addresses = elements(ports[0]).filter(n => n.name.namespace === addressNamespace && n.name.local === 'address');
+    if (addresses.length !== 1 || elements(ports[0]).some(n => !(n.name.namespace === addressNamespace && n.name.local === 'address')
         && !(n.name.namespace === WSDL_NAMESPACE && n.name.local === 'documentation')))
         throw new DirectSoapSourceError('SOAP port extension');
 }

package/dist/compiler/directSourceCapsule.js

@@ -316,6 +316,8 @@ export function checkDirectSourceCompatibility(expected, contract, selection, si
 const componentVersions = Object.freeze({ ...versions, scope: 'component-soap11-utf8-graph-v1', mapping: 'component-values-v1',
     runtimePolicy: 'explicit-http-verified-https-transport-v1' });
 const scopedComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-utf8-graph-v2', mapping: 'component-values-and-record-scope-v1' });
+const soap12ComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap12-document-literal-v1' });
+const scopedSoap12ComponentVersions = Object.freeze({ ...scopedComponentVersions, scope: 'component-soap12-document-literal-record-v1' });
 const rpcComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-rpc-strings-v1', mapping: 'component-rpc-string-values-v1' });
 const typedRpcComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-rpc-typed-latin1-v1', mapping: 'component-rpc-typed-values-v1' });
 const componentReconstructions = new WeakMap();
@@ -380,6 +382,7 @@ async function componentDescriptor(contract, selection, signal, responseProjecti
     const input = make({ kind: 'input' }), output = make({ kind: 'output' });
     const faults = contract.faults.map(fault => ({ name: fault.name, root: make({ kind: 'fault', name: fault.name }) }));
     const compatibility = { selector: contract.selector, service: owned.service, port: owned.port,
+        ...(contract.binding.version === '1.2' ? { binding: { version: '1.2', actionRequired: contract.binding.actionRequired } } : {}),
         action: contract.binding.action, input, output, faults };
     let projection = null;
     if (responseProjection) {
@@ -431,7 +434,7 @@ function componentCapsule(derived, budget) {
     const typedRpc = rpc && compatibility.input.parts.some(part => part.type.namespace !== 'http://www.w3.org/2001/XMLSchema' || part.type.local !== 'string');
     if (rpc && (extended || derived.applicationGroups))
         throw new Stop('unsupported', 'rpc-artifact-extension');
-    const value = { versions: typedRpc ? typedRpcComponentVersions : rpc ? rpcComponentVersions : extended ? scopedComponentVersions : componentVersions, resources, compatibility,
+    const value = { versions: compatibility.binding?.version === '1.2' ? extended ? scopedSoap12ComponentVersions : soap12ComponentVersions : typedRpc ? typedRpcComponentVersions : rpc ? rpcComponentVersions : extended ? scopedComponentVersions : componentVersions, resources, compatibility,
         ...(extended ? { libraries, projection } : {}), ...(derived.applicationGroups ? { applicationGroups: derived.applicationGroups, applicationGroupIdentity: derived.applicationGroupIdentity } : {}) };
     return { ...value, fingerprint: hash(json(value, budget)) };
 }
@@ -493,7 +496,8 @@ function readComponent(bytes, budget, signal) {
     const rpc = typedRpc || !!parsed.versions && typeof parsed.versions === 'object' && parsed.versions.scope === rpcComponentVersions.scope;
     if (rpc && (extended || grouped))
         reject('rpc-artifact-extension');
-    const expectedVersions = typedRpc ? typedRpcComponentVersions : rpc ? rpcComponentVersions : extended ? scopedComponentVersions : componentVersions;
+    const soap12 = !!parsed.versions && typeof parsed.versions === 'object' && ['component-soap12-document-literal-v1', 'component-soap12-document-literal-record-v1'].includes(parsed.versions.scope);
+    const expectedVersions = soap12 ? extended ? scopedSoap12ComponentVersions : soap12ComponentVersions : typedRpc ? typedRpcComponentVersions : rpc ? rpcComponentVersions : extended ? scopedComponentVersions : componentVersions;
     const actual = record(parsed.versions, Object.keys(expectedVersions));
     for (const key of Object.keys(expectedVersions))
         if (actual[key] !== expectedVersions[key])
@@ -564,7 +568,12 @@ function readComponent(bytes, budget, signal) {
         if (!parsed.libraries.length && parsed.projection === null)
             reject('empty-component-extension');
     }
-    const c = record(parsed.compatibility, ['selector', 'service', 'port', 'action', 'input', 'output', 'faults']);
+    const c = record(parsed.compatibility, ['selector', 'service', 'port', 'action', 'input', 'output', 'faults', ...(soap12 ? ['binding'] : [])]);
+    if (soap12) {
+        const binding = record(c.binding, ['version', 'actionRequired']);
+        if (binding.version !== '1.2' || typeof binding.actionRequired !== 'boolean')
+            reject('soap12-binding');
+    }
     selector(c.selector);
     name(c.service);
     ncname(c.port);