@techspokes/typescript-wsdl-client 1.2.0 → 1.3.0

package/README.md

@@ -9,6 +9,10 @@ Turn legacy WSDL/SOAP services into typed TypeScript clients and optional REST A
 
 Created from production integration work at [TechSpokes](https://www.techspokes.com); built for teams modernizing real enterprise SOAP integrations.
 
+## Upgrading to 1.3.0
+
+Version 1.3.0 adds opt-in checked SOAP 1.2 document/literal execution through the existing adapter. Existing SOAP 1.1 and direct-runtime bindings retain their contracts. SOAP 1.2 clients use an additive runtime handshake; regenerate matched artifacts when adopting that binding. Read the [1.2.x migration guidance](docs/migration.md#from-12x-to-130) for adoption and evidence limits.
+
 ## Upgrading to 1.2.0
 
 Existing projects keep legacy generation unless they explicitly choose another profile. Regeneration can change affected DTO names, stream records and corrected scalar/simple-content results; 1.2.0 is not an unconditional drop-in regeneration upgrade. Read the [1.1.x migration guide](docs/migration.md#from-11x-to-120) before updating, including matched artifact regeneration, scaffold preservation, consumer checks and rollback.
@@ -250,6 +254,7 @@ See [CLI Reference](docs/cli-reference.md) for all flags and examples.
 | [Agent Skill Artifact](docs/agent-skill.md) | Release ZIP for consumer-project AI agents |
 | [Version Migration](docs/migration.md) | Upgrading between package versions |
 | [1.2.0 Release Notes](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/releases/v1.2.0.md) | Composition, consumer compatibility and bounded RPC qualification |
+| [1.3.0 Release Notes](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/releases/v1.3.0.md) | Checked SOAP 1.2 execution and preserved SOAP 1.1 compatibility |
 | [XML/JSON Mapping Contract](docs/mapping-contract.md) | Checked keyed, namespace, nil and group representations |
 | [Product Corpus](docs/corpus.md) | Representative public inputs and their executable evidence |
 

package/dist/client/checkedDirectRuntime.d.ts

@@ -1,4 +1,5 @@
-import { DIRECT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+import type { ComponentClientResult } from './directClientRuntime.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
 interface Name {
     readonly namespace: string;
     readonly local: string;
@@ -93,4 +94,13 @@ export declare const checkedComponentRuntimeV1: Readonly<{
     version: typeof COMPONENT_CLIENT_RUNTIME_VERSION;
     execute(expectedBase64: string, input: unknown, options: ComponentOptions, version: typeof COMPONENT_CLIENT_RUNTIME_VERSION): Promise<Failure | Success>;
 }>;
+/** 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 declare const checkedComponentRuntimeV2: Readonly<{
+    version: typeof COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION;
+    execute(expectedBase64: string, input: unknown, options: ComponentOptions, version: typeof COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION): Promise<ComponentClientResult>;
+}>;
 export {};

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, componentSoap12ClientRuntime } from './directClientRuntime.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR, 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,20 @@ export const checkedComponentRuntimeV1 = Object.freeze({
         return componentClientRuntime.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 = Object.freeze({
+    version: COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION,
+    async execute(expectedBase64, input, options, version) {
+        if (version !== COMPONENT_SOAP12_CLIENT_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 componentSoap12ClientRuntime.execute(expectedBase64, input, options);
+    },
+});

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 } 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 = Exclude<DirectClientResult, {
+    kind: 'soap-fault';
+}> | ComponentProtocolFault | 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,10 @@ 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>;
+}>;

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_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,14 @@ 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, true),
+});
+async function executeClient(expectedBase64, input, options, component, allowSoap12 = false) {
     // 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,6 +128,8 @@ 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' && !allowSoap12)
+                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');
@@ -138,8 +147,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' && !allowSoap12)
+                return fail('incompatible-artifact', 'SOAP 1.2 runtime binding required');
             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,6 @@ 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";
 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,6 @@ 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';
 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_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_CLIENT_RUNTIME_VERSION;
         const lines = [
-            '// Checked component client; inject checkedComponentRuntimeV1 from the package root.',
+            `// Checked component client; inject ${soap12 ? 'checkedComponentRuntimeV2' : 'checkedComponentRuntimeV1'} 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${soap12 ? '?' : ''}: 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${soap12 ? '?' : ''}: 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}})']
+                : faults.length ? [] : ['  | (Common & {readonly kind: "soap-fault"; readonly value: never; readonly fault: {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/directCodec.js

@@ -40,7 +40,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;

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

@@ -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');
             }
@@ -202,11 +207,11 @@ async function exchangeSoap(contract, input, application, options, profile) {
         const ignoredHeaders = [];
         const bodyRoot = (root, incoming = false) => {
             if (!same(root.name, { namespace: SOAP, local: 'Envelope' }))
-                stop('protocol', 'SOAP 1.1 Envelope required');
+                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
@@ -255,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');
@@ -294,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;
@@ -304,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(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');
@@ -315,10 +322,20 @@ 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|iso-8859-1)"|(utf-8|utf-16|utf-16le|utf-16be|iso-8859-1)))?\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();
@@ -329,7 +346,9 @@ async function exchangeSoap(contract, input, application, options, profile) {
         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);
@@ -338,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')
@@ -370,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');
 }

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

package/dist/compiler/soapHeaders.d.ts

@@ -1,4 +1,4 @@
-/** SOAP 1.1 response-header clauses for the component transport's default ultimate-receiver role. */
+/** SOAP response-header clauses for the component transport's default ultimate-receiver role. */
 import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
 export type ComponentSoapHeaderResult = Readonly<{
     kind: 'ignored-optional-headers';
@@ -9,8 +9,14 @@ export type ComponentSoapHeaderResult = Readonly<{
 }>;
 /** Assess borrowed parsed Header syntax without claiming unknown block semantics.
  * @remarks SOAP 1.1 sections 4.2 through 4.2.3 require qualified block names and define absent mustUnderstand
- *   as 0. Only immediate block attributes govern header processing. Actor-directed processing and mandatory
- *   block semantics remain unsupported; no security/header emission capability is acquired here.
+ *   as 0. SOAP 1.2 additionally defines boolean lexicals and role/relay attributes. Only immediate block
+ *   attributes govern processing. Unknown mandatory blocks targeted at this receiver remain unsupported.
+ * @param header Parsed Header in the selected envelope namespace.
+ * @param check Invocation-owned cancellation and work accounting.
+ * @param version Selected SOAP binding version; omission retains SOAP 1.1 compatibility.
+ * @returns Unprocessed block names or an explicit protocol/capability refusal.
+ * @throws Propagates caller cancellation and resource exceptions from check.
  * @see https://www.w3.org/TR/2000/NOTE-SOAP-20000508/
+ * @see https://www.w3.org/TR/soap12-part1/#soapheadblock
  */
-export declare function assessComponentSoapHeader(header: SyntaxElement, check: () => void): ComponentSoapHeaderResult;
+export declare function assessComponentSoapHeader(header: SyntaxElement, check: () => void, version?: '1.1' | '1.2'): ComponentSoapHeaderResult;

package/dist/compiler/soapHeaders.js

@@ -1,13 +1,20 @@
 const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
 /** Assess borrowed parsed Header syntax without claiming unknown block semantics.
  * @remarks SOAP 1.1 sections 4.2 through 4.2.3 require qualified block names and define absent mustUnderstand
- *   as 0. Only immediate block attributes govern header processing. Actor-directed processing and mandatory
- *   block semantics remain unsupported; no security/header emission capability is acquired here.
+ *   as 0. SOAP 1.2 additionally defines boolean lexicals and role/relay attributes. Only immediate block
+ *   attributes govern processing. Unknown mandatory blocks targeted at this receiver remain unsupported.
+ * @param header Parsed Header in the selected envelope namespace.
+ * @param check Invocation-owned cancellation and work accounting.
+ * @param version Selected SOAP binding version; omission retains SOAP 1.1 compatibility.
+ * @returns Unprocessed block names or an explicit protocol/capability refusal.
+ * @throws Propagates caller cancellation and resource exceptions from check.
  * @see https://www.w3.org/TR/2000/NOTE-SOAP-20000508/
+ * @see https://www.w3.org/TR/soap12-part1/#soapheadblock
  */
-export function assessComponentSoapHeader(header, check) {
+export function assessComponentSoapHeader(header, check, version = '1.1') {
     check();
-    if (header.name.namespace !== SOAP || header.name.local !== 'Header' || header.attributes.length)
+    const namespace = version === '1.2' ? 'http://www.w3.org/2003/05/soap-envelope' : SOAP;
+    if (header.name.namespace !== namespace || header.name.local !== 'Header' || header.attributes.length)
         return Object.freeze({ kind: 'protocol', rule: 'SOAP Header shape' });
     const headers = [];
     for (const child of header.children) {
@@ -20,21 +27,33 @@ export function assessComponentSoapHeader(header, check) {
         if (!child.name.namespace)
             return Object.freeze({ kind: 'protocol', rule: 'SOAP header block namespace required' });
         let mandatory = false;
+        let targeted = true;
         for (const attribute of child.attributes) {
             check();
-            if (attribute.name.namespace !== SOAP)
+            if (attribute.name.namespace !== namespace)
                 continue;
+            if (version === '1.2' && attribute.name.local === 'role') {
+                if (!/^[A-Za-z][A-Za-z0-9+.-]*:/.test(attribute.value))
+                    return Object.freeze({ kind: 'protocol', rule: 'SOAP role URI' });
+                targeted = [namespace + '/role/next', namespace + '/role/ultimateReceiver'].includes(attribute.value);
+                continue;
+            }
+            if (version === '1.2' && attribute.name.local === 'relay') {
+                if (!['true', 'false', '1', '0'].includes(attribute.value))
+                    return Object.freeze({ kind: 'protocol', rule: 'SOAP relay boolean' });
+                continue;
+            }
             if (attribute.name.local === 'actor')
                 return Object.freeze({ kind: 'unsupported', rule: 'SOAP actor header capability required' });
             if (attribute.name.local === 'mustUnderstand') {
-                if (attribute.value !== '0' && attribute.value !== '1')
-                    return Object.freeze({ kind: 'protocol', rule: 'SOAP 1.1 mustUnderstand value' });
-                mandatory = attribute.value === '1';
+                if (!(version === '1.2' ? ['true', 'false', '1', '0'] : ['0', '1']).includes(attribute.value))
+                    return Object.freeze({ kind: 'protocol', rule: `SOAP ${version} mustUnderstand value` });
+                mandatory = attribute.value === '1' || attribute.value === 'true';
             }
             else if (attribute.name.local !== 'encodingStyle')
                 return Object.freeze({ kind: 'unsupported', rule: 'unknown SOAP header attribute' });
         }
-        if (mandatory)
+        if (mandatory && targeted)
             return Object.freeze({ kind: 'unsupported', rule: 'incoming mandatory SOAP header' });
         headers.push(Object.freeze({ ...child.name }));
     }

package/dist/gateway/generateCheckedGateway.js

@@ -22,7 +22,7 @@ async function generateGatewayFromReconstruction(expected, options) {
         throw new Error('Checked gateway generation cancelled');
     inspectReconstructedComponentSource(expected);
     const capsule = { bytes: componentSourceCapsuleBytes(expected, options.signal) };
-    const runtime = 'checkedComponentRuntimeV1';
+    const runtime = expected.contract.binding.version === '1.2' ? 'checkedComponentRuntimeV2' : 'checkedComponentRuntimeV1';
     if (!options.routePath.startsWith('/') || options.routePath.split('/').slice(1)
         .some(segment => !segment || !/^(?:[A-Za-z0-9._~-]|%[0-9A-Fa-f]{2})+$/.test(segment))) {
         throw new TypeError('Checked routePath requires literal nonempty path segments');
@@ -40,6 +40,16 @@ async function generateGatewayFromReconstruction(expected, options) {
         }).schema;
     };
     const request = schema(input, 'Request'), response = schema(output, 'Response');
+    const soap12 = expected.contract.binding.version === '1.2';
+    const nameSchema = { type: 'object', additionalProperties: false, required: ['namespace', 'local'],
+        properties: { namespace: { type: 'string' }, local: { type: 'string' } } };
+    const protocolFaultProperties = {
+        version: { const: '1.2' }, code: nameSchema, string: { type: 'string' },
+        subcodes: { type: 'array', items: nameSchema },
+        reasons: { type: 'array', minItems: 1, items: { type: 'object', additionalProperties: false, required: ['lang', 'text'],
+                properties: { lang: { type: 'string' }, text: { type: 'string' } } } },
+        node: { type: 'string' }, role: { type: 'string' },
+    };
     const faults = expected.mappings.filter(mapping => mapping.direction.kind === 'fault').map(mapping => {
         if (mapping.direction.kind !== 'fault')
             throw new TypeError('Declared fault mapping required');
@@ -50,8 +60,8 @@ async function generateGatewayFromReconstruction(expected, options) {
         properties: {
             value: fault.value,
             fault: {
-                type: 'object', additionalProperties: false, required: ['name', 'code', 'string'],
-                properties: {
+                type: 'object', additionalProperties: false, required: ['name', 'code', 'string', ...(soap12 ? ['version', 'subcodes', 'reasons'] : [])],
+                properties: soap12 ? { ...protocolFaultProperties, name: { const: fault.name } } : {
                     name: { const: fault.name }, string: { type: 'string' }, actor: { type: 'string' },
                     code: { type: 'object', additionalProperties: false, required: ['namespace', 'local'],
                         properties: { namespace: { type: 'string' }, local: { type: 'string' } } },
@@ -59,6 +69,11 @@ async function generateGatewayFromReconstruction(expected, options) {
             },
         },
     }));
+    if (soap12)
+        faultVariants.push({ type: 'object', additionalProperties: false, required: ['fault'], properties: {
+                fault: { type: 'object', additionalProperties: false, required: ['version', 'code', 'string', 'subcodes', 'reasons'],
+                    properties: protocolFaultProperties },
+            } });
     const fault = faultVariants.length ? { oneOf: faultVariants } : { not: {} };
     const schemas = { request: { $schema: draft07, ...request }, response: { $schema: draft07, ...response }, fault: { $schema: draft07, ...fault } };
     const grouped = expected.mappings.some(mapping => mapping.kind === 'component-mapping'
@@ -97,7 +112,7 @@ async function generateGatewayFromReconstruction(expected, options) {
         openapi: '3.1.1', jsonSchemaDialect: 'https://json-schema.org/draft/2020-12/schema',
         info: { title: expected.selection.service.local, version: '1.0.0' },
         ...(grouped ? { components: { schemas: components } } : {}),
-        'x-checked-model': { model: 'checked-components-v1', scope: 'native-component-structured-soap11',
+        'x-checked-model': { model: 'checked-components-v1', scope: soap12 ? 'native-component-structured-soap12' : 'native-component-structured-soap11',
             ...(expected.responseProjection
                 ? { responseProjection: { spec: expected.responseProjection.spec, delivery: 'buffered', retainedValue: 'complete-companion-payload' } } : {}),
             documentationDialect: '2020-12', runtimeDialect: 'draft-07', jsonShapeComplete: false,
@@ -171,9 +186,14 @@ const plugin: FastifyPluginAsync<CheckedGatewayOptions> = async (fastify, option
         return reply.type('application/json').serializer(value => JSON.stringify(value)).send(result.value);
       }
       if (result.kind === 'soap-fault') {
-        const fault = {name: result.fault.name, code: {namespace: result.fault.code.namespace, local: result.fault.code.local},
+        ${soap12 ? `const fault = {version: result.fault.version, code: result.fault.code, string: result.fault.string,
+          subcodes: result.fault.subcodes, reasons: result.fault.reasons,
+          ...(result.fault.name === undefined ? {} : {name: result.fault.name}),
+          ...(result.fault.node === undefined ? {} : {node: result.fault.node}),
+          ...(result.fault.role === undefined ? {} : {role: result.fault.role})};
+        const value = result.fault.name === undefined ? {fault} : {fault, value: result.value};` : `const fault = {name: result.fault.name, code: {namespace: result.fault.code.namespace, local: result.fault.code.local},
           string: result.fault.string, ...(result.fault.actor === undefined ? {} : {actor: result.fault.actor})};
-        const value = {fault, value: result.value};
+        const value = {fault, value: result.value};`}
         if (!validateFault(value)) return reply.code(502).send({kind: 'value-invalid', rule: 'http-fault-shape'});
         return reply.code(502).type('application/json').serializer(value => JSON.stringify(value)).send(value);
       }

package/dist/index.d.ts

@@ -15,7 +15,7 @@ export type { CheckedComponentPlan, ComponentPlanBlocker } from './checkedPlanni
 export type { ComponentRecordProjectionSpec, ComponentRecordProjectionAssociation } from './compiler/componentRecordProjection.js';
 export { loadStreamConfigFile, parseStreamConfig, StreamConfigError, type OperationStreamMetadata, type ShapeCatalogRef, type StreamConfig, } from "./util/streamConfig.js";
 export { applyShapeCatalogs, type ApplyShapeCatalogsOptions } from "./compiler/shapeResolver.js";
-export { checkedDirectRuntimeV1, checkedComponentRuntimeV1 } from './client/checkedDirectRuntime.js';
+export { checkedDirectRuntimeV1, checkedComponentRuntimeV1, checkedComponentRuntimeV2 } from './client/checkedDirectRuntime.js';
 /**
  * Compiles a WSDL file to TypeScript client code
  *

package/dist/index.js

@@ -32,7 +32,7 @@ export { composeOpenApiDocuments } from './openapi/composeOpenAPI.js';
 export { planCheckedComponents, formatCheckedComponentPlan, writeCheckedPlanningFile, CheckedPlanningError } from './checkedPlanning.js';
 export { loadStreamConfigFile, parseStreamConfig, StreamConfigError, } from "./util/streamConfig.js";
 export { applyShapeCatalogs } from "./compiler/shapeResolver.js";
-export { checkedDirectRuntimeV1, checkedComponentRuntimeV1 } from './client/checkedDirectRuntime.js';
+export { checkedDirectRuntimeV1, checkedComponentRuntimeV1, checkedComponentRuntimeV2 } from './client/checkedDirectRuntime.js';
 // noinspection JSUnusedGlobalSymbols
 /**
  * Compiles a WSDL file to TypeScript client code

package/docs/api-reference.md

@@ -6,7 +6,7 @@ See the main [README](../README.md) for installation, CLI usage, and project ove
 
 All file-producing APIs automatically apply [TypeScript preambles](generated-code.md#generated-preambles-and-eslint). Adding a preamble does not change an API signature or option; existing scaffold skip/force behavior still applies. Resource and TypeScript file-write failures propagate to callers.
 
-Generated-output compatibility is versioned separately from those preambles. Read the [1.1.x-to-1.2.0 migration guide](migration.md#from-11x-to-120) before regenerating existing clients or changing their selected profile.
+Generated-output compatibility is versioned separately from those preambles. Read the [migration guide for the intended version](migration.md), including [1.2.x-to-1.3.0 SOAP binding adoption](migration.md#from-12x-to-130), before regenerating existing clients or changing their selected profile.
 
 ## compileWsdlToProject
 

package/docs/checked-gateway.md

@@ -4,6 +4,14 @@ Generation offers legacy, the default, and opt-in checked components. Start with
 
 ## Component service generation
 
+SOAP 1.2 document/literal operations use the selected binding's envelope namespace and `application/soap+xml` action parameter. Select service, port and binding through the existing checked configuration when multiple ports are available; a SOAP version flag is unnecessary. SOAP 1.2 artifacts have their own compatibility scope, so regenerate matched clients, capsules and gateways together. Existing SOAP 1.1 and direct-runtime artifacts retain their contracts.
+
+Generated SOAP 1.2 clients use the additive `checkedComponentRuntimeV2` package-root binding with protocol `checked-component-soap12-runtime-v1`. Existing SOAP 1.1 clients keep `checkedComponentRuntimeV1` and `checked-component-runtime-v2`, including their TypeScript injection contract. The older binding refuses SOAP 1.2 artifacts before SOAP dispatch.
+
+SOAP 1.2 faults retain code, nested subcodes, language-tagged reasons and optional Node/Role metadata. Declared application detail uses the existing native mapping and gateway fault validation. A valid protocol fault without declared application detail carries fault metadata without a typed application value; the client retains original response bytes. Gateways return HTTP 502 for upstream faults, including SOAP Sender faults received on HTTP 400. SOAP 1.2 protocol rules follow [the messaging framework](https://www.w3.org/TR/soap12-part1/#soapfault) and [HTTP binding](https://www.w3.org/TR/soap12-part2/#soapinhttp).
+
+SOAP 1.2 header processing uses the default ultimate receiver and next roles. Unknown mandatory blocks targeted at this receiver refuse; other-role and optional blocks may be ignored. The `mustUnderstand` and `relay` attributes accept SOAP 1.2 Boolean lexical forms. This does not enable outgoing application headers, WS-Security, streaming or RPC/encoded SOAP 1.2.
+
 The additive `checked-components-v1` mode uses the same command family and native owners for qualified structured operations, imported schema snapshots, attributes, recursive records, simple content and ordered values. It preserves the shipped direct runtime and legacy defaults. Source, mapping, artifact and transport checks remain authoritative; unsupported schema or security features refuse rather than disappearing from a successful service claim. This is a qualified component fragment, not universal XSD, streaming or provider acceptance.
 
 The [bounded SOAP 1.1 RPC/encoded profile](supported-patterns.md#checked-soap-11-rpc-string-profile) adds source-owned scalar and flat Boolean record parts without document element roots. Component responses additionally accept exact Latin1 with encoding agreement. See the [NOAA qualification](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/noaa-ndfd-qualification.md) for native restrictions, opaque string/reference results and separate owned-server/live evidence limits.

package/docs/checked-generation.md

@@ -1,18 +1,18 @@
 # Try opt-in checked generation
 
-The 1.2.0 candidate offers opt-in WSDL-to-checked-gateway generation for supported document/literal SOAP 1.1 contracts and the bounded RPC/encoded string profile. Choose `pipeline --model checked-components-v1`; omitting `--model` keeps legacy generation. See the root [README](../README.md).
+Opt-in checked generation supports qualified SOAP 1.1 and SOAP 1.2 document/literal contracts and the bounded SOAP 1.1 RPC/encoded string profile. Choose `pipeline --model checked-components-v1`; omitting `--model` keeps legacy generation. SOAP 1.2 execution is available starting with 1.3.0; see the [binding and artifact contract](checked-gateway.md#component-service-generation). See the root [README](../README.md).
 
 This is a bounded preview, not general WSDL/XSD or production-provider qualification. It adds source-backed request, response, fault and artifact checks for the supported fragment. Generation exposes legacy and components only; the shipped v1.1.5 direct runtime remains a compatibility binding for existing clients. See the [checked gateway reference](checked-gateway.md).
 
 ## Install and try the bundled contract
 
-Version 1.2.0 is a release candidate until published. During candidate verification, install the locally packed 1.2.0 tarball instead of requesting an unpublished registry version. Earlier published previews retain their historical contracts.
+The examples target 1.3.0. Before that version is published, install a locally packed 1.3.0 tarball instead of requesting an unpublished registry version. After publication, use the explicit registry version below. Earlier releases retain their own documented contracts.
 
 Use Node.js 24 or newer. Run these commands in a new trial directory:
 
 ```powershell
 npm init -y
-npm install --save-dev @techspokes/typescript-wsdl-client@1.2.0
+npm install --save-dev @techspokes/typescript-wsdl-client@1.3.0
 npm install soap
 npx wsdl-tsc pipeline --model checked-components-v1 --wsdl-source node_modules/@techspokes/typescript-wsdl-client/docs/examples/checked-forecast.wsdl --client-dir .generated/forecast/client --openapi-file .generated/forecast/openapi.json --gateway-dir .generated/forecast/gateway --gateway-version-prefix v1 --gateway-service-name forecast --init-app --app-dir .generated/forecast --test-dir .generated/forecast/test --checked-report .generated/forecast-plan.json
 ```
@@ -137,7 +137,7 @@ The qualified component fragment includes imported schemas, nested/repeated and
 
 The [bounded SOAP 1.1 RPC/encoded profile](supported-patterns.md#checked-soap-11-rpc-string-profile) supports typed scalar parts, native restrictions, one flat required Boolean record and one opaque string result. [NOAA qualification](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/noaa-ndfd-qualification.md) covers all 12 operations against an owned server; ten live operations succeeded and two GML operations returned non-SOAP failures. There is no parsed DWML/GML or geographic correctness claim.
 
-General XSD, SOAP 1.2, general RPC encoding, broader authentication/security, arbitrary wildcard conversion and checked incremental streaming remain outside this preview. OpenAPI describes the JSON shape but does not express every native scalar/order/wildcard rule. Required declarations and strict wildcard failures cannot become successful unchecked replies.
+General XSD, general RPC encoding, broader authentication/security, arbitrary wildcard conversion and checked incremental streaming remain outside this preview. SOAP 1.2 document/literal uses the separately versioned binding described in the [checked gateway reference](checked-gateway.md#component-service-generation); live-provider acceptance is separate from owned-server protocol evidence. OpenAPI describes the JSON shape but does not express every native scalar/order/wildcard rule. Required declarations and strict wildcard failures cannot become successful unchecked replies.
 
 [#409](https://github.com/TechSpokes/typescript-wsdl-client/issues/409) supplies the bounded mixed/namespace/open mapping and its schema/serialization slice of [#410](https://github.com/TechSpokes/typescript-wsdl-client/issues/410). Representative unrelated contract qualification remains under [#397](https://github.com/TechSpokes/typescript-wsdl-client/issues/397); broader HTTP translation, source, scalar, group/naming, security and streaming work retains its existing owners. Legacy defaults and full-profile activation remain unchanged. See the [roadmap](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/ROADMAP.md) for direction and [development checkpoint](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/research/docs/content-model-development-checkpoint.md) for detailed evidence.
 

package/docs/migration.md

@@ -16,6 +16,16 @@ These steps apply to every version upgrade:
 4. Regenerate matched generator-owned artifacts using the existing generation script and options.
 5. Review the generated diff and run the consumer project's TypeScript build and tests.
 
+## From 1.2.x to 1.3.0
+
+Version 1.3.0 adds checked SOAP 1.2 document/literal execution. Legacy generation remains the default. Existing SOAP 1.1 component clients keep `checkedComponentRuntimeV1` and `checked-component-runtime-v2`; the shipped direct runtime is unchanged. Updating the package alone does not adopt SOAP 1.2 or require regeneration of existing SOAP 1.1 clients.
+
+To adopt SOAP 1.2, use `--model checked-components-v1` and the source-selected SOAP 1.2 service/port/binding. Ambiguous sources still require explicit checked configuration. Regenerate matched clients, capsules, OpenAPI and gateways with 1.3.0; the generated client uses `checkedComponentRuntimeV2` and `checked-component-soap12-runtime-v1`. Do not mix runtime handshakes or substitute artifacts across ports.
+
+SOAP 1.2 `soap-fault` results can contain protocol metadata without a declared application `value` or fault `name`. Narrow the result before accessing typed detail. Declared detail retains native validation; gateway faults remain HTTP 502. Keep consumer-owned server/config/test files under the existing skip/force rules.
+
+Qualification uses owned HTTP services, generated gateways and isolated installed consumers. It does not establish live-provider acceptance. SOAP 1.2 streaming, RPC/encoded and broader authentication/header capabilities remain separate work; see the [checked gateway contract](checked-gateway.md#component-service-generation).
+
 ## From 1.1.x to 1.2.0
 
 ### Published starting points

package/docs/start-here.md

@@ -6,7 +6,7 @@ See the root [README](../README.md) for installation and the documentation index
 
 ## Upgrade an existing project
 
-Read the [1.1.x-to-1.2.0 migration guide](migration.md#from-11x-to-120) before regenerating an existing gateway. Installing the package does not itself rewrite generated code, but consumer build/install scripts can run generation. Legacy remains the default; affected generated names, stream record shapes and corrected scalar/simple-content results need review.
+Read the [migration guide for the intended version](migration.md) before regenerating an existing gateway. The [1.3.0 upgrade](migration.md#from-12x-to-130) adds checked SOAP 1.2; earlier generation changes retain their historical migration guidance. Installing the package does not itself rewrite generated code, but consumer build/install scripts can run generation. Legacy remains the default.
 
 Use the existing generation command and preserve app/test customizations first. Adopt native composition or checked generation separately; successful representative release tests do not certify migration of every consumer project.
 

package/docs/supported-patterns.md

@@ -6,6 +6,12 @@ The matrix describes the existing legacy generator. The unreleased opt-in [check
 
 The qualified checked domain includes [keyed mixed, namespace-collision and source-permitted open values](checked-gateway.md#mixed-namespaced-and-open-values), with production conformance and installed request/response/fault evidence. Native strict/lax/skip checks remain distinct from schema-source wildcard checks and from the legacy rows below.
 
+## Checked SOAP 1.2 document/literal
+
+Checked component generation executes supported SOAP 1.2 document/literal operations through the existing buffered adapter. The selected service/port/binding determines version and action; mixed SOAP 1.1/1.2 ports remain independent. [The checked gateway reference](checked-gateway.md#component-service-generation) describes fault results, artifact compatibility and header processing. The legacy matrix below continues to describe binding detection rather than checked execution.
+
+SOAP 1.2 RPC/encoded, streaming, authentication and outgoing application/security headers remain separate capabilities. Owned-server evidence establishes the exercised protocol combinations, not general provider qualification.
+
 ## Checked SOAP 1.1 RPC string profile
 
 Checked component generation supports the bounded RPC/encoded profile below. The [NOAA qualification](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/noaa-ndfd-qualification.md) distinguishes all-12 owned-server execution, offline provider-response replay and the 2026-11-09 live retest: ten operations succeeded, while two GML operations returned non-SOAP provider errors. No geographic correctness claim follows.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techspokes/typescript-wsdl-client",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Turn legacy WSDL/SOAP services into typed TypeScript clients, OpenAPI 3.1 specs, and production-ready Fastify REST gateways. Built for enterprise SOAP modernization.",
   "keywords": [
     "wsdl",