@forestadmin/agent-bff 1.16.0 → 1.18.0

package/dist/openapi/collect-unfolding.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPABILITIES_CONCURRENCY = void 0;
+exports.default = collectUnfolding;
+const errors_1 = require("../errors");
+const operator_normalizer_1 = require("../validation/operator-normalizer");
+// A cold document costs one capabilities call per collection. They are capped rather than fired all
+// at once so a 200-collection deployment cannot open 200 sockets to the agent at the same time; a
+// warm BFF pays nothing, the per-collection cache is shared with the data routes.
+exports.CAPABILITIES_CONCURRENCY = 10;
+async function mapWithConcurrency(items, limit, run) {
+    const results = new Array(items.length);
+    let cursor = 0;
+    // Recursive rather than a while loop: each worker takes the next item only once the previous one
+    // settled, which is what caps the concurrency.
+    const worker = async () => {
+        if (cursor >= items.length)
+            return;
+        const index = cursor;
+        cursor += 1;
+        results[index] = await run(items[index]);
+        await worker();
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}
+const UNTYPED = (degraded) => ({
+    projectable: [],
+    filterable: [],
+    degraded,
+});
+/**
+ * The operators to document for one field, or null to leave the field out of the filterable set.
+ *
+ * An operator with no canonical mapping means the agent runs a newer operator set than this package.
+ * The field is dropped rather than widened, because `capabilities-validator` normalizes a field's
+ * WHOLE operator list before comparing the one that was sent: a skewed field answers 500
+ * `mapping_error` on ANY filter, even a plain `Equal`. Documenting it as filterable would promise a
+ * call the BFF never honours, and a raw snake_case operator must never reach the public document. The
+ * skew is surfaced in the log instead — dropping the field keeps the document truthful, so it stays
+ * cacheable.
+ */
+function documentedOperators(collection, field, operators, logger) {
+    const normalized = [];
+    for (const operator of operators) {
+        const canonical = (0, operator_normalizer_1.normalizeOperator)(operator);
+        if (!canonical) {
+            logger('Warn', 'Documenting a field as not filterable: one of its operators has no mapping', {
+                collection,
+                field,
+                operator,
+            });
+            return null;
+        }
+        normalized.push(canonical);
+    }
+    return (0, operator_normalizer_1.toCanonicalOperatorSet)(normalized);
+}
+function collectFilterableFields(collection, capabilities, logger) {
+    return capabilities.fields.flatMap(field => {
+        if ((field.operators?.length ?? 0) === 0)
+            return [];
+        const operators = documentedOperators(collection, field.name, field.operators, logger);
+        return operators === null ? [] : [{ name: field.name, operators }];
+    });
+}
+async function collectFields(collection, { store, capabilitiesFetcher, logger }) {
+    try {
+        const { capabilities } = await store.getCapabilities(collection, capabilitiesFetcher);
+        if (capabilities.fields.length === 0) {
+            logger('Warn', 'Documenting a collection without a field set: capabilities returned none', {
+                collection,
+            });
+            return UNTYPED('no_fields');
+        }
+        return {
+            projectable: capabilities.fields.map(field => field.name),
+            filterable: collectFilterableFields(collection, capabilities, logger),
+            degraded: null,
+        };
+    }
+    catch (error) {
+        // A single unreachable collection must not cost the whole document: the collection keeps its
+        // paths, untyped. The alternative — dropping it — would hide a collection the runtime serves.
+        logger('Warn', 'Documenting a collection without a field set: capabilities are unavailable', {
+            collection,
+            error: (0, errors_1.extractErrorMessage)(error),
+        });
+        return UNTYPED('capabilities_unavailable');
+    }
+}
+// A to-many relation pointing at a collection absent from the allow-list is dropped: the runtime
+// answers 404 on it (data-routes-middleware checks the foreign collection), so documenting it would
+// promise a dead path.
+function collectRelations(readModel, collection) {
+    const listable = readModel
+        .getListableRelations(collection)
+        .filter(relation => readModel.isCollectionAllowed(relation.foreignCollection));
+    // By name, in code-unit order like the collection and action levels — NOT `localeCompare`, which
+    // follows the process locale: the route and the CLI could then order one schema's relations
+    // differently and stop producing the same document.
+    return listable.sort((left, right) => left.name < right.name ? -1 : Number(left.name > right.name));
+}
+function collectActions(readModel, collection) {
+    const byName = readModel.getActionEndpoints()[collection] ?? {};
+    return Object.keys(byName)
+        .sort()
+        .map(name => ({
+        name,
+        // A form field with no usable name is dropped: the schema is cast from untyped JSON, and the
+        // read-model turns a malformed entry into `{}`, which would otherwise document a property
+        // literally called "undefined".
+        fields: (byName[name].fields ?? [])
+            .filter(field => typeof field?.field === 'string')
+            .map(field => ({
+            name: field.field,
+            type: field.type,
+            isRequired: field.isRequired === true,
+            enums: field.enums ?? null,
+        })),
+    }));
+}
+/**
+ * Collects everything the document unfolds. Sorted at every level so two runs over one schema
+ * produce byte-identical documents — the route/CLI comparison depends on it.
+ *
+ * A schema refresh landing mid-collect can mix the new generation's field sets into this snapshot's
+ * structure. Detecting it belongs to the caller, which knows whether the read-model it passed is
+ * still the current one once this resolves.
+ */
+async function collectUnfolding(options) {
+    const { readModel, concurrency = exports.CAPABILITIES_CONCURRENCY } = options;
+    const names = readModel.getAllowedCollections().sort();
+    const fields = await mapWithConcurrency(names, concurrency, name => collectFields(name, options));
+    const collections = names.map((name, index) => ({
+        name,
+        fields: fields[index],
+        primaryKeys: readModel.getPrimaryKeys(name),
+        relations: collectRelations(readModel, name),
+        actions: collectActions(readModel, name),
+    }));
+    return { collections };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/openapi/component-pool.d.ts

@@ -0,0 +1,18 @@
+import type { z } from './zod-openapi';
+import type { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import type { ReferenceObject, SchemaObject } from 'openapi3-ts/oas31';
+/**
+ * Registers schema components on demand. Nothing is registered eagerly: a component no path
+ * references trips redocly's unused-component rule, and which shared pieces an unfolded document
+ * needs depends on the schema it was built from.
+ */
+export default class ComponentPool {
+    private readonly registry;
+    private readonly shared;
+    constructor(registry: OpenAPIRegistry);
+    /** A hand-written OpenAPI component. The caller owns name uniqueness. */
+    add(name: string, component: SchemaObject): ReferenceObject;
+    /** A zod schema shared by several paths, registered the first time it is referenced. */
+    reuse(name: string, schema: z.ZodType): ReferenceObject;
+}
+//# sourceMappingURL=component-pool.d.ts.map

package/dist/openapi/component-pool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SCHEMA_PREFIX = '#/components/schemas/';
+/**
+ * Registers schema components on demand. Nothing is registered eagerly: a component no path
+ * references trips redocly's unused-component rule, and which shared pieces an unfolded document
+ * needs depends on the schema it was built from.
+ */
+class ComponentPool {
+    constructor(registry) {
+        this.shared = new Set();
+        this.registry = registry;
+    }
+    /** A hand-written OpenAPI component. The caller owns name uniqueness. */
+    add(name, component) {
+        return this.registry.registerComponent('schemas', name, component).ref;
+    }
+    /** A zod schema shared by several paths, registered the first time it is referenced. */
+    reuse(name, schema) {
+        if (!this.shared.has(name)) {
+            this.registry.register(name, schema);
+            this.shared.add(name);
+        }
+        return { $ref: `${SCHEMA_PREFIX}${name}` };
+    }
+}
+exports.default = ComponentPool;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LXBvb2wuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3BlbmFwaS9jb21wb25lbnQtcG9vbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLE1BQU0sYUFBYSxHQUFHLHVCQUF1QixDQUFDO0FBRTlDOzs7O0dBSUc7QUFDSCxNQUFxQixhQUFhO0lBSWhDLFlBQVksUUFBeUI7UUFGcEIsV0FBTSxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7UUFHMUMsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDM0IsQ0FBQztJQUVELHlFQUF5RTtJQUN6RSxHQUFHLENBQUMsSUFBWSxFQUFFLFNBQXVCO1FBQ3ZDLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxTQUFTLEVBQUUsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQztJQUN6RSxDQUFDO0lBRUQsd0ZBQXdGO0lBQ3hGLEtBQUssQ0FBQyxJQUFZLEVBQUUsTUFBaUI7UUFDbkMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDM0IsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1lBQ3JDLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3hCLENBQUM7UUFFRCxPQUFPLEVBQUUsSUFBSSxFQUFFLEdBQUcsYUFBYSxHQUFHLElBQUksRUFBRSxFQUFFLENBQUM7SUFDN0MsQ0FBQztDQUNGO0FBdEJELGdDQXNCQyJ9

package/dist/openapi/field-schemas.d.ts

@@ -0,0 +1,9 @@
+import type { FieldType } from '../read-model/capabilities-cache';
+import type { SchemaObject } from 'openapi3-ts/oas31';
+/**
+ * Turns a Forest column type into a JSON Schema. Anything unrecognized — a relation marker such as
+ * `ManyToOne`, or a type a newer agent introduced — maps to an unconstrained schema rather than a
+ * guess, so the document never rejects a value the runtime accepts.
+ */
+export default function toFieldSchema(type: FieldType): SchemaObject;
+//# sourceMappingURL=field-schemas.d.ts.map

package/dist/openapi/field-schemas.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = toFieldSchema;
+// Forest primitives, mapped to the closest JSON Schema shape. `Json` maps to no constraint at all,
+// which is honest: any JSON value is accepted there.
+const PRIMITIVE_SCHEMAS = {
+    Binary: { type: 'string' },
+    Boolean: { type: 'boolean' },
+    Date: { type: 'string', format: 'date-time' },
+    Dateonly: { type: 'string', format: 'date' },
+    Enum: { type: 'string' },
+    File: { type: 'string', description: 'A data URI.' },
+    Json: {},
+    Number: { type: 'number' },
+    Point: { type: 'string' },
+    String: { type: 'string' },
+    Time: { type: 'string' },
+    Timeonly: { type: 'string' },
+    Uuid: { type: 'string', format: 'uuid' },
+};
+/**
+ * Turns a Forest column type into a JSON Schema. Anything unrecognized — a relation marker such as
+ * `ManyToOne`, or a type a newer agent introduced — maps to an unconstrained schema rather than a
+ * guess, so the document never rejects a value the runtime accepts.
+ */
+function toFieldSchema(type) {
+    if (Array.isArray(type)) {
+        const [item] = type;
+        return { type: 'array', items: item === undefined ? {} : toFieldSchema(item) };
+    }
+    // Null-checked, and its elements checked rather than trusted: the payload a column type comes from
+    // is cast from untyped JSON, so nothing guarantees the declared shape. A malformed entry is dropped
+    // instead of aborting the whole document — one bad field is not worth losing the spec over.
+    if (typeof type === 'object' && type !== null && Array.isArray(type.fields)) {
+        const named = type.fields.filter(field => typeof field === 'object' && field !== null && typeof field.field === 'string');
+        return {
+            type: 'object',
+            properties: Object.fromEntries(named.map(field => [field.field, toFieldSchema(field.type)])),
+        };
+    }
+    return typeof type === 'string' ? PRIMITIVE_SCHEMAS[type] ?? {} : {};
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQtc2NoZW1hcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcGVuYXBpL2ZpZWxkLXNjaGVtYXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUEwQkEsZ0NBc0JDO0FBN0NELG1HQUFtRztBQUNuRyxxREFBcUQ7QUFDckQsTUFBTSxpQkFBaUIsR0FBaUM7SUFDdEQsTUFBTSxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTtJQUMxQixPQUFPLEVBQUUsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFO0lBQzVCLElBQUksRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRTtJQUM3QyxRQUFRLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUU7SUFDNUMsSUFBSSxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTtJQUN4QixJQUFJLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUU7SUFDcEQsSUFBSSxFQUFFLEVBQUU7SUFDUixNQUFNLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFO0lBQzFCLEtBQUssRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUU7SUFDekIsTUFBTSxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTtJQUMxQixJQUFJLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFO0lBQ3hCLFFBQVEsRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUU7SUFDNUIsSUFBSSxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFO0NBQ3pDLENBQUM7QUFFRjs7OztHQUlHO0FBQ0gsU0FBd0IsYUFBYSxDQUFDLElBQWU7SUFDbkQsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDeEIsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLElBQUksQ0FBQztRQUVwQixPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsSUFBSSxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztJQUNqRixDQUFDO0lBRUQsbUdBQW1HO0lBQ25HLG9HQUFvRztJQUNwRyw0RkFBNEY7SUFDNUYsSUFBSSxPQUFPLElBQUksS0FBSyxRQUFRLElBQUksSUFBSSxLQUFLLElBQUksSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1FBQzVFLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUM5QixLQUFLLENBQUMsRUFBRSxDQUFDLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxLQUFLLEtBQUssSUFBSSxJQUFJLE9BQU8sS0FBSyxDQUFDLEtBQUssS0FBSyxRQUFRLENBQ3hGLENBQUM7UUFFRixPQUFPO1lBQ0wsSUFBSSxFQUFFLFFBQVE7WUFDZCxVQUFVLEVBQUUsTUFBTSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsS0FBSyxFQUFFLGFBQWEsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQzdGLENBQUM7SUFDSixDQUFDO0lBRUQsT0FBTyxPQUFPLElBQUksS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO0FBQ3ZFLENBQUMifQ==

package/dist/openapi/names.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Collection, relation and action names are arbitrary customer strings: spaces, dots, slashes,
+ * accents. A path segment carries them URL-encoded, but an `operationId` cannot — redocly rejects a
+ * non-URL-safe one, and a codegen tool turns it into a method name. So identifiers are sanitized,
+ * and the exact name is carried in prose instead.
+ */
+export declare function sanitizeIdentifier(raw: string): string;
+/**
+ * Hands out unique sanitized identifiers. Sanitizing collapses distinct names (`Mark as paid` and
+ * `Mark-as-paid` both become `Mark_as_paid`), so the second one gets a numeric suffix. Callers must
+ * feed names in a stable order — the suffix depends on it, and two runs over one schema have to
+ * produce the same document.
+ */
+export type Namer = (raw: string) => string;
+export default function createNamer(): Namer;
+//# sourceMappingURL=names.d.ts.map

package/dist/openapi/names.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeIdentifier = sanitizeIdentifier;
+exports.default = createNamer;
+/**
+ * Collection, relation and action names are arbitrary customer strings: spaces, dots, slashes,
+ * accents. A path segment carries them URL-encoded, but an `operationId` cannot — redocly rejects a
+ * non-URL-safe one, and a codegen tool turns it into a method name. So identifiers are sanitized,
+ * and the exact name is carried in prose instead.
+ */
+function sanitizeIdentifier(raw) {
+    return raw.replace(/[^A-Za-z0-9_]/g, '_') || '_';
+}
+function createNamer() {
+    const used = new Set();
+    return (raw) => {
+        const base = sanitizeIdentifier(raw);
+        let candidate = base;
+        let counter = 2;
+        while (used.has(candidate)) {
+            candidate = `${base}_${counter}`;
+            counter += 1;
+        }
+        used.add(candidate);
+        return candidate;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmFtZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3BlbmFwaS9uYW1lcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLGdEQUVDO0FBVUQsOEJBaUJDO0FBbkNEOzs7OztHQUtHO0FBQ0gsU0FBZ0Isa0JBQWtCLENBQUMsR0FBVztJQUM1QyxPQUFPLEdBQUcsQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLEVBQUUsR0FBRyxDQUFDLElBQUksR0FBRyxDQUFDO0FBQ25ELENBQUM7QUFVRCxTQUF3QixXQUFXO0lBQ2pDLE1BQU0sSUFBSSxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7SUFFL0IsT0FBTyxDQUFDLEdBQVcsRUFBVSxFQUFFO1FBQzdCLE1BQU0sSUFBSSxHQUFHLGtCQUFrQixDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3JDLElBQUksU0FBUyxHQUFHLElBQUksQ0FBQztRQUNyQixJQUFJLE9BQU8sR0FBRyxDQUFDLENBQUM7UUFFaEIsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUM7WUFDM0IsU0FBUyxHQUFHLEdBQUcsSUFBSSxJQUFJLE9BQU8sRUFBRSxDQUFDO1lBQ2pDLE9BQU8sSUFBSSxDQUFDLENBQUM7UUFDZixDQUFDO1FBRUQsSUFBSSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUVwQixPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDLENBQUM7QUFDSixDQUFDIn0=

package/dist/openapi/openapi-document.d.ts

@@ -1,6 +1,7 @@
+import type { Unfolding } from './unfolding';
 import type { OpenAPIObject } from 'openapi3-ts/oas31';
 export declare const OPENAPI_VERSION = "3.1.0";
 export declare const ROUTE_PREFIX = "/agent/v1";
-export declare function generateOpenApiDocument(version: string): OpenAPIObject;
+export declare function generateOpenApiDocument(version: string, unfolding?: Unfolding): OpenAPIObject;
 export declare function serializeOpenApi(document: OpenAPIObject): string;
 //# sourceMappingURL=openapi-document.d.ts.map

package/dist/openapi/openapi-document.js

@@ -7,7 +7,9 @@ exports.ROUTE_PREFIX = exports.OPENAPI_VERSION = void 0;
 exports.generateOpenApiDocument = generateOpenApiDocument;
 exports.serializeOpenApi = serializeOpenApi;
 const zod_to_openapi_1 = require("@asteasolutions/zod-to-openapi");
+const component_pool_1 = __importDefault(require("./component-pool"));
 const schemas_1 = require("./schemas");
+const unfolded_paths_1 = __importDefault(require("./unfolded-paths"));
 const zod_openapi_1 = require("./zod-openapi");
 const body_limit_1 = __importDefault(require("../http/body-limit"));
 exports.OPENAPI_VERSION = '3.1.0';
@@ -31,39 +33,53 @@ const ERROR_STATUSES = {
 };
 const UNSUPPORTED_RESULT_DESCRIPTION = 'Either the BFF runs without an agent configured, or the action returned a result shape the ' +
     'BFF cannot normalize. The second case carries no message field.';
-function errorResponses(statuses, executeResults) {
-    return Object.fromEntries(statuses.map(status => {
+const ERROR_RESPONSE_REF = '#/components/schemas/ErrorResponse';
+const MESSAGELESS_ERROR_RESPONSE_REF = '#/components/schemas/MessagelessErrorResponse';
+const UNSUPPORTED_ACTION_RESULT_COMPONENT = 'UnsupportedActionResult';
+const RETRY_AFTER_HEADER = {
+    'Retry-After': {
+        description: 'Seconds to wait before retrying. Set when the API key could not be resolved.',
+        required: false,
+        schema: { type: 'integer' },
+    },
+};
+// Every error body is identical across paths, and their descriptions are long: inlining them costs
+// ~2.8kB per path, which the unfolded document multiplies by every collection, relation and action.
+// Registering them once as components keeps a path's error block to a dozen refs.
+function registerErrorResponses(registry, statuses, withActionResults) {
+    registry.register('ErrorResponse', schemas_1.ErrorResponseSchema);
+    const byStatus = {};
+    statuses.forEach(status => {
         const description = ERROR_STATUSES[status];
         if (!description)
             throw new Error(`No OpenAPI description for error status ${status}`);
-        if (status === '501' && executeResults) {
-            return [
-                status,
-                {
-                    description: UNSUPPORTED_RESULT_DESCRIPTION,
-                    content: {
-                        'application/json': {
-                            schema: zod_openapi_1.z.union([schemas_1.ErrorResponseSchema, schemas_1.MessagelessErrorResponseSchema]),
-                        },
-                    },
-                },
-            ];
-        }
-        const response = {
+        byStatus[status] = registry.registerComponent('responses', `Error${status}`, {
             description,
-            content: { 'application/json': { schema: schemas_1.ErrorResponseSchema } },
-        };
-        if (status === '503') {
-            response.headers = {
-                'Retry-After': {
-                    description: 'Seconds to wait before retrying. Set when the API key could not be resolved.',
-                    required: false,
-                    schema: { type: 'integer' },
+            content: { 'application/json': { schema: { $ref: ERROR_RESPONSE_REF } } },
+            ...(status === '503' ? { headers: RETRY_AFTER_HEADER } : {}),
+        }).ref;
+    });
+    // A document with no action path must not carry this response, nor the messageless body it
+    // references: an unreferenced component trips redocly's unused-component rule.
+    if (!withActionResults)
+        return { byStatus, unsupportedActionResult: byStatus['501'] };
+    registry.register('MessagelessErrorResponse', schemas_1.MessagelessErrorResponseSchema);
+    const unsupportedActionResult = registry.registerComponent('responses', UNSUPPORTED_ACTION_RESULT_COMPONENT, {
+        description: UNSUPPORTED_RESULT_DESCRIPTION,
+        content: {
+            'application/json': {
+                schema: {
+                    anyOf: [{ $ref: ERROR_RESPONSE_REF }, { $ref: MESSAGELESS_ERROR_RESPONSE_REF }],
                 },
-            };
-        }
-        return [status, response];
-    }));
+            },
+        },
+    }).ref;
+    return { byStatus, unsupportedActionResult };
+}
+function errorResponses(refs, executeResults) {
+    return executeResults
+        ? { ...refs.byStatus, 501: refs.unsupportedActionResult }
+        : { ...refs.byStatus };
 }
 const DATA_ERRORS = [
     '400',
@@ -148,17 +164,42 @@ const PARAM_DESCRIPTIONS = {
 function buildParams(names) {
     return zod_openapi_1.z.object(Object.fromEntries(names.map(name => [name, zod_openapi_1.z.string().openapi({ description: PARAM_DESCRIPTIONS[name] })])));
 }
-const TIMEZONE_HEADER_PARAM = zod_openapi_1.z.object({
-    'X-Forest-Timezone': zod_openapi_1.z
-        .string()
-        .optional()
-        .openapi({
-        description: 'An IANA timezone. Takes precedence over the `timezone` body field; the BFF default ' +
-            'applies when neither is sent.',
-    }),
+// Registered as a parameter component rather than inlined: it is the same header on every path, and
+// its description costs a quarter of a path once the error responses are refs.
+const TIMEZONE_HEADER_COMPONENT = 'XForestTimezone';
+const TIMEZONE_HEADER = zod_openapi_1.z
+    .string()
+    .optional()
+    .openapi({
+    param: { name: 'X-Forest-Timezone', in: 'header' },
+    description: 'An IANA timezone. Takes precedence over the `timezone` body field; the BFF default ' +
+        'applies when neither is sent.',
 });
-function generateOpenApiDocument(version) {
+const SHARED_DESCRIPTION = 'The timezone is resolved from the `X-Forest-Timezone` header first, then a `timezone` body ' +
+    'field, then the BFF default when one is configured. A deployment without a default rejects a ' +
+    'request carrying neither with 400 missing_timezone, so send one of the two to be safe. Sending ' +
+    'a content type other than application/json is not an error: a form-urlencoded body is parsed ' +
+    'like JSON, while any other content type is read as absent, which silently drops any filter, ' +
+    'sort, or page.';
+const GENERIC_DESCRIPTION = 'Paths are generic: one per operation, with the collection, relation and action passed as path ' +
+    'segments, and no field enumerated. This is the fallback form — a deployment configured to ' +
+    'reach its Forest schema and its agent unfolds one path per real collection, relation and ' +
+    'action instead, each carrying its own field set.';
+const UNFOLDED_DESCRIPTION = 'Paths are unfolded: one per exposed collection, to-many relation and action, each carrying the ' +
+    "collection's real field set. The RUNTIME routes stay generic — a path here is the generic " +
+    'route with its segments already filled in, so the collection, relation and action segments are ' +
+    'the exact schema names, URL-encoded. Every operationId is sanitized to stay usable as a ' +
+    'method name, so the exact name lives in the summary and description. A path whose fields are ' +
+    'not enumerated says so in its request description: the document was built without that ' +
+    "collection's capabilities. Only to-many relations appear; a to-one or polymorphic relation has " +
+    'no list or count route. This document describes the whole exposed schema regardless of the ' +
+    'caller: it is not filtered by the permissions of whoever fetched it.';
+function generateOpenApiDocument(version, unfolding) {
     const registry = new zod_to_openapi_1.OpenAPIRegistry();
+    const hasActions = unfolding === undefined ||
+        unfolding.collections.some(collection => collection.actions.length > 0);
+    const errorRefs = registerErrorResponses(registry, DATA_ERRORS, hasActions);
+    const timezoneHeader = [registry.registerParameter(TIMEZONE_HEADER_COMPONENT, TIMEZONE_HEADER)];
     registry.registerComponent('securitySchemes', SESSION_SCHEME, {
         type: 'http',
         scheme: 'bearer',
@@ -172,44 +213,49 @@ function generateOpenApiDocument(version) {
         name: 'X-Forest-Bff-Key',
         description: 'Mode 2: a BFF API key. Never send both this and an Authorization header.',
     });
-    ROUTES.forEach(route => {
-        registry.registerPath({
-            method: 'post',
-            path: `${exports.ROUTE_PREFIX}${route.path}`,
-            operationId: route.operationId,
-            summary: route.summary,
+    if (unfolding) {
+        (0, unfolded_paths_1.default)({
+            registry,
+            pool: new component_pool_1.default(registry),
+            prefix: exports.ROUTE_PREFIX,
             security: SECURITY,
-            request: {
-                params: buildParams(route.params),
-                headers: TIMEZONE_HEADER_PARAM,
-                body: {
-                    required: route.bodyRequired === true,
-                    content: { 'application/json': { schema: route.request } },
+            timezoneHeader,
+            errorResponses: executeResults => errorResponses(errorRefs, executeResults),
+        }, unfolding);
+    }
+    else {
+        ROUTES.forEach(route => {
+            registry.registerPath({
+                method: 'post',
+                path: `${exports.ROUTE_PREFIX}${route.path}`,
+                operationId: route.operationId,
+                summary: route.summary,
+                security: SECURITY,
+                request: {
+                    params: buildParams(route.params),
+                    headers: timezoneHeader,
+                    body: {
+                        required: route.bodyRequired === true,
+                        content: { 'application/json': { schema: route.request } },
+                    },
                 },
-            },
-            responses: {
-                200: {
-                    description: route.responseDescription,
-                    content: { 'application/json': { schema: route.response } },
+                responses: {
+                    200: {
+                        description: route.responseDescription,
+                        content: { 'application/json': { schema: route.response } },
+                    },
+                    ...errorResponses(errorRefs, route.executeResults === true),
                 },
-                ...errorResponses(DATA_ERRORS, route.executeResults === true),
-            },
+            });
         });
-    });
+    }
     return new zod_to_openapi_1.OpenApiGeneratorV31(registry.definitions).generateDocument({
         openapi: exports.OPENAPI_VERSION,
         info: {
             title: 'Forest Admin BFF',
             version,
             license: { name: 'GPL-3.0', url: 'https://www.gnu.org/licenses/gpl-3.0.html' },
-            description: 'Runtime routes are generic: one path per operation, with the collection, relation and ' +
-                'action passed as path segments. The timezone is resolved from the `X-Forest-Timezone` ' +
-                'header first, then a `timezone` body field, then the BFF default when one is ' +
-                'configured. A deployment without a default rejects a request carrying neither with ' +
-                '400 missing_timezone, so send one of the two to be safe. Sending a content type other ' +
-                'than application/json is not an error: a form-urlencoded body is parsed like JSON, ' +
-                'while any other content type is read as absent, which silently drops any filter, ' +
-                'sort, or page.',
+            description: `${unfolding ? UNFOLDED_DESCRIPTION : GENERIC_DESCRIPTION} ${SHARED_DESCRIPTION}`,
         },
         servers: [{ url: '/' }],
     });
@@ -217,4 +263,4 @@ function generateOpenApiDocument(version) {
 function serializeOpenApi(document) {
     return JSON.stringify(document, null, 2);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlbmFwaS1kb2N1bWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcGVuYXBpL29wZW5hcGktZG9jdW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBeU1BLDBEQTZEQztBQUVELDRDQUVDO0FBeFFELG1FQUFzRjtBQUV0Rix1Q0FVbUI7QUFDbkIsK0NBQWtDO0FBQ2xDLG9FQUE0QztBQUUvQixRQUFBLGVBQWUsR0FBRyxPQUFPLENBQUM7QUFDMUIsUUFBQSxZQUFZLEdBQUcsV0FBVyxDQUFDO0FBRXhDLE1BQU0sY0FBYyxHQUFHLFlBQVksQ0FBQztBQUNwQyxNQUFNLGNBQWMsR0FBRyxXQUFXLENBQUM7QUFFbkMsTUFBTSxRQUFRLEdBQUcsQ0FBQyxFQUFFLENBQUMsY0FBYyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztBQUU1QyxNQUFNLGNBQWMsR0FBMkI7SUFDN0MsR0FBRyxFQUFFLHlRQUF5UTtJQUM5USxHQUFHLEVBQUUsMENBQTBDO0lBQy9DLEdBQUcsRUFBRSwwT0FBME87SUFDL08sR0FBRyxFQUFFLHlDQUF5QztJQUM5QyxHQUFHLEVBQUUsNkNBQTZDLG9CQUFVLEVBQUU7SUFDOUQsR0FBRyxFQUFFLDJWQUEyVjtJQUNoVyxHQUFHLEVBQUUsa0VBQWtFO0lBQ3ZFLEdBQUcsRUFBRSxvQ0FBb0M7SUFDekMsR0FBRyxFQUFFLDJEQUEyRDtJQUNoRSxHQUFHLEVBQUUsaUZBQWlGO0lBQ3RGLEdBQUcsRUFBRSxnQ0FBZ0M7SUFDckMsR0FBRyxFQUFFLGlHQUFpRztDQUN2RyxDQUFDO0FBRUYsTUFBTSw4QkFBOEIsR0FDbEMsNkZBQTZGO0lBQzdGLGlFQUFpRSxDQUFDO0FBRXBFLFNBQVMsY0FBYyxDQUFDLFFBQWtCLEVBQUUsY0FBdUI7SUFDakUsT0FBTyxNQUFNLENBQUMsV0FBVyxDQUN2QixRQUFRLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFO1FBQ3BCLE1BQU0sV0FBVyxHQUFHLGNBQWMsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUUzQyxJQUFJLENBQUMsV0FBVztZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsMkNBQTJDLE1BQU0sRUFBRSxDQUFDLENBQUM7UUFFdkYsSUFBSSxNQUFNLEtBQUssS0FBSyxJQUFJLGNBQWMsRUFBRSxDQUFDO1lBQ3ZDLE9BQU87Z0JBQ0wsTUFBTTtnQkFDTjtvQkFDRSxXQUFXLEVBQUUsOEJBQThCO29CQUMzQyxPQUFPLEVBQUU7d0JBQ1Asa0JBQWtCLEVBQUU7NEJBQ2xCLE1BQU0sRUFBRSxlQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsNkJBQW1CLEVBQUUsd0NBQThCLENBQUMsQ0FBQzt5QkFDdkU7cUJBQ0Y7aUJBQ0Y7YUFDRixDQUFDO1FBQ0osQ0FBQztRQUVELE1BQU0sUUFBUSxHQUE0QjtZQUN4QyxXQUFXO1lBQ1gsT0FBTyxFQUFFLEVBQUUsa0JBQWtCLEVBQUUsRUFBRSxNQUFNLEVBQUUsNkJBQW1CLEVBQUUsRUFBRTtTQUNqRSxDQUFDO1FBRUYsSUFBSSxNQUFNLEtBQUssS0FBSyxFQUFFLENBQUM7WUFDckIsUUFBUSxDQUFDLE9BQU8sR0FBRztnQkFDakIsYUFBYSxFQUFFO29CQUNiLFdBQVcsRUFDVCw4RUFBOEU7b0JBQ2hGLFFBQVEsRUFBRSxLQUFLO29CQUNmLE1BQU0sRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUU7aUJBQzVCO2FBQ0YsQ0FBQztRQUNKLENBQUM7UUFFRCxPQUFPLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQzVCLENBQUMsQ0FBQyxDQUNILENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxXQUFXLEdBQUc7SUFDbEIsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0NBQ04sQ0FBQztBQWNGLE1BQU0sTUFBTSxHQUFzQjtJQUNoQztRQUNFLElBQUksRUFBRSxvQkFBb0I7UUFDMUIsV0FBVyxFQUFFLGFBQWE7UUFDMUIsT0FBTyxFQUFFLDhCQUE4QjtRQUN2QyxPQUFPLEVBQUUsMkJBQWlCO1FBQzFCLFFBQVEsRUFBRSw0QkFBa0I7UUFDNUIsbUJBQW1CLEVBQUUsbUJBQW1CO1FBQ3hDLE1BQU0sRUFBRSxDQUFDLFlBQVksQ0FBQztLQUN2QjtJQUNEO1FBQ0UsSUFBSSxFQUFFLHFCQUFxQjtRQUMzQixXQUFXLEVBQUUsY0FBYztRQUMzQixPQUFPLEVBQUUsK0JBQStCO1FBQ3hDLE9BQU8sRUFBRSw0QkFBa0I7UUFDM0IsUUFBUSxFQUFFLDZCQUFtQjtRQUM3QixtQkFBbUIsRUFBRSwyQkFBMkI7UUFDaEQsTUFBTSxFQUFFLENBQUMsWUFBWSxDQUFDO0tBQ3ZCO0lBQ0Q7UUFDRSxJQUFJLEVBQUUseUNBQXlDO1FBQy9DLFdBQVcsRUFBRSxvQkFBb0I7UUFDakMsT0FBTyxFQUFFLG9DQUFvQztRQUM3QyxPQUFPLEVBQUUsbUNBQXlCO1FBQ2xDLFFBQVEsRUFBRSw0QkFBa0I7UUFDNUIsbUJBQW1CLEVBQUUsMkJBQTJCO1FBQ2hELE1BQU0sRUFBRSxDQUFDLFlBQVksRUFBRSxVQUFVLENBQUM7UUFDbEMsWUFBWSxFQUFFLElBQUk7S0FDbkI7SUFDRDtRQUNFLElBQUksRUFBRSwwQ0FBMEM7UUFDaEQsV0FBVyxFQUFFLHFCQUFxQjtRQUNsQyxPQUFPLEVBQUUscUNBQXFDO1FBQzlDLE9BQU8sRUFBRSxvQ0FBMEI7UUFDbkMsUUFBUSxFQUFFLDZCQUFtQjtRQUM3QixtQkFBbUIsRUFBRSxtQ0FBbUM7UUFDeEQsTUFBTSxFQUFFLENBQUMsWUFBWSxFQUFFLFVBQVUsQ0FBQztRQUNsQyxZQUFZLEVBQUUsSUFBSTtLQUNuQjtJQUNEO1FBQ0UsSUFBSSxFQUFFLHFDQUFxQztRQUMzQyxXQUFXLEVBQUUsZUFBZTtRQUM1QixPQUFPLEVBQUUsa0NBQWtDO1FBQzNDLE9BQU8sRUFBRSw2QkFBbUI7UUFDNUIsUUFBUSxFQUFFLGVBQUMsQ0FBQyxPQUFPLEVBQUU7UUFDckIsbUJBQW1CLEVBQUUsd0JBQXdCO1FBQzdDLE1BQU0sRUFBRSxDQUFDLFlBQVksRUFBRSxRQUFRLENBQUM7UUFDaEMsWUFBWSxFQUFFLElBQUk7S0FDbkI7SUFDRDtRQUNFLElBQUksRUFBRSx3Q0FBd0M7UUFDOUMsV0FBVyxFQUFFLGVBQWU7UUFDNUIsT0FBTyxFQUFFLHlCQUF5QjtRQUNsQyxPQUFPLEVBQUUsNkJBQW1CO1FBQzVCLFFBQVEsRUFBRSxlQUFDLENBQUMsT0FBTyxFQUFFO1FBQ3JCLG1CQUFtQixFQUFFLDhCQUE4QjtRQUNuRCxNQUFNLEVBQUUsQ0FBQyxZQUFZLEVBQUUsUUFBUSxDQUFDO1FBQ2hDLFlBQVksRUFBRSxJQUFJO1FBQ2xCLGNBQWMsRUFBRSxJQUFJO0tBQ3JCO0NBQ0YsQ0FBQztBQUVGLE1BQU0sa0JBQWtCLEdBQTJCO0lBQ2pELFVBQVUsRUFBRSxrREFBa0Q7SUFDOUQsUUFBUSxFQUFFLHdFQUF3RTtJQUNsRixNQUFNLEVBQUUscUZBQXFGO0NBQzlGLENBQUM7QUFFRixTQUFTLFdBQVcsQ0FBQyxLQUFlO0lBQ2xDLE9BQU8sZUFBQyxDQUFDLE1BQU0sQ0FDYixNQUFNLENBQUMsV0FBVyxDQUNoQixLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxJQUFJLEVBQUUsZUFBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLE9BQU8sQ0FBQyxFQUFFLFdBQVcsRUFBRSxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUN6RixDQUNGLENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxxQkFBcUIsR0FBRyxlQUFDLENBQUMsTUFBTSxDQUFDO0lBQ3JDLG1CQUFtQixFQUFFLGVBQUM7U0FDbkIsTUFBTSxFQUFFO1NBQ1IsUUFBUSxFQUFFO1NBQ1YsT0FBTyxDQUFDO1FBQ1AsV0FBVyxFQUNULHFGQUFxRjtZQUNyRiwrQkFBK0I7S0FDbEMsQ0FBQztDQUNMLENBQUMsQ0FBQztBQUVILFNBQWdCLHVCQUF1QixDQUFDLE9BQWU7SUFDckQsTUFBTSxRQUFRLEdBQUcsSUFBSSxnQ0FBZSxFQUFFLENBQUM7SUFFdkMsUUFBUSxDQUFDLGlCQUFpQixDQUFDLGlCQUFpQixFQUFFLGNBQWMsRUFBRTtRQUM1RCxJQUFJLEVBQUUsTUFBTTtRQUNaLE1BQU0sRUFBRSxRQUFRO1FBQ2hCLFdBQVcsRUFDVCwwRkFBMEY7WUFDMUYsdUZBQXVGO1lBQ3ZGLHVFQUF1RTtLQUMxRSxDQUFDLENBQUM7SUFDSCxRQUFRLENBQUMsaUJBQWlCLENBQUMsaUJBQWlCLEVBQUUsY0FBYyxFQUFFO1FBQzVELElBQUksRUFBRSxRQUFRO1FBQ2QsRUFBRSxFQUFFLFFBQVE7UUFDWixJQUFJLEVBQUUsa0JBQWtCO1FBQ3hCLFdBQVcsRUFBRSwwRUFBMEU7S0FDeEYsQ0FBQyxDQUFDO0lBRUgsTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUNyQixRQUFRLENBQUMsWUFBWSxDQUFDO1lBQ3BCLE1BQU0sRUFBRSxNQUFNO1lBQ2QsSUFBSSxFQUFFLEdBQUcsb0JBQVksR0FBRyxLQUFLLENBQUMsSUFBSSxFQUFFO1lBQ3BDLFdBQVcsRUFBRSxLQUFLLENBQUMsV0FBVztZQUM5QixPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU87WUFDdEIsUUFBUSxFQUFFLFFBQVE7WUFDbEIsT0FBTyxFQUFFO2dCQUNQLE1BQU0sRUFBRSxXQUFXLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQztnQkFDakMsT0FBTyxFQUFFLHFCQUFxQjtnQkFDOUIsSUFBSSxFQUFFO29CQUNKLFFBQVEsRUFBRSxLQUFLLENBQUMsWUFBWSxLQUFLLElBQUk7b0JBQ3JDLE9BQU8sRUFBRSxFQUFFLGtCQUFrQixFQUFFLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxPQUFPLEVBQUUsRUFBRTtpQkFDM0Q7YUFDRjtZQUNELFNBQVMsRUFBRTtnQkFDVCxHQUFHLEVBQUU7b0JBQ0gsV0FBVyxFQUFFLEtBQUssQ0FBQyxtQkFBbUI7b0JBQ3RDLE9BQU8sRUFBRSxFQUFFLGtCQUFrQixFQUFFLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxRQUFRLEVBQUUsRUFBRTtpQkFDNUQ7Z0JBQ0QsR0FBRyxjQUFjLENBQUMsV0FBVyxFQUFFLEtBQUssQ0FBQyxjQUFjLEtBQUssSUFBSSxDQUFDO2FBQzlEO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUFDLENBQUM7SUFFSCxPQUFPLElBQUksb0NBQW1CLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxDQUFDLGdCQUFnQixDQUFDO1FBQ3BFLE9BQU8sRUFBRSx1QkFBZTtRQUN4QixJQUFJLEVBQUU7WUFDSixLQUFLLEVBQUUsa0JBQWtCO1lBQ3pCLE9BQU87WUFDUCxPQUFPLEVBQUUsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEdBQUcsRUFBRSwyQ0FBMkMsRUFBRTtZQUM5RSxXQUFXLEVBQ1Qsd0ZBQXdGO2dCQUN4Rix3RkFBd0Y7Z0JBQ3hGLCtFQUErRTtnQkFDL0UscUZBQXFGO2dCQUNyRix3RkFBd0Y7Z0JBQ3hGLHFGQUFxRjtnQkFDckYsbUZBQW1GO2dCQUNuRixnQkFBZ0I7U0FDbkI7UUFDRCxPQUFPLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsQ0FBQztLQUN4QixDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsU0FBZ0IsZ0JBQWdCLENBQUMsUUFBdUI7SUFDdEQsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDM0MsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openapi-document.js","sourceRoot":"","sources":["../../src/openapi/openapi-document.ts"],"names":[],"mappings":"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"}

package/dist/openapi/openapi-routes.d.ts

@@ -1,8 +1,11 @@
+import type { UnfoldSource } from './unfolded-document';
 import type { Middleware } from 'koa';
 export declare const OPENAPI_PATH = "/agent/openapi.json";
 export interface OpenApiRoutesOptions {
     version: string;
     enabled: boolean;
+    /** Absent (no agent or no read-model configuration) serves the generic document. */
+    source?: UnfoldSource;
 }
-export default function createOpenApiRoutes({ version, enabled, }: OpenApiRoutesOptions): Middleware;
+export default function createOpenApiRoutes({ version, enabled, source, }: OpenApiRoutesOptions): Middleware;
 //# sourceMappingURL=openapi-routes.d.ts.map