@zenera/gym 0.0.0-stage → 1.1.38

package/dist/probe.js

@@ -0,0 +1,307 @@
+import { properties } from "./schema.js";
+// ---------------------------------------------------------------------------
+// Probes
+//
+// A generator is judged before it is trusted, and it is judged on inputs made
+// up here rather than on traffic. That is not only about cost: a probe built
+// from a request body would put whatever a caller sent into the next prompt,
+// and a mock server is exactly the kind of thing people point at with real
+// payloads by accident.
+//
+// Two probes, deliberately. One ordinary, one at the edges of whatever the
+// schema allows — a generator that hard-codes the first probe's id passes once
+// and fails the second, which is the mistake this catches.
+// ---------------------------------------------------------------------------
+/**
+ * How many items a probe asks a paged operation for.
+ *
+ * Not the schema's maximum. `bounded` below answers an unbounded want with
+ * `maximum - 1`, so a `page_size` declared `maximum: 1000` used to make every
+ * probe ask for 999 fabricated objects — minutes of Faker inside a container
+ * with a 30s budget, reported as "the file took longer than 30s" and blamed on
+ * a generator that was doing exactly what it was told. A page is judged on its
+ * shape, and three rows show it.
+ */
+const PROBE_PAGE_SIZE = 3;
+export function probesFor(operation) {
+    const size = operation.paging?.size;
+    return [0, 1].map((variant) => ({
+        operationId: operation.operationId,
+        method: operation.method,
+        path: operation.path,
+        pathParams: values(operation.params, 'path', variant, size),
+        query: values(operation.params, 'query', variant, size),
+        headers: {},
+        body: operation.requestBody
+            ? sample(operation.requestBody.schema, variant, 0, operation.requestBody.schema)
+            : undefined,
+        seed: variant === 0 ? 1 : 2,
+    }));
+}
+function values(params, where, variant, size) {
+    const out = {};
+    for (const p of params) {
+        if (p.in !== where) {
+            continue;
+        }
+        // An optional query parameter is present in one probe and absent in the
+        // other, so a generator cannot assume either.
+        if (!p.required && variant === 1) {
+            continue;
+        }
+        out[p.name] =
+            p.name === size
+                ? bounded(p.schema, PROBE_PAGE_SIZE, true)
+                : sample(p.schema, variant, 0, p.schema);
+    }
+    return out;
+}
+const NAMES = ['ada', 'grace', 'linus'];
+/**
+ * A value the schema would accept. Not a faker — that job belongs to the
+ * generator; this only has to be *valid*, so that a probe failure is the
+ * generator's fault and never the probe's.
+ */
+function sample(schema, variant, depth, root) {
+    if (depth > 4) {
+        return null;
+    }
+    // Normalisation hoists anything shared or recursive, so a top-level schema
+    // is quite often nothing but a pointer into `$defs`.
+    const target = follow(schema, root);
+    if (target !== schema) {
+        return sample(target, variant, depth + 1, root);
+    }
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        return schema.enum[variant % schema.enum.length];
+    }
+    if (schema.const !== undefined) {
+        return schema.const;
+    }
+    for (const key of ['allOf', 'anyOf', 'oneOf']) {
+        const list = schema[key];
+        if (Array.isArray(list) && list.length > 0) {
+            return sample(list[0], variant, depth + 1, root);
+        }
+    }
+    switch (typeOf(schema)) {
+        case 'integer':
+            return bounded(schema, variant === 0 ? 12324 : 7, true);
+        case 'number':
+            return bounded(schema, variant === 0 ? 42.5 : 1.5, false);
+        case 'boolean':
+            return variant === 0;
+        case 'null':
+            return null;
+        case 'array': {
+            const items = schema.items;
+            const one = typeof items === 'object' && items !== null
+                ? sample(items, variant, depth + 1, root)
+                : 1;
+            return variant === 0 ? [one] : [one, one];
+        }
+        case 'object': {
+            const properties = (schema.properties ?? {});
+            const required = Array.isArray(schema.required) ? schema.required : [];
+            const out = {};
+            for (const [name, sub] of Object.entries(properties)) {
+                if (variant === 1 && !required.includes(name)) {
+                    continue;
+                }
+                out[name] = sample(sub, variant, depth + 1, root);
+            }
+            return out;
+        }
+        default:
+            return text(schema, variant);
+    }
+}
+/** One hop through a local `#/$defs/...` pointer, or the schema itself. */
+function follow(schema, root) {
+    const ref = schema.$ref;
+    if (typeof ref !== 'string' || !ref.startsWith('#/$defs/')) {
+        return schema;
+    }
+    const defs = root.$defs;
+    if (typeof defs !== 'object' || defs === null) {
+        return schema;
+    }
+    const target = defs[ref.slice('#/$defs/'.length)];
+    return typeof target === 'object' && target !== null ? target : schema;
+}
+function typeOf(schema) {
+    const type = schema.type;
+    if (typeof type === 'string') {
+        return type;
+    }
+    if (Array.isArray(type)) {
+        return type.find((t) => t !== 'null');
+    }
+    return schema.properties !== undefined
+        ? 'object'
+        : schema.items !== undefined
+            ? 'array'
+            : undefined;
+}
+function bounded(schema, wanted, integer) {
+    const min = num(schema.minimum) ?? num(schema.exclusiveMinimum);
+    const max = num(schema.maximum) ?? num(schema.exclusiveMaximum);
+    let value = wanted;
+    if (min !== undefined && value <= min) {
+        value = min + 1;
+    }
+    if (max !== undefined && value >= max) {
+        value = max - 1;
+    }
+    return integer ? Math.round(value) : value;
+}
+const num = (v) => (typeof v === 'number' ? v : undefined);
+function text(schema, variant) {
+    switch (schema.format) {
+        case 'uuid':
+            return variant === 0
+                ? '3f2504e0-4f89-11d3-9a0c-0305e82c3301'
+                : '9c858901-8a57-4791-81fe-4c455b099bc9';
+        case 'date':
+            return variant === 0 ? '2024-01-15' : '1999-12-31';
+        case 'date-time':
+            return variant === 0 ? '2024-01-15T09:30:00Z' : '1999-12-31T23:59:59Z';
+        case 'email':
+            return `${NAMES[variant % NAMES.length]}@example.com`;
+        case 'uri':
+        case 'url':
+            return 'https://example.com/thing';
+        default:
+            break;
+    }
+    // A `pattern` cannot be satisfied by guessing, so it is left to the
+    // parameter check to tell us the probe was wrong rather than the generator.
+    const base = NAMES[variant % NAMES.length];
+    const min = num(schema.minLength) ?? 0;
+    return base.length >= min ? base : base.padEnd(min, 'x');
+}
+// ---------------------------------------------------------------------------
+// The walk
+//
+// The probes above are independent, which is the right shape for everything one
+// response can be wrong about and the wrong shape for pagination: a cursor only
+// means anything in the answer it arrived with, so the pages have to be asked
+// for in order.
+//
+// The seed is held still across the whole walk on purpose. A generator that
+// mints its token out of `seed` rather than out of the request is the exact
+// mistake being looked for, and a still seed makes it a fixed point — visible
+// on the second page here instead of on somebody's client.
+// ---------------------------------------------------------------------------
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** The first page: an ordinary probe with the paging control taken back off. */
+export function walkStart(operation, paging) {
+    const input = probesFor(operation)[0];
+    if (paging.paramIn === 'body') {
+        const body = isObject(input.body) ? { ...input.body } : {};
+        delete body[paging.param];
+        return { ...input, body };
+    }
+    const query = { ...input.query };
+    delete query[paging.param];
+    return { ...input, query };
+}
+/** The same request again, asking for whatever the last answer pointed at. */
+export function nextPage(previous, paging, token) {
+    if (paging.paramIn === 'body') {
+        const body = isObject(previous.body) ? { ...previous.body } : {};
+        body[paging.param] = token;
+        return { ...previous, body };
+    }
+    return { ...previous, query: { ...previous.query, [paging.param]: token } };
+}
+// ---------------------------------------------------------------------------
+// The echo rule
+//
+// `get_user_by_id(12324)` answering `{ user_id: 999 }` validates perfectly and
+// is still wrong, so schema conformance is not the whole test. Where the
+// response declares a property with a parameter's name, the parameter's value
+// has to be the one that comes back.
+//
+// **Path parameters only.** A path segment identifies the resource, so a
+// mismatch there is a broken mock. A query parameter is usually a control
+// rather than content — `?source=realtime`, `?page_size=50`, `?cursor=…` — and
+// real APIs collide those names with unrelated response properties all the
+// time. Enforcing on them rejected working generators for a rule they were
+// right to ignore. The prompt still asks for query echo where it is meaningful;
+// it is simply not a reason to throw the file away.
+// ---------------------------------------------------------------------------
+export function echoIssues(input, value, schema) {
+    if (!schema) {
+        return [];
+    }
+    const declared = new Map();
+    for (const p of properties(schema)) {
+        declared.set(p.name, [...(declared.get(p.name) ?? []), p.schema]);
+    }
+    const out = [];
+    for (const [name, expected] of Object.entries(input.pathParams)) {
+        const subs = declared.get(name);
+        if (!subs || expected === undefined || expected === null) {
+            continue;
+        }
+        // A value the response may not hold cannot be echoed: the schema check wins.
+        if (!subs.some((s) => admits(s, expected))) {
+            continue;
+        }
+        if (!carries(value, name, expected)) {
+            out.push({
+                where: `/${name}`,
+                message: `must echo the path parameter ${JSON.stringify(expected)}, the response schema declares this property`,
+            });
+        }
+    }
+    return out;
+}
+function admits(schema, value) {
+    if (typeof schema.pattern !== 'string') {
+        return true;
+    }
+    try {
+        return new RegExp(schema.pattern, 'u').test(String(value));
+    }
+    catch {
+        return true;
+    }
+}
+/** Whether `name` anywhere in the value holds something equal to `expected`. */
+function carries(value, name, expected) {
+    const stack = [value];
+    const seen = new Set();
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (typeof node !== 'object' || node === null) {
+            continue;
+        }
+        if (Array.isArray(node)) {
+            stack.push(...node);
+            continue;
+        }
+        if (seen.has(node)) {
+            continue;
+        }
+        seen.add(node);
+        const record = node;
+        if (name in record && same(record[name], expected)) {
+            return true;
+        }
+        stack.push(...Object.values(record));
+    }
+    return false;
+}
+/** A path segment is text on the wire; `"12324"` and `12324` are the same id. */
+function same(got, expected) {
+    if (got === expected) {
+        return true;
+    }
+    if (got === null || got === undefined || typeof got === 'object') {
+        return false;
+    }
+    return String(got) === String(expected);
+}
+//# sourceMappingURL=probe.js.map

package/dist/prompt.d.ts

@@ -0,0 +1,25 @@
+import type { GeneratorInput } from './envelope.ts';
+import { type Operation } from './spec.ts';
+export declare const SYSTEM: string;
+export declare function brief(operation: Operation): string;
+/**
+ * Repeated in the file the model writes, so it is worth spelling out: the
+ * schema it validates against must be the one it was shown, embedded, not
+ * loaded from anywhere.
+ */
+export declare function instruction(operation: Operation): string;
+export declare function retry(diagnostics: readonly string[]): string;
+export interface ExampleRequest {
+    input: GeneratorInput;
+    output?: unknown;
+}
+export interface RegenerationPromptContext {
+    operation: Operation;
+    currentSource: string;
+    failingInput: GeneratorInput;
+    fault: string;
+    stderr?: string;
+    examples?: readonly ExampleRequest[];
+}
+export declare function regenerationInstruction(ctx: RegenerationPromptContext): string;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/prompt.js

@@ -0,0 +1,188 @@
+import { AVAILABLE } from "./image.js";
+import { called } from "./spec.js";
+// ---------------------------------------------------------------------------
+// What the model is told
+//
+// A contract, not a request. The generator is a program with a fixed calling
+// convention that this package depends on in three places — the entry point,
+// the input shape, the output file — so those are stated as rules rather than
+// as suggestions, and everything discretionary is stated as taste.
+//
+// The one rule worth its own paragraph is the echo: a mock that answers
+// `GET /users/12324` with somebody else's id is worse than useless, because it
+// validates and quietly breaks whatever is being developed against it.
+// ---------------------------------------------------------------------------
+export const SYSTEM = [
+    'You write one Python 3 file that fabricates a plausible HTTP response body.',
+    '',
+    'CALLING CONVENTION',
+    '- `sys.argv[1]` is a path to a JSON file to read; `sys.argv[2]` is a path to write to.',
+    '- Write exactly one JSON document to `sys.argv[2]` and print nothing to stdout.',
+    '- Exit non-zero with a message on stderr if you cannot produce a valid body.',
+    '',
+    'THE INPUT FILE holds:',
+    '  operationId, method, path, pathParams, query, headers, body, seed',
+    '',
+    'ENVIRONMENT',
+    `- These libraries are installed: ${AVAILABLE.join(', ')}, plus the standard library.`,
+    '- There is no network and no pip. Importing anything else fails the file.',
+    '- Seed both `random.seed(seed)` and `Faker.seed(seed)` from the input, first thing.',
+    '',
+    'RULES',
+    '1. The output must validate against the response schema given below. Build the',
+    '   object, then check it with `jsonschema.validate` before writing, and fix it',
+    '   rather than emitting something that fails.',
+    '2. Echo the request. Where a path parameter has the same name as a property',
+    "   in the response schema, that property must carry the request's value,",
+    '   converted to the type the schema declares. `GET /users/{user_id}` called',
+    '   with `user_id=12324` answers with `user_id` 12324, not a random one. Do',
+    '   this generically, by looking the names up at run time. If the value would',
+    "   break that property's schema (it fails a `pattern`, say), the schema wins:",
+    '   generate a valid value instead, and do not exit non-zero. Do the same for a',
+    '   query parameter where it plainly describes the content rather than',
+    '   controlling the call. A paging control — a cursor, page, offset or',
+    '   page-size parameter (whether in query or request body) — is never content',
+    '   and must not be copied into the body; see PAGINATION below where the',
+    '   operation has one.',
+    '3. Every required property must be present. Optional ones may be omitted',
+    '   sometimes; that is what makes a mock useful.',
+    '4. Values must suit their names, not just their types. Use `faker` for anything',
+    '   a person would recognise — names, emails, addresses, companies, phone',
+    '   numbers, sentences. Use `exrex.getone(pattern)` when a string schema has a',
+    '   `pattern`. Respect `enum`, `format`, `minimum`, `maxLength` and friends.',
+    '5. Arrays get 1 to 5 items unless the schema says otherwise.',
+    '6. The file is run once per request and must be deterministic for a given seed.',
+    '',
+    'ANSWER WITH THE FILE AND NOTHING ELSE. No explanation, no markdown fence.',
+].join('\n');
+export function brief(operation) {
+    const lines = [
+        `OPERATION  ${operation.method.toUpperCase()} ${called(operation)}`,
+        `operationId: ${operation.operationId}`,
+    ];
+    if (operation.summary) {
+        lines.push(`summary: ${operation.summary}`);
+    }
+    if (operation.description && operation.description !== operation.summary) {
+        lines.push(`description: ${operation.description.slice(0, 600)}`);
+    }
+    lines.push('', 'PARAMETERS');
+    if (operation.params.length === 0) {
+        lines.push('  (none)');
+    }
+    for (const p of operation.params) {
+        const note = p.description ? `  # ${p.description.split('\n')[0].slice(0, 100)}` : '';
+        lines.push(`  ${p.name} (in ${p.in}${p.required ? ', required' : ''}): ${JSON.stringify(p.schema)}${note}`);
+    }
+    if (operation.requestBody) {
+        lines.push('', 'REQUEST BODY SCHEMA (arrives as `body`)', json(operation.requestBody.schema));
+    }
+    if (operation.paging) {
+        lines.push('', ...pagination(operation.paging));
+    }
+    lines.push('', `RESPONSE SCHEMA (status ${operation.success.status})`);
+    lines.push(operation.success.schema ? json(operation.success.schema) : '  (no body)');
+    return lines.join('\n');
+}
+/**
+ * Said only to the operations that page, and said in terms of their own
+ * property names. The rule that earns the paragraph is the third one: a body
+ * offering the token it was just given passes the schema, passes the echo rule,
+ * and hangs every client that walks the list.
+ */
+function pagination(paging) {
+    const advance = paging.style === 'cursor'
+        ? 'the base64 of a small JSON object holding the next page index, such as {"p": 2}'
+        : "the offset of the next page — this page's offset plus its size";
+    const where = paging.paramIn === 'body' ? 'In the request `body`, ' : '';
+    const lines = [
+        'PAGINATION',
+        `  This operation is paged. ${where}\`${paging.param}\` asks for a page;`,
+        '  absent or empty means the first one.',
+        '  - Fabricate a random number of pages between 1 and 10 in total and no more.',
+    ];
+    if (paging.next) {
+        lines.push(`  - \`${paging.next}\` carries the token for the page after this one.`, `    Build it out of \`${paging.param}\`:`, `    ${advance}.`, '  - Never build it out of `seed`. Unpinned, the seed changes on every', '    request; pinned, it is a function of the query. A token made from it', '    either wanders or never changes.', '  - It must strictly advance. Answering with the token you were given is', '    the one failure that matters: a client following it loops forever.');
+    }
+    if (paging.more && !stuck(paging)) {
+        lines.push(`  - \`${paging.more}\` is false on the last page and true before it.`);
+    }
+    if (paging.next) {
+        lines.push(...last(paging));
+    }
+    lines.push('  - A token you cannot read, or one past the end, is the last page,', `    ended the same way and with ${paging.items ? `\`${paging.items}\` empty` : 'nothing listed'}.`, '    Never an error, and never the first page again.');
+    return lines;
+}
+/**
+ * How the last page says so. A token that is required and cannot be null has
+ * nowhere to put the ending, so the ending has to be said some other way —
+ * telling the model to null it anyway would only ask for an invalid body.
+ */
+const stuck = (paging) => !paging.nextNullable && paging.nextRequired === true;
+function last(paging) {
+    if (paging.nextNullable) {
+        return [`  - On the last page set \`${paging.next}\` to null.`];
+    }
+    if (!stuck(paging)) {
+        return [`  - On the last page leave \`${paging.next}\` out.`];
+    }
+    const otherwise = [paging.more && `\`${paging.more}\` false`, paging.items && 'nothing listed']
+        .filter(Boolean)
+        .join(' and ');
+    return [
+        `  - The schema requires \`${paging.next}\` on every page, so the last page`,
+        `    ends the list the other way: ${otherwise || 'an empty page'} (e.g. \`${paging.items || 'results'}\` as an empty list \`[]\`).`,
+    ];
+}
+/**
+ * Repeated in the file the model writes, so it is worth spelling out: the
+ * schema it validates against must be the one it was shown, embedded, not
+ * loaded from anywhere.
+ */
+export function instruction(operation) {
+    return [
+        brief(operation),
+        '',
+        'Embed the response schema in the file as a literal and validate against it.',
+    ].join('\n');
+}
+export function retry(diagnostics) {
+    return [
+        'That file did not pass. Fix it and answer with the whole file again.',
+        '',
+        ...diagnostics,
+    ].join('\n');
+}
+export function regenerationInstruction(ctx) {
+    const { operation, currentSource, failingInput, fault, stderr, examples } = ctx;
+    const lines = [
+        brief(operation),
+        '',
+        'Embed the response schema in the file as a literal and validate against it.',
+        '',
+        'CURRENT GENERATOR CODE:',
+        '```python',
+        currentSource.trim(),
+        '```',
+        '',
+        'THE GENERATOR FAILED ON THIS REQUEST:',
+        'Input:',
+        json(failingInput),
+        '',
+        `Fault: ${fault}`,
+    ];
+    if (stderr && stderr.trim()) {
+        lines.push('', 'Stderr / Traceback:', '```', stderr.trim(), '```');
+    }
+    if (examples && examples.length > 0) {
+        lines.push('', 'PREVIOUS SUCCESSFUL REQUESTS (use as examples):');
+        for (let i = 0; i < examples.length; i++) {
+            const ex = examples[i];
+            lines.push(`Example ${i + 1}:`, 'Input:', json(ex.input), 'Output produced:', json(ex.output), '');
+        }
+    }
+    lines.push('TASK:', 'Fix the generator code so that it handles the failing request without error, produces valid output that matches the schema, and continues to produce valid output for the previous example requests.', 'ANSWER WITH THE COMPLETE REVISED PYTHON FILE AND NOTHING ELSE. No explanation, no markdown fence.');
+    return lines.join('\n');
+}
+const json = (value) => JSON.stringify(value, null, 1);
+//# sourceMappingURL=prompt.js.map

package/dist/router.d.ts

@@ -0,0 +1,20 @@
+import { type Method, type Operation } from './spec.ts';
+export interface Match {
+    operation: Operation;
+    pathParams: Record<string, string>;
+}
+export declare class Router {
+    #private;
+    readonly operations: readonly Operation[];
+    constructor(operations: readonly Operation[]);
+    match(method: string, pathname: string, search?: URLSearchParams): Match | undefined;
+    /** Whether the path exists under some other method — a 405, not a 404. */
+    allowed(pathname: string, search?: URLSearchParams): Method[];
+    /**
+     * The query strings this method would have answered on this path. Empty
+     * unless the document pinned one, which is the only way a request can miss
+     * a route whose path it matched exactly.
+     */
+    expects(method: string, pathname: string): string[];
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/router.js

@@ -0,0 +1,101 @@
+import { SpecError } from "./spec.js";
+export class Router {
+    #routes = new Map();
+    operations;
+    constructor(operations) {
+        this.operations = operations;
+        const seen = new Map();
+        for (const operation of operations) {
+            const fixed = Object.entries(operation.fixed ?? {}).sort(([a], [b]) => a.localeCompare(b));
+            const id = `${operation.method} ${operation.path}${query(fixed)}`;
+            const clash = seen.get(id);
+            if (clash) {
+                throw new SpecError(`${id} is declared twice`, `${clash.source} and ${operation.source} both define it`);
+            }
+            seen.set(id, operation);
+            const segments = compile(operation.path);
+            const list = this.#routes.get(operation.method) ?? [];
+            list.push({
+                operation,
+                segments,
+                fixed,
+                specificity: segments.filter((s) => s.name === undefined).length,
+            });
+            this.#routes.set(operation.method, list);
+        }
+        for (const list of this.#routes.values()) {
+            list.sort((a, b) => b.fixed.length - a.fixed.length || b.specificity - a.specificity);
+        }
+    }
+    match(method, pathname, search) {
+        const parts = split(pathname);
+        for (const route of this.#routes.get(method.toLowerCase()) ?? []) {
+            if (!pins(route, search)) {
+                continue;
+            }
+            const pathParams = apply(route.segments, parts);
+            if (pathParams) {
+                return { operation: route.operation, pathParams };
+            }
+        }
+        return undefined;
+    }
+    /** Whether the path exists under some other method — a 405, not a 404. */
+    allowed(pathname, search) {
+        const parts = split(pathname);
+        const out = [];
+        for (const [method, list] of this.#routes) {
+            if (list.some((r) => pins(r, search) && apply(r.segments, parts) !== undefined)) {
+                out.push(method);
+            }
+        }
+        return out;
+    }
+    /**
+     * The query strings this method would have answered on this path. Empty
+     * unless the document pinned one, which is the only way a request can miss
+     * a route whose path it matched exactly.
+     */
+    expects(method, pathname) {
+        const parts = split(pathname);
+        return (this.#routes.get(method.toLowerCase()) ?? [])
+            .filter((r) => r.fixed.length > 0 && apply(r.segments, parts) !== undefined)
+            .map((r) => query(r.fixed));
+    }
+}
+const query = (fixed) => fixed.length === 0 ? '' : `?${new URLSearchParams(fixed).toString()}`;
+const pins = (route, search) => route.fixed.every(([name, value]) => search?.get(name) === value);
+function compile(template) {
+    return split(template).map((raw) => {
+        const m = /^\{(.+)\}$/.exec(raw);
+        return m ? { name: m[1] } : { literal: decode(raw) };
+    });
+}
+const split = (path) => path.split('/').filter((s) => s.length > 0);
+function apply(segments, parts) {
+    if (segments.length !== parts.length) {
+        return undefined;
+    }
+    const out = {};
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (segment.name === undefined) {
+            if (segment.literal !== decode(parts[i])) {
+                return undefined;
+            }
+            continue;
+        }
+        out[segment.name] = decode(parts[i]);
+    }
+    return out;
+}
+/** A malformed escape is the client's problem; take the segment verbatim. */
+function decode(part) {
+    try {
+        return decodeURIComponent(part);
+    }
+    catch {
+        return part;
+    }
+}
+//# sourceMappingURL=router.js.map

package/dist/schema.d.ts

@@ -0,0 +1,21 @@
+export type Schema = Record<string, unknown>;
+export type Dialect = 'swagger-2.0' | 'openapi-3.0' | 'openapi-3.1';
+/**
+ * Converts a dereferenced schema into 2020-12, hoisting anything reached more
+ * than once into `$defs`. The result is acyclic and safe to stringify.
+ */
+export declare function normalize(root: unknown, dialect: Dialect): Schema;
+export interface Declared {
+    name: string;
+    /** the property's own schema, with a `$defs` pointer already followed */
+    schema: Schema;
+    /** whether the object declaring it lists it in `required` */
+    required: boolean;
+    /** how many objects deep it sits; 0 is the top level */
+    depth: number;
+}
+/** Every property a schema declares, at any depth, nearest first. */
+export declare function properties(root: Schema): Declared[];
+/** Every property name a schema mentions, at any depth. */
+export declare const propertyNames: (root: Schema) => Set<string>;
+//# sourceMappingURL=schema.d.ts.map