@wirebench/engine 2.2.1 → 3.1.0-rc.1

package/dist/soap/files.js

@@ -0,0 +1,114 @@
+/**
+ * The SOAP files of a project folder: `interfaces/<slug>/interface.yaml` and each
+ * `operations/<slug>/<name>.request.yaml` under it (spec §3.2). The shared pieces and the
+ * strictness policy are `project/schema-parts.ts`'s.
+ */
+import { z } from 'zod';
+import { assertionsSchema } from '../assert/schema.js';
+import { attachmentSourceSchema, nonEmpty, scriptsSchema, soapOwnerAuthSchema } from '../project/schema-parts.js';
+const endpointSchema = z.looseObject({
+    id: nonEmpty,
+    name: z.string(),
+    url: z.string(),
+    auth: soapOwnerAuthSchema.optional(),
+    authMode: z.enum(['override', 'complement']),
+    trustInvalid: z.boolean().optional(),
+});
+/**
+ * A stored WS-Addressing configuration. Every field beyond `enabled` is optional so a project
+ * written before the WS-Addressing task — which only ever held `{ enabled, version? }` — still
+ * loads; `normalizeWsa` fills the rest in with the v1 defaults.
+ */
+const wsaSchema = z.looseObject({
+    enabled: z.boolean(),
+    version: z.enum(['2005/08', '2004/08']).optional(),
+    mustUnderstand: z.enum(['none', 'true', 'false']).optional(),
+    action: z.string().optional(),
+    to: z.string().optional(),
+    messageId: z.string().optional(),
+    replyTo: z.string().optional(),
+    from: z.string().optional(),
+    faultTo: z.string().optional(),
+    relatesTo: z.string().optional(),
+    relationshipType: z.string().optional(),
+    addDefaultAction: z.boolean().optional(),
+    addDefaultTo: z.boolean().optional(),
+    generateMessageId: z.boolean().optional(),
+});
+const operationEntrySchema = z.looseObject({
+    name: nonEmpty,
+    bindingName: z.string(),
+    slug: nonEmpty,
+    order: z.number().int(),
+});
+/** `interfaces/<slug>/interface.yaml`. */
+export const interfaceFileSchema = z.looseObject({
+    kind: z.literal('soap'),
+    id: nonEmpty,
+    name: z.string(),
+    order: z.number().int(),
+    definitionUrl: z.string(),
+    cacheDefinition: z.boolean(),
+    targetNamespace: z.string().optional(),
+    endpoints: z.array(endpointSchema),
+    defaultEndpointId: z.string().optional(),
+    wsa: wsaSchema,
+    auth: soapOwnerAuthSchema.optional(),
+    operations: z.array(operationEntrySchema),
+});
+const requestPropertiesSchema = z.looseObject({
+    encoding: z.string(),
+    timeoutMs: z.number().int().nonnegative().optional(),
+    bindAddress: z.string().optional(),
+    followRedirects: z.boolean(),
+    skipSoapAction: z.boolean(),
+    enableMtom: z.boolean(),
+    forceMtom: z.boolean(),
+    inlineResponseAttachments: z.boolean(),
+    expandMtomAttachments: z.boolean(),
+    disableMultiparts: z.boolean(),
+    encodeAttachments: z.boolean(),
+    enableInlineFiles: z.boolean(),
+    removeEmptyContent: z.boolean(),
+    entitizeProperties: z.boolean(),
+    prettyPrint: z.boolean(),
+    stripWhitespaces: z.boolean(),
+    dumpFile: z.string().optional(),
+    maxSizeBytes: z.number().int().nonnegative().optional(),
+    wssPasswordType: z.enum(['text', 'digest']).optional(),
+    wssTimeToLive: z.number().int().nonnegative().optional(),
+    sslKeystoreRef: z.string().optional(),
+});
+const attachmentSchema = z.looseObject({
+    id: nonEmpty,
+    name: z.string(),
+    contentType: z.string(),
+    size: z.number().int().nonnegative(),
+    part: z.string().optional(),
+    type: z.enum(['XOP', 'MIME', 'SWAREF', 'CONTENT', 'UNKNOWN']),
+    contentId: z.string(),
+    cached: z.boolean(),
+    source: attachmentSourceSchema,
+});
+/** `interfaces/<slug>/operations/<slug>/<name>.request.yaml` (the envelope lives in the sibling `.xml`). */
+export const requestFileSchema = z.looseObject({
+    kind: z.literal('soap'),
+    id: nonEmpty,
+    name: z.string(),
+    order: z.number().int(),
+    description: z.string().optional(),
+    endpointId: z.string().optional(),
+    endpointUrl: z.string().optional(),
+    soapVersion: z.enum(['1.1', '1.2']),
+    soapAction: z.string().optional(),
+    headers: z.array(z.looseObject({ name: z.string(), value: z.string() })),
+    attachments: z.array(attachmentSchema),
+    auth: soapOwnerAuthSchema.optional(),
+    wsa: wsaSchema.optional(),
+    wssOutgoingRef: z.string().optional(),
+    wssIncomingRef: z.string().optional(),
+    properties: requestPropertiesSchema,
+    assertions: assertionsSchema.default([]),
+    orphaned: z.boolean().optional(),
+    scripts: scriptsSchema.optional(),
+});

package/dist/soap/form-request.d.ts

@@ -6,6 +6,7 @@
  * envelope, its namespace declarations, any headers — is never touched.
  */
 import type { BuildFormOptions, FormNode, TextRange } from '../xsd/form-model.js';
+import type { ScannedElement } from '../xsd/xml-scan.js';
 import type { OperationRef, RequestBuildInput } from './request-builder.js';
 /** What {@link buildRequestForm} returns. */
 export interface RequestForm {
@@ -16,6 +17,18 @@ export interface RequestForm {
     /** Everything that could not be modelled; the view falls back to "Edit in XML" for those parts. */
     readonly problems: readonly string[];
 }
+/** Depth-first search for the `soapenv:Body` element, whichever SOAP version declares it. */
+export declare function findBody(elements: readonly ScannedElement[]): ScannedElement | undefined;
+/**
+ * Every `xmlns:prefix="uri"` declared anywhere in the envelope. A body fragment
+ * sliced out of it carries none of its own (the request builder hoists them all
+ * onto `soapenv:Envelope`), so the form model needs both directions: `byUri` to
+ * name a new element, `byPrefix` to resolve the ones already written.
+ */
+export declare function namespacesInScope(text: string): {
+    byUri: Record<string, string>;
+    byPrefix: Record<string, string>;
+};
 /**
  * Models the Body of `envelopeXml` for one binding operation.
  *

package/dist/soap/form-request.js

@@ -12,7 +12,7 @@ import { buildForm, buildFormForType } from '../xsd/form-model.js';
 import { scanXml } from '../xsd/xml-scan.js';
 const ENVELOPE_NAMESPACES = new Set([NS.SOAP11_ENV, NS.SOAP12_ENV]);
 /** Depth-first search for the `soapenv:Body` element, whichever SOAP version declares it. */
-function findBody(elements) {
+export function findBody(elements) {
     for (const element of elements) {
         if (element.localName === 'Body' && ENVELOPE_NAMESPACES.has(element.namespaceUri)) {
             return element;
@@ -30,7 +30,7 @@ function findBody(elements) {
  * onto `soapenv:Envelope`), so the form model needs both directions: `byUri` to
  * name a new element, `byPrefix` to resolve the ones already written.
  */
-function namespacesInScope(text) {
+export function namespacesInScope(text) {
     const byUri = {};
     const byPrefix = {};
     const re = /xmlns:([A-Za-z_][\w.-]*)\s*=\s*"([^"]*)"/g;

package/dist/soap/generate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convenience wrappers around `buildSampleRequest`/`buildEmptyRequest` that
+ * take a {@link WsdlImportResult} directly, so callers don't have to thread
+ * `definition`/`schemaSet` through by hand.
+ */
+import type { GeneratedRequest, OperationRef, RequestBuildOptions } from './request-builder.js';
+import type { GenerateOptions } from '../xsd/sample-generator.js';
+import type { WsdlImportResult } from './types.js';
+/** Builds the sample SOAP request for one operation of an imported definition. */
+export declare function generateSoapRequest(result: WsdlImportResult, op: OperationRef, genOptions?: Partial<GenerateOptions>, options?: RequestBuildOptions): GeneratedRequest;
+/** Builds an empty SOAP request (empty `Header`/`Body`) for one operation of an imported definition. */
+export declare function generateEmptySoapRequest(result: WsdlImportResult, op: OperationRef, options?: RequestBuildOptions): GeneratedRequest;

package/dist/{generate.js → soap/generate.js}

@@ -1,14 +1,14 @@
 /**
  * Convenience wrappers around `buildSampleRequest`/`buildEmptyRequest` that
- * take an {@link ImportResult} directly, so callers don't have to thread
+ * take a {@link WsdlImportResult} directly, so callers don't have to thread
  * `definition`/`schemaSet` through by hand.
  */
-import { buildEmptyRequest, buildSampleRequest } from './soap/request-builder.js';
+import { buildEmptyRequest, buildSampleRequest } from './request-builder.js';
 /** Builds the sample SOAP request for one operation of an imported definition. */
-export function generateRequest(result, op, genOptions, options) {
+export function generateSoapRequest(result, op, genOptions, options) {
     return buildSampleRequest({ definition: result.definition, schemaSet: result.schemaSet }, op, genOptions, options);
 }
 /** Builds an empty SOAP request (empty `Header`/`Body`) for one operation of an imported definition. */
-export function generateEmptyRequest(result, op, options) {
+export function generateEmptySoapRequest(result, op, options) {
     return buildEmptyRequest({ definition: result.definition, schemaSet: result.schemaSet }, op, options);
 }

package/dist/{import.d.ts → soap/import.d.ts}

@@ -3,18 +3,18 @@
  * merged WSDL, compile the schema set, and summarize the operations a user
  * can pick from.
  */
-import type { ImportOptions, ImportResult, ImportSource } from './types.js';
+import type { WsdlImportOptions, WsdlImportResult, WsdlImportSource } from './types.js';
 /**
  * Imports a WSDL definition from a URL, file path, or inline text: resolves
  * its full import graph, parses the merged WSDL, compiles the schema set,
  * and summarizes its operations for a picker UI.
  *
  * Never throws for a modelling problem in the definition itself — those are
- * reported in {@link ImportResult.problems}. It does throw for a malformed
- * `ImportSource` (an invalid URL) or when the root document cannot be
+ * reported in {@link WsdlImportResult.problems}. It does throw for a malformed
+ * `WsdlImportSource` (an invalid URL) or when the root document cannot be
  * fetched at all.
  *
  * @param source where the WSDL comes from
  * @param options fetch override, Basic auth for fetching, abort signal, progress callback, definition cache
  */
-export declare function importDefinition(source: ImportSource, options?: ImportOptions): Promise<ImportResult>;
+export declare function importWsdl(source: WsdlImportSource, options?: WsdlImportOptions): Promise<WsdlImportResult>;

package/dist/{import.js → soap/import.js}

@@ -4,15 +4,15 @@
  * can pick from.
  */
 import { pathToFileURL } from 'node:url';
-import { HttpError, ProjectError, WsdlParseError } from './errors.js';
-import { summarizeOperations } from './operations.js';
-import { summarizeWsa } from './wsa/policy-detect.js';
-import { readDefinitionCache, writeDefinitionCache } from './wsdl/cache.js';
-import { createDefaultFetchDocument } from './wsdl/fetch.js';
-import { parseWsdlBundle } from './wsdl/merge.js';
-import { resolveDefinition } from './wsdl/resolver.js';
-import { buildSchemaSet } from './xsd/schema-set.js';
-/** Turns an {@link ImportSource} into the `DefinitionSource` the resolver understands. */
+import { HttpError, ProjectError, WsdlParseError } from '../errors.js';
+import { summarizeSoapOperations } from './operations.js';
+import { summarizeWsa } from '../wsa/policy-detect.js';
+import { readDefinitionCache, writeDefinitionCache } from '../wsdl/cache.js';
+import { createDefaultFetchDocument } from '../http/fetch-document.js';
+import { parseWsdlBundle } from '../wsdl/merge.js';
+import { resolveDefinition } from '../wsdl/resolver.js';
+import { buildSchemaSet } from '../xsd/schema-set.js';
+/** Turns a {@link WsdlImportSource} into the `DefinitionSource` the resolver understands. */
 function toDefinitionSource(source) {
     if (source.kind === 'file') {
         return { location: pathToFileURL(source.path).href };
@@ -124,14 +124,14 @@ async function resolveWithCache(definitionSource, fetchDocument, signal, cache,
  * and summarizes its operations for a picker UI.
  *
  * Never throws for a modelling problem in the definition itself — those are
- * reported in {@link ImportResult.problems}. It does throw for a malformed
- * `ImportSource` (an invalid URL) or when the root document cannot be
+ * reported in {@link WsdlImportResult.problems}. It does throw for a malformed
+ * `WsdlImportSource` (an invalid URL) or when the root document cannot be
  * fetched at all.
  *
  * @param source where the WSDL comes from
  * @param options fetch override, Basic auth for fetching, abort signal, progress callback, definition cache
  */
-export async function importDefinition(source, options) {
+export async function importWsdl(source, options) {
     const signal = options?.signal;
     const baseFetch = options?.fetchDocument ?? createDefaultFetchDocument();
     const fetchDocument = options?.auth !== undefined ? withBasicAuth(baseFetch, options.auth) : baseFetch;
@@ -149,7 +149,7 @@ export async function importDefinition(source, options) {
         ...definition.problems.map((p) => ({ source: 'wsdl', ...p })),
         ...schemaSet.problems.map((p) => ({ source: 'schema', ...p })),
     ];
-    const operations = summarizeOperations(definition);
+    const operations = summarizeSoapOperations(definition);
     options?.onProgress?.({ phase: 'done' });
     return {
         definition,

package/dist/soap/json-operation.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A SOAP operation's body as JSON (#33 spec §3.1, §4.1, §5). One document/literal element part is
+ * that element's content; any other shape is one property per part, inside the rpc wrapper element
+ * for rpc. The envelope's transport (version, action) is the one a new request of the operation has.
+ */
+import type { MessageDirection } from '../validate/index.js';
+import type { JsonFromXmlResult, JsonSchemaObject } from '../xsd/json-bridge.js';
+import type { SoapEnvelopeVersion } from './envelope.js';
+import type { OperationRef, RequestBuildInput } from './request-builder.js';
+export interface OperationSchema {
+    readonly schema: JsonSchemaObject;
+    readonly notes: readonly string[];
+}
+export interface JsonEnvelope {
+    readonly envelopeXml: string;
+    readonly soapVersion: SoapEnvelopeVersion;
+    readonly soapAction?: string;
+    readonly notes: readonly string[];
+    /** Why no body could be written; nothing may be sent when any. */
+    readonly problems: readonly string[];
+}
+/** The JSON Schema of an operation's input (or output) body, `$defs` shared across its parts. */
+export declare function operationJsonSchema(input: RequestBuildInput, op: OperationRef, direction?: MessageDirection): OperationSchema;
+/**
+ * The request envelope for `args`: the body written through the form model, in an envelope with no
+ * indentation (`createEnvelope` indents every line of the body, which would change a multi-line value).
+ */
+export declare function envelopeFromJson(input: RequestBuildInput, op: OperationRef, args: Readonly<Record<string, unknown>>): JsonEnvelope;
+/** An envelope's body read back as the JSON {@link envelopeFromJson} takes. */
+export declare function jsonFromEnvelope(input: RequestBuildInput, op: OperationRef, xml: string, direction?: MessageDirection): JsonFromXmlResult;
+/**
+ * A fault's `detail` as JSON, when its first element is the element of a fault message part the
+ * operation declares; undefined otherwise (the caller keeps the XML).
+ */
+export declare function faultDetailJson(input: RequestBuildInput, op: OperationRef, detailXml: string): JsonFromXmlResult | undefined;

package/dist/soap/json-operation.js

@@ -0,0 +1,225 @@
+import { bindingContextFor } from '../validate/index.js';
+import { findBinding, findMessage, findPortType } from '../wsdl/model.js';
+import { qnameToString } from '../wsdl/qname.js';
+import { NS } from '../xml/namespaces.js';
+import { prefixForNamespace } from '../xml/prefixes.js';
+import { createJsonSchemaWriter, freeKey, jsonFromXml, targetType, xmlFromJson } from '../xsd/json-bridge.js';
+import { scanXml } from '../xsd/xml-scan.js';
+import { escapeAttribute } from '../xsd/xml-writer.js';
+import { createEnvelope } from './envelope.js';
+import { findBody, namespacesInScope } from './form-request.js';
+import { buildEmptyRequest } from './request-builder.js';
+const ANY_TYPE = { namespaceUri: NS.XSD, localName: 'anyType' };
+function bodyShape(input, op, direction) {
+    const binding = bindingContextFor(input.definition, op, direction);
+    if (binding === undefined) {
+        return undefined;
+    }
+    const parts = binding.parts.map((part) => ({
+        name: part.name,
+        target: part.element !== undefined
+            ? { element: part.element }
+            : { name: { namespaceUri: '', localName: part.name }, type: part.type ?? ANY_TYPE },
+    }));
+    const [first] = parts;
+    if (binding.style === 'document') {
+        return { single: parts.length === 1 && first !== undefined && 'element' in first.target, parts };
+    }
+    const operation = findBinding(input.definition, op.bindingName)?.operations.find((candidate) => candidate.name === op.operationName);
+    const body = direction === 'request' ? operation?.input?.body : operation?.output?.body;
+    return {
+        single: false,
+        parts,
+        wrapper: {
+            namespaceUri: body?.namespace ?? input.definition.targetNamespace,
+            localName: direction === 'request' ? op.operationName : `${op.operationName}Response`,
+        },
+    };
+}
+/**
+ * Whether a body element's content is a value rather than an object (a simple type, `anyType`, a
+ * SOAP-encoded array): its one argument is then `#text`. Decided by the resolved type, so the schema,
+ * the writer and the reader agree whatever shape the generated schema takes.
+ */
+function textBodied(set, target) {
+    const kind = targetType(set, target)?.kind;
+    return kind !== undefined && kind !== 'complex';
+}
+const DEFS_REF = '#/$defs/';
+/** A root that came out as a `$ref` (a type that refers back to itself), as the definition it names. */
+function inlineRoot(content, defs) {
+    const ref = content['$ref'];
+    if (typeof ref !== 'string' || !ref.startsWith(DEFS_REF) || defs === undefined) {
+        return content;
+    }
+    const def = defs[ref.slice(DEFS_REF.length).replaceAll('~1', '/').replaceAll('~0', '~')];
+    return typeof def === 'object' && def !== null && !Array.isArray(def) ? def : content;
+}
+const OBJECT_OF_NOTHING = { type: 'object', properties: {}, additionalProperties: false };
+/** The JSON Schema of an operation's input (or output) body, `$defs` shared across its parts. */
+export function operationJsonSchema(input, op, direction = 'request') {
+    const shape = bodyShape(input, op, direction);
+    if (shape === undefined) {
+        return {
+            schema: OBJECT_OF_NOTHING,
+            notes: [`${op.operationName}: the binding has no SOAP operation of that name`],
+        };
+    }
+    const writer = createJsonSchemaWriter(input.schemaSet);
+    let schema;
+    const [first] = shape.parts;
+    if (shape.single && first !== undefined) {
+        const content = writer.schemaOf(first.target);
+        schema = textBodied(input.schemaSet, first.target)
+            ? { type: 'object', properties: { '#text': content }, required: ['#text'], additionalProperties: false }
+            : inlineRoot(content, writer.defs());
+    }
+    else {
+        schema = {
+            type: 'object',
+            properties: Object.fromEntries(shape.parts.map((part) => [part.name, writer.schemaOf(part.target)])),
+            ...(shape.parts.length > 0 ? { required: shape.parts.map((part) => part.name) } : {}),
+            additionalProperties: false,
+        };
+    }
+    const defs = writer.defs();
+    return { schema: defs === undefined ? schema : { ...schema, $defs: defs }, notes: writer.notes() };
+}
+/**
+ * The request envelope for `args`: the body written through the form model, in an envelope with no
+ * indentation (`createEnvelope` indents every line of the body, which would change a multi-line value).
+ */
+export function envelopeFromJson(input, op, args) {
+    const empty = buildEmptyRequest(input, op);
+    const notes = empty.problems.map((problem) => problem.message);
+    const transport = {
+        soapVersion: empty.soapVersion,
+        ...(empty.soapAction !== undefined ? { soapAction: empty.soapAction } : {}),
+    };
+    const shape = bodyShape(input, op, 'request');
+    if (shape === undefined) {
+        return {
+            envelopeXml: '',
+            ...transport,
+            notes,
+            problems: [`${op.operationName}: the binding has no SOAP operation of that name`],
+        };
+    }
+    const problems = [];
+    const write = (target, value) => {
+        const written = xmlFromJson(input.schemaSet, target, value);
+        notes.push(...written.notes);
+        problems.push(...written.problems);
+        return written.xml;
+    };
+    const [first] = shape.parts;
+    let bodyXml;
+    if (shape.single && first !== undefined) {
+        bodyXml = write(first.target, textBodied(input.schemaSet, first.target) ? args['#text'] : args);
+    }
+    else {
+        const pieces = shape.parts.map((part) => write(part.target, args[part.name])).filter((piece) => piece !== '');
+        const wrapper = shape.wrapper;
+        if (wrapper === undefined) {
+            bodyXml = pieces.join('\n');
+        }
+        else if (wrapper.namespaceUri === '') {
+            bodyXml = [`<${wrapper.localName}>`, ...pieces, `</${wrapper.localName}>`].join('\n');
+        }
+        else {
+            const prefix = prefixForNamespace(wrapper.namespaceUri, new Set());
+            const name = `${prefix}:${wrapper.localName}`;
+            bodyXml = [`<${name} xmlns:${prefix}="${escapeAttribute(wrapper.namespaceUri)}">`, ...pieces, `</${name}>`].join('\n');
+        }
+    }
+    if (problems.length > 0) {
+        return { envelopeXml: '', ...transport, notes, problems };
+    }
+    return { envelopeXml: createEnvelope(empty.soapVersion, { bodyXml }, { indent: '' }), ...transport, notes, problems };
+}
+function matches(element, name) {
+    return element.localName === name.localName && element.namespaceUri === name.namespaceUri;
+}
+const nameOf = (element) => qnameToString({ namespaceUri: element.namespaceUri, localName: element.localName });
+/** An envelope's body read back as the JSON {@link envelopeFromJson} takes. */
+export function jsonFromEnvelope(input, op, xml, direction = 'response') {
+    const shape = bodyShape(input, op, direction);
+    const body = findBody(scanXml(xml).elements);
+    if (shape === undefined || body === undefined) {
+        return { value: undefined, notes: ['the message has no SOAP Body this operation describes'] };
+    }
+    const inScope = namespacesInScope(xml).byPrefix;
+    const slice = (element) => xml.slice(element.range.start, element.range.end);
+    const read = (target, element) => jsonFromXml(input.schemaSet, target, slice(element), { inScope });
+    const [first] = shape.parts;
+    const [child, ...rest] = body.children;
+    const notes = rest.map((extra) => `the SOAP Body holds ${nameOf(extra)} after the body element; not read`);
+    /** The element the body should start with: the single part's (or a substitute), or the rpc wrapper. */
+    const expected = shape.single && first !== undefined && 'element' in first.target ? first.target.element : shape.wrapper;
+    if (expected === undefined) {
+        return readParts(op, shape.parts, body.children, read, slice);
+    }
+    if (child === undefined) {
+        return { value: undefined, notes: ['the SOAP Body is empty'] };
+    }
+    const named = matches(child, expected) ||
+        (shape.single && input.schemaSet.substitutionsFor(expected).some((decl) => matches(child, decl.name)));
+    if (!named) {
+        return {
+            value: slice(child),
+            notes: [`the SOAP Body holds ${nameOf(child)}, not ${qnameToString(expected)}; kept as its XML`, ...notes],
+        };
+    }
+    if (shape.single && first !== undefined) {
+        const result = read(first.target, child);
+        const value = textBodied(input.schemaSet, first.target) && result.value !== undefined
+            ? { '#text': result.value }
+            : result.value;
+        return { value, notes: [...result.notes, ...notes] };
+    }
+    const parts = readParts(op, shape.parts, child.children, read, slice);
+    return { value: parts.value, notes: [...parts.notes, ...notes] };
+}
+/**
+ * One property per part, each read from the child of its element name (rpc: its part name); a part
+ * with no child is noted, and a child no part names is kept under its local name as its XML (§5).
+ */
+function readParts(op, parts, children, read, slice) {
+    const value = {};
+    const notes = [];
+    const unread = new Set(children);
+    for (const part of parts) {
+        const element = children.find((candidate) => unread.has(candidate) &&
+            ('element' in part.target ? matches(candidate, part.target.element) : candidate.localName === part.name));
+        if (element === undefined) {
+            notes.push(`${part.name}: the message has no element for this part`);
+            continue;
+        }
+        unread.delete(element);
+        const result = read(part.target, element);
+        value[part.name] = result.value;
+        notes.push(...result.notes);
+    }
+    for (const element of unread) {
+        value[freeKey(value, element.localName)] = slice(element);
+        notes.push(`${element.localName}: not a part of ${op.operationName}; kept as its XML`);
+    }
+    return { value, notes };
+}
+/**
+ * A fault's `detail` as JSON, when its first element is the element of a fault message part the
+ * operation declares; undefined otherwise (the caller keeps the XML).
+ */
+export function faultDetailJson(input, op, detailXml) {
+    const binding = findBinding(input.definition, op.bindingName);
+    const operation = binding === undefined
+        ? undefined
+        : findPortType(input.definition, binding.type)?.operations.find((candidate) => candidate.name === op.operationName);
+    const declared = (operation?.faults ?? []).flatMap((fault) => findMessage(input.definition, fault.message)?.parts.flatMap((part) => part.element !== undefined ? [part.element] : []) ?? []);
+    const first = scanXml(detailXml).elements[0];
+    const element = first === undefined ? undefined : declared.find((name) => matches(first, name));
+    if (first === undefined || element === undefined) {
+        return undefined;
+    }
+    return jsonFromXml(input.schemaSet, { element }, detailXml.slice(first.range.start, first.range.end));
+}

package/dist/soap/legacy-project/env-refs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A pre-pass over a parsed legacy project that rewrites `${#Project#name}` references to `${name}`
+ * when an imported environment defines `name` as a property. In the source tool, environment
+ * properties override project properties, so such a reference already changes with the active
+ * environment there; in Wirebench `${#Project#name}` only ever reads the project scope. Rewriting it
+ * to the shorthand `${name}` (which resolves Env -> Project -> Workspace -> Global, see
+ * `project/properties.ts`) makes the imported request behave the same way it did before the import,
+ * silently — this is not a mapping loss, so it is never reported.
+ *
+ * Pure and byte-identical when nothing needs rewriting: a project with no environments (or none
+ * defining any properties) is returned as the same object.
+ */
+import type { LegacyProject } from './model.js';
+/**
+ * Rewrites every `${#Project#<name>}` reference to `${<name>}` throughout `project`, for every
+ * `<name>` that at least one imported environment defines as a property. Returns `project` itself
+ * (same object) when there is nothing to rewrite, e.g. a project with no environments.
+ */
+export declare function rewriteProjectRefsToEnv(project: LegacyProject): LegacyProject;

package/dist/soap/legacy-project/env-refs.js

@@ -0,0 +1,105 @@
+/**
+ * A pre-pass over a parsed legacy project that rewrites `${#Project#name}` references to `${name}`
+ * when an imported environment defines `name` as a property. In the source tool, environment
+ * properties override project properties, so such a reference already changes with the active
+ * environment there; in Wirebench `${#Project#name}` only ever reads the project scope. Rewriting it
+ * to the shorthand `${name}` (which resolves Env -> Project -> Workspace -> Global, see
+ * `project/properties.ts`) makes the imported request behave the same way it did before the import,
+ * silently — this is not a mapping loss, so it is never reported.
+ *
+ * Pure and byte-identical when nothing needs rewriting: a project with no environments (or none
+ * defining any properties) is returned as the same object.
+ */
+const PROJECT_REF = /\$\{#Project#([^${}]+)\}/g;
+/** Rewrites `${#Project#<name>}` to `${<name>}` in `text` for every `<name>` in `names`. Leaves everything else, including unrecognized `${...}` expressions, byte-identical. */
+function rewrite(text, names) {
+    return text.replace(PROJECT_REF, (whole, name) => (names.has(name) ? `\${${name}}` : whole));
+}
+function rewriteOptional(text, names) {
+    return text === undefined ? undefined : rewrite(text, names);
+}
+function rewriteCall(call, names) {
+    const endpoint = rewriteOptional(call.endpoint, names);
+    const envelope = rewriteOptional(call.envelope, names);
+    const username = rewriteOptional(call.credentials.username, names);
+    if (endpoint === call.endpoint && envelope === call.envelope && username === call.credentials.username) {
+        return call;
+    }
+    return {
+        ...call,
+        ...(endpoint !== undefined ? { endpoint } : {}),
+        ...(envelope !== undefined ? { envelope } : {}),
+        credentials: username === call.credentials.username || username === undefined
+            ? call.credentials
+            : { ...call.credentials, username },
+    };
+}
+function rewriteOperation(operation, names) {
+    const calls = operation.calls.map((call) => rewriteCall(call, names));
+    if (calls.every((call, index) => call === operation.calls[index])) {
+        return operation;
+    }
+    return { ...operation, calls };
+}
+function rewriteInterface(iface, names) {
+    const endpoints = iface.endpoints.map((url) => rewrite(url, names));
+    const operations = iface.operations.map((operation) => rewriteOperation(operation, names));
+    const endpointsChanged = endpoints.some((url, index) => url !== iface.endpoints[index]);
+    const operationsChanged = operations.some((operation, index) => operation !== iface.operations[index]);
+    if (!endpointsChanged && !operationsChanged) {
+        return iface;
+    }
+    return { ...iface, ...(endpointsChanged ? { endpoints } : {}), ...(operationsChanged ? { operations } : {}) };
+}
+function rewriteProperty(property, names) {
+    const value = rewrite(property.value, names);
+    return value === property.value ? property : { ...property, value };
+}
+function rewriteEnvironment(env, names) {
+    const properties = env.properties.map((property) => rewriteProperty(property, names));
+    const endpoints = env.endpoints.map((override) => {
+        const url = rewrite(override.url, names);
+        return url === override.url ? override : { ...override, url };
+    });
+    const propertiesChanged = properties.some((property, index) => property !== env.properties[index]);
+    const endpointsChanged = endpoints.some((override, index) => override !== env.endpoints[index]);
+    if (!propertiesChanged && !endpointsChanged) {
+        return env;
+    }
+    return {
+        ...env,
+        ...(propertiesChanged ? { properties } : {}),
+        ...(endpointsChanged ? { endpoints } : {}),
+    };
+}
+/**
+ * Rewrites every `${#Project#<name>}` reference to `${<name>}` throughout `project`, for every
+ * `<name>` that at least one imported environment defines as a property. Returns `project` itself
+ * (same object) when there is nothing to rewrite, e.g. a project with no environments.
+ */
+export function rewriteProjectRefsToEnv(project) {
+    const names = new Set();
+    for (const env of project.environments) {
+        for (const property of env.properties) {
+            names.add(property.name);
+        }
+    }
+    if (names.size === 0) {
+        return project;
+    }
+    const interfaces = project.interfaces.map((iface) => rewriteInterface(iface, names));
+    const environments = project.environments.map((env) => rewriteEnvironment(env, names));
+    const properties = project.properties.map((property) => rewriteProperty(property, names));
+    const interfacesChanged = interfaces.some((iface, index) => iface !== project.interfaces[index]);
+    const environmentsChanged = environments.some((env, index) => env !== project.environments[index]);
+    const propertiesChanged = properties.some((property, index) => property !== project.properties[index]);
+    if (!interfacesChanged && !environmentsChanged && !propertiesChanged) {
+        return project;
+    }
+    return {
+        ...project,
+        ...(interfacesChanged ? { interfaces } : {}),
+        ...(environmentsChanged ? { environments } : {}),
+        ...(propertiesChanged ? { properties } : {}),
+    };
+}