@zackbart/connecta 0.34.1 → 0.35.0

package/dist/http/tools.js

@@ -0,0 +1,383 @@
+// Provider kit (decision 0010, B.4). Unreachable from src/index.ts.
+//
+// Tool builders. A tool is a name, a description, an input Schema, an output
+// Schema, and a program; the builder renders both Schemas as catalog JSON
+// Schema and annotates the tool from which builder was called (never from an
+// HTTP method). At run time the call's served classification decides, so a
+// deployment that reclassifies a tool is obeyed by the transport and the
+// write-outcome rule alike. Failures leave through the one mapping in
+// src/http/errors.ts.
+//
+// The result is an ordinary `ApiTool`, so a kit tool sits in `api()` beside
+// hand-written ones and keeps every guarantee `api()` already gives:
+// argument validation, sent-secret redaction, withheld handler text. Its
+// boundary also decides every write's outcome, from the core ledger the kit's
+// transport records into, so a kit connector declares `tracksEveryRequest`.
+import { Context, Effect, Schema } from "effect";
+import { inLogicalCall } from "../provider-call.js";
+import { registerToolEntry } from "../runtime/call-entry.js";
+import { ConnectorCallError } from "../errors.js";
+import { refuseWithheldValues } from "../providers/_shared/rest/value-safety.js";
+import { causeError, runEdge } from "../runtime/run.js";
+import { recordUnauthorized, Refusal, RequestRefused, toConnectorCallError, withheldDefect, } from "./errors.js";
+import { fieldsInput, fieldsProblem, selectFields } from "./fields.js";
+import { catalogSchema, Integer } from "./json-schema.js";
+import { boundCursor, Cursor, PageInfo, StandardPage } from "./paging.js";
+import { Classification, Dispatches, IdempotencyKey, Recovery, ReadTool, WriteCapacity, writeRequestKey, fromConnectorContext, } from "./services.js";
+const inputs = new WeakMap();
+const keyed = new WeakSet();
+/** Whether a kit write builder declared an idempotency key for this tool. */
+export function takesIdempotencyKey(tool) {
+    return keyed.has(tool);
+}
+/** Copy decoded values only; the input supplies key order, never values or admission. */
+function originalOrder(decoded, original) {
+    const copies = new WeakMap();
+    const copy = (value, source) => {
+        if (value === source || value === null || typeof value !== "object")
+            return value;
+        if (copies.has(value))
+            return copies.get(value);
+        if (Array.isArray(value)) {
+            const out = [];
+            copies.set(value, out);
+            value.forEach((item, index) => out.push(copy(item, Array.isArray(source) ? source[index] : undefined)));
+            return out;
+        }
+        const values = value;
+        const keys = source !== null && typeof source === "object" && !Array.isArray(source) ? Object.keys(source) : [];
+        const present = keys.filter((key) => Object.hasOwn(values, key));
+        const ordered = new Set(present);
+        const out = {};
+        copies.set(value, out);
+        for (const key of [...present, ...Object.keys(values).filter((key) => !ordered.has(key))]) {
+            Object.defineProperty(out, key, {
+                value: copy(values[key], source !== null && typeof source === "object" ? source[key] : undefined),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        }
+        return out;
+    };
+    return copy(decoded, original);
+}
+/** The input Schema a kit tool decodes with, for the catalog/decoder agreement check. */
+export function kitInput(tool) {
+    return inputs.get(tool);
+}
+/** A Struct's own property names, for `fields`. */
+function propertyNames(schema, what) {
+    const fields = schema.fields;
+    if (!fields)
+        throw new Error(`fields needs ${what} declared as a Schema.Struct.`);
+    return new Set(Object.keys(fields));
+}
+/** Refuse a bad `fields` path before anything is sent. */
+function checkFields(fields, names, of) {
+    const error = fieldsProblem(fields, names, of);
+    return error ? Effect.fail(new Refusal({ error })) : Effect.void;
+}
+const fieldsExample = (names) => {
+    const first = [...names][0];
+    return first === undefined ? "" : `, e.g. ["${first}"]`;
+};
+/**
+ * A read: admitted to call_tool and programs. `fields: true` (decision 0011
+ * S5) appends a `fields` argument that narrows the returned record; the input
+ * and output must then be Structs, and a path outside the output's properties
+ * is refused before anything is sent.
+ */
+export function read(connection, spec) {
+    if (spec.review !== undefined && !spec.review.trim())
+        throw new Error("A read review must be nonempty.");
+    if (spec.fields === undefined)
+        return build(connection, spec, "read", { readOnlyHint: true }, undefined, spec.review);
+    const names = propertyNames(spec.output, "the output");
+    propertyNames(spec.input, "the input");
+    const input = Schema.Struct({
+        ...spec.input.fields,
+        fields: Schema.optionalKey(fieldsInput(`Dot paths to keep in the result${fieldsExample(names)}. It only narrows the result.`)),
+    });
+    return build(connection, {
+        ...spec,
+        input,
+        run: (args) => Effect.gen(function* () {
+            yield* checkFields(args.fields, names, "the result");
+            const { fields, ...rest } = args;
+            return selectFields(yield* spec.run(rest), fields);
+        }),
+        // A selection may omit any property: the result is typed unknown and rendered sparse.
+        output: Schema.Unknown,
+    }, "read", { readOnlyHint: true }, undefined, spec.review, sparse(catalogSchema(spec.output, "output")));
+}
+/** Fetch one entity with the same read contract as a list. */
+export function get(connection, spec) {
+    return read(connection, spec);
+}
+export function list(connection, spec) {
+    if (spec.cursor !== undefined && spec.cursor !== "plain" && spec.cursor !== "bound")
+        throw new Error('A list cursor must be "plain" or "bound".');
+    if (!("key" in spec))
+        return standardList(connection, spec);
+    if (!spec.key || spec.key === "page")
+        throw new Error("A list needs a row key distinct from page.");
+    return read(connection, {
+        ...spec,
+        output: Schema.Struct({ [spec.key]: Schema.Array(spec.row), page: PageInfo }),
+        run: (args) => Effect.gen(function* () {
+            const fields = args;
+            const supplied = typeof fields.cursor === "string" ? fields.cursor : undefined;
+            const cursor = supplied !== undefined && spec.cursor === "bound"
+                ? yield* boundCursor.decode(spec.name, fields, supplied)
+                : supplied;
+            const result = yield* spec.page(args, cursor);
+            const nextCursor = result.page.nextCursor !== null && spec.cursor === "bound"
+                ? yield* boundCursor.encode(spec.name, fields, result.page.nextCursor)
+                : result.page.nextCursor;
+            return { [spec.key]: result.rows, page: { ...result.page, nextCursor } };
+        }),
+    });
+}
+function standardList(connection, spec) {
+    const { default: size, max } = spec.limit;
+    if (spec.total !== undefined && spec.total !== true)
+        throw new Error(`${spec.name} total must opt in with true for a vendor-stated exact count.`);
+    if (!Number.isSafeInteger(size) || !Number.isSafeInteger(max) || size < 1 || max < size)
+        throw new Error(`${spec.name} limit needs positive whole default and max values, with default <= max.`);
+    const values = spec.limit.values === undefined ? undefined : [...spec.limit.values];
+    if (values &&
+        (!values.length ||
+            new Set(values).size !== values.length ||
+            !values.includes(size) ||
+            values.some((value) => !Number.isSafeInteger(value) || value < 1 || value > max)))
+        throw new Error(`${spec.name} limit values must be unique positive whole sizes within max and include the default.`);
+    const limit = Integer.check(Schema.isBetween({ minimum: 1, maximum: max }));
+    const allowedLimit = values
+        ? limit.check(Schema.makeFilter((value) => values.includes(value), {
+            expected: `one of ${values.join(", ")}`,
+            toJsonSchema: () => ({ enum: [...values] }),
+        }))
+        : limit;
+    for (const name of ["limit", "cursor", "fields"]) {
+        if (name in spec.filters)
+            throw new Error(`${spec.name} filters cannot declare ${name}; the kit supplies it.`);
+    }
+    const names = propertyNames(spec.row, "the row");
+    const input = Schema.Struct({
+        ...spec.filters,
+        limit: Schema.optionalKey(allowedLimit.annotate({
+            description: spec.limit.description,
+            default: size,
+        })),
+        cursor: Schema.optionalKey(Cursor),
+        fields: Schema.optionalKey(fieldsInput(`Dot paths to keep in each item${fieldsExample(names)}. It only narrows the result.`)),
+    });
+    return build(connection, {
+        name: spec.name,
+        description: spec.description,
+        input,
+        // `fields` narrows each item, so items render sparse; the envelope keeps items and page required.
+        output: Schema.Unknown,
+        run: (args) => Effect.gen(function* () {
+            yield* checkFields(args.fields, names, "an item");
+            // A cursor stays valid when only the projection changes between pages.
+            const { fields, cursor: supplied, ...rest } = args;
+            const scope = spec.cursorScope === undefined
+                ? rest
+                : {
+                    arguments: Object.fromEntries(Object.entries(rest).filter(([key]) => key !== "limit")),
+                    deploymentPolicy: spec.cursorScope,
+                };
+            const bound = spec.cursor === "bound";
+            const cursor = typeof supplied === "string" && bound ? yield* boundCursor.decode(spec.name, scope, supplied) : supplied;
+            const result = yield* spec.page({ ...rest, limit: typeof rest["limit"] === "number" ? rest["limit"] : size }, cursor);
+            const items = selectFields(result.rows, fields);
+            const total = spec.total ? result.page.total : undefined;
+            if (total !== undefined && (!Number.isSafeInteger(total) || total < 0))
+                return yield* Effect.fail(new Refusal({
+                    error: new ConnectorCallError("connector_call_failed", "The vendor returned an invalid exact total.", {
+                        retryable: false,
+                    }),
+                }));
+            const count = total === undefined ? {} : { total };
+            if (!result.page.hasMore)
+                return { items, page: { hasMore: false, ...count } };
+            if (result.page.nextCursor === null)
+                return yield* Effect.fail(new Refusal({
+                    error: new ConnectorCallError("connector_call_failed", "The vendor reported another page without a next cursor.", { retryable: false }),
+                }));
+            const nextCursor = bound
+                ? yield* boundCursor.encode(spec.name, scope, result.page.nextCursor)
+                : result.page.nextCursor;
+            return { items, page: { hasMore: true, nextCursor, ...count } };
+        }),
+    }, "read", { readOnlyHint: true }, undefined, spec.review, sparseItems(catalogSchema(Schema.Struct({
+        items: Schema.Array(spec.row),
+        page: spec.total
+            ? Schema.Struct({
+                ...StandardPage.fields,
+                total: Schema.optionalKey(Integer.check(Schema.isGreaterThanOrEqualTo(0))),
+            })
+            : StandardPage,
+    }), "output")));
+}
+/** What a `fields` selection may return: the declared shape with no property required, at any depth. */
+function sparse(schema) {
+    // Walk schema positions deliberately: drop each `required` keyword, keep property names (a
+    // property may be called "required") and literal data (enum, const, default, examples) as is.
+    const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+    const map = (value) => object(value) ? Object.fromEntries(Object.entries(value).map(([name, child]) => [name, walk(child)])) : value;
+    const walk = (node) => {
+        if (!object(node))
+            return node;
+        return Object.fromEntries(Object.entries(node).flatMap(([key, value]) => {
+            if (key === "required")
+                return [];
+            if (["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"].includes(key))
+                return [[key, map(value)]];
+            if (["anyOf", "oneOf", "allOf", "prefixItems"].includes(key))
+                return [[key, Array.isArray(value) ? value.map(walk) : value]];
+            if (["items", "additionalProperties", "not", "if", "then", "else", "contains", "propertyNames"].includes(key))
+                return [[key, Array.isArray(value) ? value.map(walk) : walk(value)]];
+            return [[key, value]];
+        }));
+    };
+    return walk(schema);
+}
+/** A standard list's output with each item sparse. */
+function sparseItems(schema) {
+    const root = schema;
+    return {
+        ...schema,
+        properties: {
+            ...root.properties,
+            items: { ...root.properties.items, items: sparse(root.properties.items.items) },
+        },
+    };
+}
+/** A write: approval-gated, dispatched once, and its failures reported by the write-outcome rule. */
+export function write(connection, spec) {
+    return build(connection, spec, "write", {
+        readOnlyHint: false,
+        destructiveHint: spec.destructive,
+        ...(spec.idempotent === undefined ? {} : { idempotentHint: spec.idempotent }),
+    }, spec.idempotency);
+}
+/** Money, mail, and refunds are always destructive and never idempotent hints. */
+export function action(connection, spec) {
+    return build(connection, spec, "write", { readOnlyHint: false, destructiveHint: true, idempotentHint: false });
+}
+/**
+ * A key the transport may send: not blank, and only characters an HTTP
+ * header carries. The REST layer refuses the same keys before dispatch.
+ */
+function unsendableKey(key) {
+    return key.trim() === "" || !/^[\t\x20-\x7e\x80-\xff]*$/.test(key);
+}
+function build(connection, spec, verdict, annotations, idempotency, review, 
+/** A rendered output schema that replaces the Schema's, for sparse `fields` results. */
+rendered) {
+    // One key protects one request: a tool with several write steps cannot share it.
+    const declared = Object.entries(spec.writeSteps ?? { write: "once" });
+    if (idempotency && (declared.length !== 1 || declared[0]?.[1] !== "once" || !idempotency.header.trim())) {
+        throw new Error("An idempotency key needs a header name and a tool with one write step sent once.");
+    }
+    if (idempotency) {
+        try {
+            new Headers([[idempotency.header, "key"]]);
+        }
+        catch {
+            throw new Error("An idempotency key needs a valid HTTP header name.");
+        }
+    }
+    // Snapshot the declaration now; mutations and retries cannot add step names or increase bounds.
+    const steps = Object.entries(spec.writeSteps ?? { write: "once" }).map(([name, declaration]) => {
+        if (!name ||
+            (declaration !== "once" &&
+                (!Number.isSafeInteger(declaration.maxItems) ||
+                    declaration.maxItems < 1 ||
+                    typeof declaration.items !== "function" ||
+                    typeof declaration.request !== "function"))) {
+            throw new Error("Write steps need nonempty names and a positive whole maxItems bound.");
+        }
+        return [name, declaration === "once" ? declaration : { ...declaration }];
+    });
+    const capacity = (args) => {
+        const identities = new Set();
+        return new Map(steps.map(([name, declaration]) => {
+            if (declaration === "once")
+                return [name, new Map([[undefined, undefined]])];
+            const items = [...declaration.items(args)];
+            if (items.length > declaration.maxItems ||
+                items.some((item) => typeof item !== "string" || item.length === 0) ||
+                new Set(items).size !== items.length) {
+                throw new Error("Write item identities must be unique nonempty strings within the declared maxItems bound.");
+            }
+            const requests = items.map((item) => {
+                // Copy identifying content: a retained mutable object cannot change its request later.
+                const request = structuredClone(declaration.request(item, args));
+                const key = writeRequestKey(request);
+                if (identities.has(key))
+                    throw new Error("Write item aliases must not identify identical request content.");
+                identities.add(key);
+                return [item, request];
+            });
+            return [name, new Map(requests)];
+        }));
+    };
+    const decode = Schema.decodeUnknownEffect(spec.input, { onExcessProperty: "error" });
+    const tool = {
+        name: spec.name,
+        description: spec.description,
+        inputSchema: catalogSchema(spec.input, "input"),
+        outputSchema: rendered ?? catalogSchema(spec.output, "output"),
+        annotations,
+        handler: (args, ctx) => runEdge(program(args, ctx), { signal: ctx.signal }),
+    };
+    const program = (args, ctx, served = false) => Effect.suspend(() => {
+        // The builder's verdict only stands in for a call no invocation dispatched.
+        const lease = fromConnectorContext(ctx, verdict);
+        const classification = Context.get(lease.services, Classification);
+        const dispatches = Context.get(lease.services, Dispatches);
+        const map = { classification, dispatches, withholds: connection.safety.withholdsErrors, signal: ctx.signal };
+        return Effect.try({
+            try: () => {
+                if (verdict === "write" || classification === "write")
+                    refuseWithheldValues(args, spec.name);
+            },
+            catch: (error) => error,
+        }).pipe(Effect.catch((error) => error instanceof ConnectorCallError ? Effect.fail(new Refusal({ error })) : Effect.die(error)), 
+        // Its message can quote the argument; as a defect, api() withholds it.
+        Effect.flatMap(() => decode(args).pipe(Effect.orDie)), Effect.map((decoded) => (spec.inputOrder === "original" ? originalOrder(decoded, args) : decoded)), Effect.flatMap((decoded) => Effect.gen(function* () {
+            const key = idempotency?.key(decoded);
+            if (key !== undefined && unsendableKey(key)) {
+                return yield* Effect.fail(new RequestRefused({
+                    message: "The idempotency key is blank or holds a character an HTTP header cannot carry.",
+                }));
+            }
+            // Recorded before anything leaves: a deadline that interrupts
+            // the call still returns the key for reconciliation.
+            if (key !== undefined)
+                yield* (yield* Recovery).record({ idempotencyKey: key });
+            return yield* Effect.suspend(() => spec.run(decoded)).pipe(Effect.provideService(ReadTool, verdict === "read" ? (review ? { review } : {}) : undefined), Effect.provideService(WriteCapacity, capacity(decoded)), Effect.provideService(IdempotencyKey, key === undefined ? undefined : { header: idempotency.header, key }));
+        })), 
+        // A native served call shares its invocation's cancellation. The
+        // invocation settles that interruption from the raw ledger before
+        // any completed handler verdict exists, just as at the Promise edge.
+        Effect.mapError((failure) => served && ctx.signal?.aborted ? ctx.signal.reason : toConnectorCallError(failure, connection.errors, map)), Effect.catchDefect((defect) => Effect.die(withheldDefect(defect, map))), Effect.provideContext(lease.services), 
+        // The call's finalizer: every capability kept from it refuses after this.
+        Effect.ensuring(Effect.sync(lease.close)), Effect.onError((cause) => Effect.sync(() => {
+            if (!served &&
+                ctx.signal?.aborted === true &&
+                causeError(cause, ctx.signal) === ctx.signal.reason &&
+                map.classification === "write")
+                recordUnauthorized(connection.errors, map);
+        })));
+    });
+    registerToolEntry(tool, (args, ctx) => program(args, ctx, inLogicalCall(ctx)));
+    inputs.set(tool, spec.input);
+    if (idempotency)
+        keyed.add(tool);
+    return tool;
+}

package/dist/http/vendor-index.js

@@ -0,0 +1,138 @@
+// Internal provider kit (decision 0011 S1). Unreachable from src/index.ts.
+//
+// The standard hatch validates every request against an operation index. A
+// vendor with a pinned OpenAPI document compiles one at generation time; a
+// kit vendor without one (its reference is per-page prose, as Tithe.ly's is)
+// derives it here from its own declarations, through `manifest(vendor)`. The
+// vendor stays the one operation list: what the typed client sends, what drift
+// checks compare and what the hatch admits are the same declarations.
+import { OperationIndex, } from "../providers/_shared/rest/operation-index.js";
+import { manifest } from "./vendor.js";
+const METHODS = ["get", "head", "post", "put", "patch", "delete"];
+/** How the manifest renders a number carried in a query or form string. */
+const NUMERIC_STRING = "^[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?$";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+/** Compact one manifest schema into the index's node form, resolving local references. */
+function node(schema, components, seen = new Set()) {
+    const source = record(schema);
+    const ref = typeof source["$ref"] === "string" ? source["$ref"] : undefined;
+    if (ref !== undefined) {
+        const name = ref.replace(/^#\/components\/schemas\//, "");
+        // A recursive reference stops validating below itself rather than looping.
+        return seen.has(name) ? { x: 1 } : node(components[name], components, new Set([...seen, name]));
+    }
+    const out = {};
+    const type = source["type"];
+    // A numeric query or form string is a number to the caller; the transport stringifies it.
+    if (type === "string" && source["pattern"] === NUMERIC_STRING)
+        out.t = "number";
+    else if (typeof type === "string" || Array.isArray(type))
+        out.t = type;
+    if (Array.isArray(source["enum"]))
+        out.e = source["enum"];
+    if (typeof source["description"] === "string")
+        out.d = source["description"];
+    // A property's key annotation renders as an `allOf` member beside its encoded type.
+    for (const member of Array.isArray(source["allOf"]) ? source["allOf"] : []) {
+        if (out.d === undefined && typeof record(member)["description"] === "string")
+            out.d = record(member)["description"];
+    }
+    const branches = source["anyOf"] ?? source["oneOf"];
+    if (Array.isArray(branches))
+        out.a = branches.map((branch) => node(branch, components, seen));
+    const properties = record(source["properties"]);
+    if (Object.keys(properties).length > 0) {
+        out.p = Object.fromEntries(Object.entries(properties).map(([key, value]) => [key, node(value, components, seen)]));
+    }
+    if (Array.isArray(source["required"]) && source["required"].length > 0)
+        out.r = source["required"];
+    if (source["items"] !== undefined)
+        out.i = node(source["items"], components, seen);
+    if (record(source["additionalProperties"]) === source["additionalProperties"]) {
+        out.m = node(source["additionalProperties"], components, seen);
+    }
+    return out;
+}
+/** Every property path a schema declares, local references resolved once each. */
+function propertyPaths(schema, components, prefix = "", seen = new Set()) {
+    const source = record(schema);
+    const ref = typeof source["$ref"] === "string" ? source["$ref"].replace(/^#\/components\/schemas\//, "") : undefined;
+    if (ref !== undefined)
+        return seen.has(ref) ? [] : propertyPaths(components[ref], components, prefix, new Set([...seen, ref]));
+    const branches = [source["anyOf"], source["oneOf"], source["allOf"]].flatMap((list) => Array.isArray(list) ? list : []);
+    return [
+        ...Object.entries(record(source["properties"])).flatMap(([name, child]) => [
+            `${prefix}${name}`,
+            ...propertyPaths(child, components, `${prefix}${name}.`, seen),
+        ]),
+        ...(source["items"] === undefined
+            ? []
+            : propertyPaths(source["items"], components, prefix ? `${prefix.slice(0, -1)}[].` : "[].", seen)),
+        ...branches.flatMap((branch) => propertyPaths(branch, components, prefix, seen)),
+    ];
+}
+/**
+ * An operation index over a kit vendor's own declarations: every operation's
+ * method, path, `operationId`, `Summary`, path and query parameters, and
+ * request body with its content type, plus the request and response
+ * properties `OperationIndex.fields` answers. `prefix` names the hatch tools in
+ * refusals; `revision` identifies the declared API version.
+ */
+export function vendorIndex(vendor, names) {
+    const document = manifest(vendor);
+    const components = record(record(document["components"])["schemas"]);
+    const ops = [];
+    const details = [];
+    const fields = [];
+    for (const [path, item] of Object.entries(record(document["paths"]))) {
+        for (const method of METHODS) {
+            const operation = record(record(item)[method]);
+            if (Object.keys(operation).length === 0)
+                continue;
+            const operationId = typeof operation["operationId"] === "string" ? operation["operationId"] : "";
+            const summary = typeof operation["summary"] === "string" ? operation["summary"] : "";
+            ops.push([method.toUpperCase(), path, operationId, summary, 0]);
+            const params = (Array.isArray(operation["parameters"]) ? operation["parameters"] : [])
+                .map(record)
+                .filter((param) => param["in"] === "path" || param["in"] === "query")
+                .map((param) => {
+                // The parameter row carries the description once, beside its schema.
+                const { d, ...schema } = node(param["schema"], components);
+                const description = typeof param["description"] === "string" ? param["description"] : d;
+                return [
+                    String(param["name"]),
+                    param["in"],
+                    param["required"] === true ? 1 : 0,
+                    schema,
+                    ...(description === undefined ? [] : [description]),
+                ];
+            });
+            const requestBody = record(operation["requestBody"]);
+            const [contentType, media] = Object.entries(record(requestBody["content"]))[0] ?? [];
+            const body = contentType === undefined
+                ? 0
+                : [contentType, node(record(media)["schema"], components), ...(requestBody["required"] === true ? [1] : [])];
+            details.push(params.length === 0 && body === 0 ? 0 : [params, body]);
+            const success = Object.entries(record(operation["responses"])).find(([status]) => status.startsWith("2"))?.[1];
+            const paths = (where, schema) => [...new Set(propertyPaths(schema, components))].map((path) => ({ in: where, path }));
+            fields.push([
+                ...paths("response", record(record(record(success)["content"])["application/json"])["schema"]),
+                ...paths("body", record(media)["schema"]),
+            ]);
+        }
+    }
+    const data = {
+        source: `${names.title} kit vendor declarations`,
+        revision: names.revision,
+        digest: "",
+        version: names.revision,
+        servers: [],
+        tags: [""],
+        ops,
+        details: JSON.stringify({ d: [], o: details }),
+        fields,
+    };
+    return new OperationIndex(data, { vendor: names.prefix, title: names.title });
+}