@wirebench/engine 2.1.1

package/dist/soap/envelope.js

@@ -0,0 +1,76 @@
+/**
+ * SOAP envelope assembly: wraps already-rendered header and body fragments in
+ * a `soapenv:Envelope`, following the conventions classic SOAP workbenches
+ * produce (three-space indent, `soapenv` prefix, an always-present `Header`).
+ */
+import { NS } from '../xml/namespaces.js';
+import { escapeAttribute } from '../xsd/xml-writer.js';
+/** The prefix every generated envelope binds its SOAP envelope namespace to. */
+export const SOAP_ENVELOPE_PREFIX = 'soapenv';
+/** The SOAP envelope namespace URI for `version`. */
+export function envelopeNamespace(version) {
+    return version === '1.2' ? NS.SOAP12_ENV : NS.SOAP11_ENV;
+}
+/**
+ * The SOAP version of a parsed document, from its root element's namespace, or
+ * `undefined` when the root is not a SOAP `Envelope`.
+ */
+export function detectEnvelopeVersion(doc) {
+    const root = doc.documentElement;
+    if (root === null || root.localName !== 'Envelope') {
+        return undefined;
+    }
+    if (root.namespaceURI === NS.SOAP11_ENV) {
+        return '1.1';
+    }
+    return root.namespaceURI === NS.SOAP12_ENV ? '1.2' : undefined;
+}
+/** Prepends `pad` to every non-empty line of `text`. */
+function indentBlock(text, pad) {
+    return text
+        .split('\n')
+        .map((line) => (line.length === 0 ? line : `${pad}${line}`))
+        .join('\n');
+}
+/**
+ * Wraps `parts` in a SOAP envelope.
+ *
+ * The `Header` element is always emitted (empty when there are no header
+ * blocks): it gives the user somewhere to paste a security
+ * header without re-typing the element. Every namespace in
+ * {@link EnvelopeParts.namespaces} is declared on the `Envelope` root, so the
+ * fragments inside carry no `xmlns` declarations of their own.
+ *
+ * Deterministic: identical inputs always produce byte-identical output.
+ *
+ * @param version which SOAP envelope namespace to bind
+ * @param parts the header/body fragments and the namespaces they use
+ * @param options `indent` defaults to three spaces
+ */
+export function createEnvelope(version, parts, options) {
+    const indent = options?.indent ?? '   ';
+    const declarations = [
+        `xmlns:${SOAP_ENVELOPE_PREFIX}="${escapeAttribute(envelopeNamespace(version))}"`,
+        ...Object.entries(parts.namespaces ?? {}).map(([prefix, uri]) => `xmlns:${prefix}="${escapeAttribute(uri)}"`),
+    ];
+    const lines = [`<${SOAP_ENVELOPE_PREFIX}:Envelope ${declarations.join(' ')}>`];
+    const header = parts.headerXml?.trim() ?? '';
+    if (header.length === 0) {
+        lines.push(`${indent}<${SOAP_ENVELOPE_PREFIX}:Header/>`);
+    }
+    else {
+        lines.push(`${indent}<${SOAP_ENVELOPE_PREFIX}:Header>`);
+        lines.push(indentBlock(parts.headerXml ?? '', indent.repeat(2)));
+        lines.push(`${indent}</${SOAP_ENVELOPE_PREFIX}:Header>`);
+    }
+    if (parts.bodyXml.trim().length === 0) {
+        lines.push(`${indent}<${SOAP_ENVELOPE_PREFIX}:Body/>`);
+    }
+    else {
+        lines.push(`${indent}<${SOAP_ENVELOPE_PREFIX}:Body>`);
+        lines.push(indentBlock(parts.bodyXml, indent.repeat(2)));
+        lines.push(`${indent}</${SOAP_ENVELOPE_PREFIX}:Body>`);
+    }
+    lines.push(`</${SOAP_ENVELOPE_PREFIX}:Envelope>`);
+    return lines.join('\n');
+}

package/dist/soap/fault.d.ts

@@ -0,0 +1,46 @@
+/**
+ * SOAP fault parsing for both versions.
+ *
+ * SOAP 1.1 (§4.4) and SOAP 1.2 (Part 1 §5.4) describe structurally different
+ * faults; this module normalises them onto one shape so callers never branch
+ * on the version to show a fault to the user.
+ */
+import type { Document, Element } from '@xmldom/xmldom';
+import type { SoapEnvelopeVersion } from './envelope.js';
+/** One localised `Reason/Text` of a SOAP 1.2 fault. */
+export interface FaultReason {
+    /** The `xml:lang` of this text, when the server supplied one. */
+    readonly lang?: string;
+    readonly text: string;
+}
+/** A SOAP fault, normalised across SOAP 1.1 and 1.2. */
+export interface SoapFault {
+    readonly version: SoapEnvelopeVersion;
+    /** 1.1: the `faultcode` text. 1.2: the `Code/Value` text. Both keep their lexical prefix. */
+    readonly code: string;
+    /** 1.2 only: the nested `Subcode/Value` chain, outermost first. Empty for 1.1. */
+    readonly subcodes: readonly string[];
+    /** 1.1: `faultstring`. 1.2: the first `Reason/Text`. */
+    readonly reason: string;
+    /** 1.2 only: every `Reason/Text` with its `xml:lang`. */
+    readonly reasons?: readonly FaultReason[];
+    /** 1.1 only: `faultactor`. */
+    readonly actor?: string;
+    /** 1.2 only: `Role`. */
+    readonly role?: string;
+    /** 1.2 only: `Node`. */
+    readonly node?: string;
+    /** The serialized *children* of `detail`/`Detail`, when it has element children. */
+    readonly detailXml?: string;
+    /** The `Fault` element itself, for callers that need to inspect it further. */
+    readonly element: Element;
+}
+/**
+ * Parses the SOAP fault in a response document, or returns `undefined` when
+ * the document is not a SOAP envelope or its `Body` carries no `Fault`.
+ *
+ * @param doc a parsed SOAP response
+ */
+export declare function parseFault(doc: Document): SoapFault | undefined;
+/** True when the document is a SOAP envelope whose `Body` carries a `Fault`. */
+export declare function isSoapFault(doc: Document): boolean;

package/dist/soap/fault.js

@@ -0,0 +1,129 @@
+/**
+ * SOAP fault parsing for both versions.
+ *
+ * SOAP 1.1 (§4.4) and SOAP 1.2 (Part 1 §5.4) describe structurally different
+ * faults; this module normalises them onto one shape so callers never branch
+ * on the version to show a fault to the user.
+ */
+import { NS } from '../xml/namespaces.js';
+import { serializeXml } from '../xml/serialize.js';
+/** Element children of `parent`, optionally filtered by namespace and local name. */
+function children(parent, namespaceUri, localName) {
+    const result = [];
+    for (let node = parent.firstChild; node !== null; node = node.nextSibling) {
+        if (node.nodeType !== 1) {
+            continue;
+        }
+        const element = node;
+        // SOAP 1.1's fault children are unqualified; `namespaceUri: undefined` means "any".
+        if (namespaceUri !== undefined && element.namespaceURI !== namespaceUri) {
+            continue;
+        }
+        if (localName !== undefined && element.localName !== localName) {
+            continue;
+        }
+        result.push(element);
+    }
+    return result;
+}
+/** The first matching child element, or `undefined`. */
+function child(parent, namespaceUri, localName) {
+    return children(parent, namespaceUri, localName)[0];
+}
+/** The concatenated text content of `element`, trimmed. */
+function textOf(element) {
+    return element?.textContent?.trim() ?? '';
+}
+/** The `soapenv:Body` of a parsed envelope, if the document is one. */
+function bodyOf(doc) {
+    const root = doc.documentElement;
+    if (root === null || root.localName !== 'Envelope') {
+        return undefined;
+    }
+    const version = root.namespaceURI === NS.SOAP11_ENV ? '1.1' : root.namespaceURI === NS.SOAP12_ENV ? '1.2' : undefined;
+    if (version === undefined) {
+        return undefined;
+    }
+    const body = child(root, root.namespaceURI ?? undefined, 'Body');
+    return body === undefined ? undefined : { body, version };
+}
+/** Serializes the element children of a `detail` element, one per line. */
+function detailXmlOf(detail) {
+    if (detail === undefined) {
+        return undefined;
+    }
+    const elements = children(detail);
+    return elements.length === 0 ? undefined : elements.map((element) => serializeXml(element)).join('\n');
+}
+/** Walks the nested `Subcode/Value` chain of a SOAP 1.2 `Code`, outermost first. */
+function subcodesOf(code, envelopeNs) {
+    const result = [];
+    let current = child(code, envelopeNs, 'Subcode');
+    while (current !== undefined) {
+        result.push(textOf(child(current, envelopeNs, 'Value')));
+        current = child(current, envelopeNs, 'Subcode');
+    }
+    return result;
+}
+function parseFault11(fault) {
+    // SOAP 1.1 fault children are unqualified, but servers in the wild
+    // occasionally qualify them; matching on local name alone accepts both.
+    const actor = child(fault, undefined, 'faultactor');
+    const detailXml = detailXmlOf(child(fault, undefined, 'detail'));
+    return {
+        version: '1.1',
+        code: textOf(child(fault, undefined, 'faultcode')),
+        subcodes: [],
+        reason: textOf(child(fault, undefined, 'faultstring')),
+        ...(actor !== undefined ? { actor: textOf(actor) } : {}),
+        ...(detailXml !== undefined ? { detailXml } : {}),
+        element: fault,
+    };
+}
+function parseFault12(fault) {
+    const ns = NS.SOAP12_ENV;
+    const code = child(fault, ns, 'Code');
+    const reasonEl = child(fault, ns, 'Reason');
+    const reasons = reasonEl === undefined
+        ? []
+        : children(reasonEl, ns, 'Text').map((text) => {
+            const lang = text.getAttributeNS(NS.XML, 'lang') ?? text.getAttribute('xml:lang');
+            return { ...(lang !== null && lang !== '' ? { lang } : {}), text: textOf(text) };
+        });
+    const role = child(fault, ns, 'Role');
+    const node = child(fault, ns, 'Node');
+    const detailXml = detailXmlOf(child(fault, ns, 'Detail'));
+    return {
+        version: '1.2',
+        code: code === undefined ? '' : textOf(child(code, ns, 'Value')),
+        subcodes: code === undefined ? [] : subcodesOf(code, ns),
+        reason: reasons[0]?.text ?? '',
+        reasons,
+        ...(role !== undefined ? { role: textOf(role) } : {}),
+        ...(node !== undefined ? { node: textOf(node) } : {}),
+        ...(detailXml !== undefined ? { detailXml } : {}),
+        element: fault,
+    };
+}
+/**
+ * Parses the SOAP fault in a response document, or returns `undefined` when
+ * the document is not a SOAP envelope or its `Body` carries no `Fault`.
+ *
+ * @param doc a parsed SOAP response
+ */
+export function parseFault(doc) {
+    const found = bodyOf(doc);
+    if (found === undefined) {
+        return undefined;
+    }
+    const envelopeNs = found.version === '1.2' ? NS.SOAP12_ENV : NS.SOAP11_ENV;
+    const fault = child(found.body, envelopeNs, 'Fault');
+    if (fault === undefined) {
+        return undefined;
+    }
+    return found.version === '1.2' ? parseFault12(fault) : parseFault11(fault);
+}
+/** True when the document is a SOAP envelope whose `Body` carries a `Fault`. */
+export function isSoapFault(doc) {
+    return parseFault(doc) !== undefined;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Bridges the Form view to a whole SOAP envelope: finds the `soapenv:Body`
+ * child element(s) a request's operation is built from, models them with the
+ * schema-driven form model, and reports the exact text range the renderer must
+ * splice a re-serialised fragment over. Everything outside that range — the
+ * envelope, its namespace declarations, any headers — is never touched.
+ */
+import type { BuildFormOptions, FormNode, TextRange } from '../xsd/form-model.js';
+import type { OperationRef, RequestBuildInput } from './request-builder.js';
+/** What {@link buildRequestForm} returns. */
+export interface RequestForm {
+    /** The form tree for the Body's content. */
+    readonly root: FormNode;
+    /** The range of the Body's element children in the envelope text, for splicing. */
+    readonly bodyRange: TextRange;
+    /** Everything that could not be modelled; the view falls back to "Edit in XML" for those parts. */
+    readonly problems: readonly string[];
+}
+/**
+ * Models the Body of `envelopeXml` for one binding operation.
+ *
+ * Document/literal envelopes with exactly one Body child model that element
+ * directly; several body parts are gathered under a synthetic group root whose
+ * children each serialise on their own. An rpc wrapper is itself the root.
+ *
+ * Never throws: an unresolvable operation or an unparsable envelope yields an
+ * empty form and a problem, so the view can fall back to the XML editor.
+ *
+ * @param input the parsed WSDL definition and its compiled schema set
+ * @param op which operation of which binding the request belongs to
+ * @param envelopeXml the request's current envelope text — the single source of truth
+ * @param options depth cut-off and sample-value knobs passed through to `buildForm`
+ */
+export declare function buildRequestForm(input: RequestBuildInput, op: OperationRef, envelopeXml: string, options?: BuildFormOptions): RequestForm;

package/dist/soap/form-request.js

@@ -0,0 +1,251 @@
+/**
+ * Bridges the Form view to a whole SOAP envelope: finds the `soapenv:Body`
+ * child element(s) a request's operation is built from, models them with the
+ * schema-driven form model, and reports the exact text range the renderer must
+ * splice a re-serialised fragment over. Everything outside that range — the
+ * envelope, its namespace declarations, any headers — is never touched.
+ */
+import { NS } from '../xml/namespaces.js';
+import { findBinding, findMessage, findPortType } from '../wsdl/model.js';
+import { qnameToString } from '../wsdl/qname.js';
+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) {
+    for (const element of elements) {
+        if (element.localName === 'Body' && ENVELOPE_NAMESPACES.has(element.namespaceUri)) {
+            return element;
+        }
+        const nested = findBody(element.children);
+        if (nested !== undefined) {
+            return nested;
+        }
+    }
+    return 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.
+ */
+function namespacesInScope(text) {
+    const byUri = {};
+    const byPrefix = {};
+    const re = /xmlns:([A-Za-z_][\w.-]*)\s*=\s*"([^"]*)"/g;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        const [, prefix, uri] = match;
+        if (prefix === undefined || uri === undefined) {
+            continue;
+        }
+        if (byUri[uri] === undefined) {
+            byUri[uri] = prefix;
+        }
+        if (byPrefix[prefix] === undefined) {
+            byPrefix[prefix] = uri;
+        }
+    }
+    return { byUri, byPrefix };
+}
+/** The abstract operation's input message parts, or an empty list when anything is missing. */
+function inputParts(input, op, problems) {
+    const binding = findBinding(input.definition, op.bindingName);
+    if (binding === undefined) {
+        problems.push(`No binding named ${qnameToString(op.bindingName)}`);
+        return [];
+    }
+    const portType = findPortType(input.definition, binding.type);
+    const operation = portType?.operations.find((candidate) => candidate.name === op.operationName);
+    const messageRef = operation?.input;
+    if (messageRef === undefined) {
+        problems.push(`Operation "${op.operationName}" declares no input message`);
+        return [];
+    }
+    const message = findMessage(input.definition, messageRef.message);
+    if (message === undefined) {
+        problems.push(`Unknown message ${qnameToString(messageRef.message)}`);
+        return [];
+    }
+    return message.parts;
+}
+/** True when the binding operation is rpc-style, so the Body child is a wrapper, not a schema element. */
+function isRpc(input, op) {
+    const binding = findBinding(input.definition, op.bindingName);
+    if (binding === undefined) {
+        return false;
+    }
+    const bindingOperation = binding.operations.find((candidate) => candidate.name === op.operationName);
+    return (bindingOperation?.style ?? binding.style) === 'rpc';
+}
+/** The form for one document/literal body child: its own global element declaration. */
+function documentChildForm(input, child, envelopeXml, options) {
+    const name = { namespaceUri: child.namespaceUri, localName: child.localName };
+    // The fragment is sliced out of the envelope, so its own ranges start at 0;
+    // `offset` puts every reported `valueRange` back into envelope coordinates,
+    // which is what the renderer splices against.
+    return buildForm(input.schemaSet, name, envelopeXml.slice(child.range.start, child.range.end), {
+        ...options,
+        offset: child.range.start,
+    });
+}
+/**
+ * Builds the rpc wrapper's form: the wrapper element itself is not declared in
+ * any schema, so it is modelled as a group whose children come from the message
+ * parts (each part naming a *type*, per WSDL 1.1 rpc rules).
+ */
+/** Wraps a wrapper child no message part claims, keeping its text verbatim — same treatment
+ * `form-model.ts` gives an unclaimed particle child, so a structural edit never drops it. */
+function rawWrapperChild(envelopeXml, source, id) {
+    return {
+        id,
+        kind: 'any',
+        name: { namespaceUri: source.namespaceUri, localName: source.localName },
+        label: source.name,
+        required: false,
+        occurs: { min: 0, max: 'unbounded' },
+        present: true,
+        raw: envelopeXml.slice(source.range.start, source.range.end),
+        children: [],
+    };
+}
+function rpcWrapperForm(input, wrapper, parts, envelopeXml, options, problems) {
+    const children = [];
+    const used = wrapper.children.map(() => false);
+    for (const [index, part] of parts.entries()) {
+        const accessorIndex = wrapper.children.findIndex((candidate, i) => !used[i] && candidate.localName === part.name);
+        const accessor = accessorIndex === -1 ? undefined : wrapper.children[accessorIndex];
+        if (accessorIndex !== -1) {
+            used[accessorIndex] = true;
+        }
+        const accessorXml = accessor === undefined ? undefined : envelopeXml.slice(accessor.range.start, accessor.range.end);
+        const accessorOptions = { ...options, offset: accessor?.range.start ?? 0 };
+        const name = { namespaceUri: '', localName: part.name };
+        if (part.type !== undefined) {
+            children.push(reroot(buildFormForType(input.schemaSet, name, part.type, accessorXml, accessorOptions), `r/${index}`));
+            continue;
+        }
+        if (part.element !== undefined) {
+            children.push(reroot(buildForm(input.schemaSet, part.element, accessorXml, accessorOptions), `r/${index}`));
+            continue;
+        }
+        problems.push(`Part "${part.name}" declares neither an element nor a type`);
+    }
+    // Elements standing in the wrapper that no message part claims must survive a structural
+    // edit verbatim — the same "nothing in the source is dropped" invariant `form-model.ts`
+    // upholds for particle children.
+    for (const [index, leftover] of wrapper.children.entries()) {
+        if (!used[index]) {
+            children.push(rawWrapperChild(envelopeXml, leftover, `r/~${index}`));
+        }
+    }
+    return {
+        id: 'r',
+        kind: 'group',
+        name: { namespaceUri: wrapper.namespaceUri, localName: wrapper.localName },
+        label: wrapper.name,
+        required: true,
+        occurs: { min: 1, max: 1 },
+        present: true,
+        extraAttributes: wrapper.attributes.map((attribute) => ({ name: attribute.name, value: attribute.value })),
+        children,
+    };
+}
+/** Rewrites a subtree's ids so several independently built forms can share one root. */
+function reroot(node, id) {
+    return {
+        ...node,
+        id,
+        children: node.children.map((child, i) => reroot(child, `${id}/${i}`)),
+        ...(node.repeat !== undefined
+            ? {
+                repeat: {
+                    ...node.repeat,
+                    instances: node.repeat.instances.map((instance, i) => reroot(instance, `${id}#${i}`)),
+                    template: reroot(node.repeat.template, `${id}#t`),
+                },
+            }
+            : {}),
+    };
+}
+/** An empty form for an envelope whose Body could not be modelled at all. */
+function emptyForm(label) {
+    return {
+        id: 'r',
+        kind: 'any',
+        name: { namespaceUri: '', localName: label },
+        label,
+        required: false,
+        occurs: { min: 0, max: 1 },
+        present: false,
+        children: [],
+    };
+}
+/**
+ * Models the Body of `envelopeXml` for one binding operation.
+ *
+ * Document/literal envelopes with exactly one Body child model that element
+ * directly; several body parts are gathered under a synthetic group root whose
+ * children each serialise on their own. An rpc wrapper is itself the root.
+ *
+ * Never throws: an unresolvable operation or an unparsable envelope yields an
+ * empty form and a problem, so the view can fall back to the XML editor.
+ *
+ * @param input the parsed WSDL definition and its compiled schema set
+ * @param op which operation of which binding the request belongs to
+ * @param envelopeXml the request's current envelope text — the single source of truth
+ * @param options depth cut-off and sample-value knobs passed through to `buildForm`
+ */
+export function buildRequestForm(input, op, envelopeXml, options) {
+    const problems = [];
+    const scanned = scanXml(envelopeXml);
+    problems.push(...scanned.problems);
+    const body = findBody(scanned.elements);
+    if (body === undefined) {
+        problems.push('This envelope has no soapenv:Body element');
+        return { root: emptyForm('Body'), bodyRange: { start: 0, end: 0 }, problems };
+    }
+    const children = body.children;
+    const bodyRange = children.length === 0
+        ? { start: body.range.end, end: body.range.end }
+        : {
+            start: children[0].range.start,
+            end: children[children.length - 1].range.end,
+        };
+    const scope = namespacesInScope(envelopeXml);
+    const buildOptions = { ...options, prefixes: scope.byUri, inScope: scope.byPrefix };
+    if (children.length === 0) {
+        problems.push('This envelope has an empty Body');
+        return { root: emptyForm('Body'), bodyRange, problems };
+    }
+    if (isRpc(input, op)) {
+        const wrapper = children[0];
+        const parts = inputParts(input, op, problems);
+        return { root: rpcWrapperForm(input, wrapper, parts, envelopeXml, buildOptions, problems), bodyRange, problems };
+    }
+    if (children.length === 1) {
+        return {
+            root: documentChildForm(input, children[0], envelopeXml, buildOptions),
+            bodyRange,
+            problems,
+        };
+    }
+    // Several body parts: a synthetic root that owns them, so one `applyForm`
+    // re-renders the whole Body content in one splice.
+    return {
+        root: {
+            id: 'r',
+            kind: 'group',
+            name: { namespaceUri: '', localName: 'Body' },
+            // An empty label makes `applyForm` splice the children out without a tag of its own.
+            label: '',
+            required: true,
+            occurs: { min: 1, max: 1 },
+            present: true,
+            children: children.map((child, index) => reroot(documentChildForm(input, child, envelopeXml, buildOptions), `r/${index}`)),
+        },
+        bodyRange,
+        problems,
+    };
+}

package/dist/soap/legacy-project/definition-fetcher.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A {@link FetchDocument} that answers from a legacy project's cached definition parts, so an
+ * interface resolves exactly as it was when the file was saved, without touching the network.
+ */
+import type { FetchDocument } from '../../wsdl/resolver.js';
+import type { LegacyDefinitionCache } from './model.js';
+/** Options for {@link fetchDocumentFromCache}. */
+export interface CacheFetchOptions {
+    /** Asked for any location the cache does not hold. Without one, such a location is an error. */
+    readonly fallback?: FetchDocument;
+    /** Told each location that had to be fetched through {@link fallback}. */
+    readonly onFallback?: (location: string) => void;
+}
+/**
+ * Serves every location held in `cache` from memory, and anything else through `options.fallback`.
+ *
+ * @throws WsdlParseError `legacy-cache-miss` for a location the cache lacks when there is no fallback.
+ */
+export declare function fetchDocumentFromCache(cache: LegacyDefinitionCache | undefined, options?: CacheFetchOptions): FetchDocument;
+/** The location to resolve an interface from: the cache's root part, else the definition URL. */
+export declare function definitionRootOf(cache: LegacyDefinitionCache | undefined, definitionUrl: string | undefined): string | undefined;

package/dist/soap/legacy-project/definition-fetcher.js

@@ -0,0 +1,43 @@
+/**
+ * A {@link FetchDocument} that answers from a legacy project's cached definition parts, so an
+ * interface resolves exactly as it was when the file was saved, without touching the network.
+ */
+import { WsdlParseError } from '../../errors.js';
+/** `location` in a canonical form, so `HTTP://Host/a/../b` and `http://host/b` find the same part. */
+function canonical(location) {
+    try {
+        return new URL(location).href;
+    }
+    catch {
+        return location;
+    }
+}
+/**
+ * Serves every location held in `cache` from memory, and anything else through `options.fallback`.
+ *
+ * @throws WsdlParseError `legacy-cache-miss` for a location the cache lacks when there is no fallback.
+ */
+export function fetchDocumentFromCache(cache, options = {}) {
+    const parts = new Map();
+    for (const part of cache?.parts ?? []) {
+        parts.set(canonical(part.url), part.content);
+    }
+    const encoder = new TextEncoder();
+    return async (location, signal) => {
+        const text = parts.get(canonical(location));
+        if (text !== undefined) {
+            return { location, bytes: encoder.encode(text), text };
+        }
+        if (options.fallback === undefined) {
+            throw new WsdlParseError('legacy-cache-miss', `The project file does not hold a copy of ${location}`, {
+                details: { location },
+            });
+        }
+        options.onFallback?.(location);
+        return options.fallback(location, signal);
+    };
+}
+/** The location to resolve an interface from: the cache's root part, else the definition URL. */
+export function definitionRootOf(cache, definitionUrl) {
+    return cache?.rootPart ?? definitionUrl ?? cache?.parts[0]?.url;
+}

package/dist/soap/legacy-project/format.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The legacy single-XML SOAP project format's own identifiers.
+ *
+ * This file and `fixtures/legacy-soap-project/` are the only tracked paths exempt from
+ * `pnpm check:banned-terms`: the namespace URI and root element name below have to be written out
+ * verbatim to recognise the format, and they contain names the check otherwise forbids. Keep
+ * everything else — comments included — out of this file, and never let these strings reach UI text.
+ */
+/** The namespace every element of the format lives in. */
+export declare const LEGACY_PROJECT_NAMESPACE = "http://eviware.com/soapui/config";
+/** The local name of the document element. */
+export declare const LEGACY_PROJECT_ROOT = "soapui-project";
+/**
+ * A cheap check on the first few kilobytes of `text`, for import auto-detection: the root element's
+ * local name has to appear, and the format's namespace has to be declared in an `xmlns` attribute.
+ * `parseLegacyProject` is the real test.
+ */
+export declare function looksLikeLegacyProject(text: string): boolean;

package/dist/soap/legacy-project/format.js

@@ -0,0 +1,24 @@
+/**
+ * The legacy single-XML SOAP project format's own identifiers.
+ *
+ * This file and `fixtures/legacy-soap-project/` are the only tracked paths exempt from
+ * `pnpm check:banned-terms`: the namespace URI and root element name below have to be written out
+ * verbatim to recognise the format, and they contain names the check otherwise forbids. Keep
+ * everything else — comments included — out of this file, and never let these strings reach UI text.
+ */
+/** The namespace every element of the format lives in. */
+export const LEGACY_PROJECT_NAMESPACE = 'http://eviware.com/soapui/config';
+/** The local name of the document element. */
+export const LEGACY_PROJECT_ROOT = 'soapui-project';
+const ESCAPED_NAMESPACE = LEGACY_PROJECT_NAMESPACE.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+const NAMESPACE_DECLARATION = new RegExp(`\\sxmlns(?::[\\w.-]+)?\\s*=\\s*(["'])${ESCAPED_NAMESPACE}\\1`);
+const ROOT_ELEMENT = new RegExp(`<(?:[\\w.-]+:)?${LEGACY_PROJECT_ROOT}[\\s>]`);
+/**
+ * A cheap check on the first few kilobytes of `text`, for import auto-detection: the root element's
+ * local name has to appear, and the format's namespace has to be declared in an `xmlns` attribute.
+ * `parseLegacyProject` is the real test.
+ */
+export function looksLikeLegacyProject(text) {
+    const head = text.slice(0, 4096);
+    return ROOT_ELEMENT.test(head) && NAMESPACE_DECLARATION.test(head);
+}

package/dist/soap/legacy-project/import.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Reading a legacy single-XML SOAP project from a file or text. Mapping it onto a Wirebench project
+ * is `map.ts`'s job, once each interface's definition has been resolved.
+ */
+import type { LegacyProject } from './model.js';
+/** Where a legacy project comes from: a file on disk or text already held in memory. */
+export type LegacyProjectSource = {
+    readonly kind: 'file';
+    readonly path: string;
+} | {
+    readonly kind: 'text';
+    readonly text: string;
+};
+/** Largest project accepted, in bytes (file) or UTF-16 code units (text). */
+export declare const MAX_LEGACY_PROJECT_BYTES: number;
+/**
+ * Reads and parses a legacy SOAP project.
+ *
+ * @throws LegacyProjectError when the file cannot be read, is too large, or is not a readable project.
+ */
+export declare function readLegacySoapProject(source: LegacyProjectSource): Promise<LegacyProject>;