@wirebench/engine 2.2.1 → 3.1.0-rc.1

package/dist/soap/script-types.js

@@ -0,0 +1,379 @@
+import { qnameToString } from '../wsdl/qname.js';
+import { findBinding, findMessage, findPortType } from '../wsdl/model.js';
+import { resolveType } from '../xsd/sample-types.js';
+import { builtinBaseOf, facetsOf } from '../xsd/sample-values.js';
+import { scanXml } from '../xsd/xml-scan.js';
+import { NS } from '../xml/namespaces.js';
+import { propertyKey } from '../script/types/json-schema.js';
+/** Past these the projection widens to `unknown`, and the walk stops. */
+const LIMITS = { depth: 32, aliases: 500 };
+const NUMBER_TYPES = new Set([
+    'int',
+    'short',
+    'byte',
+    'unsignedInt',
+    'unsignedShort',
+    'unsignedByte',
+    'float',
+    'double',
+]);
+function isMany(occurs) {
+    return occurs.max === 'unbounded' || occurs.max > 1;
+}
+function declOf(set, particle) {
+    if (particle.kind === 'localElement')
+        return particle.decl;
+    if (particle.kind === 'elementRef')
+        return set.lookupElement(particle.ref);
+    return undefined;
+}
+/** The child elements a content particle allows, in schema order. */
+export function elementSlots(set, particle) {
+    const found = [];
+    const walk = (p, many, optional, inChoice, depth) => {
+        if (depth > LIMITS.depth)
+            return;
+        const here = many || isMany(p.occurs);
+        const opt = optional || p.occurs.min === 0 || inChoice;
+        if (p.kind === 'sequence' || p.kind === 'all' || p.kind === 'choice') {
+            for (const child of p.particles)
+                walk(child, here, opt, p.kind === 'choice', depth + 1);
+            return;
+        }
+        if (p.kind === 'groupRef') {
+            const group = set.lookupGroup(p.ref);
+            if (group !== undefined)
+                walk(group.particle, here, opt, false, depth + 1);
+            return;
+        }
+        const decl = declOf(set, p);
+        if (decl !== undefined)
+            found.push({ decl, many: here, optional: opt });
+    };
+    if (particle !== undefined)
+        walk(particle, false, false, false, 0);
+    // The same element twice in one content model (a, b, a) is one field holding every occurrence.
+    const merged = new Map();
+    for (const slot of found) {
+        const id = qnameToString(slot.decl.name);
+        const previous = merged.get(id);
+        merged.set(id, previous === undefined ? slot : { decl: previous.decl, many: true, optional: previous.optional && slot.optional });
+    }
+    const localCounts = new Map();
+    for (const { decl } of merged.values()) {
+        localCounts.set(decl.name.localName, (localCounts.get(decl.name.localName) ?? 0) + 1);
+    }
+    return [...merged.values()].map((slot) => ({
+        ...slot,
+        key: (localCounts.get(slot.decl.name.localName) ?? 0) > 1 ? qnameToString(slot.decl.name) : slot.decl.name.localName,
+    }));
+}
+function scalarOf(set, ref) {
+    const builtin = builtinBaseOf(set, ref);
+    if (builtin === undefined || builtin.name.namespaceUri !== NS.XSD)
+        return 'string';
+    if (builtin.name.localName === 'boolean')
+        return 'boolean';
+    return NUMBER_TYPES.has(builtin.name.localName) ? 'number' : 'string';
+}
+function scalarType(set, ref) {
+    const values = facetsOf(set, ref).enum;
+    const scalar = scalarOf(set, ref);
+    if (values !== undefined && values.length > 0) {
+        if (scalar === 'number' && values.every((v) => Number.isFinite(Number(v))))
+            return values.join(' | ');
+        return values.map((v) => JSON.stringify(v)).join(' | ');
+    }
+    return scalar;
+}
+function attributeKey(attribute) {
+    return `@${attribute.name.localName}`;
+}
+/** The type of an element's value, declaring an alias for each named complex type it meets. */
+class XsdTypes {
+    set;
+    aliases = new Map();
+    declared = [];
+    constructor(set) {
+        this.set = set;
+    }
+    element(decl, depth) {
+        const type = this.valueOf(decl.type ?? decl.anonymousType, depth);
+        return decl.nillable && type !== 'unknown' ? `${type} | null` : type;
+    }
+    valueOf(ref, depth) {
+        if (depth > LIMITS.depth)
+            return 'unknown';
+        const resolved = resolveType(this.set, ref);
+        switch (resolved.kind) {
+            case 'simple':
+                return scalarType(this.set, resolved.ref);
+            case 'complex':
+                return this.complex(resolved.type, depth);
+            default:
+                return 'unknown';
+        }
+    }
+    complex(type, depth) {
+        if (type.name === undefined)
+            return this.complexBody(type, depth);
+        const id = qnameToString(type.name);
+        const existing = this.aliases.get(id);
+        if (existing !== undefined)
+            return existing;
+        if (this.aliases.size >= LIMITS.aliases)
+            return 'unknown';
+        const alias = `WbX_${type.name.localName.replace(/[^A-Za-z0-9_]/g, '_')}_${String(this.aliases.size + 1)}`;
+        this.aliases.set(id, alias);
+        this.declared.push(`/** ${id} */\ntype ${alias} = ${this.complexBody(type, depth)};\n`);
+        return alias;
+    }
+    complexBody(type, depth) {
+        const content = this.set.resolveContent(type);
+        const lines = [];
+        for (const attribute of content.attributes) {
+            const optional = attribute.use === 'required' ? '' : '?';
+            lines.push(`  ${JSON.stringify(attributeKey(attribute))}${optional}: ${scalarType(this.set, attribute.type ?? attribute.anonymousType)};\n`);
+        }
+        if (content.simpleContentBase !== undefined) {
+            const text = scalarType(this.set, content.simpleContentBase);
+            if (content.attributes.length === 0)
+                return text;
+            lines.push(`  "#text": ${text};\n`);
+        }
+        for (const slot of elementSlots(this.set, content.particle)) {
+            const value = this.element(slot.decl, depth + 1);
+            const item = /^[A-Za-z0-9_$"]+$/.test(value) ? value : `(${value})`;
+            lines.push(`  ${propertyKey(slot.key)}${slot.optional ? '?' : ''}: ${slot.many ? `${item}[]` : value};\n`);
+        }
+        return lines.length === 0 ? 'Record<string, never>' : `{\n${lines.join('')}}`;
+    }
+    declarations() {
+        return this.declared.join('');
+    }
+}
+/** `WbSoapRequestBody` and `WbSoapResponseBody` for an operation's input and output elements. */
+export function soapScriptTypes(set, input, output) {
+    const lines = [];
+    const types = set !== undefined ? new XsdTypes(set) : undefined;
+    const bodyOf = (name) => {
+        const decl = name !== undefined ? set?.lookupElement(name) : undefined;
+        return decl !== undefined && types !== undefined ? types.element(decl, 0) : 'unknown';
+    };
+    const request = bodyOf(input);
+    const response = bodyOf(output);
+    if (request === 'unknown' || response === 'unknown') {
+        lines.push('// A body this operation does not describe with a schema element is untyped; use envelope and select.');
+    }
+    lines.push(types?.declarations() ?? '', `type WbSoapRequestBody = ${request};`, `type WbSoapResponseBody = ${response};`, '');
+    return lines.join('\n');
+}
+// --- The projection -----------------------------------------------------------------------------
+function toScalar(text, scalar) {
+    const trimmed = text.trim();
+    if (scalar === 'boolean')
+        return trimmed === 'true' || trimmed === '1';
+    if (scalar === 'number') {
+        const n = Number(trimmed);
+        return trimmed !== '' && Number.isFinite(n) ? n : text;
+    }
+    return text;
+}
+function isNil(element) {
+    return element.attributes.some((a) => (a.name === 'xsi:nil' || a.name.endsWith(':nil')) && (a.value === 'true' || a.value === '1'));
+}
+/** The text of an element: its own text, or empty. */
+function textOf(element) {
+    return element.text?.value ?? '';
+}
+function decodeEntities(text) {
+    return text.replace(/&(lt|gt|amp|quot|apos|#\d+|#x[0-9a-fA-F]+);/g, (whole, name) => {
+        switch (name) {
+            case 'lt':
+                return '<';
+            case 'gt':
+                return '>';
+            case 'amp':
+                return '&';
+            case 'quot':
+                return '"';
+            case 'apos':
+                return "'";
+            default: {
+                const code = name.startsWith('#x') ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
+                return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
+            }
+        }
+    });
+}
+/** The value `element` holds as `decl` describes it. */
+export function projectElement(set, decl, element, depth = 0) {
+    if (depth > LIMITS.depth)
+        return undefined;
+    if (decl.nillable && isNil(element))
+        return null;
+    const resolved = resolveType(set, decl.type ?? decl.anonymousType);
+    if (resolved.kind === 'simple') {
+        return toScalar(decodeEntities(textOf(element)), scalarOf(set, resolved.ref));
+    }
+    if (resolved.kind !== 'complex')
+        return undefined;
+    const content = set.resolveContent(resolved.type);
+    const out = {};
+    for (const attribute of content.attributes) {
+        const found = element.attributes.find((a) => (a.name.includes(':') ? a.name.split(':')[1] : a.name) === attribute.name.localName &&
+            !a.name.startsWith('xmlns'));
+        if (found !== undefined) {
+            out[attributeKey(attribute)] = toScalar(decodeEntities(found.value), scalarOf(set, attribute.type ?? attribute.anonymousType));
+        }
+    }
+    if (content.simpleContentBase !== undefined) {
+        const text = toScalar(decodeEntities(textOf(element)), scalarOf(set, content.simpleContentBase));
+        if (content.attributes.length === 0)
+            return text;
+        out['#text'] = text;
+        return out;
+    }
+    const slots = elementSlots(set, content.particle);
+    for (const child of element.children) {
+        const slot = slots.find((s) => s.decl.name.localName === child.localName && s.decl.name.namespaceUri === child.namespaceUri);
+        if (slot === undefined)
+            continue;
+        const value = projectElement(set, slot.decl, child, depth + 1);
+        if (slot.many) {
+            const list = out[slot.key] ?? [];
+            list.push(value);
+            out[slot.key] = list;
+        }
+        else {
+            out[slot.key] = value;
+        }
+    }
+    return out;
+}
+function escapeXml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function scalarText(value) {
+    if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string')
+        return String(value);
+    throw new TypeError(`expected a string, number or boolean, got ${value === null ? 'null' : typeof value}`);
+}
+/**
+ * `value` as the XML for `decl`, children in schema order. A namespace is declared as the default
+ * wherever it changes from the parent's, so the fragment stands on its own inside any envelope.
+ *
+ * @throws TypeError when `value` does not have the shape the schema needs
+ */
+export function serializeElement(set, decl, value, parentNamespace, depth = 0) {
+    if (depth > LIMITS.depth)
+        throw new TypeError('the body is nested too deeply');
+    const name = decl.name.localName;
+    const namespace = decl.name.namespaceUri;
+    const xmlns = namespace === parentNamespace ? '' : ` xmlns="${escapeXml(namespace)}"`;
+    if (value === null) {
+        if (!decl.nillable)
+            throw new TypeError(`${name} cannot be null`);
+        return `<${name}${xmlns} xmlns:xsi="${NS.XSI}" xsi:nil="true"/>`;
+    }
+    const resolved = resolveType(set, decl.type ?? decl.anonymousType);
+    if (resolved.kind === 'simple') {
+        return `<${name}${xmlns}>${escapeXml(scalarText(value))}</${name}>`;
+    }
+    if (resolved.kind !== 'complex')
+        throw new TypeError(`${name} has no schema type a script can write`);
+    const content = set.resolveContent(resolved.type);
+    if (content.simpleContentBase !== undefined && content.attributes.length === 0) {
+        return `<${name}${xmlns}>${escapeXml(scalarText(value))}</${name}>`;
+    }
+    if (typeof value !== 'object' || Array.isArray(value))
+        throw new TypeError(`${name} must be an object`);
+    const record = value;
+    let attributes = '';
+    for (const attribute of content.attributes) {
+        const v = record[attributeKey(attribute)];
+        if (v !== undefined)
+            attributes += ` ${attribute.name.localName}="${escapeXml(scalarText(v))}"`;
+    }
+    if (content.simpleContentBase !== undefined) {
+        const text = record['#text'];
+        return `<${name}${xmlns}${attributes}>${text === undefined ? '' : escapeXml(scalarText(text))}</${name}>`;
+    }
+    const children = [];
+    for (const slot of elementSlots(set, content.particle)) {
+        const v = record[slot.key];
+        if (v === undefined)
+            continue;
+        const items = slot.many ? (Array.isArray(v) ? v : [v]) : [v];
+        for (const item of items)
+            children.push(serializeElement(set, slot.decl, item, namespace, depth + 1));
+    }
+    return children.length === 0
+        ? `<${name}${xmlns}${attributes}/>`
+        : `<${name}${xmlns}${attributes}>${children.join('')}</${name}>`;
+}
+/** The first element inside the envelope's SOAP Body, if the envelope has one. */
+export function soapBodyElement(envelope) {
+    const root = scanXml(envelope).elements[0];
+    if (root?.localName !== 'Envelope')
+        return undefined;
+    const body = root.children.find((child) => child.localName === 'Body' && (child.namespaceUri === NS.SOAP11_ENV || child.namespaceUri === NS.SOAP12_ENV));
+    return body?.children[0];
+}
+/** The projection of the envelope's body element, when `element` names its declaration. */
+export function projectSoapBody(set, element, envelope) {
+    const decl = element !== undefined ? set?.lookupElement(element) : undefined;
+    const body = soapBodyElement(envelope);
+    if (set === undefined || decl === undefined || body === undefined)
+        return undefined;
+    if (body.localName !== decl.name.localName || body.namespaceUri !== decl.name.namespaceUri)
+        return undefined;
+    return projectElement(set, decl, body);
+}
+/**
+ * The envelope with its body element replaced by `value` written as `element`. Everything outside
+ * the body element is kept byte for byte.
+ *
+ * @throws TypeError when the envelope has no body element or `value` does not fit the schema
+ */
+export function replaceSoapBody(set, element, envelope, value) {
+    const decl = set.lookupElement(element);
+    const body = soapBodyElement(envelope);
+    if (decl === undefined || body === undefined)
+        throw new TypeError('the envelope has no body element to replace');
+    const xml = serializeElement(set, decl, value, undefined);
+    return envelope.slice(0, body.range.start) + xml + envelope.slice(body.range.end);
+}
+/** `{namespace}local` as a QName. */
+export function qnameFromClark(clark) {
+    const match = /^\{([^}]*)\}(.*)$/.exec(clark);
+    return match === null ? { namespaceUri: '', localName: clark } : { namespaceUri: match[1], localName: match[2] };
+}
+/**
+ * The elements a document-style SOAP operation's input and output messages name, when each message
+ * has exactly one element part — the shape a typed body needs. An RPC-style operation, or a message
+ * of type parts, has none.
+ */
+export function soapOperationElements(definition, bindingName, operationName) {
+    const binding = findBinding(definition, qnameFromClark(bindingName));
+    if (binding === undefined)
+        return {};
+    const bindingOperation = binding.operations.find((op) => op.name === operationName);
+    // An operation's own style overrides its binding's.
+    if ((bindingOperation?.style ?? binding.style) === 'rpc')
+        return {};
+    const operation = findPortType(definition, binding.type)?.operations.find((op) => op.name === operationName);
+    const elementOf = (ref) => {
+        const message = ref === undefined ? undefined : findMessage(definition, ref.message);
+        const elements = message?.parts.filter((part) => part.element !== undefined) ?? [];
+        return elements.length === 1 ? elements[0].element : undefined;
+    };
+    const input = elementOf(operation?.input);
+    const output = elementOf(operation?.output);
+    return { ...(input !== undefined ? { input } : {}), ...(output !== undefined ? { output } : {}) };
+}

package/dist/soap/scripting.d.ts

@@ -0,0 +1,45 @@
+import type { ProtocolScripting } from '../protocol/module.js';
+import type { HeaderPair } from '../script/model.js';
+import type { SoapExchange, SoapSendInput } from './types.js';
+import type { QName } from '../wsdl/qname.js';
+import type { SchemaSet } from '../xsd/schema-set.js';
+export interface SoapRequestSnapshot {
+    readonly protocol: 'soap';
+    readonly endpoint: string;
+    readonly soapAction: string;
+    readonly headers: readonly HeaderPair[];
+    /** The whole envelope, after property expansion and before WS-Addressing or WS-Security. */
+    readonly envelope: string;
+    /** The body element as the object its schema describes (`types/xsd.ts`); absent when there is no schema. */
+    readonly body?: unknown;
+}
+export interface SoapResponseSnapshot {
+    readonly protocol: 'soap';
+    readonly status: number;
+    readonly headers: readonly HeaderPair[];
+    /** The response envelope. */
+    readonly text: string;
+    readonly durationMs: number;
+    readonly fault?: {
+        readonly code: string;
+        readonly reason: string;
+    };
+    /** The body element as the object its schema describes; absent when there is no schema. */
+    readonly body?: unknown;
+}
+/** A SOAP send already expanded (with placeholders), as a script sees it. */
+export declare function soapRequestSnapshot(expanded: SoapSendInput): SoapRequestSnapshot;
+/** The expanded send with a pre-request script's changes; a header set twice keeps its last value. */
+export declare function applySoapSnapshot(expanded: SoapSendInput, after: SoapRequestSnapshot): SoapSendInput;
+export declare function soapResponseSnapshot(exchange: SoapExchange): SoapResponseSnapshot;
+/**
+ * What SOAP's script types carry for the typed `request.body` and `response.body`
+ * (`RequestScriptTypes.binding`): the schema and the operation's input and output elements.
+ */
+export interface SoapScriptBinding {
+    readonly schemas: SchemaSet;
+    readonly input?: QName;
+    readonly output?: QName;
+}
+/** SOAP's scripting facet. */
+export declare const soapScripting: ProtocolScripting<SoapRequestSnapshot, SoapResponseSnapshot>;

package/dist/soap/scripting.js

@@ -0,0 +1,221 @@
+/**
+ * What a script sees of a SOAP request and its response (spec §3.4): the snapshots, the converters
+ * between an expanded send and a snapshot, the API's declarations, its sandbox-side source, what
+ * the script rules check, and the typed `body` a schema gives the script.
+ */
+import { z } from 'zod';
+import { headerPairSchema } from '../script/apply.js';
+import { recordPairs } from '../script/send.js';
+import { projectSoapBody, replaceSoapBody } from './script-types.js';
+/** A SOAP send already expanded (with placeholders), as a script sees it. */
+export function soapRequestSnapshot(expanded) {
+    return {
+        protocol: 'soap',
+        endpoint: expanded.endpoint,
+        soapAction: expanded.soapAction ?? '',
+        headers: recordPairs(expanded.headers),
+        envelope: expanded.envelopeXml,
+    };
+}
+/** The expanded send with a pre-request script's changes; a header set twice keeps its last value. */
+export function applySoapSnapshot(expanded, after) {
+    return {
+        ...expanded,
+        endpoint: after.endpoint,
+        ...(after.soapAction !== '' || expanded.soapAction !== undefined ? { soapAction: after.soapAction } : {}),
+        headers: Object.fromEntries(after.headers.map(([n, v]) => [n, v])),
+        envelopeXml: after.envelope,
+    };
+}
+export function soapResponseSnapshot(exchange) {
+    const fault = exchange.response?.fault;
+    return {
+        protocol: 'soap',
+        status: exchange.http.status,
+        headers: exchange.http.rawHeaders.map(([n, v]) => [n, v]),
+        text: exchange.response?.envelopeXml ?? new TextDecoder().decode(exchange.http.body),
+        durationMs: exchange.durationMs,
+        ...(fault !== undefined ? { fault: { code: fault.code, reason: fault.reason } } : {}),
+    };
+}
+const SOAP_PRE = `
+declare const request: {
+  readonly endpoint: string;
+  soapAction: string;
+  readonly headers: WbWritablePairs;
+  /** The whole envelope, after property expansion and before WS-Addressing and WS-Security. */
+  envelope: string;
+  /** The SOAP body's element, typed from the operation's input message. */
+  body: WbSoapRequestBody;
+};
+`;
+const SOAP_POST = `
+declare const request: {
+  readonly endpoint: string;
+  readonly soapAction: string;
+  readonly headers: WbPairs;
+  readonly envelope: string;
+  readonly body: WbSoapRequestBody;
+};
+declare const response: {
+  readonly status: number;
+  readonly headers: WbPairs;
+  readonly envelope: string;
+  readonly text: string;
+  /** The SOAP body's element, typed from the operation's output message. */
+  readonly body: WbSoapResponseBody;
+  readonly fault?: { readonly code: string; readonly reason: string };
+  /** Strings an XPath expression selects in the response envelope. */
+  select(xpath: string, namespaces?: Record<string, string>): string[];
+  readonly durationMs: number;
+};
+`;
+const SOAP = String.raw `
+const soapRequest = (snapshot, writable) => {
+  const data = {
+    endpoint: snapshot.endpoint,
+    soapAction: snapshot.soapAction,
+    headers: snapshot.headers.map(([n, v]) => [n, v]),
+    envelope: snapshot.envelope,
+    body: snapshot.body === undefined ? undefined : JSON.parse(JSON.stringify(snapshot.body)),
+  };
+  const refuse = (what) => () => { throw new TypeError('The ' + what + ' of a sent request cannot be changed'); };
+  const noSchema = () => {
+    throw new TypeError('This operation\'s body has no schema element, so request.body is not available; use request.envelope');
+  };
+  const request = Object.freeze({
+    get endpoint() { return data.endpoint; },
+    set endpoint(value) { if (!writable) refuse('endpoint')(); data.endpoint = String(value); },
+    get soapAction() { return data.soapAction; },
+    set soapAction(value) {
+      if (!writable) refuse('SOAPAction')();
+      const text = String(value);
+      if (hasCrlf(text)) throw new ScriptValueInvalid('The SOAPAction may not hold CR, LF or NUL');
+      data.soapAction = text;
+    },
+    headers: pairsApi(data.headers, writable, 'header'),
+    get envelope() { return data.envelope; },
+    set envelope(value) { if (!writable) refuse('envelope')(); data.envelope = String(value); },
+    get body() {
+      if (snapshot.body === undefined) noSchema();
+      return writable ? data.body : deepFreeze(data.body);
+    },
+    set body(value) {
+      if (!writable) refuse('body')();
+      if (snapshot.body === undefined) noSchema();
+      const text = JSON.stringify(value);
+      if (text === undefined) throw new TypeError('request.body must be a JSON value');
+      data.body = JSON.parse(text);
+    },
+  });
+  const snapshotOf = () => ({
+    protocol: 'soap',
+    endpoint: data.endpoint,
+    soapAction: data.soapAction,
+    headers: data.headers,
+    envelope: data.envelope,
+    ...(data.body === undefined ? {} : { body: data.body }),
+  });
+  return { request, snapshotOf };
+};
+
+const soapResponse = (snapshot) => deepFreeze({
+  status: snapshot.status,
+  headers: pairsApi(snapshot.headers.map(([n, v]) => [n, v]), false, 'header'),
+  text: snapshot.text,
+  envelope: snapshot.text,
+  fault: snapshot.fault,
+  body: snapshot.body,
+  select: (xpath, namespaces) => JSON.parse(__host.xpath(snapshot.text, String(xpath), JSON.stringify(namespaces === undefined ? {} : namespaces))),
+  durationMs: snapshot.durationMs,
+});
+
+if (input.phase === 'pre') {
+  const built = soapRequest(input.request, true);
+  define('request', built.request);
+  state.request = built.snapshotOf;
+} else {
+  define('request', soapRequest(input.request, false).request);
+  define('response', soapResponse(input.response));
+}
+`;
+function withBody(snapshot, body) {
+    return body === undefined ? snapshot : { ...snapshot, body };
+}
+/** The binding this module put on a request's script types, if it put one. */
+function bindingOf(types) {
+    const binding = types.binding;
+    if (typeof binding !== 'object' || binding === null || !('schemas' in binding))
+        return undefined;
+    return binding;
+}
+const requestSchema = z.object({
+    protocol: z.literal('soap'),
+    endpoint: z.string(),
+    soapAction: z.string(),
+    headers: z.array(headerPairSchema),
+    envelope: z.string(),
+    body: z.unknown().optional(),
+});
+/** SOAP's scripting facet. */
+export const soapScripting = {
+    declarations: (phase) => (phase === 'pre' ? SOAP_PRE : SOAP_POST),
+    reference: () => [
+        { title: 'SOAP: pre-request', declarations: SOAP_PRE },
+        { title: 'SOAP: post-response', declarations: SOAP_POST },
+    ],
+    prelude: () => SOAP,
+    requestSchema,
+    inspect(snapshot) {
+        return {
+            destination: snapshot.endpoint,
+            fixed: null,
+            pairs: snapshot.headers,
+            lines: [snapshot.endpoint, snapshot.soapAction],
+            // Not `body`: it is a view of the envelope. Core runs the rules again on the envelope it is
+            // written back into, so a secret added through the body is caught there.
+            texts: [snapshot.endpoint, snapshot.soapAction, snapshot.envelope, ...snapshot.headers.flat()],
+        };
+    },
+    views: {
+        /** The request with its body projected, when the schema describes the body element. */
+        request(snapshot, types) {
+            const binding = bindingOf(types);
+            return binding === undefined
+                ? snapshot
+                : withBody(snapshot, projectSoapBody(binding.schemas, binding.input, snapshot.envelope));
+        },
+        response(snapshot, types) {
+            const binding = bindingOf(types);
+            return binding === undefined
+                ? snapshot
+                : withBody(snapshot, projectSoapBody(binding.schemas, binding.output, snapshot.text));
+        },
+        /**
+         * Writes a changed `request.body` back into the envelope, replacing the body element. The body
+         * wins over an envelope the script also edited, since it is written into that edited envelope.
+         */
+        writeBack(before, after, types) {
+            const binding = bindingOf(types);
+            const { body, ...rest } = after;
+            if (body === undefined || JSON.stringify(body) === JSON.stringify(before.body) || binding?.input === undefined) {
+                return { ok: true, request: rest };
+            }
+            try {
+                return {
+                    ok: true,
+                    request: { ...rest, envelope: replaceSoapBody(binding.schemas, binding.input, rest.envelope, body) },
+                };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    error: {
+                        code: 'script-error',
+                        message: `request.body could not be written: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                };
+            }
+        },
+    },
+};