@techspokes/typescript-wsdl-client 1.2.0 → 1.4.0

package/dist/client/checkedDirectRuntime.js

@@ -1,6 +1,6 @@
 import { types } from 'node:util';
-import { directClientRuntime, componentClientRuntime } from './directClientRuntime.js';
-import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR } from './directClientVersion.js';
+import { directClientRuntime, componentClientRuntime, componentSoap11ClientRuntime, componentSoap12ClientRuntime } from './directClientRuntime.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR, COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
 function dataOptions(options, allowed) {
     return !!options && typeof options === 'object' && !types.isProxy(options)
         && [null, Object.prototype].includes(Object.getPrototypeOf(options))
@@ -41,3 +41,28 @@ export const checkedComponentRuntimeV1 = Object.freeze({
         return componentClientRuntime.execute(expectedBase64, input, options);
     },
 });
+function checkedProtocolRuntime(runtime) {
+    return Object.freeze({
+        version: runtime.version,
+        async execute(expectedBase64, input, options, version) {
+            if (version !== runtime.version)
+                return Object.freeze({ kind: 'incompatible-artifact',
+                    rule: 'generated-runtime-version', repair: COMPONENT_CLIENT_RUNTIME_REPAIR, usage: Object.freeze({ nodes: 0, work: 0 }) });
+            if (!dataOptions(options, ['localSource', 'fileRoots', 'capsule', 'soap', 'sourceResources', 'sourceOrigins', 'sourceUri', 'namespaceLocations', 'standardLibraries', 'recordSources'])) {
+                return Object.freeze({ kind: 'unsupported', rule: 'data-only checked component options required', usage: Object.freeze({ nodes: 0, work: 0 }) });
+            }
+            return runtime.execute(expectedBase64, input, options);
+        },
+    });
+}
+/** Additive SOAP 1.2 binding permits protocol faults without declared application detail.
+ * @since 1.3.0
+ * @remarks Source reconstruction, endpoint restrictions and native validation use the shared component runtime.
+ * @returns Native component values, SOAP 1.2 protocol faults or explicit refusal; no full-profile admission.
+ */
+export const checkedComponentRuntimeV2 = checkedProtocolRuntime(componentSoap12ClientRuntime);
+/** SOAP 1.1 binding for generated clients that distinguish protocol faults from declared detail values.
+ * @since 1.4.0
+ * @returns Native-validated values, SOAP 1.1 protocol faults with their original bytes, or explicit refusal.
+ */
+export const checkedComponentRuntimeV3 = checkedProtocolRuntime(componentSoap11ClientRuntime);

package/dist/client/directClientRuntime.d.ts

@@ -1,6 +1,6 @@
 import type { SemanticBudgetLimits, ResolverUsage } from '../compiler/semanticBudget.js';
 import type { DirectCapsuleFailure } from '../compiler/directSourceCapsule.js';
-import type { DirectSoapOptions, ComponentSoapOptions, DirectSoapFailure } from '../compiler/directSoap.js';
+import type { DirectSoapOptions, ComponentSoapOptions, DirectSoapFailure, ComponentProtocolFault, DeclaredSoapFault, Soap11FaultMetadata, Soap12FaultMetadata } from '../compiler/directSoap.js';
 import type { DirectOperationSelector } from '../compiler/directOperation.js';
 import type { DirectApplicationValue } from '../compiler/directValues.js';
 import { DIRECT_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
@@ -65,6 +65,16 @@ export interface DirectClientRuntime {
     readonly version: typeof DIRECT_CLIENT_RUNTIME_VERSION;
     execute(expectedBase64: string, input: unknown, options: DirectClientOptions): Promise<DirectClientResult>;
 }
+/** Component-only protocol faults retain raw bytes without claiming an application value.
+ * @since 1.3.0
+ */
+export type ComponentClientResult<F extends Soap11FaultMetadata | Soap12FaultMetadata = Soap12FaultMetadata> = Exclude<DirectClientResult, {
+    kind: 'soap-fault';
+}> | ComponentProtocolFault<F> | Readonly<Omit<Extract<DirectClientResult, {
+    kind: 'soap-fault';
+}>, 'fault'> & {
+    fault: Omit<DeclaredSoapFault, 'codeNode'>;
+}>;
 /** The generated literal is the expected artifact; caller bytes never choose its static contract. */
 export declare const directClientRuntime: DirectClientRuntime;
 /** Same artifact/execution chain, with explicit physical dependency snapshots and component-profile reconstruction. */
@@ -72,3 +82,17 @@ export declare const componentClientRuntime: Readonly<{
     version: "checked-component-runtime-v2";
     execute: (expectedBase64: string, input: unknown, options: ComponentClientOptions) => Promise<DirectClientResult>;
 }>;
+/** Additive SOAP 1.2 injection shares reconstruction and transport with SOAP 1.1.
+ * @since 1.3.0
+ */
+export declare const componentSoap12ClientRuntime: Readonly<{
+    version: "checked-component-soap12-runtime-v1";
+    execute: (expectedBase64: string, input: unknown, options: ComponentClientOptions) => Promise<ComponentClientResult>;
+}>;
+/** SOAP 1.1 protocol faults require a generated client that can represent a missing application value.
+ * @since 1.4.0
+ */
+export declare const componentSoap11ClientRuntime: Readonly<{
+    version: "checked-component-soap11-runtime-v1";
+    execute: (expectedBase64: string, input: unknown, options: ComponentClientOptions) => Promise<ComponentClientResult<Soap11FaultMetadata>>;
+}>;

package/dist/client/directClientRuntime.js

@@ -6,7 +6,7 @@ import { types } from 'node:util';
 import { createApplicationBudget } from '../compiler/semanticBudget.js';
 import { reconstructDirectSourceCapsuleInRequest, reconstructComponentSourceCapsuleInRequest, checkDirectSourceCompatibility, DIRECT_CAPSULE_LIMITS } from '../compiler/directSourceCapsule.js';
 import { exchangeDirectSoap, exchangeComponentSoap, directSoapOptionsShape } from '../compiler/directSoap.js';
-import { DIRECT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
 import { prepareSchemaSnapshotFiles } from '../loader/schemaInput.js';
 import { SchemaLoadingError } from '../loader/orderedSyntax.js';
 /** The generated literal is the expected artifact; caller bytes never choose its static contract. */
@@ -19,7 +19,21 @@ export const componentClientRuntime = Object.freeze({
     version: COMPONENT_CLIENT_RUNTIME_VERSION,
     execute: (expectedBase64, input, options) => executeClient(expectedBase64, input, options, true),
 });
-async function executeClient(expectedBase64, input, options, component) {
+/** Additive SOAP 1.2 injection shares reconstruction and transport with SOAP 1.1.
+ * @since 1.3.0
+ */
+export const componentSoap12ClientRuntime = Object.freeze({
+    version: COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION,
+    execute: (expectedBase64, input, options) => executeClient(expectedBase64, input, options, true, '1.2'),
+});
+/** SOAP 1.1 protocol faults require a generated client that can represent a missing application value.
+ * @since 1.4.0
+ */
+export const componentSoap11ClientRuntime = Object.freeze({
+    version: COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION,
+    execute: (expectedBase64, input, options) => executeClient(expectedBase64, input, options, true, '1.1'),
+});
+async function executeClient(expectedBase64, input, options, component, protocol) {
     // Constant-sized entry introspection precedes budget configuration and all reads.
     const entryFailure = () => ({ kind: 'unsupported', rule: 'data-only client options required', usage: { nodes: 0, work: 0 } });
     if (!options || typeof options !== 'object' || types.isProxy(options)
@@ -121,11 +135,12 @@ async function executeClient(expectedBase64, input, options, component) {
                 standardLibraries: sources.standards, recordSources: sources.records }, budget);
             if (fresh.kind !== 'reconstructed-component')
                 return fresh;
+            if (fresh.contract.binding.version === '1.2' && protocol !== '1.2')
+                return fail('incompatible-artifact', 'SOAP 1.2 runtime binding required');
             if (fresh.selection.port !== options.soap.port || fresh.selection.service.namespace !== options.soap.service.namespace
                 || fresh.selection.service.local !== options.soap.service.local)
                 return fail('incompatible-artifact', 'explicit source selection mismatch');
-            result = fresh.responseProjection ? await exchangeComponentSoap(fresh.contract, fresh.mappings[0], input, supplied.soap, fresh.responseProjection)
-                : await exchangeComponentSoap(fresh.contract, fresh.mappings[0], input, supplied.soap);
+            result = await exchangeComponentSoap(fresh.contract, fresh.mappings[0], input, supplied.soap, fresh.responseProjection, protocol === '1.1');
         }
         else {
             const fresh = await reconstructDirectSourceCapsuleInRequest(bytes, options.localSource, { policy: { fileRoots: options.fileRoots }, limits: options.budget, signal: options.soap.signal }, budget);
@@ -138,8 +153,11 @@ async function executeClient(expectedBase64, input, options, component) {
             // by the original adapter; no catch-and-cast turns a failure into typed success.
             result = await exchangeDirectSoap(fresh.contract, fresh.mappings[0], input, options.soap);
         }
-        if (!('decoded' in result))
+        if (!('decoded' in result)) {
+            if (result.kind === 'soap-fault' && result.fault.version !== protocol)
+                throw new TypeError('Protocol fault requires its generated runtime binding');
             return result;
+        }
         if (options.soap.signal?.aborted)
             return fail('cancelled', 'cooperative-cancellation');
         const common = { value: result.decoded.validated.value, status: result.status, admitted: false,

package/dist/client/directClientVersion.d.ts

@@ -3,4 +3,8 @@ export declare const DIRECT_CLIENT_RUNTIME_VERSION: "checked-direct-runtime-v1";
 export declare const DIRECT_CLIENT_RUNTIME_REPAIR = "Regenerate matched direct client and capsule with the installed runtime.";
 /** Component profile never impersonates the supported direct preview protocol. */
 export declare const COMPONENT_CLIENT_RUNTIME_VERSION: "checked-component-runtime-v2";
+/** SOAP 1.2 can return protocol faults without declared application values. */
+export declare const COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION: "checked-component-soap12-runtime-v1";
+/** SOAP 1.1 component clients with value-less protocol faults use their own injection contract. */
+export declare const COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION: "checked-component-soap11-runtime-v1";
 export declare const COMPONENT_CLIENT_RUNTIME_REPAIR = "Regenerate matched component client and source artifacts with the installed runtime.";

package/dist/client/directClientVersion.js

@@ -3,4 +3,8 @@ export const DIRECT_CLIENT_RUNTIME_VERSION = 'checked-direct-runtime-v1';
 export const DIRECT_CLIENT_RUNTIME_REPAIR = 'Regenerate matched direct client and capsule with the installed runtime.';
 /** Component profile never impersonates the supported direct preview protocol. */
 export const COMPONENT_CLIENT_RUNTIME_VERSION = 'checked-component-runtime-v2';
+/** SOAP 1.2 can return protocol faults without declared application values. */
+export const COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION = 'checked-component-soap12-runtime-v1';
+/** SOAP 1.1 component clients with value-less protocol faults use their own injection contract. */
+export const COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION = 'checked-component-soap11-runtime-v1';
 export const COMPONENT_CLIENT_RUNTIME_REPAIR = 'Regenerate matched component client and source artifacts with the installed runtime.';

package/dist/client/generateDirectClient.js

@@ -1,5 +1,5 @@
 import { directLimit } from '../compiler/directExecutionPolicy.js';
-import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR } from './directClientVersion.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
 /** Native-plan generator consumed by the opt-in checked pipeline. */
 import { checkSemanticBudget } from '../compiler/semanticBudget.js';
 import { writeFileSync, mkdirSync } from 'node:fs';
@@ -170,12 +170,15 @@ export async function generateComponentClient(expected, signal) {
             ...response.declarations, `export type Response = ${response.type};`,
             ...faults.flatMap(({ shape }, index) => [...shape.declarations, `export type Fault_${index} = ${shape.type};`])
         ];
+        const soap12 = expected.contract.binding.version === '1.2';
+        const runtimeVersion = soap12 ? COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION : COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION;
         const lines = [
-            '// Checked component client; inject checkedComponentRuntimeV1 from the package root.',
+            `// Checked component client; inject ${soap12 ? 'checkedComponentRuntimeV2' : 'checkedComponentRuntimeV3'} from the package root.`,
             '// Scalar facets, ordered occurrence correlation and wildcard membership remain native runtime duties.',
             ...declarations,
             'export interface Usage {readonly nodes: number; readonly work: number}',
             'export interface Name {readonly namespace: string; readonly local: string}',
+            ...(soap12 ? ['export interface Soap12Fault {readonly version: "1.2"; readonly code: Name; readonly subcodes: readonly Name[]; readonly reasons: readonly {readonly lang: string; readonly text: string}[]; readonly string: string; readonly node?: string; readonly role?: string}'] : []),
             'export interface Options {',
             '  readonly localSource: string; readonly fileRoots: readonly string[]; readonly capsule: Uint8Array;',
             '  readonly sourceResources: readonly {readonly uri: string; readonly file: string; readonly canonicalUri?: string}[]; readonly sourceOrigins: readonly string[];',
@@ -190,26 +193,28 @@ export async function generateComponentClient(expected, signal) {
             '}',
             'export interface Failure {readonly kind: "incompatible-artifact" | "unsupported" | "missing-authority" | "resource-limit" | "cancelled" | "inconclusive" | "invalid-schema" | "scalar-invalid" | "value-invalid" | "xml-invalid" | "mismatch" | "transport" | "protocol";',
             '  readonly rule: string; readonly repair?: string; readonly phase?: "input" | "response"; readonly usage: Usage}',
-            'export interface NativeSuccess {readonly kind: "soap-response" | "soap-fault"; readonly value: unknown; readonly admitted: false;',
+            'export interface NativeSuccess {readonly kind: "soap-response" | "soap-fault"; readonly value?: unknown; readonly admitted: false;',
             '  readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array;',
-            '  readonly fault?: {readonly name: string; readonly code: Name; readonly string: string; readonly actor?: string}}',
-            `export interface Runtime {readonly version: ${literal(COMPONENT_CLIENT_RUNTIME_VERSION)}; execute(expectedBase64: string, input: unknown, options: Options, version: ${literal(COMPONENT_CLIENT_RUNTIME_VERSION)}): Promise<Failure | NativeSuccess>}`,
+            '  readonly fault?: {readonly name?: string; readonly code: Name; readonly string: string; readonly actor?: string}}',
+            `export interface Runtime {readonly version: ${literal(runtimeVersion)}; execute(expectedBase64: string, input: unknown, options: Options, version: ${literal(runtimeVersion)}): Promise<Failure | NativeSuccess>}`,
             'type Common = {readonly admitted: false; readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array};',
             'export type Result = Failure | (Common & {readonly kind: "soap-response"; readonly value: Response})',
             ...faults.map(({ mapping }, index) => {
                 if (mapping.direction.kind !== 'fault')
                     throw new TypeError('Native fault mapping required');
-                return `  | (Common & {readonly kind: "soap-fault"; readonly value: Fault_${index}; readonly fault: {readonly name: ${literal(mapping.direction.name)}; readonly code: Name; readonly string: string; readonly actor?: string}})`;
+                return soap12 ? `  | (Common & {readonly kind: "soap-fault"; readonly value: Fault_${index}; readonly fault: Soap12Fault & {readonly name: ${literal(mapping.direction.name)}}})`
+                    : `  | (Common & {readonly kind: "soap-fault"; readonly value: Fault_${index}; readonly fault: {readonly name: ${literal(mapping.direction.name)}; readonly code: Name; readonly string: string; readonly actor?: string}})`;
             }),
-            ...(faults.length ? [] : ['  | (Common & {readonly kind: "soap-fault"; readonly value: never; readonly fault: {readonly name: never; readonly code: Name; readonly string: string; readonly actor?: string}})']),
+            soap12 ? '  | (Common & {readonly kind: "soap-fault"; readonly value?: never; readonly fault: Soap12Fault & {readonly name?: never}})'
+                : '  | (Common & {readonly kind: "soap-fault"; readonly value?: never; readonly fault: {readonly version: "1.1"; readonly name?: never; readonly code: Name; readonly string: string; readonly actor?: string}})',
             ';',
             `export const expectedCapsuleBase64 = ${literal(Buffer.from(capsule.bytes).toString('base64'))};`,
             `export const selection = ${literal(JSON.stringify({ selector: expected.contract.selector, ...expected.selection }))};`,
             'export function createClient(runtime: Runtime) {',
             '  return Object.freeze({',
             `    [${literal(expected.contract.selector.operation)}]: async (input: Request, options: Options): Promise<Result> => {`,
-            `      if (runtime.version !== ${literal(COMPONENT_CLIENT_RUNTIME_VERSION)}) return {kind: "incompatible-artifact", rule: "generated-runtime-version", repair: ${literal(COMPONENT_CLIENT_RUNTIME_REPAIR)}, usage: {nodes: 0, work: 0}};`,
-            `      return await runtime.execute(expectedCapsuleBase64, input, options, ${literal(COMPONENT_CLIENT_RUNTIME_VERSION)}) as Result;`,
+            `      if (runtime.version !== ${literal(runtimeVersion)}) return {kind: "incompatible-artifact", rule: "generated-runtime-version", repair: ${literal(COMPONENT_CLIENT_RUNTIME_REPAIR)}, usage: {nodes: 0, work: 0}};`,
+            `      return await runtime.execute(expectedCapsuleBase64, input, options, ${literal(runtimeVersion)}) as Result;`,
             '    },', '  });', '}', '',
         ];
         const source = composeGeneratedSource(lines.join('\n'), resolvePreamble('direct-client'));

package/dist/compiler/componentRecordProjection.d.ts

@@ -57,6 +57,7 @@ export interface ComponentRecordDecodedXml {
 type Leaf = Readonly<{
     kind: 'standard';
     declaration: StandardSchemaElementDeclaration;
+    optional: boolean;
 } | {
     kind: 'boundary';
     namespace: NamespaceConstraint;

package/dist/compiler/componentRecordProjection.js

@@ -160,7 +160,9 @@ export function createComponentRecordProjection(outer, companion, supplied, opti
             while (pending.length) {
                 check();
                 const particle = pending.pop();
-                if (particle.occurs.min !== '1' || particle.occurs.max !== '1')
+                // @why Only metadata may be absent, and only when the authenticated source declares it optional.
+                if (particle.occurs.max !== '1' || (particle.occurs.min !== '1'
+                    && !(particle.standardElement && particle.occurs.min === '0')))
                     stop('record-wrapper-unit-occurrence');
                 if (particle.kind === 'sequence')
                     for (let index = particle.children.length - 1; index >= 0; index--) {
@@ -168,7 +170,7 @@ export function createComponentRecordProjection(outer, companion, supplied, opti
                         pending.push(particle.children[index]);
                     }
                 else if (particle.standardElement)
-                    leaves.push(Object.freeze({ kind: 'standard', declaration: particle.standardElement }));
+                    leaves.push(Object.freeze({ kind: 'standard', declaration: particle.standardElement, optional: particle.occurs.min === '0' }));
                 else if (particle.kind === 'any' && particle.wildcard?.processContents === 'strict') {
                     if (++boundaries > 1 || !namespaceAllows(particle.wildcard.namespace, spec.payloadPath[0].namespace, budget.chargeWork))
                         stop('record-wrapper-wildcard-boundary');
@@ -266,12 +268,19 @@ export function decodeComponentRecordXml(outer, projection, bytes, options = {})
             if (wrapper.attributes.length || wrapper.children.some(node => node.kind === 'text' && /[^\t\r\n ]/.test(node.value)))
                 throw new ScopeStop('mismatch', 'record-wrapper-attributes-or-text');
             const children = syntaxElements(wrapper);
-            if (children.length !== owned.leaves.length)
+            const required = owned.leaves.filter(leaf => leaf.kind === 'boundary' || !leaf.optional).length;
+            if (children.length < required || children.length > owned.leaves.length)
                 throw new ScopeStop('mismatch', 'record-wrapper-child-count');
             let payload;
+            let cursor = 0;
             for (let index = 0; index < owned.leaves.length; index++) {
                 check();
-                const leaf = owned.leaves[index], child = children[index];
+                const leaf = owned.leaves[index], child = children[cursor];
+                if (leaf.kind === 'standard' && leaf.optional && (!child || !same(child.name, leaf.declaration.name)))
+                    continue;
+                if (!child)
+                    throw new ScopeStop('mismatch', 'record-wrapper-child-count');
+                cursor++;
                 if (leaf.kind === 'standard') {
                     if (!same(child.name, leaf.declaration.name))
                         throw new ScopeStop('mismatch', 'record-wrapper-standard-order');
@@ -287,6 +296,8 @@ export function decodeComponentRecordXml(outer, projection, bytes, options = {})
                     payload = child;
                 }
             }
+            if (cursor !== children.length)
+                throw new ScopeStop('mismatch', 'record-wrapper-child-count');
             if (!payload)
                 throw new TypeError('Native record boundary unavailable');
             const decoded = assessObservedComponentPayload(owned.companion, owned.mapping, observation, payload, options);

package/dist/compiler/directCodec.js

@@ -3,6 +3,7 @@ import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
 import { checkSemanticBudget } from './semanticBudget.js';
 import { DataOwnershipLimitError } from './dataOwnership.js';
 import { types } from 'node:util';
+import { xmlByteLength, snapshotXmlBytes } from '../util/xmlBytes.js';
 import { inspectDirectOperation, isRpcMessageRoot } from './directOperation.js';
 import { inspectDirectValueMapping, expandDirectValue, assessDirectScalars, inspectComponentValueMapping, expandProjectionValue, assessProjectionScalars } from './directValues.js';
 import { matchDirectOperation, matchDirectProjection } from './directStructure.js';
@@ -40,7 +41,7 @@ function runMapping(contract, supplied, options, profile, inspect, work) {
                 && contract.binding.style === 'rpc' && contract.binding.use === 'encoded' && contract.binding.encoding === 'http://schemas.xmlsoap.org/soap/encoding/';
             if ((!rpc && mapping.version !== profile.version) || mapping.contextId !== contract.contextId
                 || contract.basis !== profile.basis || contract.correspondence !== profile.correspondence
-                || contract.binding.version !== '1.1' || !rpc && (contract.binding.style !== 'document' || contract.binding.use !== 'literal')
+                || !(contract.binding.version === '1.1' || profile === componentProfile && contract.binding.version === '1.2' && !rpc) || !rpc && (contract.binding.style !== 'document' || contract.binding.use !== 'literal')
                 || contract.binding.transport !== 'http://schemas.xmlsoap.org/soap/http')
                 throw new Stop('unsupported', profile.rule);
             const direction = mapping.direction;
@@ -262,20 +263,11 @@ export function encodeComponentXml(contract, mapping, application, options = {})
 }
 /** Retain the shared byte-copy, XML-version, entity and explicit capacity boundaries for both profiles. */
 function parseObservedXml(bytes, { budget, limits, check }, sourceUri, componentResponseEncoding) {
-    if (!types.isUint8Array(bytes) || types.isProxy(bytes))
-        throw new TypeError('XML requires Uint8Array bytes');
-    // Use native internal-slot access, avoiding subclass/own length, buffer and
-    // iterator getters. Shared backing stores are outside the data-only contract.
-    const typed = Object.getPrototypeOf(Uint8Array.prototype);
-    const length = Object.getOwnPropertyDescriptor(typed, 'byteLength').get.call(bytes);
-    const backing = Object.getOwnPropertyDescriptor(typed, 'buffer').get.call(bytes);
-    if (types.isSharedArrayBuffer(backing))
-        throw new TypeError('Shared XML bytes are unsupported');
+    const length = xmlByteLength(bytes);
     if (length > limits.maxBytes)
         throw new Stop('resource-limit', 'XML byte limit');
     check();
-    const input = new Uint8Array(length);
-    Uint8Array.prototype.set.call(input, bytes);
+    const input = snapshotXmlBytes(bytes);
     const uri = sourceUri ?? 'urn:typescript-wsdl-client:observed-direct-xml';
     if (typeof uri !== 'string')
         throw new TypeError('XML source URI must be a string');

package/dist/compiler/directOperation.d.ts

@@ -46,12 +46,13 @@ export interface DirectOperationContract {
     readonly basis: 'native-direct-premises-v1' | 'native-component-premises-v1';
     readonly correspondence: 'dated-XSD-2004-direct-v1' | 'dated-XSD-2004-components-v1';
     readonly binding: Readonly<{
-        version: '1.1';
+        version: '1.1' | '1.2';
         style: 'document' | 'rpc';
         use: 'literal' | 'encoded';
         encoding?: string;
         transport: string;
         action: string;
+        actionRequired?: boolean;
         source: SyntaxSource;
     }>;
     readonly input: DirectMessageRoot | RpcMessageRoot;

package/dist/compiler/directOperation.js

@@ -8,6 +8,7 @@ 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.
@@ -171,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)
@@ -179,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));
@@ -200,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) {
@@ -208,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');
@@ -253,10 +257,14 @@ 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'))
@@ -264,11 +272,19 @@ async function selectOperationInRequest(source, selector, options, budget, profi
             if (attr(soapBinding, 'transport') !== HTTP)
                 return refuse('unsupported', 'soap-transport');
             const style = attr(soapOperation, 'style') ?? attr(soapBinding, 'style') ?? 'document';
-            if (style !== 'document' && !(profile === 'components' && style === 'rpc'))
+            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');
@@ -289,7 +305,7 @@ 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')
@@ -393,7 +409,7 @@ 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: style, use: style === 'rpc' ? 'encoded' : 'literal',
+                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,

package/dist/compiler/directSoap.d.ts

@@ -1,6 +1,6 @@
 import type { DirectOperationContract } from './directOperation.js';
 import type { DirectCodecFailure, DirectDecodedXml, ComponentDecodedXml, DirectXmlLimits } from './directCodec.js';
-import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+import type { ExpandedName, SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
 import type { ResolverUsage } from './semanticBudget.js';
 import type { ComponentRecordProjection, ComponentRecordDecodedXml } from './componentRecordProjection.js';
 export interface DirectSoapOptions {
@@ -20,26 +20,69 @@ export interface DirectSoapFailure {
     readonly rule: string;
     readonly usage: ResolverUsage;
     readonly phase?: 'input' | 'response';
+    readonly source?: SyntaxSource;
+    readonly schemaPath?: string;
+    readonly payloadPath?: string;
 }
-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;
+}
+/** SOAP 1.1 protocol fields retained when the selected operation supplies no matching detail.
+ * @since 1.4.0
+ */
+export interface Soap11FaultMetadata {
+    readonly version: '1.1';
+    readonly code: ExpandedName;
+    readonly string: string;
+    readonly actor?: string;
+}
+type ProtocolFaultMetadata = Soap11FaultMetadata | Soap12FaultMetadata;
+export type DeclaredSoapFault = Readonly<{
+    name: string;
+    code: ExpandedName;
+    codeNode: SyntaxElement;
+    string: string;
+    actor?: string;
+}> & Partial<Soap12FaultMetadata>;
+/** A valid protocol fault without an application detail mapped by the selected operation.
+ * @since 1.3.0
+ * @constraints Unassessed detail remains only in responseBytes; no native value receipt is issued.
+ */
+export interface ComponentProtocolFault<F extends ProtocolFaultMetadata = ProtocolFaultMetadata> {
+    readonly kind: 'soap-fault';
+    readonly admitted: false;
+    readonly fault: F;
+    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'> {
@@ -62,5 +105,37 @@ export declare function exchangeDirectSoap(contract: DirectOperationContract, in
  * @throws TypeError For foreign native handles. Invalid explicit timer/XML capacities throw RangeError.
  */
 export declare function exchangeComponentSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: ComponentSoapOptions): Promise<ComponentSoapResult>;
-export declare function exchangeComponentSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: ComponentSoapOptions, responseProjection: ComponentRecordProjection): Promise<ComponentRecordSoapResult>;
+export declare function exchangeComponentSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: ComponentSoapOptions, responseProjection: ComponentRecordProjection | undefined, soap11ProtocolFaults?: boolean): Promise<ComponentRecordSoapResult>;
+/** Actual HTTP entity metadata; omission leaves HTTP status and media duties unassessed.
+ * @since Unreleased
+ */
+export interface ObservedSoapResponseMetadata {
+    readonly status: number;
+    readonly contentType: string;
+    readonly contentEncoding?: string;
+}
+export type ComponentSoapResponseAssessment = DirectSoapFailure | Readonly<{
+    kind: 'soap-response' | 'soap-fault';
+    admitted: false;
+    decoded?: ComponentDecodedXml | ComponentRecordDecodedXml;
+    fault?: DeclaredSoapFault | ProtocolFaultMetadata;
+    ignoredHeaders?: readonly ExpandedName[];
+    usage: ResolverUsage;
+}>;
+/** 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 declare function inspectComponentSoapResponse(contract: DirectOperationContract, inputMapping: unknown, bytes: Uint8Array, options?: Readonly<{
+    signal?: AbortSignal;
+    limits?: DirectXmlLimits;
+    uri?: string;
+    responseMetadata?: ObservedSoapResponseMetadata;
+    responseProjection?: ComponentRecordProjection;
+}>): ComponentSoapResponseAssessment;
 export {};