@zenera/gym 1.1.40 → 1.1.41

package/dist/cache.js

@@ -1,8 +1,9 @@
-import { Cache as Store } from '@zenera/cli/lib';
+import { Cache as Store, paths } from '@zenera/cli/lib';
 import { join } from 'node:path';
-import { build, BuildFailed, regenerate } from "./generate.js";
+import { build, BuildFailed } from "./generate.js";
 import { saveBuildDump } from "./logger.js";
-import { GENERATOR_RULES_VERSION } from "./spec.js";
+import { CONTRACT_VERSION } from "./spec.js";
+import { leaseOwner, WorldStore } from "./store.js";
 // ---------------------------------------------------------------------------
 // The cache
 //
@@ -11,36 +12,45 @@ import { GENERATOR_RULES_VERSION } from "./spec.js";
 // simply never asked for again — there is nothing to invalidate, which is the
 // part of a cache that is usually wrong.
 //
-// The generator itself lives in the machine's shared cache rather than beside
-// the container's workspace, so the same spec served from two directories is
+// The handler itself lives in the machine's shared cache rather than beside
+// the box's workspace, so the same spec served from two directories is
 // written once. The box root is scratch: a hit is copied back into it, because
-// the container can only run what is under its mount.
+// the worker imports a file, not a string.
 //
 // The in-flight map is the other half and matters more than it looks: ten
 // requests arriving together for an uncached operation must produce one build,
 // not ten. A failed build is remembered too, for the same reason — an operation
 // the model could not write for should not re-ask on every request.
 // ---------------------------------------------------------------------------
-export const GYM_KIND = 'gym-generator';
+export const GYM_KIND = 'gym-handler';
 const DEFAULT_CONCURRENCY = 4;
+/** Longer than any build; a crashed builder's lease lapses at once. */
+const BUILD_LEASE_MS = 20 * 60_000;
+const BUILD_POLL_MS = 500;
 export class Cache {
     #opts;
     #store;
     #dumpDir;
+    #reportDir;
     #records = new Map();
     #live = new Map();
     #settled = new Set();
     #slots;
+    #leaseFile;
+    #owner = leaseOwner();
+    #leaseStore;
     #waiting = [];
     #running = 0;
     constructor(opts) {
         this.#opts = opts;
         this.#store = new Store(GYM_KIND, { dir: opts.cacheDir, mode: 0o600 });
+        this.#leaseFile = join(opts.cacheDir ?? paths.cache(), GYM_KIND, 'leases.sqlite');
         this.#dumpDir = opts.dumpDir ?? join(opts.box.root, 'builds');
+        this.#reportDir = opts.reportDir ?? join(opts.box.root, 'reports');
         this.#slots = Math.max(1, opts.concurrency ?? DEFAULT_CONCURRENCY);
     }
     /**
-     * The generator for an operation, written if it does not exist yet. Callers
+     * The handler for an operation, written if it does not exist yet. Callers
      * that arrive during a build wait for that build rather than starting one.
      *
      * `cached` answers "did this call cost a model turn", which is what the
@@ -78,37 +88,12 @@ export class Cache {
         return found?.source?.trim() ? found.source : undefined;
     }
     async regenerate(operation, ctx) {
-        const { box, model, checks, ephemeral } = this.#opts;
+        const { box } = this.#opts;
         await this.#enter();
         this.#opts.onStart?.({ operation });
         try {
-            const built = await regenerate(operation, {
-                model,
-                box,
-                checks,
-                attempts: this.#opts.attempts,
-                currentSource: ctx.currentSource,
-                failingInput: ctx.failingInput,
-                fault: ctx.fault,
-                stderr: ctx.stderr,
-                examples: ctx.examples,
-                onAttempt: (attempt, diagnostics, source, limit) => this.#rejected(operation, attempt, diagnostics, source, limit, true),
-            });
-            if (!ephemeral) {
-                this.#store.put(operation.key, {
-                    source: built.source,
-                    meta: {
-                        operationId: operation.operationId,
-                        method: operation.method,
-                        path: operation.path,
-                        source: operation.source,
-                        model: model.id,
-                        attempts: built.attempts,
-                        rulesVersion: GENERATOR_RULES_VERSION,
-                        createdAt: new Date().toISOString(),
-                    },
-                });
-            }
+            const built = await build(operation, this.#builder(operation, true), ctx);
+            this.#keep(operation, built);
             this.#opts.onReady?.({ operation, cached: false, attempts: built.attempts });
             const gen = { key: operation.key, source: built.source, cached: false };
             this.#settled.add(operation.key);
@@ -128,8 +113,44 @@ export class Cache {
             this.#leave();
         }
     }
+    #builder(operation, regeneration) {
+        const { box, model, checks, catalog, world, operations, bindings } = this.#opts;
+        return {
+            model,
+            box,
+            checks,
+            catalog,
+            world,
+            bindings,
+            operations,
+            attempts: this.#opts.attempts,
+            reportDir: this.#reportDir,
+            sourceOf: (other) => this.getSource(other.key),
+            onAttempt: (attempt, diagnostics, source, limit) => this.#rejected(operation, attempt, diagnostics, source, limit, regeneration),
+        };
+    }
+    #keep(operation, built) {
+        if (this.#opts.ephemeral) {
+            return;
+        }
+        const { source, attempts, bindings } = built;
+        this.#store.put(operation.key, {
+            source,
+            bindings,
+            meta: {
+                operationId: operation.operationId,
+                method: operation.method,
+                path: operation.path,
+                source: operation.source,
+                model: this.#opts.model.id,
+                attempts,
+                rulesVersion: CONTRACT_VERSION,
+                createdAt: new Date().toISOString(),
+            },
+        });
+    }
     async #make(operation) {
-        const { box, model, checks, rebuild, ephemeral } = this.#opts;
+        const { box, rebuild } = this.#opts;
         // Read before queueing: a cache hit costs nothing and must not wait
         // behind somebody else's model call.
         const source = rebuild ? undefined : await this.#read(box, operation.key);
@@ -137,31 +158,30 @@ export class Cache {
             this.#opts.onReady?.({ operation, cached: true, attempts: 0 });
             return { key: operation.key, source, cached: true };
         }
+        // Another process writing the same handler — same documents, other
+        // port — is waited for, and its handler read, rather than paid for twice.
+        const lease = `build:${operation.key}`;
+        while (!this.#leases().claim(lease, this.#owner, BUILD_LEASE_MS)) {
+            await new Promise((settle) => setTimeout(settle, BUILD_POLL_MS));
+            const theirs = await this.#read(box, operation.key);
+            if (theirs !== undefined) {
+                this.#opts.onReady?.({ operation, cached: true, attempts: 0 });
+                return { key: operation.key, source: theirs, cached: true };
+            }
+        }
+        try {
+            return await this.#write(operation);
+        }
+        finally {
+            this.#leases().release(lease, this.#owner);
+        }
+    }
+    async #write(operation) {
         await this.#enter();
         this.#opts.onStart?.({ operation });
         try {
-            const built = await build(operation, {
-                model,
-                box,
-                checks,
-                attempts: this.#opts.attempts,
-                onAttempt: (attempt, diagnostics, source, limit) => this.#rejected(operation, attempt, diagnostics, source, limit, false),
-            });
-            if (!ephemeral) {
-                this.#store.put(operation.key, {
-                    source: built.source,
-                    meta: {
-                        operationId: operation.operationId,
-                        method: operation.method,
-                        path: operation.path,
-                        source: operation.source,
-                        model: model.id,
-                        attempts: built.attempts,
-                        rulesVersion: GENERATOR_RULES_VERSION,
-                        createdAt: new Date().toISOString(),
-                    },
-                });
-            }
+            const built = await build(operation, this.#builder(operation, false));
+            this.#keep(operation, built);
             this.#opts.onReady?.({ operation, cached: false, attempts: built.attempts });
             await this.#finished(operation);
             return { key: operation.key, source: built.source, cached: false };
@@ -178,9 +198,9 @@ export class Cache {
     }
     /**
      * An attempt the judge threw out. The report is rewritten with the file
-     * still in it before the next attempt overwrites `gen.py` — for a timeout
-     * that source is the only evidence there will ever be, since a generator
-     * that hangs leaves no traceback behind.
+     * still in it before the next test overwrites `handler.ts` — for a timeout
+     * that source is the only evidence there will ever be, since a handler
+     * that hangs leaves no stack behind.
      */
     async #rejected(operation, attempt, diagnostics, source, limit, regeneration) {
         let record = this.#records.get(operation.key);
@@ -199,7 +219,7 @@ export class Cache {
         this.#opts.onAttempt?.({ operation, attempt, diagnostics, dump: record.path });
     }
     /** A report that cannot be written is not worth failing a build over. */
-    async #report(record, gaveUp = false) {
+    async #report(record, gaveUp = false, report) {
         try {
             record.path = await saveBuildDump(this.#dumpDir, {
                 started: record.started,
@@ -212,6 +232,7 @@ export class Cache {
                 model: this.#opts.model.id,
                 attempts: record.attempts,
                 gaveUp,
+                report,
             });
         }
         catch {
@@ -230,14 +251,14 @@ export class Cache {
             return undefined;
         }
         if (error instanceof BuildFailed) {
-            await this.#report(record, true);
+            await this.#report(record, true, error.report);
             error.dump = record.path;
         }
         return record.path;
     }
     /**
-     * A hit is written into the box before it is returned. The container runs
-     * files under its mount and nothing else, and the mount is scratch that any
+     * A hit is written into the box before it is returned. The worker imports
+     * files from the box and nothing else, and the box is scratch that any
      * `cache clear` is free to delete.
      */
     async #read(box, key) {
@@ -245,6 +266,16 @@ export class Cache {
         if (!found?.source?.trim()) {
             return undefined;
         }
+        // Written against a placement that no longer holds: it would read and
+        // write somewhere nobody else looks.
+        const bindings = Object.entries(found.bindings ?? {});
+        if (bindings.some(([type, b]) => this.#opts.bindings.conflict(type, b))) {
+            return undefined;
+        }
+        // A cleared bindings store gets back what its handlers relied on.
+        for (const [type, b] of bindings) {
+            this.#opts.bindings.bind(type, b);
+        }
         try {
             await box.write(key, found.source);
         }
@@ -254,6 +285,11 @@ export class Cache {
         }
         return found.source;
     }
+    /** Opened on the first build, so a server that never writes one never opens it. */
+    #leases() {
+        this.#leaseStore ??= new WorldStore(this.#leaseFile);
+        return this.#leaseStore;
+    }
     #enter() {
         if (this.#running < this.#slots) {
             this.#running++;

package/dist/catalog.d.ts

@@ -0,0 +1,83 @@
+import type { AnyTool } from '@zenera/neo';
+import { type ValidateFunction } from 'ajv/dist/2020.js';
+import * as rag from '@zenera/rag';
+import type { Operation } from './spec.ts';
+export declare class Catalog {
+    #private;
+    readonly corpus: rag.Corpus;
+    readonly graph: rag.ApiGraph;
+    readonly types: Record<string, rag.Schema>;
+    private constructor();
+    static open(files: readonly string[]): Promise<Catalog>;
+    hasType(name: string): boolean;
+    /** A validator for records of a named type, or undefined for a name nobody declared. */
+    validator(name: string): ValidateFunction | undefined;
+    /** A validator for a schema of gym's own, outside the documents. */
+    compile(schema: object): ValidateFunction;
+    /** The named types and everything they refer to, as TypeScript. */
+    declare(names: readonly string[], maxChars?: number): {
+        code: string;
+        omitted: string[];
+    };
+    /** Names reachable from these through `$ref`, the named ones first. */
+    closure(names: readonly string[]): string[];
+    /** An inline type expression for a schema, e.g. `Message[]`. */
+    signature(schema: unknown): string;
+    /** The document's own record of an operation, matched by method and path. */
+    find(operation: Operation): rag.Operation | undefined;
+    /**
+     * The operation's request and response as TypeScript: what an agent writing
+     * its handler needs to read first, and usually all it needs.
+     */
+    describe(operation: Operation): string;
+    /**
+     * `list_api`, `grep_api`, `trace_api` and `find_types_with_property` over
+     * the graph — exact, and needing no embedder. `describe_types` is gym's own.
+     */
+    tools(): AnyTool[];
+    /**
+     * The type of the records an operation is about: its response type, or —
+     * when that is a list envelope with no identity of its own — the type its
+     * list holds. `Tier0ListResult` is about `Tier0`; `Event` is about `Event`.
+     */
+    itemType(operation: Operation): string | undefined;
+    /**
+     * A type's own properties and the ones it inherits through `allOf`, which is
+     * how most documents spell inheritance — an NSX `Tier0` declares little of
+     * what it holds itself.
+     */
+    properties(type: string): {
+        name: string;
+        schema: rag.Schema;
+        required: boolean;
+    }[];
+    /** The property a type's records are known by. */
+    idField(type: string): string;
+    /**
+     * Fields that point at other entities, judged by name: `*_id`, `*_path`,
+     * `*Ref`, `parent`, `owner`… Names rather than the schema because the
+     * schema rarely says: an NSX `connectivity_path` is a string, and only its
+     * name and its description say it names a Tier-1.
+     */
+    references(type: string): {
+        name: string;
+        signature: string;
+        doc: string;
+    }[];
+    /**
+     * The type a reference field most likely names, from the field's name:
+     * `labelIds` → `Label`, `transport_zone_path` → `PolicyTransportZone`. A
+     * field that names no type — a `threadId` where threads are not a schema —
+     * has no referent, and cannot dangle.
+     */
+    referent(field: string): string | undefined;
+    /** Every operation that accepts or returns a type, as method and path. */
+    carriers(type: string, maxHops?: number): {
+        method: string;
+        path: string;
+        direction: string;
+    }[];
+    /** The component types a response carries, nearest first: the candidates for a collection. */
+    responseTypes(operation: Operation): string[];
+}
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.js

@@ -0,0 +1,293 @@
+import addFormatsDefault from 'ajv-formats';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import * as rag from '@zenera/rag';
+const addFormats = addFormatsDefault;
+// ---------------------------------------------------------------------------
+// The catalog
+//
+// The documents as `@zenera/rag` reads them: bundled rather than dereferenced,
+// so `Message` stays one named type instead of being pasted into every
+// operation that returns it. That is what lets an agent be shown a response as
+// a few TypeScript interfaces instead of a page of JSON Schema, ask for a
+// nested type by name when it needs one, and be told that the records it makes
+// for a collection must be a `Message` — validated here against that one name.
+//
+// Nothing here is embedded or indexed. Reading and graphing a document is
+// milliseconds even at thousands of operations; only search needs vectors, and
+// nothing here searches.
+// ---------------------------------------------------------------------------
+/** A brief stops quoting declarations past this, and points at describe_types. */
+const BRIEF_CHARS = 12_000;
+const TYPES_ID = 'gym:types';
+export class Catalog {
+    corpus;
+    graph;
+    types;
+    #printer;
+    #ajv;
+    #validators = new Map();
+    constructor(corpus) {
+        this.corpus = corpus;
+        const built = rag.buildGraph(corpus);
+        this.graph = built.graph;
+        this.types = built.types;
+        this.#printer = new rag.Printer(this.types);
+        this.#ajv = new Ajv2020({ allErrors: true, strict: false, logger: false });
+        addFormats(this.#ajv);
+        this.#ajv.addSchema({ $id: TYPES_ID, $defs: stripSchemaKeys(this.types) });
+    }
+    static async open(files) {
+        return new Catalog(await rag.loadSpecs(files));
+    }
+    hasType(name) {
+        return name in this.types;
+    }
+    /** A validator for records of a named type, or undefined for a name nobody declared. */
+    validator(name) {
+        if (!this.hasType(name)) {
+            return undefined;
+        }
+        let found = this.#validators.get(name);
+        if (!found) {
+            found = this.#ajv.compile({ $ref: `${TYPES_ID}#/$defs/${pointer(name)}` });
+            this.#validators.set(name, found);
+        }
+        return found;
+    }
+    /** A validator for a schema of gym's own, outside the documents. */
+    compile(schema) {
+        return this.#ajv.compile(schema);
+    }
+    /** The named types and everything they refer to, as TypeScript. */
+    declare(names, maxChars = Infinity) {
+        const wanted = this.closure(names);
+        const blocks = [];
+        const omitted = [];
+        let size = 0;
+        for (const name of wanted) {
+            const block = this.#printer.declaration(name, { docs: true, maxDoc: 160 });
+            if (size + block.length > maxChars && blocks.length > 0) {
+                omitted.push(name);
+                continue;
+            }
+            blocks.push(block);
+            size += block.length;
+        }
+        return { code: blocks.join('\n'), omitted };
+    }
+    /** Names reachable from these through `$ref`, the named ones first. */
+    closure(names) {
+        const out = [];
+        const seen = new Set();
+        const queue = names.filter((n) => this.hasType(n));
+        while (queue.length > 0) {
+            const name = queue.shift();
+            if (seen.has(name)) {
+                continue;
+            }
+            seen.add(name);
+            out.push(name);
+            for (const ref of rag.refsIn(this.types[name])) {
+                if (this.hasType(ref) && !seen.has(ref)) {
+                    queue.push(ref);
+                }
+            }
+        }
+        return out;
+    }
+    /** An inline type expression for a schema, e.g. `Message[]`. */
+    signature(schema) {
+        return this.#printer.signature(schema);
+    }
+    /** The document's own record of an operation, matched by method and path. */
+    find(operation) {
+        const candidates = this.corpus.operations.filter((o) => o.method === operation.method && o.path.split('?')[0] === operation.path);
+        return (candidates.find((o) => o.operationId === operation.operationId) ??
+            candidates.find((o) => o.path.includes('?') === Boolean(operation.fixed)) ??
+            candidates[0]);
+    }
+    /**
+     * The operation's request and response as TypeScript: what an agent writing
+     * its handler needs to read first, and usually all it needs.
+     */
+    describe(operation) {
+        const op = this.find(operation);
+        if (!op) {
+            return '';
+        }
+        const lines = [];
+        const roots = [];
+        const note = (schema) => {
+            roots.push(...rag.refsIn(schema));
+            return this.signature(schema);
+        };
+        for (const p of op.params) {
+            lines.push(`  ${p.in} ${p.name}${p.required ? '' : '?'}: ${note(p.schema)}${p.doc ? `  // ${oneLine(p.doc)}` : ''}`);
+        }
+        if (op.requestBody) {
+            lines.push(`  body${op.requestBody.required ? '' : '?'}: ${note(op.requestBody.schema)}`);
+        }
+        const response = op.responses[0];
+        const out = [
+            'REQUEST',
+            ...(lines.length > 0 ? lines : ['  (no parameters)']),
+            '',
+            `RESPONSE ${response ? `${response.status}: ${note(response.schema)}` : '(no body)'}`,
+        ];
+        const declared = this.declare([...new Set(roots)], BRIEF_CHARS);
+        if (declared.code) {
+            out.push('', 'TYPES', declared.code.trimEnd());
+        }
+        if (declared.omitted.length > 0) {
+            out.push('', `Not shown for length (ask describe_types): ${declared.omitted.join(', ')}`);
+        }
+        return out.join('\n');
+    }
+    /**
+     * `list_api`, `grep_api`, `trace_api` and `find_types_with_property` over
+     * the graph — exact, and needing no embedder. `describe_types` is gym's own.
+     */
+    tools() {
+        return rag
+            .graphTools({
+            graph: this.graph,
+            sources: this.corpus.docs.map((d) => d.source),
+            schemas: () => Promise.resolve(this.types),
+        })
+            .filter((t) => t.name !== 'describe_types');
+    }
+    /**
+     * The type of the records an operation is about: its response type, or —
+     * when that is a list envelope with no identity of its own — the type its
+     * list holds. `Tier0ListResult` is about `Tier0`; `Event` is about `Event`.
+     */
+    itemType(operation) {
+        const op = this.find(operation);
+        const schema = op?.responses[0]?.schema ?? op?.requestBody?.schema;
+        const root = rag.refName(schema) ?? rag.refName(isObject(schema) ? schema.items : undefined);
+        const type = root ? this.types[root] : undefined;
+        if (!root || !type) {
+            return undefined;
+        }
+        const properties = isObject(type.properties) ? type.properties : {};
+        if (Object.keys(properties).some((k) => IDENTITY.test(k))) {
+            return root;
+        }
+        const lists = Object.entries(properties)
+            .map(([name, p]) => [name, isObject(p) ? rag.refName(p.items) : undefined])
+            .filter((entry) => Boolean(entry[1]));
+        const preferred = lists.find(([name]) => LIST_NAMES.test(name)) ?? lists[0];
+        return preferred?.[1] ?? root;
+    }
+    /**
+     * A type's own properties and the ones it inherits through `allOf`, which is
+     * how most documents spell inheritance — an NSX `Tier0` declares little of
+     * what it holds itself.
+     */
+    properties(type) {
+        const out = new Map();
+        const visit = (schema, depth) => {
+            if (!isObject(schema) || depth > 6) {
+                return;
+            }
+            const ref = rag.refName(schema);
+            if (ref) {
+                visit(this.types[ref], depth + 1);
+                return;
+            }
+            for (const member of Array.isArray(schema.allOf) ? schema.allOf : []) {
+                visit(member, depth + 1);
+            }
+            const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+            for (const [name, sub] of Object.entries(isObject(schema.properties) ? schema.properties : {})) {
+                if (isObject(sub)) {
+                    out.set(name, { name, schema: sub, required: required.has(name) });
+                }
+            }
+        };
+        visit(this.types[type], 0);
+        return [...out.values()];
+    }
+    /** The property a type's records are known by. */
+    idField(type) {
+        const names = this.properties(type).map((p) => p.name);
+        return names.find((n) => n === 'id') ?? names.find((n) => IDENTITY.test(n)) ?? 'id';
+    }
+    /**
+     * Fields that point at other entities, judged by name: `*_id`, `*_path`,
+     * `*Ref`, `parent`, `owner`… Names rather than the schema because the
+     * schema rarely says: an NSX `connectivity_path` is a string, and only its
+     * name and its description say it names a Tier-1.
+     */
+    references(type) {
+        const own = this.idField(type);
+        return this.properties(type)
+            .filter((p) => p.name !== own && REFERENCE.test(p.name) && stringy(p.schema))
+            .map((p) => ({
+            name: p.name,
+            signature: this.signature(p.schema),
+            doc: oneLine(typeof p.schema.description === 'string' ? p.schema.description : ''),
+        }));
+    }
+    /**
+     * The type a reference field most likely names, from the field's name:
+     * `labelIds` → `Label`, `transport_zone_path` → `PolicyTransportZone`. A
+     * field that names no type — a `threadId` where threads are not a schema —
+     * has no referent, and cannot dangle.
+     */
+    referent(field) {
+        const base = squash(field.replace(REFERENCE, ''));
+        if (!base) {
+            return undefined;
+        }
+        const types = Object.keys(this.types);
+        return (types.find((t) => squash(t) === base) ??
+            types.filter((t) => squash(t).endsWith(base)).sort((a, b) => a.length - b.length)[0]);
+    }
+    /** Every operation that accepts or returns a type, as method and path. */
+    carriers(type, maxHops = 4) {
+        const id = `Type:${type}`;
+        if (!this.graph.hasNode(id)) {
+            return [];
+        }
+        const traced = rag.traceNodes(this.graph, { ids: [id], maxHops, maxRoutes: 100 });
+        return (traced.traces[0]?.routes ?? []).map((r) => ({
+            method: r.attributes.httpMethod.toLowerCase(),
+            path: r.attributes.path.split('?')[0],
+            direction: r.direction,
+        }));
+    }
+    /** The component types a response carries, nearest first: the candidates for a collection. */
+    responseTypes(operation) {
+        const op = this.find(operation);
+        const schema = op?.responses[0]?.schema;
+        return schema ? this.closure(rag.refsIn(schema)) : [];
+    }
+}
+/** A subschema must not carry its own `$schema`; only the root may. */
+function stripSchemaKeys(types) {
+    return Object.fromEntries(Object.entries(types).map(([name, schema]) => {
+        const { $schema: _a, $id: _b, ...rest } = schema;
+        return [name, rest];
+    }));
+}
+/** A property that makes an object a record rather than an envelope. */
+const IDENTITY = /^(id|uid|uuid|_id|key|name)$/i;
+/** A field named for the thing it points at. */
+const REFERENCE = /(_id|Id|_ids|Ids|_path|Path|_paths|Paths|_ref|Ref|_refs|Refs|_uri|Uri)$|^(parent|owner|organizer|assignee|author|creator|manager)$/;
+const squash = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, '');
+/** A string, or a list of them: what an id or a path is written as. */
+function stringy(schema) {
+    const type = schema.type;
+    if (type === 'string' || (Array.isArray(type) && type.includes('string'))) {
+        return true;
+    }
+    const items = schema.items;
+    return type === 'array' && isObject(items) && items.type === 'string';
+}
+/** What an envelope usually calls its list. */
+const LIST_NAMES = /^(items|results|data|records|entries|values|objects|list|content)$/i;
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const pointer = (name) => encodeURIComponent(name.replace(/~/g, '~0').replace(/\//g, '~1'));
+const oneLine = (text) => text.replace(/\s+/g, ' ').trim().slice(0, 120);
+//# sourceMappingURL=catalog.js.map

package/dist/command.d.ts

@@ -1,3 +1,4 @@
+import './quiet.ts';
 import { type Command } from '@zenera/cli/lib';
 export declare const command: Command;
 //# sourceMappingURL=command.d.ts.map