@zenera/rag 1.1.9 → 1.1.11

package/dist/docs/files.js

@@ -0,0 +1,80 @@
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { MANIFEST_FILE, readHead } from "../common/manifest.js";
+// ---------------------------------------------------------------------------
+// What a document index is, on disk
+//
+// A directory, written in an order that is the whole crash story: the manifest
+// goes last, so a half-built index has no manifest and reads as "not indexed"
+// rather than as a store that quietly lost half its documents.
+//
+//   manifest.json   what this index is and what built it
+//   outline.json    the headings and tables of every document, read whole
+//   sources/        the documents themselves, verbatim
+//   lance/          the chunks: the search text, the vectors, the filters
+//
+// `sources/` is not a convenience here, the way it is for a schema index — it
+// is where the answers come from. A search returns line ranges, and the lines
+// are read back out of these copies, so what is quoted is the document and not
+// a reconstruction of it. That also makes the index one portable thing: nothing
+// in it names a path outside itself, so it can be moved, shipped, or mounted
+// somewhere else in an agent's sandbox and still answer.
+//
+// It is also why there is no table of lines. The original design kept one row
+// per physical line beside the chunks, carrying the text and its structure. With
+// the document itself sitting in `sources/`, that table would be a second copy
+// of the same bytes; the per-line structure it also held is derivable from the
+// outline, since a section runs from its heading to the next heading at the same
+// depth or shallower. One store, one copy, same answers.
+//
+// `outline.json` is deliberately thin — headings, tables, counts — because it is
+// parsed whole every time anything is asked. It is what makes `list`, `show` and
+// section scoping work with no store, no embedder and no credential.
+// ---------------------------------------------------------------------------
+export const INDEX_VERSION = 1;
+/** How a document index is found, read, and refused. */
+export const DOCS_INDEX = {
+    kind: 'docs',
+    version: INDEX_VERSION,
+    defaultDir: './docs-db',
+    envName: 'ZEN_DOCS_DB',
+};
+export const OUTLINE_FILE = 'outline.json';
+export const LANCE_DIR = 'lance';
+export const SOURCES_DIR = 'sources';
+export const lancePath = (dir) => join(dir, LANCE_DIR);
+export async function writeIndex(dir, index) {
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, OUTLINE_FILE), JSON.stringify(index.outline));
+    for (const [name, text] of Object.entries(index.documents)) {
+        const target = join(dir, SOURCES_DIR, name);
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, text);
+    }
+    await writeFile(join(dir, MANIFEST_FILE), `${JSON.stringify(index.manifest, null, 4)}\n`);
+}
+export async function openIndex(dir) {
+    const manifest = await readManifest(dir);
+    const outline = JSON.parse(await readFile(join(dir, OUTLINE_FILE), 'utf8'));
+    return { dir, manifest, outline };
+}
+export const readManifest = (dir) => readHead(dir, DOCS_INDEX);
+/**
+ * A document, verbatim, as it was indexed. The name is looked up in the
+ * manifest rather than joined onto the directory, so nothing a caller types
+ * ever reaches the filesystem — and a name that is not in the index is told so
+ * instead of becoming a path that happens not to exist.
+ */
+export async function readSource(index, name) {
+    const record = index.manifest.sources.find((s) => s.name === name);
+    if (!record) {
+        throw new CliError(`${index.dir} holds no document called ${name}`, EXIT.failed, `list them with \`zen rag docs list files\``);
+    }
+    return await readFile(join(index.dir, record.path), 'utf8');
+}
+/** The same document, split the way every line number in the index counts it. */
+export async function readLines(index, name) {
+    return (await readSource(index, name)).split('\n');
+}
+//# sourceMappingURL=files.js.map

package/dist/docs/index.d.ts

@@ -0,0 +1,13 @@
+export * from './assemble.ts';
+export * from './build.ts';
+export * from './chunk.ts';
+export * from './files.ts';
+export * from './load.ts';
+export * from './lookup.ts';
+export * from './parse.ts';
+export * from './readme.ts';
+export * from './render.ts';
+export * from './search.ts';
+export * from './store.ts';
+export * from './tools.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/docs/index.js

@@ -0,0 +1,13 @@
+export * from "./assemble.js";
+export * from "./build.js";
+export * from "./chunk.js";
+export * from "./files.js";
+export * from "./load.js";
+export * from "./lookup.js";
+export * from "./parse.js";
+export * from "./readme.js";
+export * from "./render.js";
+export * from "./search.js";
+export * from "./store.js";
+export * from "./tools.js";
+//# sourceMappingURL=index.js.map

package/dist/docs/load.d.ts

@@ -0,0 +1,42 @@
+import type { Chunk, ChunkOptions } from './chunk.ts';
+import type { FileOutline } from './files.ts';
+import { type DocFormat } from './parse.ts';
+/** Markdown, and plain text read as paragraphs. Anything else is not a document. */
+export declare const DOC_EXTENSIONS: readonly [".md", ".markdown", ".txt", ".text"];
+export interface LoadedDoc {
+    name: string;
+    file: string;
+    sha256: string;
+    bytes: number;
+    format: DocFormat;
+    /** the document verbatim, CRLF normalized: what goes into `sources/` */
+    text: string;
+    chunks: Chunk[];
+    outline: FileOutline;
+}
+export interface Corpus {
+    docs: LoadedDoc[];
+    /** files that were found and not read, with the reason */
+    skipped: {
+        name: string;
+        reason: string;
+    }[];
+    /** documents whose chunks came from a previous build rather than the parser */
+    cached: number;
+}
+export interface LoadOptions {
+    chunk?: ChunkOptions;
+    /** remember what documents parse to; on by default */
+    cache?: boolean;
+    /** keep the parses somewhere other than the shared store */
+    cacheDir?: string;
+    onProgress?: (done: number, total: number, pending: readonly string[]) => void;
+}
+/**
+ * Reading is cheap and parsing is not, so the two are split: every file is read
+ * and hashed here, and only the documents the cache has never seen are handed
+ * to the pool. On a rebuild of an unchanged corpus that is none of them.
+ */
+export declare function loadDocuments(inputs: readonly string[], cwd: string, options?: LoadOptions): Promise<Corpus>;
+export declare const formatOf: (path: string) => DocFormat;
+//# sourceMappingURL=load.d.ts.map

package/dist/docs/load.js

@@ -0,0 +1,203 @@
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { createHash } from 'node:crypto';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { isGlob, wildcard } from "../common/match.js";
+import { NO_PARSE_CACHE, openParseCache, parseKey } from "./parse-cache.js";
+import { normalize } from "./parse.js";
+import { parseAll } from "./pool.js";
+// ---------------------------------------------------------------------------
+// Finding the documents, and reading them
+//
+// What can be named is a file, a directory, or a pattern. A directory is walked,
+// because "index my notes" is the question people actually have and asking them
+// to enumerate it would be answering a different one. Hidden directories and
+// `node_modules` are skipped: a document nobody can see is not one anybody meant
+// to index.
+//
+// Every document is given a NAME, which is its path relative to the common root
+// of everything that was named — so indexing two release trees keeps
+// `nsx_4.1.0/api/routing.md` and `nsx_4.2.0/api/routing.md` apart, and a search
+// can be narrowed to one of them with a pattern over exactly that string. The
+// name is the identity: it is stamped on every chunk, it is what `sources/`
+// files are called, and nothing anywhere records where the file was on the
+// machine that built the index.
+// ---------------------------------------------------------------------------
+/** Markdown, and plain text read as paragraphs. Anything else is not a document. */
+export const DOC_EXTENSIONS = ['.md', '.markdown', '.txt', '.text'];
+/** A file larger than this is a data dump, not something anyone wrote. */
+const MAX_BYTES = 16 * 1024 * 1024;
+/** Enough for a documentation tree; far short of a filesystem. */
+const MAX_FILES = 20_000;
+/**
+ * Reading is cheap and parsing is not, so the two are split: every file is read
+ * and hashed here, and only the documents the cache has never seen are handed
+ * to the pool. On a rebuild of an unchanged corpus that is none of them.
+ */
+export async function loadDocuments(inputs, cwd, options = {}) {
+    const found = await discover(inputs, cwd);
+    if (found.length === 0) {
+        throw new CliError('nothing to index', EXIT.invalid, `no ${DOC_EXTENSIONS.join(', ')} files were found under ${inputs.join(', ')}`);
+    }
+    const root = commonRoot(found);
+    const taken = new Set();
+    const chunk = options.chunk ?? {};
+    const cache = options.cache === false ? NO_PARSE_CACHE : openParseCache(options.cacheDir);
+    const read = [];
+    const skipped = [];
+    for (const absolute of found) {
+        const name = distinct(nameOf(root, absolute), taken);
+        const info = await stat(absolute);
+        if (info.size > MAX_BYTES) {
+            skipped.push({ name, reason: `larger than ${MAX_BYTES / 1024 / 1024} MB` });
+            continue;
+        }
+        const raw = await readFile(absolute);
+        read.push({
+            name,
+            file: basename(absolute),
+            sha256: createHash('sha256').update(raw).digest('hex'),
+            bytes: raw.byteLength,
+            format: formatOf(absolute),
+            text: normalize(raw.toString('utf8')),
+            key: parseKey(raw, name, chunk),
+        });
+    }
+    const parsed = new Array(read.length);
+    const misses = [];
+    const missAt = [];
+    for (const [at, doc] of read.entries()) {
+        const hit = doc.key === undefined ? undefined : cache.get(doc.key);
+        if (hit) {
+            parsed[at] = hit;
+        }
+        else {
+            missAt.push(at);
+            misses.push({ name: doc.name, text: doc.text, format: doc.format });
+        }
+    }
+    const done = read.length - misses.length;
+    options.onProgress?.(done, read.length, []);
+    const fresh = await parseAll(misses, {
+        chunk,
+        onProgress: (at, _of, pending) => options.onProgress?.(done + at, read.length, pending),
+    });
+    for (const [i, result] of fresh.entries()) {
+        const at = missAt[i];
+        parsed[at] = result;
+        const key = read[at].key;
+        if (key !== undefined) {
+            cache.put(key, result);
+        }
+    }
+    cache.commit();
+    const docs = read.map((doc, at) => ({
+        name: doc.name,
+        file: doc.file,
+        sha256: doc.sha256,
+        bytes: doc.bytes,
+        format: doc.format,
+        text: doc.text,
+        chunks: parsed[at].chunks,
+        outline: parsed[at].outline,
+    }));
+    return { docs, skipped, cached: cache.hits };
+}
+export const formatOf = (path) => ['.txt', '.text'].includes(extname(path).toLowerCase()) ? 'text' : 'markdown';
+// ---------------------------------------------------------------------------
+// discovery
+// ---------------------------------------------------------------------------
+async function discover(inputs, cwd) {
+    const out = new Set();
+    for (const input of inputs) {
+        const path = resolve(cwd, input);
+        if (isGlob(input)) {
+            // The pattern is anchored at the deepest directory it names outright,
+            // so a walk of the whole tree is never needed to answer one.
+            const anchor = staticPrefix(path);
+            const match = wildcard(path, { caseSensitive: true });
+            for (const file of await walk(anchor)) {
+                if (match(file)) {
+                    out.add(file);
+                }
+            }
+            continue;
+        }
+        const info = await stat(path).catch(() => undefined);
+        if (!info) {
+            throw new CliError(`no such file or directory: ${input}`, EXIT.invalid);
+        }
+        if (info.isDirectory()) {
+            for (const file of await walk(path)) {
+                out.add(file);
+            }
+        }
+        else {
+            // A file named outright is indexed whatever it is called: someone
+            // who types a name has already decided it is a document.
+            out.add(path);
+        }
+    }
+    return [...out].sort();
+}
+async function walk(root) {
+    const out = [];
+    const queue = [root];
+    while (queue.length > 0 && out.length < MAX_FILES) {
+        const dir = queue.shift();
+        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+                continue;
+            }
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(path);
+            }
+            else if (indexable(entry.name)) {
+                out.push(path);
+            }
+        }
+    }
+    return out;
+}
+const indexable = (name) => DOC_EXTENSIONS.includes(extname(name).toLowerCase());
+/** The part of a pattern before the first wildcard, which is a real directory. */
+function staticPrefix(pattern) {
+    const parts = pattern.split(sep);
+    const at = parts.findIndex((part) => isGlob(part));
+    const head = (at === -1 ? parts : parts.slice(0, at)).join(sep);
+    return head && isAbsolute(head) ? head : dirname(pattern.split('*')[0] ?? pattern);
+}
+/**
+ * The deepest directory holding every file, which is what names are taken
+ * relative to. One file is its own directory, so a single document is named by
+ * its basename rather than by an accident of where it was kept.
+ */
+function commonRoot(files) {
+    const parts = files.map((file) => dirname(file).split(sep));
+    const first = parts[0] ?? [];
+    let at = 0;
+    while (at < first.length && parts.every((p) => p[at] === first[at])) {
+        at++;
+    }
+    return first.slice(0, at).join(sep) || sep;
+}
+function nameOf(root, absolute) {
+    const rel = relative(root, absolute);
+    // A file outside the common root cannot happen by construction; if it ever
+    // did, a name climbing out of the index directory must not.
+    return !rel || rel.startsWith('..') || isAbsolute(rel)
+        ? basename(absolute)
+        : rel.split(sep).join('/');
+}
+function distinct(name, taken) {
+    let candidate = name;
+    for (let n = 2; taken.has(candidate); n++) {
+        const dot = name.lastIndexOf('.');
+        candidate = dot === -1 ? `${name}_${n}` : `${name.slice(0, dot)}_${n}${name.slice(dot)}`;
+    }
+    taken.add(candidate);
+    return candidate;
+}
+//# sourceMappingURL=load.js.map

package/dist/docs/lookup.d.ts

@@ -0,0 +1,80 @@
+import { type MatchOptions } from '../common/match.ts';
+import type { DocsIndex } from './search.ts';
+export interface Listing<T> {
+    found: number;
+    rows: T[];
+    truncated: boolean;
+}
+export interface ListOptions {
+    /** patterns over the document name */
+    files?: readonly string[];
+    exclude_files?: readonly string[];
+    limit?: number;
+}
+export declare const DEFAULT_ROWS = 50;
+export declare const MAX_ROWS = 500;
+export interface FileRow {
+    name: string;
+    title: string;
+    format: string;
+    lines: number;
+    sections: number;
+    tables: number;
+    chunks: number;
+}
+export declare function listFiles(index: DocsIndex, options?: ListOptions): Listing<FileRow>;
+export interface SectionRow {
+    file: string;
+    id: string;
+    path: string;
+    level: number;
+    title: string;
+    line: number;
+    end: number;
+}
+export interface SectionOptions extends ListOptions {
+    /** a heading title, a structure id, or a structure path */
+    section?: readonly string[];
+    /** deepest heading level to report; the default is everything */
+    depth?: number;
+}
+export declare function listSections(index: DocsIndex, options?: SectionOptions): Listing<SectionRow>;
+export interface TableRow {
+    file: string;
+    id: string;
+    section: string;
+    caption: string;
+    columns: string;
+    rows: number;
+    line: number;
+    end: number;
+}
+export declare function listTables(index: DocsIndex, options?: SectionOptions): Listing<TableRow>;
+export interface LineRow {
+    file: string;
+    line: number;
+    text: string;
+    /** the innermost heading the line sits under, so a hit has a place */
+    section: string;
+}
+export interface GrepOptions extends SectionOptions, MatchOptions {
+}
+/**
+ * Lines matching a pattern. Substring by default, glob when it has wildcards,
+ * a regular expression when asked — the same rule every other pattern in this
+ * package follows, so nobody has to remember which flavour a flag takes.
+ */
+export declare function grepLines(index: DocsIndex, pattern: string, options?: GrepOptions): Promise<Listing<LineRow>>;
+export interface Verbatim {
+    file: string;
+    title: string;
+    start: number;
+    end: number;
+    lines: string[];
+    /** the document's length, so a caller can tell what it did not get */
+    total: number;
+}
+/** A named section, verbatim: heading line to the line before the next peer. */
+export declare function readSection(index: DocsIndex, file: string, section: string): Promise<Verbatim>;
+export declare function readRange(index: DocsIndex, file: string, from: number, to: number): Promise<Verbatim>;
+//# sourceMappingURL=lookup.d.ts.map

package/dist/docs/lookup.js

@@ -0,0 +1,147 @@
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { loose } from "../common/match.js";
+import { under } from "./search.js";
+export const DEFAULT_ROWS = 50;
+export const MAX_ROWS = 500;
+export function listFiles(index, options = {}) {
+    const names = new Set(index.resolveFiles(options.files, options.exclude_files));
+    const rows = index.manifest.sources
+        .filter((source) => names.has(source.name))
+        .map((source) => ({
+        name: source.name,
+        title: source.title,
+        format: source.format,
+        lines: source.lines,
+        sections: source.sections,
+        tables: source.tables,
+        chunks: source.chunks,
+    }));
+    return cut(rows, options.limit);
+}
+export function listSections(index, options = {}) {
+    const files = index.resolveFiles(options.files, options.exclude_files);
+    const within = new Set(files);
+    const wanted = options.section?.length
+        ? index.resolveSections(options.section, files).map((h) => h.path)
+        : [];
+    const rows = [];
+    for (const file of index.outline.files) {
+        if (!within.has(file.name)) {
+            continue;
+        }
+        for (const heading of file.headings) {
+            if (under(heading.path, wanted) && heading.level <= (options.depth ?? Infinity)) {
+                rows.push({ file: file.name, ...record(heading) });
+            }
+        }
+    }
+    return cut(rows, options.limit);
+}
+export function listTables(index, options = {}) {
+    const files = index.resolveFiles(options.files, options.exclude_files);
+    const within = new Set(files);
+    const wanted = options.section?.length
+        ? index.resolveSections(options.section, files).map((h) => h.path)
+        : [];
+    const rows = [];
+    for (const file of index.outline.files) {
+        if (!within.has(file.name)) {
+            continue;
+        }
+        for (const table of file.tables) {
+            if (!under(table.path, wanted)) {
+                continue;
+            }
+            rows.push({
+                file: file.name,
+                id: table.id,
+                section: table.section,
+                caption: table.caption,
+                columns: table.columns.join(', '),
+                rows: table.rows,
+                line: table.line,
+                end: table.end,
+            });
+        }
+    }
+    return cut(rows, options.limit);
+}
+/**
+ * Lines matching a pattern. Substring by default, glob when it has wildcards,
+ * a regular expression when asked — the same rule every other pattern in this
+ * package follows, so nobody has to remember which flavour a flag takes.
+ */
+export async function grepLines(index, pattern, options = {}) {
+    const files = index.resolveFiles(options.files, options.exclude_files);
+    const wanted = options.section?.length
+        ? index.resolveSections(options.section, files)
+        : undefined;
+    const match = loose(pattern, { regex: options.regex, caseSensitive: options.caseSensitive });
+    const rows = [];
+    for (const name of files) {
+        const spans = wanted?.filter((h) => index.file(name)?.headings.includes(h));
+        if (wanted && (!spans || spans.length === 0)) {
+            continue;
+        }
+        const lines = await index.lines(name);
+        const headings = index.file(name)?.headings ?? [];
+        for (const [at, text] of lines.entries()) {
+            const line = at + 1;
+            if (spans && !spans.some((span) => line >= span.line && line <= span.end)) {
+                continue;
+            }
+            if (match(text)) {
+                rows.push({ file: name, line, text, section: enclosing(headings, line) });
+            }
+        }
+    }
+    return cut(rows, options.limit);
+}
+/** A named section, verbatim: heading line to the line before the next peer. */
+export async function readSection(index, file, section) {
+    const found = index.resolveSections([section], [file]);
+    const heading = found[0];
+    if (!heading) {
+        throw new CliError(`${file} has no section called ${section}`, EXIT.failed, 'list them with `zen rag docs list sections --file <name>`');
+    }
+    return await readRange(index, file, heading.line, heading.end);
+}
+export async function readRange(index, file, from, to) {
+    const lines = await index.lines(file);
+    const outline = index.file(file);
+    const start = Math.max(1, from);
+    const end = Math.min(lines.length, to);
+    return {
+        file,
+        title: outline?.title ?? file,
+        start,
+        end,
+        lines: lines.slice(start - 1, end),
+        total: lines.length,
+    };
+}
+// ---------------------------------------------------------------------------
+function cut(rows, limit) {
+    const take = Math.min(Math.max(1, limit ?? DEFAULT_ROWS), MAX_ROWS);
+    return { found: rows.length, rows: rows.slice(0, take), truncated: rows.length > take };
+}
+const record = (heading) => ({
+    id: heading.id,
+    path: heading.path,
+    level: heading.level,
+    title: heading.title,
+    line: heading.line,
+    end: heading.end,
+});
+/** The last heading at or above this line, which is the section it is in. */
+function enclosing(headings, line) {
+    let title = '';
+    for (const heading of headings) {
+        if (heading.line > line) {
+            break;
+        }
+        title = heading.title;
+    }
+    return title;
+}
+//# sourceMappingURL=lookup.js.map

package/dist/docs/outline.d.ts

@@ -0,0 +1,11 @@
+import type { FileOutline } from './files.ts';
+import type { ParsedDoc } from './parse.ts';
+/**
+ * Headings and tables, with the line each ends on. That end is what makes the
+ * outline enough on its own: a section runs from its heading to the line before
+ * the next heading at the same depth or shallower, so scoping a search to a
+ * section, listing what is in one, or naming the sections a skipped range
+ * covered are all answerable without reading the document.
+ */
+export declare function outlineOf(doc: ParsedDoc, chunks: number): FileOutline;
+//# sourceMappingURL=outline.d.ts.map

package/dist/docs/outline.js

@@ -0,0 +1,55 @@
+// ---------------------------------------------------------------------------
+// What a document holds, without the document
+//
+// This lives apart from `load.ts` for one reason: a parse worker needs it, and
+// `load.ts` imports the CLI. A worker that reached for it there would load the
+// whole command layer into every thread to call one pure function. Nothing here
+// may import anything that is not pure.
+// ---------------------------------------------------------------------------
+/**
+ * Headings and tables, with the line each ends on. That end is what makes the
+ * outline enough on its own: a section runs from its heading to the line before
+ * the next heading at the same depth or shallower, so scoping a search to a
+ * section, listing what is in one, or naming the sections a skipped range
+ * covered are all answerable without reading the document.
+ */
+export function outlineOf(doc, chunks) {
+    const sections = doc.sections.filter((s) => s.line !== undefined);
+    const headings = sections.map((section, at) => {
+        const next = sections.findIndex((other, i) => i > at && other.level <= section.level);
+        const end = next === -1 ? doc.lines.length : sections[next].line - 1;
+        return {
+            line: section.line,
+            end,
+            level: section.level,
+            title: section.title,
+            id: section.id,
+            path: section.path,
+        };
+    });
+    const tables = doc.blocks
+        .filter((block) => block.table)
+        .map((block) => {
+        const table = block.table;
+        return {
+            id: block.id,
+            path: block.path,
+            section: block.section.path,
+            line: block.start,
+            end: block.end,
+            columns: table.columns,
+            rows: table.rows.length,
+            caption: table.caption,
+        };
+    });
+    return {
+        name: doc.name,
+        title: doc.title,
+        format: doc.format,
+        lines: doc.lines.length,
+        chunks,
+        headings,
+        tables,
+    };
+}
+//# sourceMappingURL=outline.js.map

package/dist/docs/parse-cache.d.ts

@@ -0,0 +1,20 @@
+import type { ChunkOptions } from './chunk.ts';
+import type { Parsed } from './pool.ts';
+export declare const PARSE_KIND = "docs-parse";
+/** Bumped when chunking changes shape, which invalidates every entry. */
+export declare const PARSE_VERSION = 1;
+export interface ParseCache {
+    get(key: string): Parsed | undefined;
+    put(key: string, parsed: Parsed): void;
+    commit(): void;
+    readonly hits: number;
+}
+export declare const NO_PARSE_CACHE: ParseCache;
+/**
+ * What the chunks depend on, and nothing else. `tokenCount` is a function and
+ * cannot be hashed; a caller that supplies one gets no cache rather than a key
+ * that quietly ignores it.
+ */
+export declare function parseKey(bytes: Buffer, name: string, options: ChunkOptions): string | undefined;
+export declare function openParseCache(dir?: string): ParseCache;
+//# sourceMappingURL=parse-cache.d.ts.map