@wirebench/engine 2.2.1 → 3.1.0-rc.1

package/dist/soap/send-input.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Turns a saved request plus the settings around it into the {@link SoapSendInput} the
+ * transport actually receives.
+ *
+ * This is the single place the three layers of configuration meet, and the precedence between
+ * them is fixed here rather than in the desktop app: the request's own property wins, then the
+ * project's setting, then the user's preference (which is also the engine default). A property
+ * left unset in the request is therefore never "off" — it is "inherit".
+ */
+import type { Preferences } from '../project/preferences.js';
+import type { Attachment, HeaderEntry, ProjectSettings, RequestProperties } from '../project/model.js';
+import type { AttachmentResolver } from './mime/types.js';
+import type { SoapSendInput } from './types.js';
+/** The parts of a request {@link toSoapSendInput} reads. */
+export interface SoapSendRequestInput {
+    readonly properties: RequestProperties;
+    readonly soapVersion: '1.1' | '1.2';
+    readonly soapAction?: string;
+    readonly headers: readonly HeaderEntry[];
+    readonly envelopeXml: string;
+}
+/**
+ * How the send is to read attachment and inline-file bytes. The engine never opens a file
+ * on its own, so without this the request's attachments (and its inline-file property) are
+ * left inert; the desktop main process supplies `createFileAttachmentResolver`.
+ */
+export interface AttachmentResolvers {
+    readonly resolver: AttachmentResolver;
+    /** Reads one file for "Enable Inline Files". */
+    readonly resolveFile?: (path: string) => Promise<Uint8Array>;
+    /** The project's resource root, for relative inline-file references. */
+    readonly resourceRoot?: string;
+}
+/** Everything {@link toSoapSendInput} needs beyond the request itself. */
+export interface ToSoapSendInputArgs {
+    readonly request: SoapSendRequestInput;
+    /** The already-resolved endpoint URL (environment overrides applied). */
+    readonly endpoint: string;
+    readonly preferences?: Preferences;
+    readonly projectSettings?: Pick<ProjectSettings, 'defaultTimeoutMs'>;
+    /** The request's attachments; only acted on together with {@link attachmentResolvers}. */
+    readonly attachments?: readonly Attachment[];
+    readonly attachmentResolvers?: AttachmentResolvers;
+}
+/**
+ * Builds the send input for one request.
+ *
+ * Timeout precedence is request > project > preference. The TLS floor (`ssl.minVersion`) and
+ * the HTTP/2 offer come from preferences alone. Headers are the request's own, plus a
+ * `User-Agent` from preferences when the request does not set one, plus `Accept-Encoding` when
+ * response compression is enabled and `Connection: close` when connection reuse is disabled.
+ * Request-body gzip is requested via `compressBody`; the transport does the compressing so the
+ * `Content-Length` it computes describes the bytes that are actually sent.
+ *
+ * The MTOM/attachment properties are mapped only when `attachmentResolvers` says how bytes
+ * can be read; without a resolver there is nothing the transport could do with them, and a
+ * half-configured send would silently drop parts.
+ *
+ * @param args the request, its resolved endpoint, and the preferences/project settings around it
+ */
+export declare function toSoapSendInput(args: ToSoapSendInputArgs): SoapSendInput;

package/dist/{send-options.js → soap/send-input.js}

@@ -7,9 +7,9 @@
  * project's setting, then the user's preference (which is also the engine default). A property
  * left unset in the request is therefore never "off" — it is "inherit".
  */
-import { DEFAULT_PREFERENCES } from './project/preferences.js';
-import { soapActionHeaders } from './soap/soap-action.js';
-import { prettyPrint, removeEmptyContent, stripWhitespaces } from './soap/transforms.js';
+import { DEFAULT_PREFERENCES } from '../project/preferences.js';
+import { soapActionHeaders } from './soap-action.js';
+import { prettyPrint, removeEmptyContent, stripWhitespaces } from './transforms.js';
 /** Case-insensitive lookup over a header map. */
 function hasHeader(headers, name) {
     const lower = name.toLowerCase();
@@ -55,7 +55,7 @@ function transformEnvelope(xml, properties, indentWidth) {
  *
  * @param args the request, its resolved endpoint, and the preferences/project settings around it
  */
-export function toSendInput(args) {
+export function toSoapSendInput(args) {
     const preferences = args.preferences ?? DEFAULT_PREFERENCES;
     const { properties } = args.request;
     const headers = {};
@@ -72,7 +72,7 @@ export function toSendInput(args) {
         headers['Connection'] = 'close';
     }
     // A non-default `encoding` property changes what bytes actually go on the wire (see
-    // `encodeBody` in `send.ts`), so the `Content-Type` charset must say the same thing — a
+    // `encodeBody` in `http/charset.ts`), so the `Content-Type` charset must say the same thing — a
     // request sent as ISO-8859-1 but declared UTF-8 would decode wrong at the far end. This is
     // skipped for the default encoding so a request with no opinion keeps getting the transport's
     // own `UTF-8` charset, computed downstream exactly as it always has been.
@@ -122,107 +122,3 @@ export function toSendInput(args) {
         ...(attachmentOptions !== undefined ? { attachments: args.attachments ?? [], attachmentOptions } : {}),
     };
 }
-/** The first of `values` that is not `undefined`, which is what "inherit" means. */
-function inherited(...values) {
-    return values.find((value) => value !== undefined);
-}
-/**
- * Builds the send input for one REST request.
- *
- * Precedence is request → API → project → preference, the same ladder a SOAP request's properties
- * climb, and for the same reason: a setting the request leaves unset means *inherit*, never *off*.
- * The headers the host adds on the request's behalf — `User-Agent`, `Accept-Encoding`, `Connection`,
- * a default `Accept` — are passed separately from the request's own, so `rest/send.ts` can let the
- * user's typed header win without having to guess which came from where.
- */
-export function toRestSendInput(args) {
-    const preferences = args.preferences ?? DEFAULT_PREFERENCES;
-    const request = args.request;
-    const api = args.apiSettings ?? {};
-    const defaultHeaders = {};
-    if (preferences.http.userAgent.length > 0) {
-        defaultHeaders['User-Agent'] = preferences.http.userAgent;
-    }
-    if (preferences.http.responseCompression) {
-        defaultHeaders['Accept-Encoding'] = 'gzip, deflate, br';
-    }
-    if (preferences.http.closeConnections) {
-        defaultHeaders.Connection = 'close';
-    }
-    if (preferences.rest.defaultAccept.length > 0) {
-        defaultHeaders.Accept = preferences.rest.defaultAccept;
-    }
-    const timeoutMs = inherited(request.settings.timeoutMs, api.timeoutMs, args.projectSettings?.defaultTimeoutMs) ??
-        preferences.http.socketTimeoutMs;
-    const followRedirects = inherited(request.settings.followRedirects, api.followRedirects) ?? preferences.rest.followRedirects;
-    const maxRedirects = inherited(request.settings.maxRedirects, api.maxRedirects) ?? preferences.rest.maxRedirects;
-    const keepBodyOnRedirect = inherited(request.settings.keepBodyOnRedirect, api.keepBodyOnRedirect);
-    const encodeUrl = inherited(request.settings.encodeUrl, api.encodeUrl);
-    const maxSizeBytes = inherited(request.settings.maxSizeBytes, api.maxSizeBytes);
-    const bindAddress = inherited(request.settings.bindAddress, api.bindAddress);
-    return {
-        baseUrl: args.baseUrl,
-        request: {
-            method: request.method,
-            url: request.url,
-            pathParams: request.pathParams,
-            query: request.query,
-            headers: request.headers,
-            body: request.body,
-        },
-        settings: {
-            timeoutMs,
-            followRedirects,
-            maxRedirects,
-            ...(keepBodyOnRedirect !== undefined ? { keepBodyOnRedirect } : {}),
-            ...(encodeUrl !== undefined ? { encodeUrl } : {}),
-            ...(maxSizeBytes !== undefined ? { maxSizeBytes } : {}),
-            ...(bindAddress !== undefined && bindAddress.length > 0 ? { localAddress: bindAddress } : {}),
-            ...(preferences.http.allowH2 ? { allowH2: true } : {}),
-        },
-        defaultHeaders,
-        ...(args.auth !== undefined ? { auth: args.auth } : {}),
-        ...(args.cookies !== undefined ? { cookies: args.cookies } : {}),
-        // As for SOAP: the TLS floor is the user's one-off choice, and everything else in `tls` is
-        // resolved by the host, which reads files and secrets, and merged onto this.
-        tls: { minVersion: preferences.ssl.minVersion, ...args.tls },
-        ...(args.proxy !== undefined ? { proxy: args.proxy } : {}),
-        ...(args.resolveFile !== undefined ? { resolveFile: args.resolveFile } : {}),
-        ...(args.signal !== undefined ? { signal: args.signal } : {}),
-    };
-}
-/**
- * Builds the transport input for one gRPC call, everything but the encoded messages.
- *
- * The same request → API → project → preference ladder as a REST request, and the same TLS rule:
- * the floor comes from preferences, and the host merges trust anchors, the client identity and the
- * per-request trust decision on top. Metadata rows are the API's first and then the request's, so
- * a repeated key resolves to the request's value on the wire.
- */
-export function toGrpcSendInput(args) {
-    const preferences = args.preferences ?? DEFAULT_PREFERENCES;
-    const request = args.request;
-    const api = args.apiSettings ?? {};
-    const defaultMetadata = {};
-    if (preferences.http.userAgent.length > 0) {
-        defaultMetadata['user-agent'] = preferences.http.userAgent;
-    }
-    const timeoutMs = inherited(request.settings.timeoutMs, api.timeoutMs, args.projectSettings?.defaultTimeoutMs) ??
-        preferences.http.socketTimeoutMs;
-    const maxSizeBytes = inherited(request.settings.maxSizeBytes, api.maxSizeBytes);
-    const bindAddress = inherited(request.settings.bindAddress, api.bindAddress);
-    return {
-        target: args.target,
-        tls: args.tls,
-        service: request.service,
-        method: request.method,
-        metadata: [...(args.apiMetadata ?? []), ...request.metadata],
-        defaultMetadata,
-        timeoutMs,
-        ...(maxSizeBytes !== undefined ? { maxSizeBytes } : {}),
-        ...(bindAddress !== undefined && bindAddress.length > 0 ? { localAddress: bindAddress } : {}),
-        ...(args.auth !== undefined ? { auth: args.auth } : {}),
-        tlsOptions: { minVersion: preferences.ssl.minVersion, ...args.tlsOptions },
-        ...(args.signal !== undefined ? { signal: args.signal } : {}),
-    };
-}

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

@@ -3,7 +3,7 @@
  * response: SOAP version, fault, or "not actually SOAP" detection.
  */
 import type { Dispatcher } from 'undici';
-import type { PropertyScopes } from './project/properties.js';
+import type { PropertyScopes } from '../project/properties.js';
 import type { SoapExchange, SoapSendInput } from './types.js';
 /**
  * Sends `input.envelopeXml` to `input.endpoint` over HTTP, computing the

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

@@ -4,17 +4,18 @@
  */
 import { randomUUID } from 'node:crypto';
 import { gzipSync } from 'node:zlib';
-import { WirebenchError } from './errors.js';
-import { expandSendInput } from './project/properties.js';
-import { sendWithAuth } from './http/auth/apply.js';
-import { headerValue, mergeHeaders } from './http/headers.js';
-import { charsetOf } from './soap/charset.js';
-import { packageRequestBody, readResponseBody, substituteInlineFiles, } from './soap/mime/send-pipeline.js';
-import { parseSoapResponse } from './soap/response-parser.js';
-import { soapActionHeaders } from './soap/soap-action.js';
-import { applyWsaHeaders, effectiveAction } from './wsa/headers.js';
-import { applyOutgoingWss } from './wss/apply.js';
-import { processIncomingWss } from './wss/incoming/index.js';
+import { WirebenchError } from '../errors.js';
+import { expandSendInput } from './expand.js';
+import { sendWithAuth } from '../http/auth/apply.js';
+import { applySoapAuth } from './auth.js';
+import { headerValue, mergeHeaders } from '../http/headers.js';
+import { charsetOf } from '../http/charset.js';
+import { packageRequestBody, readResponseBody, substituteInlineFiles } from './mime/send-pipeline.js';
+import { parseSoapResponse } from './response-parser.js';
+import { soapActionHeaders } from './soap-action.js';
+import { applyWsaHeaders, effectiveAction } from '../wsa/headers.js';
+import { applyOutgoingWss } from '../wss/apply.js';
+import { processIncomingWss } from '../wss/incoming/index.js';
 /**
  * Sends `input.envelopeXml` to `input.endpoint` over HTTP, computing the
  * `Content-Type`/`SOAPAction` headers for `input.soapVersion` and merging in
@@ -64,6 +65,12 @@ export async function sendSoapRequest(input, options) {
         effectiveInput = expanded.input;
         unresolved = expanded.unresolved;
     }
+    // Token credentials become headers or a query parameter now, after expansion so a `${token}`
+    // has resolved. The keyed endpoint is used only on the wire: WS-Addressing's `wsa:To` below
+    // keeps the configured endpoint, so an API key never lands inside the envelope.
+    const authApplied = applySoapAuth(effectiveInput.endpoint, effectiveInput.headers, effectiveInput.auth);
+    const wireEndpoint = authApplied.endpoint;
+    effectiveInput = withTransportAuth({ ...effectiveInput, headers: authApplied.headers }, authApplied.transportAuth);
     const problems = [];
     // Inline `file:` references are substituted first, with property expansion: both are envelope
     // *text* preparation, and the envelope every later stage sees must be the one that goes on
@@ -137,7 +144,7 @@ export async function sendSoapRequest(input, options) {
     }
     const timeoutMs = effectiveInput.timeoutMs ?? 60_000;
     const request = {
-        url: effectiveInput.endpoint,
+        url: wireEndpoint,
         method: 'POST',
         headers,
         body,
@@ -208,3 +215,12 @@ export async function sendSoapRequest(input, options) {
             : {}),
     };
 }
+/** The input with `auth` replaced by only what the transport handles (Basic/NTLM), or removed. */
+function withTransportAuth(input, transportAuth) {
+    if (transportAuth !== undefined) {
+        return { ...input, auth: transportAuth };
+    }
+    const copy = { ...input };
+    delete copy.auth;
+    return copy;
+}

package/dist/soap/storage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * How SOAP interfaces are stored in a project folder (spec §3.2): `interfaces/<slug>/interface.yaml`,
+ * and under `operations/<operation slug>/` one `<slug>.request.yaml` with its envelope in the sibling
+ * `<slug>.xml` and its scripts beside it.
+ */
+import type { Interface } from '../project/model.js';
+import type { ProtocolStorage } from '../protocol/module.js';
+/** SOAP's storage facet. */
+export declare const soapStorage: ProtocolStorage<Interface>;

package/dist/soap/storage.js

@@ -0,0 +1,237 @@
+/**
+ * How SOAP interfaces are stored in a project folder (spec §3.2): `interfaces/<slug>/interface.yaml`,
+ * and under `operations/<operation slug>/` one `<slug>.request.yaml` with its envelope in the sibling
+ * `<slug>.xml` and its scripts beside it.
+ */
+import { toCallbackAssertion } from '../assert/schema.js';
+import { readFileIfExists, readdirIfExists } from '../project/fs.js';
+import { abs, authConfig, byOrder, exact, loadScripts, optional, readYaml } from '../project/load-helpers.js';
+import { assertPathSegment, INTERFACES_DIR, OPERATIONS_DIR, REQUEST_SUFFIX } from '../project/paths.js';
+import { assertSupportedKind, parseFile } from '../project/schema-parts.js';
+import { authDocument, scriptsDocument, writeScriptFiles } from '../project/serialize-helpers.js';
+import { compact, stringifyYaml } from '../project/yaml.js';
+import { isScriptFileOf } from '../script/model.js';
+import { normalizeWsa } from '../wsa/model.js';
+import { interfaceFileSchema, requestFileSchema } from './files.js';
+/**
+ * Authentication at one of the three SOAP owner sites (interface, endpoint, request), loaded
+ * through {@link authConfig} so OAuth2 defaults (`scopes`, `clientAuth`, `pkce`) are filled
+ * exactly as for REST, then narrowed to {@link SoapOwnerAuth}: the schema (`soapOwnerAuthSchema`)
+ * already refuses `inherit` at these sites, so the narrowing cast only restates what parsing
+ * proved.
+ */
+function soapOwnerAuth(parsed) {
+    return parsed === undefined ? undefined : authConfig(parsed);
+}
+async function loadRequests(fs, root, dir, problems) {
+    const requests = [];
+    const entries = await readdirIfExists(fs, abs(root, dir));
+    const names = new Set(entries.filter((e) => e.isFile).map((e) => e.name));
+    for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!entry.isFile || !entry.name.endsWith(REQUEST_SUFFIX)) {
+            continue;
+        }
+        const slug = entry.name.slice(0, -REQUEST_SUFFIX.length);
+        const relative = `${dir}/${entry.name}`;
+        const document = await readYaml(fs, root, relative);
+        assertSupportedKind(document, relative);
+        const parsed = parseFile(requestFileSchema, document, relative);
+        const xmlRelative = `${dir}/${slug}.xml`;
+        const envelope = await readFileIfExists(fs, abs(root, xmlRelative));
+        if (envelope === undefined) {
+            problems.push({
+                code: 'missing-envelope',
+                message: `Request "${parsed.name}" has no envelope file; loaded with an empty body`,
+                file: xmlRelative,
+            });
+        }
+        names.delete(entry.name);
+        names.delete(`${slug}.xml`);
+        const scripts = await loadScripts(fs, root, dir, slug, parsed.scripts, parsed.name, problems, (name) => names.delete(name));
+        requests.push({
+            kind: 'soap',
+            id: parsed.id,
+            name: parsed.name,
+            slug,
+            order: parsed.order,
+            ...optional('description', parsed.description),
+            ...optional('endpointId', parsed.endpointId),
+            ...optional('endpointUrl', parsed.endpointUrl),
+            soapVersion: parsed.soapVersion,
+            ...optional('soapAction', parsed.soapAction),
+            headers: parsed.headers,
+            attachments: parsed.attachments.map((a) => exact(a)),
+            ...optional('auth', soapOwnerAuth(parsed.auth)),
+            ...(parsed.wsa !== undefined ? { wsa: normalizeWsa(parsed.wsa) } : {}),
+            ...optional('wssOutgoingRef', parsed.wssOutgoingRef),
+            ...optional('wssIncomingRef', parsed.wssIncomingRef),
+            properties: exact(parsed.properties),
+            assertions: parsed.assertions.map((a) => (a.type === 'callback' ? toCallbackAssertion(a) : exact(a))),
+            ...(parsed.orphaned === true ? { orphaned: true } : {}),
+            ...(scripts !== undefined ? { scripts } : {}),
+            envelopeXml: envelope === undefined ? '' : envelope.toString('utf8'),
+        });
+    }
+    for (const orphan of [...names].sort()) {
+        problems.push({
+            code: 'orphan-request-file',
+            message: `"${orphan}" does not belong to any request`,
+            file: `${dir}/${orphan}`,
+        });
+    }
+    return requests.sort(byOrder);
+}
+function requestDocument(request) {
+    return compact({
+        kind: request.kind,
+        id: request.id,
+        name: request.name,
+        order: request.order,
+        description: request.description,
+        endpointId: request.endpointId,
+        endpointUrl: request.endpointUrl,
+        soapVersion: request.soapVersion,
+        soapAction: request.soapAction,
+        headers: request.headers.map((h) => ({ name: h.name, value: h.value })),
+        attachments: request.attachments.map((a) => compact({ ...a })),
+        auth: request.auth === undefined ? undefined : authDocument(request.auth),
+        wsa: request.wsa === undefined ? undefined : compact({ ...request.wsa }),
+        wssOutgoingRef: request.wssOutgoingRef,
+        wssIncomingRef: request.wssIncomingRef,
+        properties: compact({ ...request.properties }),
+        assertions: request.assertions.length > 0 ? request.assertions.map((a) => compact({ ...a })) : undefined,
+        orphaned: request.orphaned === true ? true : undefined,
+        scripts: scriptsDocument(request.scripts, request.slug).document,
+    });
+}
+function interfaceDocument(iface) {
+    return compact({
+        kind: iface.kind,
+        id: iface.id,
+        name: iface.name,
+        order: iface.order,
+        definitionUrl: iface.definitionUrl,
+        cacheDefinition: iface.cacheDefinition,
+        targetNamespace: iface.targetNamespace,
+        endpoints: iface.endpoints.map((e) => compact({ ...e, auth: e.auth === undefined ? undefined : authDocument(e.auth) })),
+        defaultEndpointId: iface.defaultEndpointId,
+        wsa: compact({ ...iface.wsa }),
+        auth: iface.auth === undefined ? undefined : authDocument(iface.auth),
+        operations: iface.operations.map((op) => ({
+            name: op.name,
+            bindingName: op.bindingName,
+            slug: op.slug,
+            order: op.order,
+        })),
+    });
+}
+/** SOAP's storage facet. */
+export const soapStorage = {
+    dir: INTERFACES_DIR,
+    async load(ctx, slug, document) {
+        const { fs, root, problems } = ctx;
+        const relative = `${INTERFACES_DIR}/${slug}/interface.yaml`;
+        const parsed = parseFile(interfaceFileSchema, document, relative);
+        const operationsDir = `${INTERFACES_DIR}/${slug}/${OPERATIONS_DIR}`;
+        const folders = new Set((await readdirIfExists(fs, abs(root, operationsDir))).filter((e) => e.isDirectory).map((e) => e.name));
+        const operations = [];
+        for (const entry of parsed.operations) {
+            folders.delete(entry.slug);
+            operations.push({
+                name: entry.name,
+                bindingName: entry.bindingName,
+                slug: entry.slug,
+                order: entry.order,
+                requests: await loadRequests(fs, root, `${operationsDir}/${entry.slug}`, problems),
+            });
+        }
+        for (const orphan of [...folders].sort()) {
+            problems.push({
+                code: 'orphan-operation-folder',
+                message: `Operation folder "${orphan}" is not listed in interface.yaml`,
+                file: `${operationsDir}/${orphan}`,
+            });
+        }
+        const endpoints = parsed.endpoints.map((e) => ({
+            id: e.id,
+            name: e.name,
+            url: e.url,
+            ...optional('auth', soapOwnerAuth(e.auth)),
+            authMode: e.authMode,
+        }));
+        return {
+            kind: 'soap',
+            id: parsed.id,
+            name: parsed.name,
+            slug,
+            order: parsed.order,
+            definitionUrl: parsed.definitionUrl,
+            cacheDefinition: parsed.cacheDefinition,
+            ...optional('targetNamespace', parsed.targetNamespace),
+            endpoints,
+            ...optional('defaultEndpointId', parsed.defaultEndpointId),
+            wsa: normalizeWsa(parsed.wsa),
+            ...optional('auth', soapOwnerAuth(parsed.auth)),
+            operations: operations.sort(byOrder),
+        };
+    },
+    files(iface) {
+        const files = new Map();
+        assertPathSegment(iface.slug);
+        const base = `${INTERFACES_DIR}/${iface.slug}`;
+        files.set(`${base}/interface.yaml`, stringifyYaml(interfaceDocument(iface)));
+        for (const operation of iface.operations) {
+            assertPathSegment(operation.slug);
+            const dir = `${base}/${OPERATIONS_DIR}/${operation.slug}`;
+            for (const request of operation.requests) {
+                assertPathSegment(request.slug);
+                files.set(`${dir}/${request.slug}${REQUEST_SUFFIX}`, stringifyYaml(requestDocument(request)));
+                files.set(`${dir}/${request.slug}.xml`, request.envelopeXml);
+                writeScriptFiles(files, dir, request.scripts, request.slug);
+            }
+        }
+        return files;
+    },
+    /**
+     * `interface.yaml`, every `operations/<slug>/*.request.yaml`, and the `.xml` and script files
+     * that sit beside a request file of the same slug. An envelope with no request file, the
+     * definition cache and anything else in the folder are not Wirebench's to delete.
+     */
+    async managed(fs, root, slug) {
+        const managed = [];
+        const base = `${INTERFACES_DIR}/${slug}`;
+        const ifaceFile = `${base}/interface.yaml`;
+        if ((await readFileIfExists(fs, abs(root, ifaceFile))) !== undefined) {
+            managed.push(ifaceFile);
+        }
+        const opsDir = `${base}/${OPERATIONS_DIR}`;
+        for (const opEntry of await readdirIfExists(fs, abs(root, opsDir))) {
+            if (!opEntry.isDirectory) {
+                continue;
+            }
+            const opDir = `${opsDir}/${opEntry.name}`;
+            const requestSlugs = new Set();
+            const opFiles = await readdirIfExists(fs, abs(root, opDir));
+            for (const fileEntry of opFiles) {
+                if (fileEntry.isFile && fileEntry.name.endsWith(REQUEST_SUFFIX)) {
+                    requestSlugs.add(fileEntry.name.slice(0, -REQUEST_SUFFIX.length));
+                    managed.push(`${opDir}/${fileEntry.name}`);
+                }
+            }
+            for (const fileEntry of opFiles) {
+                if (fileEntry.isFile && fileEntry.name.endsWith('.xml')) {
+                    const requestSlug = fileEntry.name.slice(0, -'.xml'.length);
+                    if (requestSlugs.has(requestSlug)) {
+                        managed.push(`${opDir}/${fileEntry.name}`);
+                    }
+                }
+                else if (fileEntry.isFile && [...requestSlugs].some((known) => isScriptFileOf(fileEntry.name, known))) {
+                    managed.push(`${opDir}/${fileEntry.name}`);
+                }
+            }
+        }
+        return managed;
+    },
+    containers: (project) => project.interfaces,
+    withContainers: (project, interfaces) => ({ ...project, interfaces }),
+};

package/dist/soap/transforms.d.ts

@@ -10,8 +10,8 @@
  * Entitizing is the odd one out. It escapes the values substituted by property expansion,
  * which cannot be identified after the fact — by the time an envelope is a string, a `&` that
  * came from a property is indistinguishable from one the user typed. So {@link entitizeValue}
- * is applied *during* expansion instead (see `project/properties.ts`'s `entitize` option), and
- * lives here alongside its siblings.
+ * is applied *during* expansion instead (see `project/properties.ts`'s `entitize` option). It
+ * lives in `xml/entitize.ts`, which core can import, and is re-exported here beside its siblings.
  */
 /**
  * "Remove Empty Content": drops every element that has no attributes and whose whole
@@ -40,13 +40,4 @@ export declare function stripWhitespaces(xml: string): string;
  * @returns the formatted envelope, or `xml` unchanged when it could not be formatted
  */
 export declare function prettyPrint(xml: string, indentWidth?: number): string;
-/**
- * "Entitize Properties", applied to one substituted property value: escapes the three
- * characters that would otherwise be read as markup once the value lands inside an envelope.
- *
- * `"` and `'` are deliberately left alone: expansion targets element content far more often
- * than an attribute value, and escaping quotes there would show up as `"` in the payload.
- *
- * @param value the expanded property value
- */
-export declare function entitizeValue(value: string): string;
+export { entitizeValue } from '../xml/entitize.js';

package/dist/soap/transforms.js

@@ -10,8 +10,8 @@
  * Entitizing is the odd one out. It escapes the values substituted by property expansion,
  * which cannot be identified after the fact — by the time an envelope is a string, a `&` that
  * came from a property is indistinguishable from one the user typed. So {@link entitizeValue}
- * is applied *during* expansion instead (see `project/properties.ts`'s `entitize` option), and
- * lives here alongside its siblings.
+ * is applied *during* expansion instead (see `project/properties.ts`'s `entitize` option). It
+ * lives in `xml/entitize.ts`, which core can import, and is re-exported here beside its siblings.
  */
 import { formatXml } from '../xml/pretty.js';
 import { buildRangeTree, localNameOf, tokenizeXml } from '../xml/tolerant-tree.js';
@@ -150,15 +150,4 @@ export function prettyPrint(xml, indentWidth = 3) {
     const result = formatXml(xml, { indent: ' '.repeat(Math.max(0, indentWidth)) });
     return result.problem === undefined ? result.text : xml;
 }
-/**
- * "Entitize Properties", applied to one substituted property value: escapes the three
- * characters that would otherwise be read as markup once the value lands inside an envelope.
- *
- * `"` and `'` are deliberately left alone: expansion targets element content far more often
- * than an attribute value, and escaping quotes there would show up as `"` in the payload.
- *
- * @param value the expanded property value
- */
-export function entitizeValue(value) {
-    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-}
+export { entitizeValue } from '../xml/entitize.js';