@wirebench/engine 2.2.1 → 3.1.0-rc.1

package/dist/project/load.js

@@ -7,507 +7,23 @@
  * recoverable inconsistency (an orphaned envelope, an operation folder no
  * interface declares) becomes a {@link ProjectProblem} rather than an error, so
  * a slightly damaged project still opens.
+ *
+ * Core reads the manifest, environments, sequences, keystores, WS-Security references and the
+ * webhook collection. A container is read by its protocol's `storage.load` (`soap/storage.ts`,
+ * `rest/storage.ts`, `grpc/storage.ts`, `ws/storage.ts`), found through the registry.
  */
-import { join } from 'node:path';
 import { ProjectError } from '../errors.js';
-import { FORMAT_VERSION } from './model.js';
-import { nodeFs, readFileIfExists, readdirIfExists } from './fs.js';
+import { defaultRegistry } from '../protocols.js';
+import { restRequestReader, signingOf } from '../rest/storage.js';
+import { readSequences } from '../sequence/load.js';
+import { nodeFs, readdirIfExists } from './fs.js';
+import { abs, authConfig, byOrder, exact, loadFolderContents, optional, readYaml } from './load-helpers.js';
 import { migrate } from './migrate.js';
-import { normalizeWsa } from '../wsa/model.js';
-import { API_FILE, APIS_DIR, assertPathSegment, ENVIRONMENTS_DIR, FOLDER_FILE, INTERFACES_DIR, MAX_FOLDER_DEPTH, OPERATIONS_DIR, REQUEST_SUFFIX, REQUESTS_DIR, WSS_DIR, } from './paths.js';
-import { apiFileSchema, apiKindOf, assertSupportedKind, grpcApiFileSchema, grpcRequestFileSchema, environmentFileSchema, interfaceFileSchema, keystoresFileSchema, manifestSchema, parseFile, requestFileSchema, restFolderFileSchema, restRequestFileSchema, wsApiFileSchema, wsRequestFileSchema, wssIncomingFileSchema, wssOutgoingFileSchema, } from './schema.js';
+import { FORMAT_VERSION } from './model.js';
+import { API_FILE, APIS_DIR, ENVIRONMENTS_DIR, INTERFACES_DIR, REQUESTS_DIR, WEBHOOKS_DIR, WEBHOOKS_FEATURE, WEBHOOKS_FILE, WSS_DIR, } from './paths.js';
+import { parseFile } from './schema-parts.js';
+import { environmentFileSchema, keystoresFileSchema, manifestSchema, webhookFolderFileSchema, webhooksFileSchema, wssIncomingFileSchema, wssOutgoingFileSchema, } from './schema.js';
 import { KEYSTORES_PATH, MANIFEST_PATH } from './serialize.js';
-import { parseYaml } from './yaml.js';
-function abs(root, relative) {
-    return join(root, ...relative.split('/'));
-}
-async function readYaml(fs, root, relative) {
-    const buffer = await readFileIfExists(fs, abs(root, relative));
-    return buffer === undefined ? undefined : parseYaml(buffer.toString('utf8'), relative);
-}
-/** Orders entities by their persisted `order`, falling back to a stable name comparison. */
-function byOrder(a, b) {
-    return a.order - b.order || a.name.localeCompare(b.name);
-}
-function optional(key, value) {
-    return value === undefined ? {} : { [key]: value };
-}
-/**
- * Drops `undefined`-valued keys from a zod result, so an absent optional field
- * is truly absent rather than present-and-undefined (`exactOptionalPropertyTypes`).
- */
-function exact(value) {
-    const out = {};
-    for (const key of Object.keys(value)) {
-        const entry = value[key];
-        if (entry !== undefined) {
-            out[key] = entry;
-        }
-    }
-    return out;
-}
-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`);
-        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', 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) => exact(a)),
-            ...(parsed.orphaned === true ? { orphaned: true } : {}),
-            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);
-}
-async function loadInterface(fs, root, slug, problems) {
-    const relative = `${INTERFACES_DIR}/${slug}/interface.yaml`;
-    const document = await readYaml(fs, root, relative);
-    if (document === undefined) {
-        problems.push({
-            code: 'missing-interface-file',
-            message: `Folder "${slug}" has no interface.yaml and was skipped`,
-            file: relative,
-        });
-        return undefined;
-    }
-    assertSupportedKind(document, relative);
-    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', 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', parsed.auth),
-        operations: operations.sort(byOrder),
-    };
-}
-/**
- * Authentication as loaded: the same `undefined`-key drop {@link exact} performs, expressed
- * separately because `AuthConfig` is a union and so has no single mapped shape to hand `exact`.
- * The cast is safe for the same reason `exact`'s is: the schema has already established the
- * arm's own fields, and this only removes keys whose value is absent.
- */
-function authConfig(parsed) {
-    const out = {};
-    for (const [key, value] of Object.entries(parsed)) {
-        if (value !== undefined) {
-            out[key] = value;
-        }
-    }
-    return out;
-}
-/** A table row as loaded: `enabled` defaults to true, an absent description stays absent. */
-function keyValueEntries(rows) {
-    return rows.map((row) => exact({ name: row.name, value: row.value, enabled: row.enabled, description: row.description }));
-}
-/**
- * One request body as loaded. A raw body's text lives in a sibling file, so it is read here and
- * the file name is dropped: the model holds the text, the layout holds the name
- * (`project/paths.ts` rebuilds it on save from the language).
- */
-async function loadBody(fs, root, dir, document, requestName, problems) {
-    switch (document.kind) {
-        case 'raw': {
-            const relative = `${dir}/${document.file}`;
-            const text = await readFileIfExists(fs, abs(root, relative));
-            if (text === undefined) {
-                problems.push({
-                    code: 'missing-body',
-                    message: `Request "${requestName}" has no body file; loaded with an empty body`,
-                    file: relative,
-                });
-            }
-            return {
-                kind: 'raw',
-                language: document.language,
-                ...optional('contentType', document.contentType),
-                text: text === undefined ? '' : text.toString('utf8'),
-            };
-        }
-        case 'form':
-            return { kind: 'form', fields: keyValueEntries(document.fields) };
-        case 'multipart':
-            return {
-                kind: 'multipart',
-                parts: document.parts.map((part) => part.kind === 'text'
-                    ? exact({ ...part, kind: 'text' })
-                    : exact({ ...part, kind: 'file' })),
-            };
-        case 'binary':
-            return { kind: 'binary', source: document.source, contentType: document.contentType };
-        default:
-            return { kind: 'none' };
-    }
-}
-/** Reads a REST request and its raw body file. */
-function restRequestReader(fs, root, problems) {
-    return async (dir, fileName, unclaimed) => {
-        const relative = `${dir}/${fileName}`;
-        const document = await readYaml(fs, root, relative);
-        assertSupportedKind(document, relative);
-        const parsed = parseFile(restRequestFileSchema, document, relative);
-        unclaimed.delete(fileName);
-        if (parsed.body.kind === 'raw') {
-            unclaimed.delete(parsed.body.file);
-        }
-        return {
-            kind: 'rest',
-            id: parsed.id,
-            name: parsed.name,
-            slug: fileName.slice(0, -REQUEST_SUFFIX.length),
-            order: parsed.order,
-            ...optional('description', parsed.description),
-            method: parsed.method,
-            url: parsed.url,
-            pathParams: keyValueEntries(parsed.pathParams),
-            query: keyValueEntries(parsed.query),
-            headers: keyValueEntries(parsed.headers),
-            body: await loadBody(fs, root, dir, parsed.body, parsed.name, problems),
-            auth: authConfig(parsed.auth),
-            settings: exact(parsed.settings),
-            assertions: parsed.assertions.map((a) => exact(a)),
-            ...(parsed.orphaned === true ? { orphaned: true } : {}),
-        };
-    };
-}
-/**
- * Reads a gRPC request and its message file. A request whose message file is gone loads with an
- * empty message and a `missing-body` problem, exactly as a REST raw body does.
- */
-function grpcRequestReader(fs, root, problems) {
-    return async (dir, fileName, unclaimed) => {
-        const relative = `${dir}/${fileName}`;
-        const document = await readYaml(fs, root, relative);
-        assertSupportedKind(document, relative);
-        const parsed = parseFile(grpcRequestFileSchema, document, relative);
-        unclaimed.delete(fileName);
-        let message = '';
-        if (parsed.message !== undefined) {
-            unclaimed.delete(parsed.message);
-            const messageRelative = `${dir}/${parsed.message}`;
-            const text = await readFileIfExists(fs, abs(root, messageRelative));
-            if (text === undefined) {
-                problems.push({
-                    code: 'missing-body',
-                    message: `Request "${parsed.name}" has no message file; loaded with an empty message`,
-                    file: messageRelative,
-                });
-            }
-            else {
-                message = text.toString('utf8');
-            }
-        }
-        return {
-            kind: 'grpc',
-            id: parsed.id,
-            name: parsed.name,
-            slug: fileName.slice(0, -REQUEST_SUFFIX.length),
-            order: parsed.order,
-            ...optional('description', parsed.description),
-            service: parsed.service,
-            method: parsed.method,
-            methodKind: parsed.methodKind,
-            metadata: keyValueEntries(parsed.metadata),
-            message,
-            auth: authConfig(parsed.auth),
-            settings: exact(parsed.settings),
-            ...(parsed.orphaned === true ? { orphaned: true } : {}),
-        };
-    };
-}
-/**
- * Reads a WebSocket request and its saved messages, each in its own sibling file. A message whose
- * file is gone loads with empty content and a `missing-body` problem, exactly as a gRPC message
- * does; its slug is recovered from the file name between the `.msg-` marker and the extension.
- */
-function wsRequestReader(fs, root, problems) {
-    return async (dir, fileName, unclaimed) => {
-        const relative = `${dir}/${fileName}`;
-        const document = await readYaml(fs, root, relative);
-        assertSupportedKind(document, relative);
-        const parsed = parseFile(wsRequestFileSchema, document, relative);
-        unclaimed.delete(fileName);
-        const requestSlug = fileName.slice(0, -REQUEST_SUFFIX.length);
-        const messages = [];
-        for (const entry of parsed.messages) {
-            assertPathSegment(entry.file);
-            unclaimed.delete(entry.file);
-            const messageRelative = `${dir}/${entry.file}`;
-            const text = await readFileIfExists(fs, abs(root, messageRelative));
-            if (text === undefined) {
-                problems.push({
-                    code: 'missing-body',
-                    message: `Request "${parsed.name}" has no message file; loaded with an empty message`,
-                    file: messageRelative,
-                });
-            }
-            const slug = entry.file.slice(`${requestSlug}.msg-`.length, entry.file.lastIndexOf('.'));
-            messages.push({
-                id: entry.id,
-                name: entry.name,
-                slug,
-                format: entry.format,
-                content: text === undefined ? '' : text.toString('utf8'),
-            });
-        }
-        return {
-            kind: 'websocket',
-            id: parsed.id,
-            name: parsed.name,
-            slug: requestSlug,
-            order: parsed.order,
-            ...optional('description', parsed.description),
-            url: parsed.url,
-            query: keyValueEntries(parsed.query),
-            headers: keyValueEntries(parsed.headers),
-            subprotocols: parsed.subprotocols,
-            auth: authConfig(parsed.auth),
-            settings: exact(parsed.settings),
-            messages,
-        };
-    };
-}
-/**
- * Loads one directory of an API's request tree: its `*.request.yaml` files as requests (through
- * the protocol's reader), its subdirectories as folders, recursively.
- *
- * A directory with no `folder.yaml` is still a folder — named after the directory, ordered after
- * the ones that do have a file, and given a file of its own on the next save — because a folder
- * someone created with `mkdir` in a checked-out project is a folder, not a fault. A directory
- * deeper than {@link MAX_FOLDER_DEPTH} becomes a problem and is skipped whole, so nothing is ever
- * written to a path that might not open on Windows.
- */
-async function loadFolderContents(fs, root, dir, depth, problems, readRequest) {
-    const entries = await readdirIfExists(fs, abs(root, dir));
-    const unclaimed = new Set(entries.filter((e) => e.isFile && e.name !== FOLDER_FILE).map((e) => e.name));
-    const requests = [];
-    const folders = [];
-    for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-        if (entry.isFile && entry.name.endsWith(REQUEST_SUFFIX)) {
-            requests.push(await readRequest(dir, entry.name, unclaimed));
-            continue;
-        }
-        if (!entry.isDirectory) {
-            continue;
-        }
-        const childDir = `${dir}/${entry.name}`;
-        if (depth + 1 > MAX_FOLDER_DEPTH) {
-            problems.push({
-                code: 'folder-too-deep',
-                message: `Folder "${entry.name}" is nested more than ${String(MAX_FOLDER_DEPTH)} deep and was skipped`,
-                file: childDir,
-            });
-            continue;
-        }
-        const contents = await loadFolderContents(fs, root, childDir, depth + 1, problems, readRequest);
-        const relative = `${childDir}/${FOLDER_FILE}`;
-        const document = await readYaml(fs, root, relative);
-        const parsed = document === undefined ? undefined : parseFile(restFolderFileSchema, document, relative);
-        folders.push({
-            id: parsed?.id ?? `folder:${entry.name}`,
-            name: parsed?.name ?? entry.name,
-            slug: entry.name,
-            order: parsed?.order ?? Number.MAX_SAFE_INTEGER,
-            ...optional('description', parsed?.description),
-            ...(parsed?.auth !== undefined ? { auth: authConfig(parsed.auth) } : {}),
-            folders: contents.folders,
-            requests: contents.requests,
-        });
-    }
-    for (const orphan of [...unclaimed].sort()) {
-        problems.push({
-            code: 'orphan-request-file',
-            message: `"${orphan}" does not belong to any request`,
-            file: `${dir}/${orphan}`,
-        });
-    }
-    return { folders: folders.sort(byOrder), requests: requests.sort(byOrder) };
-}
-/** Loads one `apis/<slug>/` directory, or records a problem and returns nothing. */
-async function loadApi(fs, root, slug, problems) {
-    const relative = `${APIS_DIR}/${slug}/${API_FILE}`;
-    const document = await readYaml(fs, root, relative);
-    if (document === undefined) {
-        problems.push({
-            code: 'missing-api-file',
-            message: `Folder "${slug}" has no ${API_FILE} and was skipped`,
-            file: relative,
-        });
-        return undefined;
-    }
-    assertSupportedKind(document, relative);
-    const requestsDir = `${APIS_DIR}/${slug}/${REQUESTS_DIR}`;
-    switch (apiKindOf(document)) {
-        case 'grpc': {
-            const parsed = parseFile(grpcApiFileSchema, document, relative);
-            const contents = await loadFolderContents(fs, root, requestsDir, 0, problems, grpcRequestReader(fs, root, problems));
-            return {
-                kind: 'grpc',
-                api: {
-                    kind: 'grpc',
-                    id: parsed.id,
-                    name: parsed.name,
-                    slug,
-                    order: parsed.order,
-                    ...optional('description', parsed.description),
-                    target: parsed.target,
-                    tls: parsed.tls,
-                    metadata: keyValueEntries(parsed.metadata),
-                    ...(parsed.auth !== undefined ? { auth: authConfig(parsed.auth) } : {}),
-                    ...(parsed.definition !== undefined
-                        ? {
-                            definition: {
-                                kind: parsed.definition.kind,
-                                source: parsed.definition.source,
-                                cache: parsed.definition.cache,
-                                roots: parsed.definition.roots,
-                                ...optional('reflectionVersion', parsed.definition.reflectionVersion),
-                                ...optional('trustInvalid', parsed.definition.trustInvalid),
-                            },
-                        }
-                        : {}),
-                    folders: contents.folders,
-                    requests: contents.requests,
-                },
-            };
-        }
-        case 'websocket': {
-            const parsed = parseFile(wsApiFileSchema, document, relative);
-            const contents = await loadFolderContents(fs, root, requestsDir, 0, problems, wsRequestReader(fs, root, problems));
-            return {
-                kind: 'websocket',
-                api: {
-                    kind: 'websocket',
-                    id: parsed.id,
-                    name: parsed.name,
-                    slug,
-                    order: parsed.order,
-                    ...optional('description', parsed.description),
-                    url: parsed.url,
-                    headers: keyValueEntries(parsed.headers),
-                    ...(parsed.auth !== undefined ? { auth: authConfig(parsed.auth) } : {}),
-                    ...(parsed.definition !== undefined
-                        ? {
-                            definition: {
-                                kind: parsed.definition.kind,
-                                source: parsed.definition.source,
-                                cache: parsed.definition.cache,
-                            },
-                        }
-                        : {}),
-                    folders: contents.folders,
-                    requests: contents.requests,
-                },
-            };
-        }
-        default: {
-            const parsed = parseFile(apiFileSchema, document, relative);
-            const contents = await loadFolderContents(fs, root, requestsDir, 0, problems, restRequestReader(fs, root, problems));
-            return {
-                kind: 'rest',
-                api: {
-                    kind: 'rest',
-                    id: parsed.id,
-                    name: parsed.name,
-                    slug,
-                    order: parsed.order,
-                    ...optional('description', parsed.description),
-                    baseUrl: parsed.baseUrl,
-                    servers: parsed.servers.map((server) => exact(server)),
-                    ...(parsed.auth !== undefined ? { auth: authConfig(parsed.auth) } : {}),
-                    ...(parsed.definition !== undefined
-                        ? {
-                            definition: {
-                                source: parsed.definition.source,
-                                cache: parsed.definition.cache,
-                                version: parsed.definition.version,
-                            },
-                        }
-                        : {}),
-                    folders: contents.folders,
-                    requests: contents.requests,
-                },
-            };
-        }
-    }
-}
 async function loadEnvironments(fs, root) {
     const environments = [];
     for (const entry of await readdirIfExists(fs, abs(root, ENVIRONMENTS_DIR))) {
@@ -542,15 +58,98 @@ async function loadWssRefs(fs, root, direction) {
     }
     return refs.sort((a, b) => a.name.localeCompare(b.name));
 }
+/** Loads `webhooks/`, or nothing when the project has no `webhooks.yaml`. */
+async function loadWebhooks(fs, root, problems) {
+    const relative = `${WEBHOOKS_DIR}/${WEBHOOKS_FILE}`;
+    const document = await readYaml(fs, root, relative);
+    if (document === undefined)
+        return undefined;
+    const parsed = parseFile(webhooksFileSchema, document, relative);
+    const contents = await loadFolderContents(fs, root, `${WEBHOOKS_DIR}/${REQUESTS_DIR}`, 0, problems, restRequestReader(fs, root, problems), (folderDocument, folderFile) => {
+        if (folderDocument === undefined)
+            return {};
+        const folder = parseFile(webhookFolderFileSchema, folderDocument, folderFile);
+        return {
+            ...optional('target', folder.target),
+            ...(folder.source !== undefined ? { source: { apiId: folder.source.apiId } } : {}),
+            ...(folder.signing !== undefined ? { signing: signingOf(folder.signing) } : {}),
+        };
+    });
+    return {
+        target: parsed.target,
+        ...(parsed.auth !== undefined ? { auth: authConfig(parsed.auth) } : {}),
+        ...(parsed.signing !== undefined ? { signing: signingOf(parsed.signing) } : {}),
+        folders: contents.folders,
+        requests: contents.requests,
+    };
+}
 /**
- * Loads the project stored in the directory `root`.
+ * The two directories a project keeps containers in: each one's container file, the kind a file
+ * without one has (the directory's first protocol), and the problem an empty directory is.
+ */
+const CONTAINER_DIRS = [
+    { dir: INTERFACES_DIR, file: 'interface.yaml', defaultKind: 'soap', missing: 'missing-interface-file' },
+    { dir: APIS_DIR, file: API_FILE, defaultKind: 'rest', missing: 'missing-api-file' },
+];
+/** A container file's `kind`, or `fallback` when it has none. */
+function kindOf(document, fallback) {
+    const kind = typeof document === 'object' && document !== null ? document['kind'] : undefined;
+    return typeof kind === 'string' ? kind : fallback;
+}
+/**
+ * The storage that reads a container file found in `layout.dir`: the enabled module its `kind`
+ * names, when that module keeps its containers in this directory. Undefined makes a placeholder.
+ */
+function storageFor(registry, layout, document) {
+    const storage = registry.find(kindOf(document, layout.defaultKind))?.storage;
+    return storage?.dir === layout.dir ? storage : undefined;
+}
+/**
+ * What is kept of a container no enabled module reads (spec §6): where it is, its kind as written,
+ * why it was not loaded, and its name and order when the file has them as a string and a number.
+ */
+function placeholderOf(registry, layout, slug, document) {
+    const kind = kindOf(document, layout.defaultKind);
+    const fields = typeof document === 'object' && document !== null ? document : {};
+    const name = fields['name'];
+    const order = fields['order'];
+    return {
+        dir: layout.dir,
+        slug,
+        kind,
+        // A kind the registry has a module for but in the other directory is unknown here.
+        reason: registry.status(kind) === 'disabled' ? 'feature-disabled' : 'unknown-kind',
+        ...(typeof name === 'string' ? { name } : {}),
+        ...(typeof order === 'number' ? { order } : {}),
+    };
+}
+/** The problem a placeholder is reported with. */
+function unsupportedProblem(placeholder, file) {
+    const why = placeholder.reason === 'feature-disabled'
+        ? 'that protocol is switched off'
+        : `this build has no such protocol for ${placeholder.dir}/`;
+    return {
+        code: 'container-unsupported',
+        message: `${file} is a "${placeholder.kind}" container, and ${why}; it was not loaded and is left as it is`,
+        file,
+        details: { kind: placeholder.kind, reason: placeholder.reason, dir: placeholder.dir, slug: placeholder.slug },
+    };
+}
+/**
+ * Loads the project stored in the directory `root`. Each container directory under `interfaces/`
+ * and `apis/` is read by the protocol module its container file's `kind` names (spec §5.1). A
+ * container whose kind has no enabled module in that directory becomes a placeholder in
+ * `project.unsupported` and a `container-unsupported` problem; nothing below its directory is read
+ * but its container file, and a save leaves all of it as it is (spec §6).
  *
  * @throws ProjectError `project-not-found` when there is no `wirebench.yaml`,
  * `project-format-too-new` for a newer format version, `project-file-invalid`
- * for malformed or schema-violating YAML (with the offending file in `details`).
+ * for malformed or schema-violating YAML (with the offending file in `details`),
+ * `project-kind-not-supported` for a request file of a kind this build has no module for.
  */
 export async function loadProject(root, options) {
     const fs = options?.fs ?? nodeFs;
+    const registry = options?.registry ?? defaultRegistry();
     const manifestDocument = await readYaml(fs, root, MANIFEST_PATH);
     if (manifestDocument === undefined) {
         throw new ProjectError('project-not-found', `No ${MANIFEST_PATH} in ${root}`, {
@@ -559,47 +158,55 @@ export async function loadProject(root, options) {
     }
     const manifest = parseFile(manifestSchema, migrate(manifestDocument, MANIFEST_PATH), MANIFEST_PATH);
     const problems = [];
-    const interfaces = [];
-    for (const entry of await readdirIfExists(fs, abs(root, INTERFACES_DIR))) {
-        if (!entry.isDirectory) {
-            continue;
-        }
-        const iface = await loadInterface(fs, root, entry.name, problems);
-        if (iface !== undefined) {
-            interfaces.push(iface);
-        }
-    }
-    const interfaceSlugs = new Set(interfaces.map((iface) => iface.slug.toLowerCase()));
-    const apis = [];
-    const grpcApis = [];
-    const wsApis = [];
-    for (const entry of await readdirIfExists(fs, abs(root, APIS_DIR))) {
-        if (!entry.isDirectory) {
-            continue;
-        }
-        const loaded = await loadApi(fs, root, entry.name, problems);
-        if (loaded === undefined) {
-            continue;
-        }
-        // An environment's endpoint overrides are keyed by slug, so two entities sharing one would
-        // make the override ambiguous. The folders never collide; the override key would. REST and
-        // gRPC APIs share one directory, so their slugs cannot collide with each other.
-        if (interfaceSlugs.has(loaded.api.slug.toLowerCase())) {
-            problems.push({
-                code: 'api-slug-conflict',
-                message: `API "${loaded.api.name}" and an interface share the slug "${loaded.api.slug}"; the API was skipped`,
-                file: `${APIS_DIR}/${loaded.api.slug}/${API_FILE}`,
-            });
-            continue;
-        }
-        if (loaded.kind === 'grpc') {
-            grpcApis.push(loaded.api);
-        }
-        else if (loaded.kind === 'websocket') {
-            wsApis.push(loaded.api);
-        }
-        else {
-            apis.push(loaded.api);
+    const ctx = { fs, root, problems };
+    const loaded = new Map();
+    const unsupported = [];
+    const interfaceSlugs = new Set();
+    for (const layout of CONTAINER_DIRS) {
+        for (const entry of await readdirIfExists(fs, abs(root, layout.dir))) {
+            if (!entry.isDirectory) {
+                continue;
+            }
+            const relative = `${layout.dir}/${entry.name}/${layout.file}`;
+            const document = await readYaml(fs, root, relative);
+            if (document === undefined) {
+                problems.push({
+                    code: layout.missing,
+                    message: `Folder "${entry.name}" has no ${layout.file} and was skipped`,
+                    file: relative,
+                });
+                continue;
+            }
+            const storage = storageFor(registry, layout, document);
+            if (storage === undefined) {
+                // Kept whatever its slug: a placeholder that was skipped would not be live, and the next
+                // save would delete the directory this build could not read.
+                const placeholder = placeholderOf(registry, layout, entry.name, document);
+                unsupported.push(placeholder);
+                problems.push(unsupportedProblem(placeholder, relative));
+                continue;
+            }
+            const container = await storage.load(ctx, entry.name, document);
+            if (container === undefined) {
+                continue;
+            }
+            if (layout.dir === INTERFACES_DIR) {
+                interfaceSlugs.add(container.slug.toLowerCase());
+            }
+            else if (interfaceSlugs.has(container.slug.toLowerCase())) {
+                // An environment's endpoint overrides are keyed by slug, so two entities sharing one would
+                // make the override ambiguous. The folders never collide; the override key would. Every
+                // kind of API shares one directory, so their slugs cannot collide with each other.
+                problems.push({
+                    code: 'api-slug-conflict',
+                    message: `API "${container.name}" and an interface share the slug "${container.slug}"; the API was skipped`,
+                    file: `${APIS_DIR}/${container.slug}/${API_FILE}`,
+                });
+                continue;
+            }
+            const containers = loaded.get(storage) ?? [];
+            containers.push(container);
+            loaded.set(storage, containers);
         }
     }
     const keystoresDocument = await readYaml(fs, root, KEYSTORES_PATH);
@@ -610,7 +217,11 @@ export async function loadProject(root, options) {
             name: k.name,
             document: k,
         }));
-    const project = {
+    const sequenceFiles = await readSequences(fs, root);
+    problems.push(...sequenceFiles.problems);
+    // The collection is REST requests: with REST off it is not read, and a save leaves it alone.
+    const webhooks = registry.features.isEnabled(WEBHOOKS_FEATURE) ? await loadWebhooks(fs, root, problems) : undefined;
+    const core = {
         formatVersion: FORMAT_VERSION,
         id: manifest.id,
         name: manifest.name,
@@ -619,16 +230,28 @@ export async function loadProject(root, options) {
         properties: manifest.properties,
         disabledProperties: manifest.disabled ?? [],
         ...optional('activeEnvironmentId', manifest.activeEnvironmentId),
-        interfaces: interfaces.sort(byOrder),
-        apis: apis.sort(byOrder),
-        grpcApis: grpcApis.sort(byOrder),
-        wsApis: wsApis.sort(byOrder),
+        interfaces: [],
+        apis: [],
+        grpcApis: [],
+        wsApis: [],
+        sequences: sequenceFiles.loaded.map((entry) => entry.sequence).sort(byOrder),
+        ...(webhooks !== undefined ? { webhooks } : {}),
         environments: await loadEnvironments(fs, root),
         wss: {
             outgoing: await loadWssRefs(fs, root, 'outgoing'),
             incoming: await loadWssRefs(fs, root, 'incoming'),
             keystores,
         },
+        // Absent when there is none, as every project written before placeholders is.
+        ...(unsupported.length > 0
+            ? { unsupported: unsupported.sort((a, b) => a.dir.localeCompare(b.dir) || a.slug.localeCompare(b.slug)) }
+            : {}),
     };
+    // A module that loaded nothing is not asked: the four built-in lists are already empty, and a
+    // kind kept in `extraContainers` must not appear there when the project holds none of it.
+    let project = core;
+    for (const [storage, containers] of loaded) {
+        project = storage.withContainers(project, containers.sort(byOrder));
+    }
     return { project, problems };
 }