@zenera/gym 1.1.39 → 1.1.41

package/dist/command.js

@@ -1,14 +1,17 @@
-import { bold, cacheItems, clearCache, CliError, cyan, dim, EXIT, green, json, KeyStore, note, ownedContainers, parse, paths, red, removeContainers, table, usageError, write, writeAll, yellow, } from '@zenera/cli/lib';
-import { createModel } from '@zenera/neo';
-import { rmSync } from 'node:fs';
+import "./quiet.js";
+import { bold, cacheItems, clearCache, CliError, cyan, dim, EXIT, green, json, KeyStore, note, parse, paths, red, table, usageError, write, writeAll, yellow, } from '@zenera/cli/lib';
+import { createEmbedder, createModel } from '@zenera/neo';
+import { existsSync, rmSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
-import { CONTAINER_PREFIX, GENERATORS } from "./box.js";
+import { BINDINGS_KIND } from "./bindings.js";
+import { HANDLERS } from "./box.js";
 import { GYM_KIND } from "./cache.js";
 import { reason } from "./generate.js";
 import { formatDumpPath } from "./logger.js";
 import { listen } from "./server.js";
-import { chooseModel, MODEL_ENV, open, readSettings, SOURCE_LABELS, writeSettings, } from "./setup.js";
+import { configuredEmbedding, chooseModel, EMBEDDING_ENV, MODEL_ENV, open, readSettings, SOURCE_LABELS, writeSettings, } from "./setup.js";
 import { called } from "./spec.js";
+import { listWorlds, removeWorld, worldPath, worldsDir } from "./store.js";
 // ---------------------------------------------------------------------------
 // zen gym — a mock API from a specification
 //
@@ -20,14 +23,19 @@ import { called } from "./spec.js";
 // resolve until a signal arrives, and the process lives as long as the answer
 // takes, which is what every other command already means.
 // ---------------------------------------------------------------------------
-const USAGE = 'zen gym <serve|build|cache|model> [spec...]';
+const USAGE = 'zen gym <serve|build|cache|world|model> [spec...]';
+const SERVE_USAGE = 'zen gym serve [spec...] [--schema <path>]... [--story <path>]... [--docs <path>]... [--world <name|file>]';
 // `--json` is the frame's, lifted out of the arguments before they arrive; it
 // reaches us as `ctx.json` and must not be declared again or `strict` rejects it.
 const OPTIONS = {
     port: { type: 'string' },
     host: { type: 'string' },
     model: { type: 'string' },
-    image: { type: 'string' },
+    schema: { type: 'string', multiple: true },
+    story: { type: 'string', multiple: true },
+    docs: { type: 'string', multiple: true },
+    world: { type: 'string' },
+    embedding: { type: 'string' },
     cache: { type: 'string' },
     attempts: { type: 'string' },
     concurrency: { type: 'string' },
@@ -37,6 +45,7 @@ const OPTIONS = {
     'regen-limit': { type: 'string' },
     'requests-dir': { type: 'string' },
     rebuild: { type: 'boolean' },
+    reset: { type: 'boolean' },
     'no-cache': { type: 'boolean' },
     clear: { type: 'boolean' },
     quiet: { type: 'boolean' },
@@ -47,34 +56,59 @@ export const command = {
     details: [
         'Commands',
         ...table([
-            ['  serve <spec...>', dim('Serve the documents. Generators are written on demand.')],
-            ['  build <spec...>', dim('Write every generator now and exit.')],
-            ['  cache ls|clear', dim('What has been generated, or throw it away.')],
-            ['  model [ref]', dim('Show or set the model it uses. Remembered between runs.')],
+            ['  serve [spec...]', dim('Serve the APIs. Handlers are written on first use.')],
+            ['  build [spec...]', dim('Index everything and write every handler, then exit.')],
+            ['  cache ls|clear', dim('Handlers, bindings and indexes: list them, or clear them.')],
+            ['  world ls|rm <name>', dim('Worlds are data: list them, or delete one.')],
+            ['  model [ref]', dim('Show or set the models it uses. Remembered between runs.')],
         ]),
         '',
         'Options',
         ...table([
             ['  --port <n>', dim('Default 8787.')],
             ['  --host <h>', dim('Default 127.0.0.1. Anything else is reachable off-machine.')],
-            ['  --model <ref>', dim('Which model writes the generators, for this run only.')],
-            ['  --image <ref>', dim('Skip the baked image and use this one.')],
-            ['  --cache <dir>', dim("The container's workspace. Default ~/.zenera/neo/gym.")],
+            [
+                '  --schema <path>',
+                dim('API documents: files, directories, quoted globs. Repeatable.'),
+            ],
+            ['  --story <path>', dim('The state of the world, quoted to every agent. Repeatable.')],
+            ['  --docs <path>', dim('Reference material, searched by agents. Repeatable.')],
+            [
+                '  --world <name|file>',
+                dim('Which world. Default: one per story, shared by processes.'),
+            ],
+            ['  --reset', dim('Start from an empty world.')],
+            ['  --model <ref>', dim('Which model writes handlers and content, for this run only.')],
+            [
+                '  --embedding <on|ref>',
+                dim('Search --docs by meaning too: `on` for the configured model, or a ref.'),
+            ],
+            [
+                '  --cache <dir>',
+                dim('Handlers, worlds, indexes and reports. Default ~/.zenera/neo/gym.'),
+            ],
             ['  --seed <n>', dim('Answer the same request the same way every time.')],
-            ['  --attempts <n>', dim('Tries per generator before giving up. Default 5.')],
-            ['  --concurrency <n>', dim('Generators written at once. Default 4.')],
-            ['  --timeout <s>', dim('Seconds one generator may take. Default 30.')],
+            ['  --attempts <n>', dim('Failed tests per handler before giving up. Default 5.')],
+            ['  --concurrency <n>', dim('Handlers written at once. Default 4.')],
+            ['  --timeout <s>', dim('Seconds one handler may run, agent time aside. Default 30.')],
             ['  --max-body <n>', dim('Largest request body accepted, in bytes.')],
             ['  --regen-limit <n>', dim('Maximum regenerations per URL on error. Default 3.')],
             ['  --requests-dir <dir>', dim('Where to save request/response .md files.')],
             ['  --rebuild', dim('Ignore what is cached and write it again.')],
             ['  --no-cache', dim('Do not record what is written.')],
-            ['  --clear', dim('With `model`: forget the stored one.')],
+            [
+                '  --clear',
+                dim('With `model`: forget the stored model. `--embedding clear` forgets that one.'),
+            ],
             ['  --quiet', dim('No narration.')],
         ]),
         '',
         dim(`The model is looked for in this order: ${cyan('--model')}, ${cyan(MODEL_ENV)}, ` +
             `${cyan('zen gym model')}, then the best one your keys can buy.`),
+        dim(`Docs are searched by wording unless ${cyan('--embedding')} is given. ` +
+            `${cyan('--embedding on')} uses ${cyan(EMBEDDING_ENV)}, then ` +
+            `${cyan('zen gym model --embedding')}, then the first model your keys offer.`),
+        dim(`Quote globs (${cyan("--docs 'kb/*.md'")}) so the shell leaves them to gym.`),
         dim(`Credentials come from the ${cyan('zen')} keyring — try ${cyan('zen key ls')}.`),
     ],
     async run(ctx) {
@@ -86,6 +120,8 @@ export const command = {
                 return await warm(rest, ctx);
             case 'cache':
                 return await cache(rest, ctx);
+            case 'world':
+                return await worlds(rest, ctx);
             case 'model':
                 return await model(rest, ctx);
             default:
@@ -97,12 +133,8 @@ export const command = {
 // serve
 // ---------------------------------------------------------------------------
 async function serve(args, ctx) {
-    const { values, positionals } = parse(args, OPTIONS, 'zen gym serve <spec...>');
-    const loud = !values.quiet && !ctx.json;
+    const { values, positionals } = parse(args, OPTIONS, SERVE_USAGE);
     const setup = await start(values, positionals, ctx, 'serve');
-    if (loud) {
-        printSpecs(setup.router.operations, ctx.cwd);
-    }
     const host = values.host ?? '127.0.0.1';
     const requestsDir = values['requests-dir']
         ? resolve(ctx.cwd, values['requests-dir'])
@@ -124,9 +156,9 @@ async function serve(args, ctx) {
         if (host !== '127.0.0.1' && host !== 'localhost') {
             note(yellow(`bound to ${host} — this mock is reachable from the network`));
         }
-        note(dim(`generators: ${setup.root}/${GENERATORS}`));
+        note(dim(`handlers: ${setup.root}/${HANDLERS}`));
         note(dim(`request logs: ${requestsDir ?? `${setup.root}/requests`}`));
-        note(dim(`failed builds: ${setup.root}/builds`));
+        note(dim(`agent runs: ${setup.root}/reports  failed builds: ${setup.root}/builds`));
     }
     // The address is the answer; the rest was narration.
     write(`http://${host}:${listener.port}`);
@@ -152,26 +184,19 @@ function until(signals) {
     });
 }
 // ---------------------------------------------------------------------------
-// build — every generator, up front
+// build — every handler, up front
 // ---------------------------------------------------------------------------
 async function warm(args, ctx) {
-    const { values, positionals } = parse(args, OPTIONS, 'zen gym build <spec...>');
+    const { values, positionals } = parse(args, OPTIONS, SERVE_USAGE.replace('serve', 'build'));
     const loud = !values.quiet && !ctx.json;
     const setup = await start(values, positionals, ctx, 'build');
-    if (loud) {
-        printSpecs(setup.router.operations, ctx.cwd);
-    }
     const results = [];
     try {
         for (const operation of setup.router.operations) {
             const id = `${operation.method.toUpperCase()} ${called(operation)}`;
-            if (!operation.success.schema) {
-                results.push({ operation: id, status: 'skipped', detail: 'no response body' });
-                continue;
-            }
             try {
-                const generator = await setup.cache.ensure(operation);
-                results.push({ operation: id, status: generator.cached ? 'cached' : 'built' });
+                const handler = await setup.cache.ensure(operation);
+                results.push({ operation: id, status: handler.cached ? 'cached' : 'built' });
             }
             catch (err) {
                 results.push({
@@ -198,7 +223,7 @@ async function warm(args, ctx) {
     // Reported first, then failed: the table is the answer either way.
     const failed = results.filter((r) => r.status === 'failed').length;
     if (failed > 0) {
-        throw new CliError(`${failed} of ${results.length} generators failed`, EXIT.failed, 'run again to retry, or raise --attempts');
+        throw new CliError(`${failed} of ${results.length} handlers failed`, EXIT.failed, 'run again to retry, or raise --attempts');
     }
 }
 const mark = (status) => status === 'failed' ? red('failed') : status === 'skipped' ? dim('skipped') : green(status);
@@ -210,7 +235,7 @@ async function cache(args, ctx) {
     const root = values.cache ? resolve(ctx.cwd, values.cache) : paths.gym();
     const sub = positionals[0] ?? 'ls';
     if (sub === 'ls') {
-        const entries = listGenerators();
+        const entries = listHandlers();
         if (ctx.json) {
             json(entries);
             return;
@@ -232,17 +257,14 @@ async function cache(args, ctx) {
     }
     if (sub === 'clear') {
         clearCache({ kind: GYM_KIND });
+        clearCache({ kind: BINDINGS_KIND });
         // The workspace is scratch — whatever a hit was copied into it is
-        // written again from the cache, or by the model.
-        rmSync(join(root, GENERATORS), { recursive: true, force: true });
-        // The container is named after its configuration, so a stale one would
-        // otherwise sit there stopped forever with nothing pointing at it.
-        // `zn-<key>-<digest>` is the shape, and this one's key is `gym`.
-        const mine = (await ownedContainers()).filter((c) => c.name.startsWith(CONTAINER_PREFIX));
-        if (mine.length > 0) {
-            await removeContainers(mine.map((c) => c.name));
-        }
-        note(`${green('cleared')} ${dim(paths.cache())}`);
+        // written again from the cache, or by the model — and an index is
+        // rebuilt from the documents. Worlds are not touched: they are data,
+        // and `zen gym world rm` or `serve --reset` is how one goes.
+        rmSync(join(root, HANDLERS), { recursive: true, force: true });
+        rmSync(join(root, 'indexes'), { recursive: true, force: true });
+        note(`${green('cleared')} ${dim(`handlers, bindings and indexes; worlds kept in ${worldsDir(root)}`)}`);
         return;
     }
     throw usageError(`unknown cache command "${sub}"`, 'zen gym cache <ls|clear>');
@@ -252,7 +274,7 @@ async function cache(args, ctx) {
  * listed at all. Anything the store cannot parse is left out rather than shown
  * as a row with nothing in it.
  */
-function listGenerators() {
+function listHandlers() {
     const { rows } = cacheItems(GYM_KIND);
     return rows
         .map((row) => ({ key: row.key, ...row.value?.meta }))
@@ -266,7 +288,7 @@ function listGenerators() {
 // this machine. Shown rather than merely set, since the question when a run
 // surprises you is not "which model" but "why that one".
 // ---------------------------------------------------------------------------
-const MODEL_USAGE = 'zen gym model [ref|--clear]';
+const MODEL_USAGE = 'zen gym model [ref|--clear] [--embedding <ref|none> [--clear]]';
 async function model(args, ctx) {
     const { values, positionals } = parse(args, OPTIONS, MODEL_USAGE);
     const ref = positionals[0];
@@ -277,27 +299,60 @@ async function model(args, ctx) {
     // environment, and the keyring is what puts it there.
     const keys = await KeyStore.open();
     keys.materialize();
-    if (ref || values.clear) {
+    // `--embedding <ref>` sets that one; `--embedding --clear` is not
+    // expressible with a string flag, so `--clear` with no ref and no
+    // `--embedding` clears the chat model and `--embedding none` stores none.
+    const embedding = values.embedding?.trim();
+    if (ref || values.clear || embedding) {
         const file = await readSettings();
         if (ref) {
             // Only that the ref parses: asking the provider costs a call, and
             // the next run makes one anyway.
             createModel(ref);
-            writeSettings({ ...file, model: ref });
+            file.model = ref;
         }
-        else {
+        else if (values.clear && !embedding) {
             delete file.model;
-            writeSettings(file);
         }
-        if (ctx.json) {
-            json({ model: ref });
-            return;
+        if (embedding === 'clear') {
+            delete file.embedding;
+        }
+        else if (embedding) {
+            if (embedding === 'on' || embedding === 'default') {
+                throw usageError(`${embedding} is what \`serve --embedding\` asks for; store a model ref, or none`, MODEL_USAGE);
+            }
+            if (embedding !== 'none') {
+                createEmbedder(embedding);
+            }
+            file.embedding = embedding;
+        }
+        writeSettings(file);
+        if (!ctx.json) {
+            if (ref) {
+                note(`${green('set')} ${ref}`);
+            }
+            else if (values.clear && !embedding) {
+                note(`${green('cleared')} ${dim('the stored model')}`);
+            }
+            if (embedding) {
+                note(embedding === 'clear'
+                    ? `${green('cleared')} ${dim('the stored embedding model')}`
+                    : `${green('set')} ${dim('embedding')} ${embedding}`);
+            }
         }
-        note(ref ? `${green('set')} ${ref}` : `${green('cleared')} ${dim('the stored model')}`);
     }
-    const chosen = await chooseModel(values.model, keys);
+    const chosen = await chooseModel(ref ? undefined : values.model, keys);
+    const embedder = await configuredEmbedding(keys);
     if (ctx.json) {
-        json({ model: chosen?.ref, from: chosen?.from, stored: (await readSettings()).model });
+        const stored = await readSettings();
+        json({
+            model: chosen?.ref,
+            from: chosen?.from,
+            stored: stored.model,
+            embedding: embedder.ref ?? 'none',
+            embeddingFrom: embedder.from,
+            storedEmbedding: stored.embedding,
+        });
         return;
     }
     if (!chosen) {
@@ -305,11 +360,68 @@ async function model(args, ctx) {
         note(dim('add a key: zen key add openai'));
         return;
     }
-    note(`${cyan(chosen.ref)} ${dim(`from ${SOURCE_LABELS[chosen.from]}`)}`);
+    note(`${dim('model    ')} ${cyan(chosen.ref)} ${dim(`from ${SOURCE_LABELS[chosen.from]}`)}`);
+    note(`${dim('embedding')} ${embedder.ref ? cyan(embedder.ref) : yellow('none')} ` +
+        dim((embedder.from === 'none'
+            ? ''
+            : `from ${embedder.from === 'env' ? EMBEDDING_ENV : SOURCE_LABELS[embedder.from]} · `) +
+            'used only with --embedding on; docs are searched by wording otherwise'));
     if (chosen.from === 'default') {
         note(dim(`set one: zen gym model <provider>:<id>`));
     }
 }
+// ---------------------------------------------------------------------------
+// world
+//
+// Worlds are data rather than cache — they hold what clients wrote, and
+// content an agent made that would come out differently next time — so they
+// have a command of their own and `cache clear` leaves them alone.
+// ---------------------------------------------------------------------------
+const WORLD_USAGE = 'zen gym world <ls|rm <name|file>>';
+async function worlds(args, ctx) {
+    const { values, positionals } = parse(args, OPTIONS, WORLD_USAGE);
+    const root = values.cache ? resolve(ctx.cwd, values.cache) : paths.gym();
+    const [sub = 'ls', target] = positionals;
+    if (sub === 'ls') {
+        const found = listWorlds(root);
+        if (ctx.json) {
+            json(found);
+            return;
+        }
+        if (found.length === 0) {
+            note(`no worlds yet in ${worldsDir(root)}`);
+            return;
+        }
+        writeAll(table([
+            [bold('WORLD'), bold('RECORDS'), bold('COLLECTIONS'), bold('USED'), bold('SIZE')],
+            ...found.map((w) => [
+                w.name,
+                String(w.collections.reduce((n, c) => n + c.count, 0)),
+                dim(w.collections
+                    .map((c) => `${c.name} ${c.count}`)
+                    .join(', ')
+                    .slice(0, 60) || '—'),
+                dim(w.usedAt.toISOString().slice(0, 16).replace('T', ' ')),
+                dim(`${Math.ceil(w.bytes / 1024)} KB`),
+            ]),
+        ]));
+        note(dim(worldsDir(root)));
+        return;
+    }
+    if (sub === 'rm') {
+        if (!target) {
+            throw usageError('name the world to remove', WORLD_USAGE);
+        }
+        const path = worldPath({ root, cwd: ctx.cwd, world: target });
+        if (!existsSync(path)) {
+            throw usageError(`no world at ${path}`, 'see them with: zen gym world ls');
+        }
+        removeWorld(path);
+        note(`${green('removed')} ${dim(path)}`);
+        return;
+    }
+    throw usageError(`unknown world command "${sub}"`, WORLD_USAGE);
+}
 function summarize(operations) {
     const by = new Map();
     for (const op of operations) {
@@ -355,28 +467,82 @@ function printSpecs(operations, cwd) {
     }
     note('');
 }
+/** The rest of what was loaded, and what it will be served with. */
+function printInputs(setup) {
+    const k = setup.knowledge;
+    const rows = [
+        ['model', `${setup.choice.ref} ${dim(`from ${SOURCE_LABELS[setup.choice.from]}`)}`],
+        [
+            'story',
+            k.storyFiles > 0
+                ? `${k.storyFiles} file${k.storyFiles === 1 ? '' : 's'}`
+                : dim('none — the agents invent a world'),
+        ],
+    ];
+    if (k.docs) {
+        rows.push([
+            'docs',
+            `${k.docs.files} files, ${k.docs.chunks} chunks · ` +
+                (k.docs.search === 'hybrid'
+                    ? `search by meaning and wording (${k.docs.embedding})`
+                    : `search by wording ${dim('(--embedding <ref> adds meaning)')}`) +
+                dim(k.docs.reused ? ' · index reused' : ' · indexed'),
+        ]);
+    }
+    rows.push(['world', setup.worldFile]);
+    for (const line of table(rows.map(([a, b]) => [`  ${dim(a)}`, b]))) {
+        note(line);
+    }
+    note('');
+}
+/** Narrates indexing at the quarters, so a long first run is not silent. */
+function indexing() {
+    let last = '';
+    return (phase, done, total) => {
+        const quarter = total === 0 ? 4 : Math.floor((done / total) * 4);
+        const mark = `${phase}:${quarter}`;
+        if (mark === last || total === 0) {
+            return;
+        }
+        last = mark;
+        note(dim(`  ${phase === 'reading' ? 'reading docs' : 'embedding docs'} ${done}/${total}`));
+    };
+}
 // ---------------------------------------------------------------------------
 // Shared
 // ---------------------------------------------------------------------------
-async function start(values, specs, ctx, what) {
+async function start(values, positionals, ctx, what) {
     const loud = !values.quiet && !ctx.json;
+    const progress = loud ? indexing() : undefined;
     const setup = await open({
-        specs,
+        schemas: [...positionals, ...(values.schema ?? [])],
+        story: values.story,
+        docs: values.docs,
         cwd: ctx.cwd,
         cache: values.cache,
         model: values.model,
-        image: values.image,
+        embedding: values.embedding,
+        world: values.world,
+        reset: values.reset,
         attempts: number(values.attempts, 'attempts'),
         concurrency: number(values.concurrency, 'concurrency'),
         timeout: number(values.timeout, 'timeout'),
         rebuild: values.rebuild,
         ephemeral: values['no-cache'],
-        onImageBuild: loud
-            ? (tag) => note(`${dim('building')} ${tag} ${dim('— once, then cached')}`)
+        onWarn: loud ? (message) => note(yellow(message)) : undefined,
+        onIndexing: progress,
+        onWorld: loud
+            ? (e) => note(`  ${e.fallback ? yellow('sampled') : green('world')} ${dim(`${e.made} × ${e.collection} in ${e.durationMs}ms`)}` +
+                (e.dependents ? dim(` + ${e.dependents} they refer to`) : '') +
+                (e.fallback ? ` ${dim(e.fallback)}` : '') +
+                (e.dangling?.length
+                    ? `\n  ${yellow('dangling')} ${dim(e.dangling.slice(0, 5).join(', '))}`
+                    : '') +
+                (e.report ? `\n${formatDumpPath('agent run', e.report)}` : ''))
             : undefined,
         events: {
             onStart: loud
-                ? ({ operation }) => note(`${dim('writing a generator for')} ${operation.method.toUpperCase()} ${called(operation)}`)
+                ? ({ operation }) => note(`${dim('writing a handler for')} ${operation.method.toUpperCase()} ${called(operation)}`)
                 : undefined,
             onAttempt: loud
                 ? ({ operation, attempt, diagnostics }) => note(`  ${yellow(`attempt ${attempt} failed`)} ${dim(`${operation.operationId}: ${(diagnostics ?? []).join(' ').slice(0, 160)}`)}`)
@@ -397,7 +563,8 @@ async function start(values, specs, ctx, what) {
         },
     });
     if (loud) {
-        note(dim(`model ${setup.choice.ref} from ${SOURCE_LABELS[setup.choice.from]}`));
+        printSpecs(setup.router.operations, ctx.cwd);
+        printInputs(setup);
     }
     return setup;
 }

package/dist/fake.d.ts

@@ -0,0 +1,4 @@
+type Schema = Record<string, unknown>;
+export declare function sample(schema: unknown, types: Readonly<Record<string, Schema>>, seed?: number): unknown;
+export {};
+//# sourceMappingURL=fake.d.ts.map

package/dist/fake.js

@@ -0,0 +1,142 @@
+import RandExp from 'randexp';
+const WORDS = ['alpha', 'bravo', 'charlie', 'delta', 'echo', 'foxtrot', 'golf', 'hotel'];
+export function sample(schema, types, seed = 1) {
+    let state = seed >>> 0 || 1;
+    const random = () => {
+        state = (Math.imul(state, 1103515245) + 12345) >>> 0;
+        return state / 4294967296;
+    };
+    const int = (min, max) => min + Math.floor(random() * (max - min + 1));
+    return value(schema, 0);
+    function value(node, depth) {
+        if (!isObject(node) || depth > 8) {
+            return null;
+        }
+        const ref = typeof node.$ref === 'string' ? refName(node.$ref) : undefined;
+        if (ref !== undefined) {
+            const target = types[ref] ?? defs(node)?.[ref];
+            return target ? value(target, depth + 1) : null;
+        }
+        if ('const' in node) {
+            return node.const;
+        }
+        if (Array.isArray(node.enum) && node.enum.length > 0) {
+            return node.enum[int(0, node.enum.length - 1)];
+        }
+        if (Array.isArray(node.allOf)) {
+            const merged = {};
+            for (const part of node.allOf) {
+                const v = value(part, depth + 1);
+                if (isObject(v)) {
+                    Object.assign(merged, v);
+                }
+            }
+            const own = node.properties ? value({ ...node, allOf: undefined }, depth + 1) : {};
+            return { ...merged, ...(isObject(own) ? own : {}) };
+        }
+        for (const key of ['oneOf', 'anyOf']) {
+            const branches = node[key];
+            if (Array.isArray(branches) && branches.length > 0) {
+                return value(branches[0], depth + 1);
+            }
+        }
+        switch (typeOf(node)) {
+            case 'null':
+                return null;
+            case 'boolean':
+                return random() < 0.5;
+            case 'integer':
+                return Math.round(bounded(node, int(1, 1000)));
+            case 'number':
+                return bounded(node, int(1, 100000) / 100);
+            case 'array': {
+                // Recursive types end where the schema lets them: empty lists, deep down.
+                const min = num(node.minItems) ?? (depth >= 3 ? 0 : 1);
+                const max = Math.max(min, Math.min(num(node.maxItems) ?? 3, min + 2));
+                return Array.from({ length: int(min, max) }, () => value(node.items, depth + 1));
+            }
+            case 'object': {
+                const out = {};
+                const props = isObject(node.properties) ? node.properties : {};
+                const required = new Set(Array.isArray(node.required) ? node.required : []);
+                for (const [name, sub] of Object.entries(props)) {
+                    if (required.has(name) || (depth < 3 && random() < 0.6)) {
+                        out[name] = value(sub, depth + 1);
+                    }
+                }
+                if (isObject(node.additionalProperties) && Object.keys(props).length === 0) {
+                    out[WORDS[int(0, WORDS.length - 1)]] = value(node.additionalProperties, depth + 1);
+                }
+                return out;
+            }
+            default:
+                return text(node);
+        }
+    }
+    function text(node) {
+        if (typeof node.pattern === 'string') {
+            try {
+                const gen = new RandExp(node.pattern);
+                gen.max = 6;
+                gen.randInt = int;
+                return gen.gen();
+            }
+            catch {
+                // an unreadable pattern falls through to plain text
+            }
+        }
+        const at = new Date(Date.UTC(2026, 0, 1) + int(0, 300) * 86_400_000 + int(0, 86_399) * 1000);
+        switch (node.format) {
+            case 'date-time':
+                return at.toISOString().replace(/\.\d+Z$/, 'Z');
+            case 'date':
+                return at.toISOString().slice(0, 10);
+            case 'email':
+                return `${WORDS[int(0, WORDS.length - 1)]}@example.com`;
+            case 'uuid':
+                return '00000000-0000-4000-8000-'.concat(Array.from({ length: 12 }, () => int(0, 15).toString(16)).join(''));
+            case 'uri':
+            case 'url':
+                return `https://example.com/${WORDS[int(0, WORDS.length - 1)]}`;
+            case 'ipv4':
+                return `10.0.${int(0, 255)}.${int(1, 254)}`;
+            default:
+                break;
+        }
+        const min = num(node.minLength) ?? 0;
+        const max = num(node.maxLength) ?? 64;
+        const word = `${WORDS[int(0, WORDS.length - 1)]} ${WORDS[int(0, WORDS.length - 1)]}`;
+        return word.padEnd(min, 'x').slice(0, Math.max(min, Math.min(max, word.length)));
+    }
+}
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const num = (v) => (typeof v === 'number' ? v : undefined);
+function refName(ref) {
+    const m = /^#\/(?:\$defs|definitions|components\/schemas)\/(.+)$/.exec(ref);
+    return m ? decodeURIComponent(m[1]).replace(/~1/g, '/').replace(/~0/g, '~') : undefined;
+}
+/** A dereferenced schema keeps its shared parts under its own `$defs`. */
+const defs = (node) => isObject(node.$defs) ? node.$defs : undefined;
+function typeOf(node) {
+    const t = node.type;
+    if (typeof t === 'string') {
+        return t;
+    }
+    if (Array.isArray(t)) {
+        return t.find((x) => x !== 'null');
+    }
+    return node.properties ? 'object' : node.items ? 'array' : undefined;
+}
+function bounded(node, wanted) {
+    const min = num(node.minimum) ?? num(node.exclusiveMinimum);
+    const max = num(node.maximum) ?? num(node.exclusiveMaximum);
+    let v = wanted;
+    if (min !== undefined && v <= min) {
+        v = min + 1;
+    }
+    if (max !== undefined && v >= max) {
+        v = max - 1;
+    }
+    return v;
+}
+//# sourceMappingURL=fake.js.map