@wirebench/engine 2.2.0 → 3.1.0-rc.1

package/dist/rest/json-form.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The JSON form model: a request body seen through its schema, as a tree of labelled nodes the form
+ * view can render, and the structural edits that view can ask for.
+ *
+ * Everything here is pure and renderer-safe. Nodes are addressed by RFC 6901 JSON pointer (`''` for
+ * the root, `/a/0/b` below it), so an edit names a place in the *value*, not in the schema, and is
+ * applied to the current value every time — an edit can never act on a stale tree.
+ *
+ * The schema has already been dereferenced and may be a cyclic graph. Two bounds keep that finite:
+ * the tree only descends where the value has something (an absent property is one node with no
+ * children), and it stops at a depth limit with an `any` node, which the view shows as raw JSON.
+ * New values come from {@link sampleFromSchema}, so the form and "generate body" agree.
+ */
+import type { JsonSchema, JsonValue } from './openapi/model.js';
+/** What a node renders as. */
+export type JsonFormKind = 'field' | 'object' | 'array' | 'choice' | 'any';
+/** The scalar type a `field` edits. */
+export type JsonFormValueType = 'string' | 'number' | 'integer' | 'boolean' | 'null';
+/** One node of the form: a place in the value, with what the schema says about it. */
+export interface JsonFormNode {
+    /** JSON pointer of the value, `''` for the root. */
+    readonly id: string;
+    readonly kind: JsonFormKind;
+    /** Property name, array index, or `''` for the root. */
+    readonly name: string;
+    /** The schema's `title`, else the name. */
+    readonly label: string;
+    readonly description?: string;
+    readonly required: boolean;
+    /** Whether the value exists in the document. */
+    readonly present: boolean;
+    /** `field` only. */
+    readonly valueType?: JsonFormValueType;
+    readonly format?: string;
+    readonly enum?: readonly JsonValue[];
+    /** `field` and `any`, when present. */
+    readonly value?: JsonValue;
+    /** Object properties, array items, or a choice's chosen branch. */
+    readonly children: readonly JsonFormNode[];
+    /** `choice`: one label per branch. */
+    readonly choices?: readonly string[];
+    /** `choice`: the index of the branch the value matches. */
+    readonly chosen?: number;
+    readonly readOnly?: boolean;
+    readonly deprecated?: boolean;
+    /** `field`: the schema allows `null` as well as `valueType`. */
+    readonly nullable?: boolean;
+}
+/** One structural change the form view can ask for, addressed by JSON pointer. */
+export type JsonFormEdit = {
+    readonly kind: 'set-value';
+    readonly id: string;
+    readonly value: JsonValue;
+}
+/** Make an absent property exist, filled from `sampleFromSchema`. */
+ | {
+    readonly kind: 'insert-optional';
+    readonly id: string;
+}
+/** Remove an optional property or an array item. */
+ | {
+    readonly kind: 'remove';
+    readonly id: string;
+}
+/** Append one item to the array at `id`. */
+ | {
+    readonly kind: 'add-item';
+    readonly id: string;
+}
+/** Replace the value at `id` with a sample of branch `index` of its `oneOf`/`anyOf`. */
+ | {
+    readonly kind: 'select-choice';
+    readonly id: string;
+    readonly index: number;
+};
+/** Options for {@link buildJsonForm}. */
+export interface JsonFormOptions {
+    /** Where the tree stops with an `any` node. Defaults to `MAX_SAMPLE_DEPTH`. */
+    readonly maxDepth?: number;
+}
+/**
+ * The form tree for a value under a schema.
+ *
+ * @param schema the dereferenced schema (it may be cyclic)
+ * @param value the current body value, `undefined` when there is none
+ */
+export declare function buildJsonForm(schema: JsonSchema, value: JsonValue | undefined, options?: JsonFormOptions): JsonFormNode;
+/**
+ * The body value after one form edit. Nothing is mutated; properties the schema does not declare
+ * are carried over untouched.
+ */
+export declare function applyJsonFormEdit(schema: JsonSchema, value: JsonValue | undefined, edit: JsonFormEdit): JsonValue;
+/**
+ * An acyclic copy of a schema, cut at `maxDepth` (and at a total node budget) with `{}` — "any
+ * value". What crosses a structured-clone or JSON boundary to the renderer.
+ */
+export declare function toWireSchema(schema: JsonSchema, maxDepth?: number): JsonSchema;

package/dist/rest/json-form.js

@@ -0,0 +1,396 @@
+/**
+ * The JSON form model: a request body seen through its schema, as a tree of labelled nodes the form
+ * view can render, and the structural edits that view can ask for.
+ *
+ * Everything here is pure and renderer-safe. Nodes are addressed by RFC 6901 JSON pointer (`''` for
+ * the root, `/a/0/b` below it), so an edit names a place in the *value*, not in the schema, and is
+ * applied to the current value every time — an edit can never act on a stale tree.
+ *
+ * The schema has already been dereferenced and may be a cyclic graph. Two bounds keep that finite:
+ * the tree only descends where the value has something (an absent property is one node with no
+ * children), and it stops at a depth limit with an `any` node, which the view shows as raw JSON.
+ * New values come from {@link sampleFromSchema}, so the form and "generate body" agree.
+ */
+import { effectiveType, MAX_SAMPLE_DEPTH, MAX_SAMPLE_NODES, mergeAllOf, sampleFromSchema, } from '../json/schema/sample.js';
+const VALUE_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'null']);
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function escapeSegment(segment) {
+    return segment.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function parsePointer(pointer) {
+    if (pointer === '') {
+        return [];
+    }
+    return pointer
+        .slice(1)
+        .split('/')
+        .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
+}
+/** The branches of a `oneOf`/`anyOf`, or none. */
+function branchesOf(schema) {
+    return schema.oneOf ?? schema.anyOf ?? [];
+}
+/** Branch `index` merged with whatever sits beside the `oneOf` — the way `sampleFromSchema` merges its first. */
+function branchSchema(schema, index) {
+    const branch = branchesOf(schema)[index];
+    if (branch === undefined) {
+        return schema;
+    }
+    const siblings = { ...schema };
+    delete siblings.oneOf;
+    delete siblings.anyOf;
+    return mergeAllOf({
+        ...branch,
+        ...siblings,
+        ...(branch.properties !== undefined ? { properties: branch.properties } : {}),
+    });
+}
+/** Whether a value has the JSON type a schema type names. */
+function typeMatches(type, value) {
+    if (type === undefined || value === undefined) {
+        return true;
+    }
+    switch (type) {
+        case 'object':
+            return isObject(value);
+        case 'array':
+            return Array.isArray(value);
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number';
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'null':
+            return value === null;
+        default:
+            return true;
+    }
+}
+/** Whether a value could be a branch: its type matches and it has every required property. */
+function branchAccepts(branch, value) {
+    if (!typeMatches(effectiveType(branch), value)) {
+        return false;
+    }
+    const required = branch.required ?? [];
+    return required.length === 0 || (isObject(value) && required.every((name) => name in value));
+}
+/** Whether a branch's discriminator property pins `tag` with a `const` or `enum`. */
+function discriminatorMatches(branch, propertyName, tag) {
+    const property = branch.properties?.[propertyName];
+    if (property === undefined) {
+        return false;
+    }
+    const same = (member) => JSON.stringify(member) === JSON.stringify(tag);
+    return (property.const !== undefined && same(property.const)) || (property.enum ?? []).some(same);
+}
+/**
+ * The branch the value is: the one its discriminator names, else the accepting branch whose declared
+ * properties cover most of the value's keys (the first on a tie), else 0.
+ */
+function chosenBranch(schema, value) {
+    const branches = branchesOf(schema).map((_, index) => branchSchema(schema, index));
+    const propertyName = schema.discriminator?.propertyName;
+    if (propertyName !== undefined && isObject(value) && value[propertyName] !== undefined) {
+        const tag = value[propertyName];
+        const named = branches.findIndex((branch) => discriminatorMatches(branch, propertyName, tag));
+        if (named !== -1) {
+            return named;
+        }
+    }
+    let best = -1;
+    let bestCovered = -1;
+    branches.forEach((branch, index) => {
+        if (!branchAccepts(branch, value)) {
+            return;
+        }
+        const declared = branch.properties ?? {};
+        const covered = isObject(value) ? Object.keys(value).filter((key) => Object.hasOwn(declared, key)).length : 0;
+        if (covered > bestCovered) {
+            best = index;
+            bestCovered = covered;
+        }
+    });
+    return best === -1 ? 0 : best;
+}
+/**
+ * The form tree for a value under a schema.
+ *
+ * @param schema the dereferenced schema (it may be cyclic)
+ * @param value the current body value, `undefined` when there is none
+ */
+export function buildJsonForm(schema, value, options = {}) {
+    return build(schema, value, { id: '', name: '', required: true, depth: 0 }, options.maxDepth ?? MAX_SAMPLE_DEPTH);
+}
+function anyNode(place, value, schema) {
+    return {
+        ...common(schema ?? {}, place, value),
+        kind: 'any',
+        ...(value !== undefined ? { value } : {}),
+        children: [],
+    };
+}
+function common(schema, place, value) {
+    return {
+        id: place.id,
+        name: place.name,
+        label: schema.title ?? place.name,
+        ...(schema.description !== undefined ? { description: schema.description } : {}),
+        required: place.required,
+        present: value !== undefined,
+        ...(schema.readOnly === true ? { readOnly: true } : {}),
+        ...(schema.deprecated === true ? { deprecated: true } : {}),
+    };
+}
+function build(input, value, place, maxDepth) {
+    if (place.depth >= maxDepth) {
+        return anyNode(place, value, input);
+    }
+    const schema = mergeAllOf(input);
+    const branches = branchesOf(schema);
+    if (branches.length > 0) {
+        const chosen = chosenBranch(schema, value);
+        return {
+            ...common(schema, place, value),
+            kind: 'choice',
+            choices: branches.map((branch, index) => branch.title ?? `Option ${index + 1}`),
+            chosen,
+            children: [build(branchSchema(schema, chosen), value, { ...place, depth: place.depth + 1 }, maxDepth)],
+        };
+    }
+    const type = effectiveType(schema) ?? inferredEnumType(schema);
+    if (type === 'object') {
+        return value === undefined || isObject(value)
+            ? { ...common(schema, place, value), kind: 'object', children: objectChildren(schema, value, place, maxDepth) }
+            : anyNode(place, value, schema);
+    }
+    if (type === 'array') {
+        if (value !== undefined && !Array.isArray(value)) {
+            return anyNode(place, value, schema);
+        }
+        const items = value ?? [];
+        return {
+            ...common(schema, place, value),
+            kind: 'array',
+            children: items.map((item, index) => build(schema.items ?? {}, item, { id: `${place.id}/${index}`, name: String(index), required: false, depth: place.depth + 1 }, maxDepth)),
+        };
+    }
+    if (type !== undefined && VALUE_TYPES.has(type)) {
+        return {
+            ...common(schema, place, value),
+            kind: 'field',
+            valueType: type,
+            ...(schema.format !== undefined ? { format: schema.format } : {}),
+            ...(schema.enum !== undefined ? { enum: schema.enum } : {}),
+            ...(allowsNull(schema) ? { nullable: true } : {}),
+            ...(value !== undefined ? { value } : {}),
+            children: [],
+        };
+    }
+    return anyNode(place, value, schema);
+}
+/** Whether a schema allows `null`, in either specification's spelling. */
+function allowsNull(schema) {
+    return schema.nullable === true || (Array.isArray(schema.type) && schema.type.includes('null'));
+}
+/** A type-less enum still reads as a field of its members' type. */
+function inferredEnumType(schema) {
+    const first = schema.enum?.[0];
+    if (first === undefined) {
+        return undefined;
+    }
+    if (first === null) {
+        return 'null';
+    }
+    return typeof first === 'object' ? undefined : typeof first;
+}
+function objectChildren(schema, value, place, maxDepth) {
+    // An absent object has nothing to show inside it; descending anyway would walk a cyclic schema
+    // breadth-first to the depth limit.
+    if (value === undefined) {
+        return [];
+    }
+    const required = new Set(schema.required ?? []);
+    const declared = schema.properties ?? {};
+    const childPlace = (name) => ({
+        id: `${place.id}/${escapeSegment(name)}`,
+        name,
+        required: required.has(name),
+        depth: place.depth + 1,
+    });
+    const children = Object.entries(declared).map(([name, property]) => build(property, value[name], childPlace(name), maxDepth));
+    const additional = schema.additionalProperties;
+    if (additional !== false) {
+        for (const [name, extra] of Object.entries(value)) {
+            if (Object.hasOwn(declared, name)) {
+                continue;
+            }
+            children.push(typeof additional === 'object'
+                ? build(additional, extra, childPlace(name), maxDepth)
+                : anyNode(childPlace(name), extra));
+        }
+    }
+    return children;
+}
+/** The schema that describes the value at `segments`, following the value through choices. */
+function schemaAt(root, value, segments) {
+    let schema = root;
+    let current = value;
+    for (const segment of segments) {
+        let resolved = mergeAllOf(schema);
+        if (branchesOf(resolved).length > 0) {
+            resolved = branchSchema(resolved, chosenBranch(resolved, current));
+        }
+        if (Array.isArray(current) || (current === undefined && effectiveType(resolved) === 'array')) {
+            schema = resolved.items ?? {};
+            current = Array.isArray(current) ? current[Number(segment)] : undefined;
+            continue;
+        }
+        const additional = resolved.additionalProperties;
+        schema = resolved.properties?.[segment] ?? (typeof additional === 'object' ? additional : {});
+        current = isObject(current) ? current[segment] : undefined;
+    }
+    return schema;
+}
+function getAt(value, segments) {
+    let current = value;
+    for (const segment of segments) {
+        if (Array.isArray(current)) {
+            current = current[Number(segment)];
+        }
+        else if (isObject(current)) {
+            current = current[segment];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+/** A copy of `value` with `replacement` at `segments`; `undefined` removes. Missing parents become objects. */
+function updateAt(value, segments, replacement) {
+    if (segments.length === 0) {
+        return replacement;
+    }
+    const [head, ...rest] = segments;
+    if (Array.isArray(value)) {
+        const items = [...value];
+        const index = head === '-' ? items.length : Number(head);
+        const next = updateAt(items[index], rest, replacement);
+        if (next === undefined) {
+            items.splice(index, 1);
+        }
+        else {
+            items[index] = next;
+        }
+        return items;
+    }
+    const object = isObject(value) ? { ...value } : {};
+    const next = updateAt(object[head], rest, replacement);
+    if (next === undefined) {
+        delete object[head];
+    }
+    else {
+        object[head] = next;
+    }
+    return object;
+}
+/**
+ * The body value after one form edit. Nothing is mutated; properties the schema does not declare
+ * are carried over untouched.
+ */
+export function applyJsonFormEdit(schema, value, edit) {
+    const segments = parsePointer(edit.id);
+    const put = (replacement) => updateAt(value, segments, replacement) ?? null;
+    switch (edit.kind) {
+        case 'set-value':
+            return put(edit.value);
+        case 'insert-optional':
+            return put(sampleFromSchema(schemaAt(schema, value, segments)));
+        case 'remove':
+            return segments.length === 0 ? null : put(undefined);
+        case 'add-item': {
+            const existing = getAt(value, segments);
+            const items = Array.isArray(existing) ? existing : [];
+            let arraySchema = mergeAllOf(schemaAt(schema, value, segments));
+            if (branchesOf(arraySchema).length > 0) {
+                arraySchema = branchSchema(arraySchema, chosenBranch(arraySchema, existing));
+            }
+            return put([...items, sampleFromSchema(arraySchema.items ?? {})]);
+        }
+        case 'select-choice': {
+            const choice = mergeAllOf(schemaAt(schema, value, segments));
+            const branch = branchSchema(choice, edit.index);
+            // A sample of only the required properties can look like an earlier branch (two branches with
+            // nothing required both sample as `{}`); the optional ones are what tell it apart then.
+            const sample = sampleFromSchema(branch);
+            return put(chosenBranch(choice, sample) === edit.index ? sample : sampleFromSchema(branch, { includeOptional: true }));
+        }
+    }
+}
+/**
+ * An acyclic copy of a schema, cut at `maxDepth` (and at a total node budget) with `{}` — "any
+ * value". What crosses a structured-clone or JSON boundary to the renderer.
+ */
+export function toWireSchema(schema, maxDepth = MAX_SAMPLE_DEPTH) {
+    return copySchema(schema, maxDepth, { remaining: MAX_SAMPLE_NODES });
+}
+/** Keys copied as they are: plain data the form and the sample generator read. */
+const WIRE_SCALAR_KEYS = [
+    'type',
+    'format',
+    'title',
+    'description',
+    'default',
+    'example',
+    'examples',
+    'enum',
+    'const',
+    'required',
+    'discriminator',
+    'nullable',
+    'deprecated',
+    'readOnly',
+    'writeOnly',
+    'xml',
+    '$ref',
+];
+/**
+ * Only the keys the form and the sample read survive; anything else (`not`, `prefixItems`,
+ * `if`/`then`/`else`, …) is dropped, since it could hold a subschema — even a cycle — this copy
+ * would otherwise pass along by reference.
+ */
+function copySchema(schema, depth, budget) {
+    if (depth <= 0 || budget.remaining <= 0) {
+        return {};
+    }
+    budget.remaining -= 1;
+    const copy = {};
+    for (const key of WIRE_SCALAR_KEYS) {
+        if (schema[key] !== undefined) {
+            copy[key] = schema[key];
+        }
+    }
+    const next = (child) => copySchema(child, depth - 1, budget);
+    if (schema.properties !== undefined) {
+        copy.properties = Object.fromEntries(Object.entries(schema.properties).map(([name, child]) => [name, next(child)]));
+    }
+    if (schema.items !== undefined) {
+        copy.items = next(schema.items);
+    }
+    if (schema.additionalProperties !== undefined) {
+        copy.additionalProperties =
+            typeof schema.additionalProperties === 'object' ? next(schema.additionalProperties) : schema.additionalProperties;
+    }
+    for (const key of ['allOf', 'oneOf', 'anyOf']) {
+        const branches = schema[key];
+        if (branches !== undefined) {
+            copy[key] = branches.map(next);
+        }
+    }
+    return copy;
+}

package/dist/rest/model.d.ts

@@ -12,7 +12,11 @@
  * `'soap'` on an interface; `'grpc'` is reserved and refused by the loader (see `project/schema.ts`).
  */
 import type { Assertion } from '../assert/model.js';
-import type { AttachmentSource, AuthConfig, CreateOptions, IdGenerator } from '../project/model.js';
+import type { KeyValueEntry } from '../http/entries.js';
+import type { RawLanguage } from '../http/escape.js';
+import type { RequestScripts } from '../script/model.js';
+import type { AttachmentSource, AuthConfig, CreateOptions, DefinitionAuth, IdGenerator } from '../project/model.js';
+import type { HookLink, WebhookSigning } from '../webhooks/model.js';
 /**
  * An HTTP method. The seven a REST client needs are spelled out so the common case is
  * autocompleted and checked; a service that wants `PURGE`, `LOCK` or `REPORT` is not told it is
@@ -21,28 +25,8 @@ import type { AttachmentSource, AuthConfig, CreateOptions, IdGenerator } from '.
 export type RestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | (string & {});
 /** The methods the editor offers by name, in the order it offers them. */
 export declare const COMMON_METHODS: readonly RestMethod[];
-/**
- * One row of a params, query, headers or form table: a name, a value, and whether it takes part
- * in the next send. Rows keep author order and may repeat a name — two `X-Trace` headers and two
- * `tag=` parameters are both legal on the wire, so neither is deduplicated here.
- *
- * `enabled` is always present in memory and written to disk only when `false`, so a file stays
- * quiet about the common case (see `project/serialize.ts`).
- */
-export interface KeyValueEntry {
-    readonly name: string;
-    readonly value: string;
-    readonly enabled: boolean;
-    /** Free-form note, carried over from an imported definition's parameter description. */
-    readonly description?: string;
-}
-/** Creates an enabled {@link KeyValueEntry}. */
-export declare function entry(name: string, value: string, options?: {
-    readonly enabled?: boolean;
-    readonly description?: string;
-}): KeyValueEntry;
-/** The languages a raw body can be edited and sent as. Picks the editor mode and a default type. */
-export type RawLanguage = 'json' | 'xml' | 'text' | 'html' | 'javascript';
+export { entry } from '../http/entries.js';
+export type { KeyValueEntry, RawLanguage };
 /** The `Content-Type` each {@link RawLanguage} implies when the request sets no header itself. */
 export declare const RAW_LANGUAGE_CONTENT_TYPES: Readonly<Record<RawLanguage, string>>;
 /** The file extension a raw body of each language is stored under, beside its request file. */
@@ -99,7 +83,7 @@ export declare const NO_BODY: RestBody;
 /**
  * Per-request transport settings. Every field is optional and an absent one means *inherit*, not
  * *off*: the send resolves request → API → project → preference, exactly as a SOAP request's
- * properties do (`send-options.ts`).
+ * properties do (`send-input.ts`).
  */
 export interface RestRequestSettings {
     readonly timeoutMs?: number;
@@ -153,6 +137,28 @@ export interface RestRequestDef {
      * a re-import; the request survives badged.
      */
     readonly orphaned?: boolean;
+    /**
+     * The operation of the API's definition this request calls: its lower-case method and its path as
+     * the definition spells it (`/pets/{petId}`). Set by an import, kept by edits; absent when unknown.
+     */
+    readonly contract?: RestContractLink;
+    /**
+     * Set only on an item of a project's webhook collection that was imported from an OpenAPI
+     * `webhooks` or `callbacks` entry: which one, so *Update definition* can keep it in step.
+     */
+    readonly hook?: HookLink;
+    /**
+     * Only on an item of a project's webhook collection: how it signs what it sends, overriding its
+     * folders and the collection (spec `2026-09-29-…-webhook-signatures-design.md` §5.1).
+     */
+    readonly signing?: WebhookSigning;
+    /** Pre-request and post-response scripts, in files beside the request (#63). */
+    readonly scripts?: RequestScripts;
+}
+/** A request's link to an operation of its API's definition. */
+export interface RestContractLink {
+    readonly method: string;
+    readonly path: string;
 }
 /** A named node in an API's tree, holding folders and requests. */
 export interface RestFolder {
@@ -178,6 +184,8 @@ export interface RestDefinitionRef {
     readonly cache: boolean;
     /** The OpenAPI version of the document, as it declared itself (e.g. `3.1.0`). */
     readonly version: string;
+    /** Credentials the document is fetched with, sent to the source's own origin only. */
+    readonly auth?: DefinitionAuth;
 }
 /** A REST API: a base URL, default credentials, and a tree of folders and requests. */
 export interface RestApi {
@@ -234,6 +242,9 @@ export interface CreateRestRequestInput extends CreateOptions {
     readonly body?: RestBody;
     readonly auth?: AuthConfig;
     readonly settings?: RestRequestSettings;
+    readonly contract?: RestContractLink;
+    readonly hook?: HookLink;
+    readonly signing?: WebhookSigning;
 }
 /** Creates a `GET` request with an empty URL, no body and inherited credentials. */
 export declare function createRestRequest(name: string, input?: CreateRestRequestInput): RestRequestDef;

package/dist/rest/model.js

@@ -23,15 +23,9 @@ export const COMMON_METHODS = Object.freeze([
     'HEAD',
     'OPTIONS',
 ]);
-/** Creates an enabled {@link KeyValueEntry}. */
-export function entry(name, value, options) {
-    return {
-        name,
-        value,
-        enabled: options?.enabled ?? true,
-        ...(options?.description !== undefined ? { description: options.description } : {}),
-    };
-}
+// Declared in `http/`, which the gRPC and WebSocket folders share with this one; re-exported so REST
+// code and the public exports keep reading them from here.
+export { entry } from '../http/entries.js';
 /** The `Content-Type` each {@link RawLanguage} implies when the request sets no header itself. */
 export const RAW_LANGUAGE_CONTENT_TYPES = Object.freeze({
     json: 'application/json',
@@ -101,6 +95,9 @@ export function createRestRequest(name, input = {}) {
         auth: input.auth ?? { type: 'inherit' },
         settings: input.settings ?? {},
         assertions: [],
+        ...(input.contract !== undefined ? { contract: { method: input.contract.method, path: input.contract.path } } : {}),
+        ...(input.hook !== undefined ? { hook: { ...input.hook } } : {}),
+        ...(input.signing !== undefined ? { signing: input.signing } : {}),
     };
 }
 /** Every request in `folder` and, depth-first, in the folders below it. */

package/dist/rest/module.d.ts

@@ -0,0 +1,2 @@
+/** The REST protocol: APIs, their folders and requests, and the project's webhook items. */
+export declare const restProtocol: import("../protocol/module.js").ProtocolModule;

package/dist/rest/module.js

@@ -0,0 +1,13 @@
+/** REST as a protocol module (spec §3). */
+import { defineProtocol } from '../protocol/module.js';
+import { restRun } from './run.js';
+import { restScripting } from './scripting.js';
+import { restStorage } from './storage.js';
+/** The REST protocol: APIs, their folders and requests, and the project's webhook items. */
+export const restProtocol = defineProtocol({
+    kind: 'rest',
+    feature: { id: 'rest', title: 'REST', default: true, stage: 'stable', requires: [] },
+    storage: restStorage,
+    run: restRun,
+    scripting: restScripting,
+});

package/dist/rest/openapi/cache.d.ts

@@ -9,8 +9,8 @@
  */
 import type { FsLike } from '../../project/fs.js';
 import type { ApiDefinitionCacheManifest } from '../../project/schema.js';
-import type { FetchDocument } from '../../wsdl/resolver.js';
-import type { ResolvedDocument } from './refs.js';
+import type { FetchDocument } from '../../http/fetch-document.js';
+import type { ResolvedDocument } from '../../json/schema/refs.js';
 /** Options accepted by the read and write halves. */
 export interface ApiDefinitionCacheOptions {
     /** Overrides the file system, e.g. for tests. Defaults to `nodeFs`. */
@@ -22,6 +22,11 @@ export interface WriteApiDefinitionCacheOptions extends ApiDefinitionCacheOption
     readonly now?: () => string;
     /** The `openapi` string the root document declared, recorded for the definition card. */
     readonly declaredVersion?: string;
+    /**
+     * The name the root document is cached under when its own location gives none. Defaults to
+     * `openapi.yaml`; an AsyncAPI import passes `asyncapi.yaml`.
+     */
+    readonly rootFile?: string;
 }
 /**
  * Writes every document byte-exact into `dir` (created if needed) alongside a `manifest.yaml`, and

package/dist/rest/openapi/cache.js

@@ -13,7 +13,7 @@ import { ProjectError } from '../../errors.js';
 import { nodeFs, readFileIfExists, readdirIfExists, writeFileAtomic } from '../../project/fs.js';
 import { apiDefinitionCacheManifestSchema, parseFile } from '../../project/schema.js';
 import { parseYaml, stringifyYaml } from '../../project/yaml.js';
-import { assignFileNames } from '../../wsdl/cache-naming.js';
+import { assignFileNames } from '../../project/cache-naming.js';
 const MANIFEST_FILE = 'manifest.yaml';
 function sha256Hex(bytes) {
     return createHash('sha256').update(bytes).digest('hex');
@@ -41,7 +41,7 @@ export async function writeApiDefinitionCache(documents, dir, options) {
         });
     }
     const existing = await readdirIfExists(fs, dir);
-    const named = assignFileNames(documents.map((document) => ({ ...document, kind: kindOf(document.text) })), { rootFile: 'openapi.yaml' });
+    const named = assignFileNames(documents.map((document) => ({ ...document, kind: kindOf(document.text) })), { rootFile: options?.rootFile ?? 'openapi.yaml' });
     const entries = named.map(({ document, file }) => ({
         file,
         location: document.location,