@zenera/rag 1.1.4 → 1.1.6

package/dist/schema/files.js

@@ -60,13 +60,30 @@ function once(load) {
     let pending;
     return () => (pending ??= load());
 }
+/**
+ * The bundled document as it was indexed. Kept only when the index was built
+ * with sources, which is why the manifest is asked first: the difference
+ * between "no such document" and "this index did not keep them" is the whole
+ * of what the caller can do next.
+ */
+export async function readSource(dir, name) {
+    const manifest = await readManifest(dir);
+    const record = manifest.sources.find((s) => s.name === name);
+    if (!record) {
+        throw new CliError(`${dir} holds no document called ${name}`, EXIT.failed, `it has: ${manifest.sources.map((s) => s.name).join(', ')}`);
+    }
+    if (!record.path) {
+        return undefined;
+    }
+    return await readFile(join(dir, record.path), 'utf8');
+}
 export async function readManifest(dir) {
     let text;
     try {
         text = await readFile(join(dir, MANIFEST_FILE), 'utf8');
     }
     catch {
-        throw new CliError(`${dir} does not hold an index`, EXIT.invalid, 'build one first with `zen rag schema index`');
+        throw new CliError(`${dir} does not hold an index`, EXIT.invalid, 'build one with `zen rag schema index`, or name an existing one with --dir or $ZEN_SCHEMA_DB');
     }
     const manifest = JSON.parse(text);
     if (manifest.version !== INDEX_VERSION) {

package/dist/schema/locate.d.ts

@@ -0,0 +1,20 @@
+/** The name a new index is given. Nothing searches for it; only `index --out` writes it. */
+export declare const DEFAULT_DIR = "./schema-db";
+export declare const DIR_ENV = "ZEN_SCHEMA_DB";
+/** How the directory was arrived at, which is what decides whether to say so. */
+export type DirSource = 'flag' | 'env' | 'found' | 'default';
+export interface Located {
+    dir: string;
+    from: DirSource;
+}
+export interface LocateOptions {
+    env?: NodeJS.ProcessEnv;
+    /** do not climb above this; the home directory, or the root, by default */
+    ceiling?: string;
+}
+export declare function locateIndex(cwd: string, flag?: string, options?: LocateOptions): Located;
+/** Where a new index goes: the same environment variable, minus the search. */
+export declare function outputDir(cwd: string, flag?: string, env?: NodeJS.ProcessEnv): string;
+/** An index is a directory with a manifest in it; nothing else is asserted here. */
+export declare function isIndex(dir: string): boolean;
+//# sourceMappingURL=locate.d.ts.map

package/dist/schema/locate.js

@@ -0,0 +1,141 @@
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, parse, relative, resolve } from 'node:path';
+import { MANIFEST_FILE } from "./files.js";
+// ---------------------------------------------------------------------------
+// Which index, when nobody said
+//
+// `--dir` and `$ZEN_SCHEMA_DB` are taken as written, missing or not: naming a
+// directory that turns out not to hold an index has to fail saying so, because
+// quietly using a different one would be a worse answer than an error.
+//
+// With neither, the directory is looked for. There is no list of blessed names
+// here and there should not be — an index is self-describing, so what is being
+// looked for is a `manifest.json`, not a directory called `schema-db`.
+// `schema-db` is only the name a *new* index is given, and nothing reads it
+// back. The search is nearest-first: this directory, then what is under it,
+// then up a level and again, so `/assets/…/whatever` is reachable from
+// `/workspace` because the two meet at a shared root on the way up.
+//
+// Three things bound it, and each is bounding a different kind of mistake.
+// Depth and a visit budget bound the cost. The ceiling — the home directory,
+// or the filesystem root when the search began outside it — bounds the
+// blast radius, because an index in someone else's tree is not yours. And two
+// indexes at the same distance is an ambiguity rather than a tie to break:
+// choosing one silently is the one failure worth ruling out entirely, since
+// the wrong index does not error, it answers confidently about another API.
+// ---------------------------------------------------------------------------
+/** The name a new index is given. Nothing searches for it; only `index --out` writes it. */
+export const DEFAULT_DIR = './schema-db';
+export const DIR_ENV = 'ZEN_SCHEMA_DB';
+/** Far enough to climb out of a package into its workspace, not far enough to roam. */
+const MAX_LEVELS = 6;
+/** How far below a directory an index may sit and still count as being in it. */
+const MAX_DEPTH = 3;
+/** A directory with more entries than this is a data store, not a place to keep an index. */
+const MAX_ENTRIES = 128;
+/** Directories the whole search may read, however it is shaped. */
+const MAX_VISITS = 400;
+export function locateIndex(cwd, flag, options = {}) {
+    const env = options.env ?? process.env;
+    if (flag) {
+        return { dir: resolve(cwd, flag), from: 'flag' };
+    }
+    const named = env[DIR_ENV]?.trim();
+    if (named) {
+        return { dir: resolve(cwd, named), from: 'env' };
+    }
+    const found = search(resolve(cwd), options.ceiling ?? ceilingFor(cwd));
+    // Nothing found still answers with the default, so the error names the
+    // directory everyone expects rather than the last place that was searched.
+    return found
+        ? { dir: found, from: 'found' }
+        : { dir: resolve(cwd, DEFAULT_DIR), from: 'default' };
+}
+/** Where a new index goes: the same environment variable, minus the search. */
+export function outputDir(cwd, flag, env = process.env) {
+    return resolve(cwd, flag ?? env[DIR_ENV]?.trim() ?? DEFAULT_DIR);
+}
+/** An index is a directory with a manifest in it; nothing else is asserted here. */
+export function isIndex(dir) {
+    try {
+        return statSync(join(dir, MANIFEST_FILE)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function search(cwd, ceiling) {
+    const budget = { left: MAX_VISITS, seen: new Set() };
+    let dir = cwd;
+    for (let level = 0; level < MAX_LEVELS; level++) {
+        const found = nearest(dir, budget);
+        if (found.length === 1) {
+            return found[0];
+        }
+        if (found.length > 1) {
+            throw new CliError(`more than one index is equally close to here: ${found.join(', ')}`, EXIT.usage, `say which with --dir, or set ${DIR_ENV}`);
+        }
+        budget.seen.add(dir);
+        const up = dirname(dir);
+        if (up === dir || dir === ceiling) {
+            break;
+        }
+        dir = up;
+    }
+    return undefined;
+}
+/** Every index at the shallowest depth that has any, so a tie can be reported as one. */
+function nearest(root, budget) {
+    let frontier = [root];
+    for (let depth = 0; depth <= MAX_DEPTH && frontier.length > 0; depth++) {
+        const found = frontier.filter(isIndex);
+        if (found.length > 0) {
+            return found;
+        }
+        const next = [];
+        for (const dir of frontier) {
+            if (budget.left <= 0) {
+                return [];
+            }
+            budget.left--;
+            next.push(...children(dir).filter((child) => !budget.seen.has(child)));
+        }
+        frontier = next;
+    }
+    return [];
+}
+/**
+ * The subdirectories of one directory. Hidden directories and `node_modules`
+ * are skipped: an index kept out of sight is not one anybody meant to be found
+ * by looking.
+ */
+function children(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    if (entries.length > MAX_ENTRIES) {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+        .map((e) => join(dir, e.name));
+}
+/**
+ * Home is the ceiling for anyone working inside it. Starting outside it —
+ * a container whose workspace is `/workspace`, a CI checkout — there is no
+ * home to stay within, so the root is the only stop.
+ */
+function ceilingFor(cwd) {
+    const home = homedir();
+    const below = relative(home, resolve(cwd));
+    return below === '' || (!below.startsWith('..') && !isAbsolute(below))
+        ? home
+        : parse(resolve(cwd)).root;
+}
+//# sourceMappingURL=locate.js.map

package/dist/schema/lookup.d.ts

@@ -0,0 +1,54 @@
+import { type ApiGraph, type NodeAttrs, type NodeKind } from './graph.ts';
+import { type Matcher } from './match.ts';
+export interface Row extends NodeAttrs {
+    id: string;
+}
+export interface ListFilter {
+    kind: NodeKind;
+    /** any one matching is enough; none means every name passes */
+    name?: readonly Matcher[];
+    path?: readonly Matcher[];
+    source?: string;
+    methodType?: string;
+    direction?: string;
+    limit?: number;
+}
+export interface Listing {
+    /** how many matched, whatever was kept */
+    found: number;
+    rows: Row[];
+    truncated: boolean;
+}
+export interface Match {
+    id: string;
+    attributes: NodeAttrs;
+    /** the indexed text this matched against */
+    text: string;
+}
+export interface GrepFilter {
+    kinds?: readonly string[];
+    source?: string;
+    /** the same two constraints `list` takes, so one question has one spelling */
+    name?: readonly Matcher[];
+    path?: readonly Matcher[];
+    limit?: number;
+}
+export interface Grep {
+    found: number;
+    matches: Match[];
+    truncated: boolean;
+}
+export declare function listNodes(graph: ApiGraph, filter: ListFilter): Listing;
+export declare function grepNodes(graph: ApiGraph, match: Matcher, filter?: GrepFilter): Grep;
+/** How many fields a type carries, which is most of what a listing wants to say. */
+export declare function propertyCount(graph: ApiGraph, id: string): number;
+/** That count, said properly, in the one phrasing the CLI and the tools share. */
+export declare const fields: (n: number) => string;
+/**
+ * The route a node sits on. An operation carries its own; a parameter carries
+ * the operation's name instead, so it is looked up. A schema has no route at
+ * all and never will — the same DTO is returned by half the API — which is
+ * why a `--path` filter is a filter on the operations and what hangs off them.
+ */
+export declare function routeOf(graph: ApiGraph, id: string, a: NodeAttrs): string;
+//# sourceMappingURL=lookup.d.ts.map

package/dist/schema/lookup.js

@@ -0,0 +1,110 @@
+import { textOf } from "./entities.js";
+import { methodId } from "./graph.js";
+import { PatternError } from "./match.js";
+/** A scan is bounded, because a pattern may have come from a model. */
+const DEADLINE_MS = 2000;
+const DEADLINE_EVERY = 500;
+export function listNodes(graph, filter) {
+    const rows = [];
+    graph.forEachNode((id, a) => {
+        if (a.kind !== filter.kind || !passes(a, filter)) {
+            return;
+        }
+        if (filter.name && !filter.name.some((match) => match(a.name))) {
+            return;
+        }
+        if (filter.path && !matchesRoute(graph, id, a, filter.path)) {
+            return;
+        }
+        rows.push({ ...a, id });
+    });
+    rows.sort(order(filter.kind));
+    return cut(rows, filter.limit);
+}
+export function grepNodes(graph, match, filter = {}) {
+    const kinds = filter.kinds?.length ? new Set(filter.kinds) : undefined;
+    const matches = [];
+    const until = Date.now() + DEADLINE_MS;
+    let seen = 0;
+    for (const id of graph.nodes()) {
+        if (++seen % DEADLINE_EVERY === 0 && Date.now() > until) {
+            throw new PatternError(`the pattern is still running after ${DEADLINE_MS / 1000}s — it is too expensive to be useful`);
+        }
+        const a = graph.getNodeAttributes(id);
+        if (kinds && !kinds.has(a.kind)) {
+            continue;
+        }
+        if (filter.source && a.source !== filter.source) {
+            continue;
+        }
+        if (filter.name && !filter.name.some((match) => match(a.name))) {
+            continue;
+        }
+        if (filter.path && !matchesRoute(graph, id, a, filter.path)) {
+            continue;
+        }
+        const text = textOf(graph, id);
+        if (match(text)) {
+            matches.push({ id, attributes: a, text });
+        }
+    }
+    matches.sort((a, b) => a.id.localeCompare(b.id));
+    const kept = cut(matches, filter.limit);
+    return { found: kept.found, matches: kept.rows, truncated: kept.truncated };
+}
+/** How many fields a type carries, which is most of what a listing wants to say. */
+export function propertyCount(graph, id) {
+    return graph
+        .outEdges(id)
+        .filter((e) => graph.getEdgeAttribute(e, 'relation') === 'HAS_PROPERTY').length;
+}
+/** That count, said properly, in the one phrasing the CLI and the tools share. */
+export const fields = (n) => `${n} ${n === 1 ? 'field' : 'fields'}`;
+/**
+ * The route a node sits on. An operation carries its own; a parameter carries
+ * the operation's name instead, so it is looked up. A schema has no route at
+ * all and never will — the same DTO is returned by half the API — which is
+ * why a `--path` filter is a filter on the operations and what hangs off them.
+ */
+export function routeOf(graph, id, a) {
+    if (a.path) {
+        return a.path;
+    }
+    if (a.kind !== 'property' || !a.parent) {
+        return '';
+    }
+    const owner = methodId(a.parent);
+    return graph.hasNode(owner) ? graph.getNodeAttribute(owner, 'path') : '';
+}
+// ---------------------------------------------------------------------------
+function matchesRoute(graph, id, a, patterns) {
+    const route = routeOf(graph, id, a);
+    return route !== '' && patterns.some((match) => match(route));
+}
+function passes(a, filter) {
+    if (filter.source && a.source !== filter.source) {
+        return false;
+    }
+    if (filter.methodType && a.methodType !== filter.methodType) {
+        return false;
+    }
+    if (filter.direction && a.direction !== filter.direction && a.direction !== 'both') {
+        return false;
+    }
+    return true;
+}
+/** Operations read as a table of routes; everything else reads as a list of names. */
+function order(kind) {
+    if (kind !== 'method') {
+        return (a, b) => a.id.localeCompare(b.id);
+    }
+    return (a, b) => a.path.localeCompare(b.path) || a.httpMethod.localeCompare(b.httpMethod);
+}
+function cut(rows, limit) {
+    const found = rows.length;
+    if (!limit || limit >= found) {
+        return { found, rows, truncated: false };
+    }
+    return { found, rows: rows.slice(0, limit), truncated: true };
+}
+//# sourceMappingURL=lookup.js.map

package/dist/schema/match.d.ts

@@ -0,0 +1,40 @@
+/** Long enough for any honest pattern, short enough to bound a bad one. */
+export declare const MAX_PATTERN = 200;
+export declare class PatternError extends Error {
+}
+export interface MatchOptions {
+    /** read the pattern as a regular expression rather than as a literal */
+    regex?: boolean;
+    caseSensitive?: boolean;
+}
+export type Matcher = (text: string) => boolean;
+/**
+ * A predicate over a string. Literal by default: someone typing `user.id` means
+ * those seven characters, and a dot that quietly matched anything would be a
+ * worse answer than no answer.
+ */
+export declare function matcher(pattern: string, options?: MatchOptions): Matcher;
+/**
+ * A glob, matched against the whole string. Globs rather than regexes because
+ * these are for naming things — a path, a schema — and a star is what everyone
+ * reaches for first.
+ */
+export declare function wildcard(pattern: string, options?: {
+    caseSensitive?: boolean;
+}): Matcher;
+/** Whether a pattern is asking to be read as a glob at all. */
+export declare const isGlob: (pattern: string) => boolean;
+/**
+ * What someone means when they type a name into a filter. With a star in it,
+ * a glob; without one, a substring — because `password` typed into `--name` is
+ * a search for the word, and a whole-string match would answer nothing and
+ * look like the field does not exist.
+ *
+ * `regex` settles it outright, and has to: a star is punctuation in both
+ * languages, so `^/(users|teams)/.*` read as a glob would match nothing and
+ * never say why.
+ */
+export declare function loose(pattern: string, options?: MatchOptions): Matcher;
+/** True when any of the patterns matches; no patterns means no opinion. */
+export declare function anyOf(matchers: readonly Matcher[]): Matcher | undefined;
+//# sourceMappingURL=match.d.ts.map

package/dist/schema/match.js

@@ -0,0 +1,92 @@
+// ---------------------------------------------------------------------------
+// Matching, with nothing learned in between
+//
+// Everything here is exact. A glob matches the characters it names and a
+// substring is a substring, which is the whole point of the surfaces built on
+// it: a vector index answers "what is near this", and near is a ranking, so it
+// can only ever return the top of a list. When the question is "does the word
+// `password` appear anywhere at all", a ranking is the wrong instrument and no
+// amount of tuning makes it the right one.
+//
+// A pattern may arrive from a model, so a regex is a bounded promise: the
+// length is capped here and the scan that uses it keeps a deadline.
+// ---------------------------------------------------------------------------
+/** Long enough for any honest pattern, short enough to bound a bad one. */
+export const MAX_PATTERN = 200;
+export class PatternError extends Error {
+}
+/**
+ * A predicate over a string. Literal by default: someone typing `user.id` means
+ * those seven characters, and a dot that quietly matched anything would be a
+ * worse answer than no answer.
+ */
+export function matcher(pattern, options = {}) {
+    guard(pattern);
+    if (!options.regex) {
+        if (options.caseSensitive) {
+            return (text) => text.includes(pattern);
+        }
+        const needle = pattern.toLowerCase();
+        return (text) => text.toLowerCase().includes(needle);
+    }
+    const expression = compile(pattern, options.caseSensitive ? '' : 'i');
+    // `lastIndex` is not carried between calls: the flags never include `g`.
+    return (text) => expression.test(text);
+}
+/**
+ * A glob, matched against the whole string. Globs rather than regexes because
+ * these are for naming things — a path, a schema — and a star is what everyone
+ * reaches for first.
+ */
+export function wildcard(pattern, options = {}) {
+    guard(pattern);
+    const source = [...pattern]
+        .map((char) => (char === '*' ? '.*' : char === '?' ? '.' : escape(char)))
+        .join('');
+    const expression = compile(`^${source}$`, options.caseSensitive ? '' : 'i');
+    return (text) => expression.test(text);
+}
+/** Whether a pattern is asking to be read as a glob at all. */
+export const isGlob = (pattern) => /[*?]/.test(pattern);
+/**
+ * What someone means when they type a name into a filter. With a star in it,
+ * a glob; without one, a substring — because `password` typed into `--name` is
+ * a search for the word, and a whole-string match would answer nothing and
+ * look like the field does not exist.
+ *
+ * `regex` settles it outright, and has to: a star is punctuation in both
+ * languages, so `^/(users|teams)/.*` read as a glob would match nothing and
+ * never say why.
+ */
+export function loose(pattern, options = {}) {
+    if (options.regex) {
+        return matcher(pattern, options);
+    }
+    return isGlob(pattern) ? wildcard(pattern, options) : matcher(pattern, options);
+}
+/** True when any of the patterns matches; no patterns means no opinion. */
+export function anyOf(matchers) {
+    if (matchers.length === 0) {
+        return undefined;
+    }
+    return (text) => matchers.some((match) => match(text));
+}
+// ---------------------------------------------------------------------------
+function guard(pattern) {
+    if (pattern.length === 0) {
+        throw new PatternError('the pattern is empty');
+    }
+    if (pattern.length > MAX_PATTERN) {
+        throw new PatternError(`the pattern is longer than ${MAX_PATTERN} characters`);
+    }
+}
+function compile(source, flags) {
+    try {
+        return new RegExp(source, flags);
+    }
+    catch (err) {
+        throw new PatternError(`invalid pattern: ${err.message}`);
+    }
+}
+const escape = (char) => char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+//# sourceMappingURL=match.js.map

package/dist/schema/render.d.ts

@@ -3,7 +3,15 @@ export type RenderFormat = 'text' | 'mermaid' | 'mermaid-flowchart';
 export interface RenderOptions {
     docs?: boolean;
     maxDoc?: number;
+    /** name the document each operation and schema came from */
+    source?: boolean;
 }
+/**
+ * Which document something came from, spelled one way everywhere. An index
+ * over four revisions of one API has four `GET /infra/tier-0s`, and a listing
+ * that does not say which is which is a listing you have to go and check.
+ */
+export declare const sourceTag: (source: string) => string;
 export declare function render(sub: Subgraph, format: RenderFormat, options?: RenderOptions): string;
 export declare function toText(sub: Subgraph, options?: RenderOptions): string;
 export declare function toMermaid(sub: Subgraph, options?: RenderOptions): string;

package/dist/schema/render.js

@@ -1,4 +1,10 @@
 const HIT = '»';
+/**
+ * Which document something came from, spelled one way everywhere. An index
+ * over four revisions of one API has four `GET /infra/tier-0s`, and a listing
+ * that does not say which is which is a listing you have to go and check.
+ */
+export const sourceTag = (source) => (source ? `[source: ${source}]` : '');
 export function render(sub, format, options = {}) {
     switch (format) {
         case 'mermaid':
@@ -44,7 +50,7 @@ export function toText(sub, options = {}) {
 function methodLines(view, method, options) {
     const a = method.attributes;
     const out = [
-        `  ${mark(method)}${a.httpMethod} ${a.path}  ${a.name}${doc(method, options, ' —')}`,
+        `  ${mark(method)}${a.httpMethod} ${a.path}  ${a.name}${from(method, options)}${doc(method, options, ' —')}`,
     ];
     for (const edge of view.out(method.id, 'HAS_PARAM')) {
         const node = view.node(edge.target);
@@ -62,7 +68,7 @@ function methodLines(view, method, options) {
 }
 function typeLines(view, type, options) {
     const out = [
-        `  ${mark(type)}${type.attributes.name}${side(type.attributes)}${doc(type, options, ' —')}`,
+        `  ${mark(type)}${type.attributes.name}${side(type.attributes)}${from(type, options)}${doc(type, options, ' —')}`,
     ];
     const composes = view.out(type.id, 'COMPOSES').map((e) => view.name(e.target));
     if (composes.length > 0) {
@@ -96,6 +102,10 @@ function doc(node, options, lead) {
     }
     return `${lead} ${clip(node.attributes.doc, options.maxDoc ?? 120)}`;
 }
+function from(node, options) {
+    const tag = options.source ? sourceTag(node.attributes.source) : '';
+    return tag ? `  ${tag}` : '';
+}
 // ---------------------------------------------------------------------------
 // Mermaid
 // ---------------------------------------------------------------------------

package/dist/schema/subgraph.d.ts

@@ -37,6 +37,12 @@ export interface StitchOptions {
 export declare const DEFAULT_MAX_HOPS = 3;
 export declare const DEFAULT_MAX_NODES = 200;
 export declare function stitch(graph: ApiGraph, seeds: readonly Seed[], options?: StitchOptions): Subgraph[];
+/**
+ * Exactly the nodes named, and only the edges between them. The counterpart to
+ * `stitch`: no neighbours are gathered, because the caller is not asking what
+ * this is connected to — they already know what they want and want it whole.
+ */
+export declare function select(graph: ApiGraph, ids: readonly string[]): Subgraph;
 /** Breadth-first, ignoring edge direction, giving up past `maxHops`. */
 export declare function path(graph: ApiGraph, from: string, to: string, maxHops: number): string[] | undefined;
 //# sourceMappingURL=subgraph.d.ts.map

package/dist/schema/subgraph.js

@@ -150,6 +150,33 @@ function connect(graph, seeds, maxHops) {
     }
     return out;
 }
+/**
+ * Exactly the nodes named, and only the edges between them. The counterpart to
+ * `stitch`: no neighbours are gathered, because the caller is not asking what
+ * this is connected to — they already know what they want and want it whole.
+ */
+export function select(graph, ids) {
+    const kept = new Set(ids.filter((id) => graph.hasNode(id)));
+    const nodes = [...kept].map((id) => ({
+        id,
+        kind: graph.getNodeAttribute(id, 'kind'),
+        attributes: graph.getNodeAttributes(id),
+        hit: true,
+        score: 1,
+    }));
+    const edges = [];
+    for (const id of kept) {
+        for (const edge of graph.outEdges(id)) {
+            const target = graph.target(edge);
+            if (!kept.has(target)) {
+                continue;
+            }
+            const a = graph.getEdgeAttributes(edge);
+            edges.push({ source: id, target, relation: a.relation, status: a.status, in: a.in });
+        }
+    }
+    return { nodes, edges, hits: [...kept], score: kept.size, truncated: false };
+}
 /** Breadth-first, ignoring edge direction, giving up past `maxHops`. */
 export function path(graph, from, to, maxHops) {
     if (from === to) {

package/dist/schema/tools.d.ts

@@ -5,6 +5,8 @@ export interface SchemaToolOptions {
     /** what `format` defaults to when the model does not say */
     format?: Format;
     docs?: boolean;
+    /** name the document each answer came from; on by default past one document */
+    source?: boolean;
 }
 export declare function schemaTools<TCtx = unknown>(index: SchemaIndex, options?: SchemaToolOptions): AnyTool<TCtx>[];
 //# sourceMappingURL=tools.d.ts.map