agentfootprint 8.9.0 → 8.10.0

package/dist/esm/rag/loaders/html.d.ts

@@ -0,0 +1,42 @@
+/**
+ * htmlLoader — HTML with the tags taken out, without a parser.
+ *
+ * Pattern: Adapter behind `DocumentLoader`.
+ * Role:    rag/ layer. Zero dependency.
+ * Emits:   N/A.
+ *
+ * ── What this is, and what it is not ────────────────────────────────────────
+ * This is a **tag stripper**, not an HTML parser, and the distinction is worth
+ * being blunt about because the failure mode is silent. It removes `<script>`
+ * and `<style>` bodies, replaces tags with whitespace, and decodes the handful
+ * of entities that appear in real prose. That is enough for documentation
+ * pages, exported articles, and saved knowledge-base entries — the things
+ * people actually put in a corpus.
+ *
+ * It is NOT enough for a modern application page. A single-page app's HTML is
+ * mostly scaffolding, and what you get back will be navigation labels and
+ * button text. If your corpus is that, run a real extractor (Readability,
+ * Mercury, your CMS's own export) and feed the result in as text — the
+ * `{ text, uri }` arm of `DocumentSource` exists for exactly that.
+ *
+ * A parser was considered and rejected for v1: every option is a dependency
+ * measured in megabytes, and the difference it buys on the documents people
+ * index is small. If that stops being true, the fix is another
+ * `DocumentLoader` passed ahead of this one — no change here.
+ *
+ * ── Offsets ─────────────────────────────────────────────────────────────────
+ * Tags are replaced with whitespace of the SAME LENGTH rather than deleted, so
+ * offsets into the extracted text line up with offsets into the original file.
+ * A chunk's `charStart` therefore points at the same place in both, and the
+ * text that gets stored is the extracted text, which is what the offsets index.
+ */
+import type { DocumentLoader } from '../types.js';
+/**
+ * Strip markup to text.
+ *
+ * Exported because the splitter tests and the security tests both need to
+ * assert on it directly, and because a consumer writing their own loader for a
+ * markup-ish format may reasonably want the same pass.
+ */
+export declare function stripTags(html: string): string;
+export declare function htmlLoader(): DocumentLoader;

package/dist/esm/rag/loaders/html.js

@@ -0,0 +1,48 @@
+import { decodeText } from './text.js';
+/** Blank a matched region, preserving newlines so line structure survives. */
+function blank(match) {
+    return match.replace(/[^\n]/g, ' ');
+}
+const ENTITIES = {
+    '&': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&#39;': "'",
+    '&apos;': "'",
+    '&nbsp;': ' ',
+};
+/**
+ * Strip markup to text.
+ *
+ * Exported because the splitter tests and the security tests both need to
+ * assert on it directly, and because a consumer writing their own loader for a
+ * markup-ish format may reasonably want the same pass.
+ */
+export function stripTags(html) {
+    let out = html;
+    // Script and style CONTENT is not prose. Blanked wholesale, bodies included.
+    out = out.replace(/<script\b[^>]*>[\s\S]*?<\/script\s*>/gi, blank);
+    out = out.replace(/<style\b[^>]*>[\s\S]*?<\/style\s*>/gi, blank);
+    out = out.replace(/<!--[\s\S]*?-->/g, blank);
+    // Every remaining tag becomes whitespace of equal length — see the header.
+    out = out.replace(/<[^>]*>/g, blank);
+    // Entities are decoded LAST and only for the fixed set above. A general
+    // numeric decode would let `&#60;script&#62;` reappear as a tag in text that
+    // has already been stripped.
+    for (const [entity, char] of Object.entries(ENTITIES)) {
+        out = out.split(entity).join(char.padEnd(entity.length, ' '));
+    }
+    return out;
+}
+export function htmlLoader() {
+    return {
+        name: 'html',
+        extensions: ['.html', '.htm', '.xhtml'],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        async load(input) {
+            return { text: stripTags(decodeText(input.bytes)) };
+        },
+    };
+}
+//# sourceMappingURL=html.js.map

package/dist/esm/rag/loaders/html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.js","sourceRoot":"","sources":["../../../../src/rag/loaders/html.ts"],"names":[],"mappings":"AAiCA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,8EAA8E;AAC9E,SAAS,KAAK,CAAC,KAAa;IAC1B,OAAO,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,QAAQ,GAAqC;IACjD,OAAO,EAAE,GAAG;IACZ,MAAM,EAAE,GAAG;IACX,MAAM,EAAE,GAAG;IACX,QAAQ,EAAE,GAAG;IACb,OAAO,EAAE,GAAG;IACZ,QAAQ,EAAE,GAAG;IACb,QAAQ,EAAE,GAAG;CACd,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,6EAA6E;IAC7E,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,wCAAwC,EAAE,KAAK,CAAC,CAAC;IACnE,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;IACjE,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;IAC7C,2EAA2E;IAC3E,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACrC,wEAAwE;IACxE,6EAA6E;IAC7E,6BAA6B;IAC7B,KAAK,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACtD,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,UAAU,UAAU;IACxB,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC;QACvC,4DAA4D;QAC5D,KAAK,CAAC,IAAI,CAAC,KAAoB;YAC7B,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QACtD,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/esm/rag/loaders/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * rag/loaders — one adapter per format, each doing exactly one job: turn
+ * bytes into text plus the positions that text came from.
+ *
+ * Pattern: Adapter (one per format) behind the `DocumentLoader` port.
+ * Role:    rag/ layer, outermost ring. Three of the five need no dependency
+ *          at all; only PDF does, and it lazy-loads a single optional peer so
+ *          importing this barrel costs nothing for a consumer indexing
+ *          Markdown.
+ * Emits:   N/A — a loader reads a file and returns text.
+ *
+ * `DEFAULT_LOADERS` is the routing table `loadDocuments` uses when you pass
+ * none. A loader you pass yourself is consulted FIRST, so overriding one is
+ * putting yours in front rather than editing a registry.
+ */
+import type { DocumentLoader } from '../types.js';
+export { textLoader } from './text.js';
+export { markdownLoader } from './markdown.js';
+export { htmlLoader } from './html.js';
+export { pdfLoader, MissingPdfSupportError, type PdfLoaderOptions } from './pdf.js';
+export { mockLoader, type MockLoaderOptions } from './mock.js';
+/**
+ * The loaders `loadDocuments` uses when the caller names none, in routing
+ * order.
+ *
+ * `pdfLoader()` is in the list, but constructing it costs nothing — the
+ * optional peer is loaded on the first PDF it is actually asked to read, so a
+ * corpus of Markdown never touches it and never needs it installed.
+ */
+export declare const DEFAULT_LOADERS: readonly DocumentLoader[];

package/dist/esm/rag/loaders/index.js

@@ -0,0 +1,24 @@
+import { textLoader } from './text.js';
+import { markdownLoader } from './markdown.js';
+import { htmlLoader } from './html.js';
+import { pdfLoader } from './pdf.js';
+export { textLoader } from './text.js';
+export { markdownLoader } from './markdown.js';
+export { htmlLoader } from './html.js';
+export { pdfLoader, MissingPdfSupportError } from './pdf.js';
+export { mockLoader } from './mock.js';
+/**
+ * The loaders `loadDocuments` uses when the caller names none, in routing
+ * order.
+ *
+ * `pdfLoader()` is in the list, but constructing it costs nothing — the
+ * optional peer is loaded on the first PDF it is actually asked to read, so a
+ * corpus of Markdown never touches it and never needs it installed.
+ */
+export const DEFAULT_LOADERS = Object.freeze([
+    markdownLoader(),
+    textLoader(),
+    htmlLoader(),
+    pdfLoader(),
+]);
+//# sourceMappingURL=index.js.map

package/dist/esm/rag/loaders/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/rag/loaders/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,sBAAsB,EAAyB,MAAM,UAAU,CAAC;AACpF,OAAO,EAAE,UAAU,EAA0B,MAAM,WAAW,CAAC;AAE/D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAA8B,MAAM,CAAC,MAAM,CAAC;IACtE,cAAc,EAAE;IAChB,UAAU,EAAE;IACZ,UAAU,EAAE;IACZ,SAAS,EAAE;CACZ,CAAC,CAAC"}

package/dist/esm/rag/loaders/markdown.d.ts

@@ -0,0 +1,27 @@
+/**
+ * markdownLoader — Markdown, kept as Markdown.
+ *
+ * Pattern: Adapter behind `DocumentLoader`.
+ * Role:    rag/ layer. Zero dependency, and it deliberately does NOT parse.
+ * Emits:   N/A.
+ *
+ * ── Why the markup stays ────────────────────────────────────────────────────
+ * The obvious thing to do here is strip the syntax and hand over prose. It is
+ * the wrong thing, twice over:
+ *
+ *  1. **The headings are the document's own structure.** `byHeading` cuts on
+ *     `#` lines, which is the one splitting rule in this library that is not a
+ *     heuristic — the author already told us where the sections are. Stripping
+ *     `#` throws that away and leaves us guessing at boundaries we were handed.
+ *  2. **Stripping shifts every offset.** `text.slice(charStart, charEnd)` has to
+ *     equal the chunk, against the text that was stored. A loader that rewrites
+ *     text and then reports offsets into the original is reporting fiction.
+ *
+ * Models read Markdown perfectly well; a table that survives as a table is
+ * more useful in a prompt than the same table flattened into a word salad.
+ *
+ * What it DOES do is the same normalisation `textLoader` does, for the same
+ * reason: line endings, before any offset exists.
+ */
+import type { DocumentLoader } from '../types.js';
+export declare function markdownLoader(): DocumentLoader;

package/dist/esm/rag/loaders/markdown.js

@@ -0,0 +1,12 @@
+import { decodeText } from './text.js';
+export function markdownLoader() {
+    return {
+        name: 'markdown',
+        extensions: ['.md', '.markdown', '.mdx'],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        async load(input) {
+            return { text: decodeText(input.bytes) };
+        },
+    };
+}
+//# sourceMappingURL=markdown.js.map

package/dist/esm/rag/loaders/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../../../../src/rag/loaders/markdown.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,MAAM,UAAU,cAAc;IAC5B,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,CAAC;QACxC,4DAA4D;QAC5D,KAAK,CAAC,IAAI,CAAC,KAAoB;YAC7B,OAAO,EAAE,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/esm/rag/loaders/mock.d.ts

@@ -0,0 +1,28 @@
+/**
+ * mockLoader — a loader with no filesystem and no format, for tests.
+ *
+ * Pattern: Adapter behind `DocumentLoader`.
+ * Role:    rag/ layer. The first rung of the mock-first ladder for indexing:
+ *          prove the pipeline runs — discover, split, plan, embed, store,
+ *          report — before a single real file or a single real embedding is
+ *          involved.
+ * Emits:   N/A.
+ *
+ * It claims whatever extensions you give it (default: everything a test is
+ * likely to name), and returns the text you handed it. Unlike the other
+ * loaders it never touches bytes at all, which is exactly what makes it
+ * useful: a test can assert on chunking and planning without a temp directory.
+ */
+import type { DocumentLoader } from '../types.js';
+export interface MockLoaderOptions {
+    /** Extensions to claim. Default: a broad set, so routing is never the thing under test. */
+    readonly extensions?: readonly string[];
+    /**
+     * Return text for a uri, instead of decoding the bytes. Use for a fixture
+     * corpus that exists only in the test file.
+     */
+    readonly textFor?: (uri: string) => string | undefined;
+    /** Pretend this uri is paginated — for exercising page provenance without a PDF. */
+    readonly pagesFor?: (uri: string) => readonly string[] | undefined;
+}
+export declare function mockLoader(options?: MockLoaderOptions): DocumentLoader;

package/dist/esm/rag/loaders/mock.js

@@ -0,0 +1,14 @@
+import { decodeText } from './text.js';
+export function mockLoader(options = {}) {
+    return {
+        name: 'mock',
+        extensions: options.extensions ?? ['.md', '.txt', '.html', '.pdf', '.mock'],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        async load(input) {
+            const pages = options.pagesFor?.(input.uri);
+            const text = options.textFor?.(input.uri) ?? decodeText(input.bytes);
+            return { text: pages ? pages.join('\n\n') : text, ...(pages && { pages }) };
+        },
+    };
+}
+//# sourceMappingURL=mock.js.map

package/dist/esm/rag/loaders/mock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.js","sourceRoot":"","sources":["../../../../src/rag/loaders/mock.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAcvC,MAAM,UAAU,UAAU,CAAC,UAA6B,EAAE;IACxD,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC;QAC3E,4DAA4D;QAC5D,KAAK,CAAC,IAAI,CAAC,KAAoB;YAC7B,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC5C,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrE,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAC9E,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/esm/rag/loaders/pdf.d.ts

@@ -0,0 +1,39 @@
+import type { DocumentLoader } from '../types.js';
+/**
+ * The slice of `unpdf` this loader uses — declared structurally, so a stub, a
+ * pinned fork, or a future version satisfies it without this package taking a
+ * hard type dependency on an optional peer.
+ */
+export interface UnpdfBackend {
+    getDocumentProxy(data: Uint8Array): Promise<unknown>;
+    extractText(doc: unknown, options?: {
+        mergePages?: boolean;
+    }): Promise<{
+        totalPages: number;
+        text: string | string[];
+    }>;
+}
+export interface PdfLoaderOptions {
+    /**
+     * An ALREADY-IMPORTED `unpdf`. Supply this and the lazy load never happens —
+     * which is what makes the loader work in a BUNDLED app, where a bare
+     * specifier reaches the runtime unresolved:
+     *
+     * ```ts
+     * import * as unpdf from 'unpdf';
+     * pdfLoader({ backend: unpdf });
+     * ```
+     *
+     * The same mechanism the embedders and the store adapters use: the library
+     * states the surface it needs, the host owns the construction.
+     */
+    readonly backend?: UnpdfBackend;
+}
+/** Raised when a PDF is met and `unpdf` is not installed. */
+export declare class MissingPdfSupportError extends Error {
+    readonly code: "ERR_MISSING_PDF_SUPPORT";
+    /** The file that could not be read. */
+    readonly uri: string;
+    constructor(uri: string);
+}
+export declare function pdfLoader(options?: PdfLoaderOptions): DocumentLoader;

package/dist/esm/rag/loaders/pdf.js

@@ -0,0 +1,90 @@
+/**
+ * pdfLoader — PDF text extraction, page by page.
+ *
+ * Pattern: Adapter behind `DocumentLoader`, over a lazily-loaded optional peer.
+ * Role:    rag/ layer. The ONE loader that needs a dependency, and the reason
+ *          it is optional rather than bundled.
+ * Emits:   N/A.
+ *
+ * ── Why `unpdf`, measured rather than assumed ───────────────────────────────
+ * PDF text extraction cannot be done without a real library. The candidates
+ * were installed and measured:
+ *
+ * | package | installed size | packages | deps | verdict |
+ * |---|---|---|---|---|
+ * | **`unpdf`** | **2.5 MB** | **1** | **none** | chosen |
+ * | `pdf-parse@2` | 86 MB | 3 | `@napi-rs/canvas` (**native**) | a native binary, to read text |
+ * | `pdf-parse@1` | 34 MB | 4 | debug, node-ensure | unmaintained since 2018 |
+ * | `pdfjs-dist@6` | 62 MB | 2 | none | 25× the size for the same engine |
+ *
+ * `unpdf` is a serverless build of the same pdf.js engine the heavyweight
+ * options wrap, with dual CJS/ESM exports and zero transitive dependencies.
+ * A real 2-page PDF extracts in ~95 ms.
+ *
+ * ── Pages are the point ─────────────────────────────────────────────────────
+ * It returns text PER PAGE, and that is why the page number in a citation is a
+ * fact rather than a guess. `<source id="handbook.pdf#7" page="2">` can be
+ * checked by opening page 2. A loader that flattened the document first could
+ * only ever say "somewhere in this PDF".
+ *
+ * ── A known warning on Node 22 ──────────────────────────────────────────────
+ * pdf.js v5 calls `Math.sumPrecise`, which arrives in V8 later than Node 22.
+ * The extraction is correct; the console shows `Warning: TypeError:
+ * Math.sumPrecise is not a function` per page. It is upstream and harmless,
+ * and it is documented here so it does not read as data loss.
+ */
+import { lazyRequire } from '../../lib/lazyRequire.js';
+/** Raised when a PDF is met and `unpdf` is not installed. */
+export class MissingPdfSupportError extends Error {
+    code = 'ERR_MISSING_PDF_SUPPORT';
+    /** The file that could not be read. */
+    uri;
+    constructor(uri) {
+        super(`Reading '${uri}' requires the \`unpdf\` peer dependency.\n` +
+            '  Install:  npm install unpdf\n' +
+            '  Or pass `backend` to pdfLoader() if your bundler resolves it statically.');
+        this.name = 'MissingPdfSupportError';
+        this.uri = uri;
+    }
+}
+export function pdfLoader(options = {}) {
+    let backend;
+    const getBackend = (uri) => {
+        if (options.backend)
+            return Promise.resolve(options.backend);
+        return (backend ??= (async () => {
+            // `unpdf` is ESM-only in its import condition, so a dynamic import is
+            // tried first and the CJS require is the fallback — one of the two works
+            // on every runtime this package supports.
+            try {
+                const spec = 'unpdf';
+                return (await import(spec));
+            }
+            catch {
+                try {
+                    return lazyRequire('unpdf');
+                }
+                catch {
+                    throw new MissingPdfSupportError(uri);
+                }
+            }
+        })());
+    };
+    return {
+        name: 'pdf',
+        extensions: ['.pdf'],
+        async load(input) {
+            const unpdf = await getBackend(input.uri);
+            const doc = await unpdf.getDocumentProxy(input.bytes);
+            const extracted = await unpdf.extractText(doc, { mergePages: false });
+            const pages = Array.isArray(extracted.text)
+                ? extracted.text.map((p) => String(p))
+                : [String(extracted.text)];
+            // Pages are joined with a blank line so `byParagraph` sees a boundary at
+            // every page break — and so the offsets a splitter computes index THIS
+            // string, which is the one that gets stored.
+            return { text: pages.join('\n\n'), pages };
+        },
+    };
+}
+//# sourceMappingURL=pdf.js.map

package/dist/esm/rag/loaders/pdf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf.js","sourceRoot":"","sources":["../../../../src/rag/loaders/pdf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAiCvD,6DAA6D;AAC7D,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IACtC,IAAI,GAAG,yBAAkC,CAAC;IACnD,uCAAuC;IAC9B,GAAG,CAAS;IAErB,YAAY,GAAW;QACrB,KAAK,CACH,YAAY,GAAG,6CAA6C;YAC1D,iCAAiC;YACjC,4EAA4E,CAC/E,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;QACrC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;CACF;AAED,MAAM,UAAU,SAAS,CAAC,UAA4B,EAAE;IACtD,IAAI,OAA0C,CAAC;IAE/C,MAAM,UAAU,GAAG,CAAC,GAAW,EAAyB,EAAE;QACxD,IAAI,OAAO,CAAC,OAAO;YAAE,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC7D,OAAO,CAAC,OAAO,KAAK,CAAC,KAAK,IAA2B,EAAE;YACrD,sEAAsE;YACtE,yEAAyE;YACzE,0CAA0C;YAC1C,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,OAAO,CAAC;gBACrB,OAAO,CAAC,MAAM,MAAM,CAAC,IAAI,CAAC,CAA4B,CAAC;YACzD,CAAC;YAAC,MAAM,CAAC;gBACP,IAAI,CAAC;oBACH,OAAO,WAAW,CAAe,OAAO,CAAC,CAAC;gBAC5C,CAAC;gBAAC,MAAM,CAAC;oBACP,MAAM,IAAI,sBAAsB,CAAC,GAAG,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;QACH,CAAC,CAAC,EAAE,CAAC,CAAC;IACR,CAAC,CAAC;IAEF,OAAO;QACL,IAAI,EAAE,KAAK;QACX,UAAU,EAAE,CAAC,MAAM,CAAC;QACpB,KAAK,CAAC,IAAI,CAAC,KAAoB;YAC7B,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC1C,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,SAAS,GAAG,MAAM,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;YACtE,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC;gBACzC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBACtC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;YAC7B,yEAAyE;YACzE,uEAAuE;YACvE,6CAA6C;YAC7C,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;QAC7C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/esm/rag/loaders/text.d.ts

@@ -0,0 +1,23 @@
+/**
+ * textLoader — plain text, decoded and left alone.
+ *
+ * Pattern: Adapter behind `DocumentLoader`.
+ * Role:    rag/ layer. The simplest possible loader, and the one that defines
+ *          what "leaving positions alone" means for the others: it decodes
+ *          UTF-8, normalises line endings, and does nothing else. No trimming,
+ *          no collapsing of blank lines, no smart quotes — every one of those
+ *          would shift every offset after it, and an offset that does not
+ *          index the original is worse than no offset at all.
+ * Emits:   N/A.
+ *
+ * Line-ending normalisation is the one exception, and it is a deliberate one:
+ * `\r\n` → `\n` happens BEFORE any offset is computed, so offsets index the
+ * normalised text, which is also the text that is stored and shown. The
+ * alternative — keeping `\r` — makes every paragraph boundary two characters
+ * on Windows and one everywhere else, so the same document chunks differently
+ * depending on who checked it out.
+ */
+import type { DocumentLoader } from '../types.js';
+/** Decode UTF-8 and normalise line endings. Shared by every text-shaped loader. */
+export declare function decodeText(bytes: Uint8Array): string;
+export declare function textLoader(): DocumentLoader;

package/dist/esm/rag/loaders/text.js

@@ -0,0 +1,21 @@
+/** Decode UTF-8 and normalise line endings. Shared by every text-shaped loader. */
+export function decodeText(bytes) {
+    // `fatal: false` — a corpus is other people's files, and one bad byte in a
+    // 200-page document should degrade that character, not lose the document.
+    const text = new TextDecoder('utf-8', { fatal: false }).decode(bytes);
+    // Strip a UTF-8 BOM: it is invisible, it is not content, and left in place it
+    // becomes the first character of the first chunk of the document.
+    const withoutBom = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+    return withoutBom.replace(/\r\n/g, '\n');
+}
+export function textLoader() {
+    return {
+        name: 'text',
+        extensions: ['.txt', '.text', '.log', '.csv', '.tsv', '.json', '.yaml', '.yml'],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        async load(input) {
+            return { text: decodeText(input.bytes) };
+        },
+    };
+}
+//# sourceMappingURL=text.js.map

package/dist/esm/rag/loaders/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../../../src/rag/loaders/text.ts"],"names":[],"mappings":"AAqBA,mFAAmF;AACnF,MAAM,UAAU,UAAU,CAAC,KAAiB;IAC1C,2EAA2E;IAC3E,0EAA0E;IAC1E,MAAM,IAAI,GAAG,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACtE,8EAA8E;IAC9E,kEAAkE;IAClE,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACxE,OAAO,UAAU,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC;AAED,MAAM,UAAU,UAAU;IACxB,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,UAAU,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC;QAC/E,4DAA4D;QAC5D,KAAK,CAAC,IAAI,CAAC,KAAoB;YAC7B,OAAO,EAAE,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/esm/rag/splitDocuments.d.ts

@@ -0,0 +1,21 @@
+import type { Chunk, LoadedDocument, Splitter } from './types.js';
+export interface SplitDocumentsOptions {
+    /**
+     * Verify each piece against its own offsets and throw on a mismatch.
+     * Default true. There is no good reason to turn it off except a splitter
+     * that deliberately rewrites text, in which case its citations cannot be
+     * checked against the source and you should know that.
+     */
+    readonly verifyOffsets?: boolean;
+}
+/**
+ * Cut documents into chunks.
+ *
+ * @throws when a splitter returns a piece whose offsets do not match its text.
+ *
+ * @example
+ * ```ts
+ * const chunks = splitDocuments(documents, byHeading());
+ * ```
+ */
+export declare function splitDocuments(documents: readonly LoadedDocument[], splitter: Splitter, options?: SplitDocumentsOptions): readonly Chunk[];

package/dist/esm/rag/splitDocuments.js

@@ -0,0 +1,65 @@
+/**
+ * splitDocuments — documents become chunks that know where they came from.
+ *
+ * Pattern: application of the `Splitter` strategy, plus identity and hashing.
+ * Role:    rag/ layer. Step two of the pipeline.
+ * Emits:   N/A — `indexCorpus` wraps this in a stage and records what it did.
+ *
+ * The splitter decides WHERE to cut; this decides what a cut is CALLED and how
+ * a later run recognises it:
+ *
+ *  - **id** is `'<docUri>#<index>'` — stable across runs for an unchanged
+ *    document, human-readable, and the string the model is asked to cite.
+ *  - **contentHash** is sha-256 of the chunk text. Two runs over an unchanged
+ *    document produce identical hashes, which is what makes "skip this one"
+ *    a fact rather than a guess about mtimes.
+ *
+ * The invariant every splitter must hold — `doc.text.slice(charStart, charEnd)
+ * === chunk.text` — is CHECKED here rather than trusted, because a custom
+ * splitter is a supported thing to write and a silently wrong offset produces
+ * citations that point at the wrong words.
+ */
+import { sha256 } from './hash.js';
+/**
+ * Cut documents into chunks.
+ *
+ * @throws when a splitter returns a piece whose offsets do not match its text.
+ *
+ * @example
+ * ```ts
+ * const chunks = splitDocuments(documents, byHeading());
+ * ```
+ */
+export function splitDocuments(documents, splitter, options = {}) {
+    const verify = options.verifyOffsets ?? true;
+    const chunks = [];
+    for (const doc of documents) {
+        const pieces = splitter.split(doc);
+        let index = 0;
+        for (const piece of pieces) {
+            if (verify && doc.text.slice(piece.charStart, piece.charEnd) !== piece.text) {
+                throw new Error(`splitter '${splitter.name}' produced a chunk of '${doc.uri}' whose offsets do not ` +
+                    `match its text (chars ${piece.charStart}–${piece.charEnd}). A chunk that cannot be ` +
+                    `located in its own document produces citations that point at the wrong words, so ` +
+                    `this refuses rather than indexing it. Splitters must slice the document rather ` +
+                    `than rebuild the text.`);
+            }
+            if (piece.text.length === 0)
+                continue;
+            chunks.push({
+                id: `${doc.uri}#${index}`,
+                docUri: doc.uri,
+                index,
+                text: piece.text,
+                charStart: piece.charStart,
+                charEnd: piece.charEnd,
+                ...(piece.page !== undefined && { page: piece.page }),
+                ...(piece.heading !== undefined && { heading: piece.heading }),
+                contentHash: sha256(piece.text),
+            });
+            index += 1;
+        }
+    }
+    return chunks;
+}
+//# sourceMappingURL=splitDocuments.js.map

package/dist/esm/rag/splitDocuments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitDocuments.js","sourceRoot":"","sources":["../../../src/rag/splitDocuments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAanC;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,SAAoC,EACpC,QAAkB,EAClB,UAAiC,EAAE;IAEnC,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC;IAC7C,MAAM,MAAM,GAAY,EAAE,CAAC;IAE3B,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;gBAC5E,MAAM,IAAI,KAAK,CACb,aAAa,QAAQ,CAAC,IAAI,0BAA0B,GAAG,CAAC,GAAG,yBAAyB;oBAClF,yBAAyB,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,OAAO,4BAA4B;oBACrF,mFAAmF;oBACnF,iFAAiF;oBACjF,wBAAwB,CAC3B,CAAC;YACJ,CAAC;YACD,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;gBAAE,SAAS;YACtC,MAAM,CAAC,IAAI,CAAC;gBACV,EAAE,EAAE,GAAG,GAAG,CAAC,GAAG,IAAI,KAAK,EAAE;gBACzB,MAAM,EAAE,GAAG,CAAC,GAAG;gBACf,KAAK;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;gBACrD,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;gBAC9D,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;aAChC,CAAC,CAAC;YACH,KAAK,IAAI,CAAC,CAAC;QACb,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/esm/rag/splitters/byHeading.d.ts

@@ -0,0 +1,36 @@
+/**
+ * byHeading — cut where the author already said a section starts.
+ *
+ * Pattern: Strategy (one of `Splitter`).
+ * Role:    rag/ layer. The default for Markdown, and the only splitter in this
+ *          library that is **not a heuristic**.
+ * Emits:   N/A.
+ *
+ * Every other strategy infers boundaries from typography. This one reads them:
+ * a Markdown `#` line is the document telling you where a section begins, and
+ * ignoring that in favour of a character count is throwing away the best
+ * information in the file.
+ *
+ * Each chunk carries its heading, which flows through to the citation the
+ * model sees — `<source id="refunds.md#3" heading="Refund timing">` — so a
+ * reader can find the passage by name rather than by counting characters.
+ *
+ * A section longer than `maxChars` is packed by paragraph within the section
+ * and, failing that, hard-cut; every piece keeps the heading it came from.
+ * Text before the first heading (a preamble, a title block) is its own
+ * heading-less section rather than being attached to a heading it precedes.
+ */
+import type { Splitter } from '../types.js';
+export interface ByHeadingOptions {
+    /** Target chunk size in characters. Default 1000. Sections longer than this are packed within. */
+    readonly maxChars?: number;
+    /** Backward overlap. Default 150. */
+    readonly overlapChars?: number;
+    /**
+     * Deepest heading level that starts a new section (1 = `#` only, 6 = all).
+     * Default 6 — every heading is a boundary. Lower it when a document uses
+     * `####` for emphasis rather than structure.
+     */
+    readonly maxLevel?: number;
+}
+export declare function byHeading(options?: ByHeadingOptions): Splitter;

package/dist/esm/rag/splitters/byHeading.js

@@ -0,0 +1,66 @@
+import { DEFAULT_MAX_CHARS, DEFAULT_OVERLAP_CHARS } from './constants.js';
+import { applyOverlap, foldRunts, hardCut, packSpans, paragraphSpans, toPieces, } from './shared.js';
+/** ATX headings only (`# Title`). Setext (`Title\n=====`) is rare in docs corpora. */
+const HEADING = /^(#{1,6})[ \t]+(.+?)[ \t]*$/gm;
+export function byHeading(options = {}) {
+    const maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
+    const overlapChars = options.overlapChars ?? DEFAULT_OVERLAP_CHARS;
+    const maxLevel = options.maxLevel ?? 6;
+    return {
+        name: 'byHeading',
+        split(doc) {
+            const text = doc.text;
+            // Where each section starts, and what it is called.
+            const starts = [];
+            HEADING.lastIndex = 0;
+            let match;
+            while ((match = HEADING.exec(text)) !== null) {
+                if ((match[1] ?? '').length > maxLevel)
+                    continue;
+                starts.push({ offset: match.index, heading: match[2] });
+            }
+            // A document with no headings at all is a paragraph document; say so by
+            // doing the paragraph thing rather than returning one giant chunk.
+            if (starts.length === 0) {
+                const packed = packSpans(paragraphSpans(text), maxChars);
+                const cut = packed.flatMap((s) => s.end - s.start > maxChars ? hardCut(s, maxChars, overlapChars) : [s]);
+                return toPieces(doc, applyOverlap(foldRunts(cut), overlapChars));
+            }
+            const sections = [];
+            // Preamble before the first heading — its own section, unnamed.
+            const firstStart = starts[0]?.offset ?? 0;
+            if (firstStart > 0)
+                sections.push({ start: 0, end: firstStart });
+            for (let i = 0; i < starts.length; i++) {
+                const start = starts[i]?.offset ?? 0;
+                const end = starts[i + 1]?.offset ?? text.length;
+                const heading = starts[i]?.heading;
+                sections.push({ start, end, ...(heading !== undefined && { heading }) });
+            }
+            // Sections that fit stay whole; the rest are packed by paragraph WITHIN
+            // the section, so a boundary never merges two headings' content.
+            const spans = [];
+            for (const section of sections) {
+                if (section.end - section.start <= maxChars) {
+                    spans.push(section);
+                    continue;
+                }
+                const inner = paragraphSpans(text.slice(section.start, section.end)).map((s) => ({
+                    start: section.start + s.start,
+                    end: section.start + s.end,
+                    ...(section.heading !== undefined && { heading: section.heading }),
+                }));
+                for (const packedSpan of packSpans(inner, maxChars)) {
+                    if (packedSpan.end - packedSpan.start > maxChars) {
+                        spans.push(...hardCut(packedSpan, maxChars, overlapChars));
+                    }
+                    else {
+                        spans.push(packedSpan);
+                    }
+                }
+            }
+            return toPieces(doc, applyOverlap(foldRunts(spans), overlapChars));
+        },
+    };
+}
+//# sourceMappingURL=byHeading.js.map

package/dist/esm/rag/splitters/byHeading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"byHeading.js","sourceRoot":"","sources":["../../../../src/rag/splitters/byHeading.ts"],"names":[],"mappings":"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"}