@techspokes/typescript-wsdl-client 1.1.8 → 1.3.0

package/dist/compiler/directOperation.js

@@ -1,15 +1,23 @@
 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 { SchemaLoadingError, WSDL_NAMESPACE, XSD_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';
 import { qualifyComponentSource, inspectComponentSourceQualification } from './checkedComponentSource.js';
 import { prepareWsdlPolicyRequirements, assertWsdlPolicyRequirements } from './wsdlPolicyRequirements.js';
 const SOAP = 'http://schemas.xmlsoap.org/wsdl/soap/';
+const SOAP12 = 'http://schemas.xmlsoap.org/wsdl/soap12/';
 const HTTP = 'http://schemas.xmlsoap.org/soap/http';
 const ADDRESSING_WSDL = 'http://www.w3.org/2006/05/addressing/wsdl';
+/** Distinguish typed RPC parameters without inventing a document element.
+ * @param root Selected native message.
+ * @returns Whether the message uses the bounded RPC profile.
+ */
+export function isRpcMessageRoot(root) {
+    return 'kind' in root && root.kind === 'rpc-typed-parts-v1';
+}
 const issued = new WeakMap();
 /** Object identity authenticates the exact issued roots; context IDs and digests do not. */
 export function inspectDirectOperation(contract, expectedContext) {
@@ -164,7 +172,8 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                 }
             };
             const ws = (local) => `${WSDL_NAMESPACE}#${local}`;
-            const soap = (local) => `${SOAP}#${local}`;
+            let soapNamespace = SOAP;
+            const soap = (local) => `${soapNamespace}#${local}`;
             const attrs = (node, allowed) => {
                 children(node);
                 for (const a of node.attributes)
@@ -172,7 +181,7 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                         && (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.
+            // @constraints Component selection admits known SOAP 1.2 syntax; the direct profile remains SOAP 1.1 only.
             // 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));
@@ -181,7 +190,7 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                 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'] };
+            const soapAttributes = { binding: ['style', 'transport'], operation: ['soapAction', 'style'], body: profile === 'components' ? ['use', 'parts', 'namespace', 'encodingStyle'] : ['use', 'parts'], fault: ['name', 'use'], address: ['location'] };
             for (const document of input.documents) {
                 const stack = [document.root];
                 while (stack.length) {
@@ -193,7 +202,9 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                         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;
+                    const soap12 = profile === 'components' && node.name.namespace === SOAP12;
+                    const allowed = node.name.namespace === WSDL_NAMESPACE ? attributes[node.name.local] : node.name.namespace === SOAP || soap12
+                        ? soap12 && node.name.local === 'operation' ? [...soapAttributes.operation, 'soapActionRequired'] : soapAttributes[node.name.local] : undefined;
                     if (!allowed)
                         return refuse('unsupported', 'wsdl-extension');
                     for (const a of node.attributes) {
@@ -201,7 +212,7 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                         //   UsingAddressing remains unsupported, so these attributes are retained metadata, never SOAP header instructions.
                         if (addressingAttribute(node, a.name.namespace, a.name.local))
                             continue;
-                        if (a.name.namespace === WSDL_NAMESPACE && a.name.local === 'required' && node.name.namespace === SOAP && ['true', '1', 'false', '0'].includes(a.value))
+                        if (a.name.namespace === WSDL_NAMESPACE && a.name.local === 'required' && (node.name.namespace === SOAP || soap12) && ['true', '1', 'false', '0'].includes(a.value))
                             continue;
                         if (a.name.namespace !== '' || !allowed.includes(a.name.local))
                             refuse('unsupported', 'wsdl-attribute');
@@ -246,21 +257,34 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                 return matches[0];
             };
             const abstract = operation(portType), bound = operation(binding);
+            const bindingExtensions = children(binding.syntax).filter(node => [SOAP, SOAP12].includes(node.name.namespace) && node.name.local === 'binding');
+            if (bindingExtensions.length !== 1)
+                return refuse('selection-refused', 'expected-one-binding');
+            soapNamespace = bindingExtensions[0].name.namespace;
             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');
+            const soapBinding = exactly(binding.syntax, soapNamespace, 'binding');
+            const soapOperation = exactly(bound, soapNamespace, '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')
+            const style = attr(soapOperation, 'style') ?? attr(soapBinding, 'style') ?? 'document';
+            if (style !== 'document' && !(profile === 'components' && style === 'rpc' && soapNamespace === SOAP))
                 return refuse('unsupported', 'soap-style');
-            const action = attr(soapOperation, 'soapAction');
-            if (action === undefined)
+            const required = attr(soapOperation, 'soapActionRequired');
+            if (required !== undefined && !['true', 'false', '1', '0'].includes(required))
+                return refuse('unsupported', 'soap-action-required-boolean');
+            const actionRequired = required !== 'false' && required !== '0';
+            const selectedAction = attr(soapOperation, 'soapAction');
+            if (selectedAction === undefined && (soapNamespace === SOAP || actionRequired))
                 return refuse('unsupported', 'soap-action-required');
+            if (soapNamespace === SOAP12 && selectedAction !== undefined && !/^[A-Za-z][A-Za-z0-9+.-]*:[^\s]*$/.test(selectedAction))
+                return refuse('unsupported', 'soap-action-absolute-uri');
+            // @why SOAP 1.2 permits an absent optional action; the existing string contract uses an empty value to omit it on HTTP.
+            const action = selectedAction ?? '';
             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');
@@ -281,8 +305,9 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                 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');
+                const body = exactly(boundSyntax, soapNamespace, faultName === undefined ? 'body' : 'fault');
                 shape(body, []);
+                attrs(body, faultName === undefined ? ['use', 'parts'] : ['use', 'name']);
                 if (attr(body, 'use') !== 'literal')
                     return refuse('unsupported', 'literal-required');
                 if (faultName !== undefined && attr(body, 'name') !== faultName)
@@ -309,17 +334,61 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                     return refuse('selection-refused', 'element-type');
                 return Object.freeze({ message: message.name, part: partName, element, type: element.type, source: part.source });
             };
+            const rpcRoot = (messageSyntax, boundSyntax, direction) => {
+                attrs(messageSyntax, ['name', 'message']);
+                attrs(boundSyntax, ['name']);
+                shape(messageSyntax, [ws('documentation')]);
+                shape(boundSyntax, [soap('body'), ws('documentation')]);
+                const body = exactly(boundSyntax, SOAP, 'body');
+                shape(body, []);
+                const encoding = 'http://schemas.xmlsoap.org/soap/encoding/';
+                if (attr(body, 'use') !== 'encoded' || attr(body, 'encodingStyle')?.trim() !== encoding)
+                    return refuse('unsupported', 'rpc-string-encoding');
+                const bodyNamespace = attr(body, 'namespace');
+                if (!bodyNamespace || !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(bodyNamespace))
+                    return refuse('unsupported', 'rpc-body-namespace');
+                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 declared = children(message.syntax).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'part');
+                if (!declared.length || direction === 'output' && declared.length !== 1)
+                    return refuse('unsupported', 'rpc-single-string-result');
+                const names = new Set();
+                const parts = declared.map(part => {
+                    attrs(part, ['name', 'type']);
+                    shape(part, [ws('documentation')]);
+                    const name = attr(part, 'name');
+                    if (!name || !isXmlNCName(name) || names.has(name))
+                        return refuse('selection-refused', 'rpc-part-name');
+                    names.add(name);
+                    const path = part.source.path.slice(message.syntax.source.path.length) || '/';
+                    const refs = message.references.filter(r => r.path === path && r.attribute === 'type');
+                    if (refs.length !== 1)
+                        return refuse('unsupported', 'rpc-part-type-required');
+                    const resolved = context.resolve(refs[0].reference);
+                    if (direction === 'output' && (resolved.kind !== 'builtin' || resolved.name.namespace !== XSD_NAMESPACE || resolved.name.local !== 'string'))
+                        return refuse('unsupported', 'rpc-string-part-required');
+                    return Object.freeze({ name, type: refs[0].reference, source: part.source });
+                });
+                if (attr(body, 'parts') !== undefined && attr(body, 'parts').trim().split(/[\t\r\n ]+/).join(' ') !== parts.map(p => p.name).join(' '))
+                    return refuse('unsupported', 'rpc-body-parts');
+                return Object.freeze({ kind: 'rpc-typed-parts-v1', message: message.name, parts, bodyNamespace, encoding,
+                    wrapper: { namespace: bodyNamespace, local: ownedSelector.operation + (direction === 'output' ? 'Response' : '') }, source: body.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);
+                return style === 'rpc' ? rpcRoot(declaration, boundIo, direction) : 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 (style === 'rpc' && (declaredFaults.length || boundFaults.length))
+                return refuse('unsupported', 'rpc-declared-fault');
             if (declaredFaults.length !== boundFaults.length)
                 return refuse('selection-refused', 'fault-mapping');
             const faultNames = new Set();
@@ -340,7 +409,8 @@ async function selectOperationInRequest(source, selector, options, budget, profi
             const contract = { selector: ownedSelector, contextId: context.contextId,
                 basis: profile === 'direct' ? 'native-direct-premises-v1' : 'native-component-premises-v1',
                 correspondence: profile === 'direct' ? 'dated-XSD-2004-direct-v1' : 'dated-XSD-2004-components-v1',
-                binding: { version: '1.1', style: 'document', use: 'literal', transport: HTTP, action, source: binding.context.source },
+                binding: { version: soapNamespace === SOAP12 ? '1.2' : '1.1', ...(soapNamespace === SOAP12 ? { actionRequired } : {}), style: style, use: style === 'rpc' ? 'encoded' : 'literal',
+                    ...(style === 'rpc' ? { encoding: 'http://schemas.xmlsoap.org/soap/encoding/' } : {}), transport: HTTP, action, source: binding.context.source },
                 input: requestRoot, output: responseRoot, faults,
                 ...(policyOwner ? { policy: policyOwner.forBinding(binding.syntax), addressingActions: { required: false,
                         input: attr(abstractInput, 'Action', ADDRESSING_WSDL), output: attr(abstractOutput, 'Action', ADDRESSING_WSDL),

package/dist/compiler/directSoap.d.ts

@@ -21,25 +21,55 @@ export interface DirectSoapFailure {
     readonly usage: ResolverUsage;
     readonly phase?: 'input' | 'response';
 }
-type SoapResult<D> = DirectSoapFailure | Readonly<{
+/** Version-specific protocol metadata; application detail remains owned by native mappings.
+ * @since 1.3.0
+ */
+export interface Soap12FaultMetadata {
+    readonly version: '1.2';
+    readonly code: ExpandedName;
+    readonly subcodes: readonly ExpandedName[];
+    readonly reasons: readonly Readonly<{
+        lang: string;
+        text: string;
+    }>[];
+    readonly string: string;
+    readonly node?: string;
+    readonly role?: string;
+}
+export type DeclaredSoapFault = Readonly<{
+    name: string;
+    code: ExpandedName;
+    codeNode: SyntaxElement;
+    string: string;
+    actor?: string;
+}> & Partial<Soap12FaultMetadata>;
+/** A valid SOAP 1.2 fault without a uniquely declared application detail.
+ * @since 1.3.0
+ * @constraints Unassessed detail remains only in responseBytes; no native value receipt is issued.
+ */
+export interface ComponentProtocolFault {
+    readonly kind: 'soap-fault';
+    readonly admitted: false;
+    readonly fault: Soap12FaultMetadata;
+    readonly responseBytes: Uint8Array;
+    readonly status: number;
+    readonly usage: ResolverUsage;
+    readonly ignoredHeaders?: readonly ExpandedName[];
+}
+type DecodedSoapResult<D> = DirectSoapFailure | Readonly<{
     kind: 'soap-response' | 'soap-fault';
     admitted: false;
     decoded: D;
     /** 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;
-    }>;
-    /** Qualified optional response blocks ignored under SOAP 1.1; their application semantics were not assessed. */
+    fault?: DeclaredSoapFault;
+    /** Unprocessed header blocks; their application semantics were not assessed. */
     ignoredHeaders?: readonly ExpandedName[];
     usage: ResolverUsage;
 }>;
-export type DirectSoapResult = SoapResult<DirectDecodedXml>;
+type SoapResult<D> = DecodedSoapResult<D> | ComponentProtocolFault;
+export type DirectSoapResult = DecodedSoapResult<DirectDecodedXml>;
 export type ComponentSoapResult = SoapResult<ComponentDecodedXml>;
 export type ComponentRecordSoapResult = SoapResult<ComponentDecodedXml | ComponentRecordDecodedXml>;
 export interface ComponentSoapOptions extends Omit<DirectSoapOptions, 'endpoint' | 'allowEndpoint'> {

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,6 +54,9 @@ 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) {
     const { mapping: input } = inspectComponentValueMapping(inputMapping, contract);
@@ -89,6 +92,8 @@ export async function exchangeComponentSoap(contract, inputMapping, application,
     });
 }
 async function exchangeSoap(contract, input, application, options, profile) {
+    const soap12 = profile.component && contract.binding.version === '1.2';
+    const SOAP = soap12 ? 'http://www.w3.org/2003/05/soap-envelope' : SOAP11;
     const { context } = inspectDirectOperation(contract);
     if (input.direction.kind !== 'input')
         throw new TypeError('SOAP request requires the exact input mapping');
@@ -120,7 +125,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');
             }
@@ -171,6 +176,7 @@ async function exchangeSoap(contract, input, application, options, profile) {
             && (typeof allowEndpoint !== 'function' || allowEndpoint(new URL(endpoint.href)) !== true))
             return fail('unsupported', 'endpoint authorization');
         const action = contract.binding.action;
+        const rpc = contract.binding.style === 'rpc';
         if (/[^\x20-\x21\x23-\x7e]|\\/.test(action))
             return fail('unsupported', 'unsafe SOAPAction');
         const elements = (node) => {
@@ -191,20 +197,21 @@ async function exchangeSoap(contract, input, application, options, profile) {
                 return fail(mapping.kind, mapping.rule);
             faults.set(fault.name, mapping);
         }
-        const shape = (node) => {
+        const shape = (node, encodedScope = false) => {
             const children = elements(node);
-            if (node.attributes.length || node.children.some(n => n.kind === 'text' && /[^\t\r\n ]/.test(n.value)))
+            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);
+                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 (profile.component && incoming) {
-                    const assessed = assessComponentSoapHeader(children[0], check);
+                    const assessed = assessComponentSoapHeader(children[0], check, contract.binding.version);
                     if (assessed.kind !== 'ignored-optional-headers')
                         stop(assessed.kind, assessed.rule);
                     else
@@ -219,13 +226,25 @@ async function exchangeSoap(contract, input, application, options, profile) {
             }
             if (children.length !== 1 || !same(children[0].name, { namespace: SOAP, local: 'Body' }))
                 stop('protocol', 'one SOAP Body required');
-            const body = shape(children[0]);
+            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 wsdl = await profile.prepare(config, check);
         check();
+        // @why node-soap's RPC writer would wrap `_xml` as a parameter. This private
+        //   instance retains its selected method/transport while native bytes own RPC construction.
+        const rpcArguments = Object.freeze({});
+        if (rpc)
+            wsdl.objectToRpcXML = (name, args) => {
+                check();
+                if (name !== contract.selector.operation || args !== rpcArguments)
+                    stop('protocol', 'dependency RPC selection mismatch');
+                return Buffer.from(encoded.bytes).toString('utf8');
+            };
         // HTTP and codec byte limits bound buffering and output copies directly.
         agent = endpoint.protocol === 'https:' ? new HttpsAgent({ keepAlive: false, maxSockets: 1, rejectUnauthorized: true,
             ...(config.ca === undefined ? {} : { ca: config.ca }) }) : new Agent({ keepAlive: false, maxSockets: 1 });
@@ -241,7 +260,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');
@@ -280,7 +300,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;
@@ -290,7 +311,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({ _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');
@@ -301,19 +322,34 @@ async function exchangeSoap(contract, input, application, options, profile) {
         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);
+        let soap12Charset;
+        let validSoap12Media = false;
+        if (soap12) {
+            try {
+                const mime = new MIMEType(observed.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(observed.contentType);
         if (!media)
             return fail('protocol', 'SOAP response Content-Type');
-        if (observed.status !== 200 && observed.status !== 500)
+        if (observed.status !== 200 && observed.status !== 500 && !(soap12 && observed.status === 400))
             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 (charset && charset !== bom && !(charset === 'utf-16' && bom.startsWith('utf-16')))
+        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 1.2 protocol fault assessed');
+        const decodeResponse = () => profile.decode(contract, output, observed.bytes, { signal, limits, uri: endpoint.href,
+            ...(profile.component ? { componentResponseEncoding: { charset } } : {}),
             selectPayload: root => {
                 const payload = bodyRoot(root, true);
                 if (!same(payload.name, { namespace: SOAP, local: 'Fault' })) {
@@ -321,6 +357,87 @@ async function exchangeSoap(contract, input, application, options, profile) {
                         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 (observed.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')
@@ -353,6 +470,22 @@ async function exchangeSoap(contract, input, application, options, profile) {
                 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,
+                responseBytes: new Uint8Array(observed.bytes), status: observed.status,
+                ...(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');
         check();

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');
 }