@oscharko-dev/keiko-local-knowledge 0.2.0

package/dist/parsers/large-document/synthetic-source.js

@@ -0,0 +1,101 @@
+// Deterministic synthetic streaming source + extractor for the bounded-RSS regression
+// (Epic #1160, Issue #1286).
+//
+// The issue allows demonstrating bounded peak memory with "an equivalent synthetic streaming
+// fixture" instead of committing a one-gigabyte binary document. This source never materializes
+// the whole document: `readWindow` generates exactly the requested bytes on the fly via a pure
+// position function, so a 1 GiB-class document can be driven through the progressive pipeline
+// while only one page window of text is resident at a time.
+//
+// The byte layout is `totalPages` pages of `pageChars` ASCII letters each, separated by "\n\n"
+// (matching the progressive PDF separator), so the synthetic extractor produces the same window
+// shape as the real PDF strategy and exercises the identical persistence/checkpoint path.
+import { WindowTextBuilder } from "./window-builder.js";
+const SEPARATOR_BYTES = 2; // "\n\n"
+const NEWLINE = 0x0a;
+function strideBytes(pageChars) {
+    return pageChars + SEPARATOR_BYTES;
+}
+// Deterministic, pure body byte for page `pageNumber` at intra-page index `k`. A-Z so every page
+// differs and the produced text chunks are distinct.
+function pageBodyByte(pageNumber, k) {
+    return 0x41 + ((pageNumber + k) % 26);
+}
+function byteAt(pos, pageChars) {
+    const stride = strideBytes(pageChars);
+    const within = pos % stride;
+    if (within < pageChars) {
+        const pageNumber = Math.floor(pos / stride) + 1;
+        return pageBodyByte(pageNumber, within);
+    }
+    return NEWLINE;
+}
+export function syntheticStreamingSource(config) {
+    const stride = strideBytes(config.pageChars);
+    const totalBytes = config.totalPages * stride - SEPARATOR_BYTES;
+    return {
+        totalBytes,
+        // Generates exactly `length` bytes; never allocates the whole document.
+        readWindow: (startByte, length) => {
+            const out = new Uint8Array(length);
+            for (let i = 0; i < length; i += 1) {
+                out[i] = byteAt(startByte + i, config.pageChars);
+            }
+            return Promise.resolve(out);
+        },
+    };
+}
+function pageByteStart(pageNumber, pageChars) {
+    return (pageNumber - 1) * strideBytes(pageChars);
+}
+async function syntheticWindow(readWindow, decoder, documentId, config, firstPage, lastPage, state) {
+    const builder = new WindowTextBuilder(documentId, state.cursor, state.anyPageEmitted);
+    for (let pageNumber = firstPage; pageNumber <= lastPage; pageNumber += 1) {
+        const bytes = await readWindow(pageByteStart(pageNumber, config.pageChars), config.pageChars);
+        builder.addPage(pageNumber, decoder.decode(bytes));
+        state.objectCursor += config.pageChars;
+    }
+    state.cursor = builder.nextCursor;
+    state.anyPageEmitted = builder.hasEmittedAnyPage;
+    const window = {
+        windowIndex: state.windowIndex,
+        pages: builder.snapshotPages(),
+        units: builder.snapshotUnits(),
+        text: builder.text(),
+        characterStart: builder.characterStart,
+        objectCursor: state.objectCursor,
+        lastPageNumber: lastPage,
+        diagnostics: [],
+    };
+    state.windowIndex += 1;
+    return window;
+}
+async function* syntheticExtractWindows(config, source, options) {
+    const readWindow = source.readWindow;
+    if (readWindow === undefined)
+        return;
+    const decoder = new TextDecoder("utf-8");
+    const resumeFromPage = options.resumeFromPage ?? 0;
+    const state = {
+        cursor: options.resumeCharacterStart ?? 0,
+        anyPageEmitted: resumeFromPage > 0,
+        objectCursor: options.resumeObjectCursor ?? 0,
+        windowIndex: options.resumeWindowIndex ?? 0,
+    };
+    for (let firstPage = resumeFromPage + 1; firstPage <= config.totalPages; firstPage += config.pagesPerWindow) {
+        if (options.signal?.aborted === true)
+            return;
+        const lastPage = Math.min(firstPage + config.pagesPerWindow - 1, config.totalPages);
+        yield syntheticWindow(readWindow, decoder, options.documentId, config, firstPage, lastPage, state);
+    }
+}
+// A ProgressiveExtractor that reads page bytes from the streaming source one window at a time.
+// `parserVersion` is configurable so resume-compatibility tests can simulate a parser upgrade.
+export function syntheticProgressiveExtractor(config, parserVersion = "synthetic@1") {
+    return {
+        strategyId: "progressive-pdf",
+        parserVersion,
+        matches: (input) => input.extension === "synthetic",
+        extractWindows: (source, options) => syntheticExtractWindows(config, source, options),
+    };
+}

package/dist/parsers/large-document/window-builder.d.ts

@@ -0,0 +1,24 @@
+import type { DocumentId, PageRecord, ParsedUnit } from "@oscharko-dev/keiko-contracts";
+export interface AddedPage {
+    readonly page: PageRecord;
+    readonly unit: ParsedUnit;
+}
+export declare class WindowTextBuilder {
+    private readonly documentId;
+    private cursor;
+    private anyPageEmitted;
+    private readonly windowStart;
+    private appended;
+    private readonly pages;
+    private readonly units;
+    constructor(documentId: DocumentId, cursor: number, anyPageEmitted: boolean);
+    addPage(pageNumber: number, pageText: string): AddedPage;
+    get pageCount(): number;
+    get nextCursor(): number;
+    get hasEmittedAnyPage(): boolean;
+    get characterStart(): number;
+    snapshotPages(): readonly PageRecord[];
+    snapshotUnits(): readonly ParsedUnit[];
+    text(): string;
+}
+//# sourceMappingURL=window-builder.d.ts.map

package/dist/parsers/large-document/window-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-builder.d.ts","sourceRoot":"","sources":["../../../src/parsers/large-document/window-builder.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAIxF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;gBAE9B,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO;IAS3E,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS;IA8BxD,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,aAAa,IAAI,SAAS,UAAU,EAAE;IAItC,aAAa,IAAI,SAAS,UAAU,EAAE;IAItC,IAAI,IAAI,MAAM;CAGf"}

package/dist/parsers/large-document/window-builder.js

@@ -0,0 +1,75 @@
+// Shared document-relative offset bookkeeping for progressive extractors (Issue #1286).
+//
+// Pages are separated by "\n\n" (two characters) — the same separator the existing full-buffer
+// PDF parser uses (`pageTexts.join("\n\n")`) — so chunk character offsets stay aligned with the
+// persisted normalized text regardless of whether a document was extracted in one pass or
+// window by window. The builder accumulates one window's appended text and the page records for
+// the pages added to it; the caller flushes the window and starts a fresh builder for the next.
+const PAGE_SEPARATOR = "\n\n";
+export class WindowTextBuilder {
+    documentId;
+    cursor;
+    anyPageEmitted;
+    windowStart;
+    appended = "";
+    pages = [];
+    units = [];
+    constructor(documentId, cursor, anyPageEmitted) {
+        this.documentId = documentId;
+        this.cursor = cursor;
+        this.anyPageEmitted = anyPageEmitted;
+        this.windowStart = cursor;
+    }
+    // Appends a non-empty page, advancing the document-relative cursor across the "\n\n" separator
+    // that precedes every page after the first emitted page of the document.
+    addPage(pageNumber, pageText) {
+        if (this.anyPageEmitted) {
+            this.appended += PAGE_SEPARATOR;
+            this.cursor += PAGE_SEPARATOR.length;
+        }
+        const characterStart = this.cursor;
+        const characterEnd = characterStart + pageText.length;
+        this.appended += pageText;
+        this.cursor = characterEnd;
+        this.anyPageEmitted = true;
+        const page = {
+            documentId: this.documentId,
+            pageNumber,
+            pageLabel: String(pageNumber),
+            characterStart,
+            characterEnd,
+        };
+        const unit = {
+            kind: "page",
+            documentId: this.documentId,
+            pageNumber,
+            pageLabel: String(pageNumber),
+            characterStart,
+            characterEnd,
+        };
+        this.pages.push(page);
+        this.units.push(unit);
+        return { page, unit };
+    }
+    get pageCount() {
+        return this.pages.length;
+    }
+    get nextCursor() {
+        return this.cursor;
+    }
+    get hasEmittedAnyPage() {
+        return this.anyPageEmitted;
+    }
+    get characterStart() {
+        return this.windowStart;
+    }
+    snapshotPages() {
+        return this.pages;
+    }
+    snapshotUnits() {
+        return this.units;
+    }
+    text() {
+        return this.appended;
+    }
+}

package/dist/parsers/ocr/index.d.ts

@@ -0,0 +1,4 @@
+export { nullOcrAdapter } from "./null-ocr-adapter.js";
+export { createOcrPipelineParser, type OcrPipelineAdapter } from "./ocr-pipeline-parser.js";
+export { type OcrAdapter, type OcrPageResult } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/parsers/ocr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/parsers/ocr/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/parsers/ocr/index.js

@@ -0,0 +1,4 @@
+// OCR adapter seam — barrel for the ocr/ subdirectory (Epic #189, Issue #202).
+export { nullOcrAdapter } from "./null-ocr-adapter.js";
+export { createOcrPipelineParser } from "./ocr-pipeline-parser.js";
+export {} from "./types.js";

package/dist/parsers/ocr/null-ocr-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { OcrAdapter } from "./types.js";
+export declare const nullOcrAdapter: OcrAdapter;
+//# sourceMappingURL=null-ocr-adapter.d.ts.map

package/dist/parsers/ocr/null-ocr-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null-ocr-adapter.d.ts","sourceRoot":"","sources":["../../../src/parsers/ocr/null-ocr-adapter.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,YAAY,CAAC;AAO5D,eAAO,MAAM,cAAc,EAAE,UAM3B,CAAC"}

package/dist/parsers/ocr/null-ocr-adapter.js

@@ -0,0 +1,14 @@
+// NullOcrAdapter (Epic #189, Issue #202). The default adapter used when no real OCR engine
+// has been configured. Always returns `ok: false, reason: "ocr-not-configured"` so the
+// pipeline parser can fire the standard unsupported-media diagnostic rather than silently
+// skipping the document.
+//
+// Never throws — the contract in OcrAdapter.ocrPage forbids throwing.
+const NOT_CONFIGURED = Object.freeze({
+    ok: false,
+    reason: "ocr-not-configured",
+});
+export const nullOcrAdapter = Object.freeze({
+    kind: "ocr",
+    ocrPage: (_input) => Promise.resolve(NOT_CONFIGURED),
+});

package/dist/parsers/ocr/ocr-pipeline-parser.d.ts

@@ -0,0 +1,8 @@
+import type { ParserResult } from "@oscharko-dev/keiko-contracts";
+import type { ParserAdapter, ParserOptions, ParserSelectionInput } from "../types.js";
+import type { OcrAdapter } from "./types.js";
+export interface OcrPipelineAdapter extends ParserAdapter {
+    readonly parseAsync: (input: ParserSelectionInput, options: ParserOptions) => Promise<ParserResult>;
+}
+export declare function createOcrPipelineParser(adapter: OcrAdapter): OcrPipelineAdapter;
+//# sourceMappingURL=ocr-pipeline-parser.d.ts.map

package/dist/parsers/ocr/ocr-pipeline-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr-pipeline-parser.d.ts","sourceRoot":"","sources":["../../../src/parsers/ocr/ocr-pipeline-parser.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAG9E,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACb,oBAAoB,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,YAAY,CAAC;AAwK5D,MAAM,WAAW,kBAAmB,SAAQ,aAAa;IACvD,QAAQ,CAAC,UAAU,EAAE,CACnB,KAAK,EAAE,oBAAoB,EAC3B,OAAO,EAAE,aAAa,KACnB,OAAO,CAAC,YAAY,CAAC,CAAC;CAC5B;AAID,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,UAAU,GAAG,kBAAkB,CAW/E"}

package/dist/parsers/ocr/ocr-pipeline-parser.js

@@ -0,0 +1,147 @@
+// OCR pipeline parser (Epic #189, Issue #202). A `ParserAdapter` factory that wraps an
+// `OcrAdapter`. The sync `parse` method always fires the unsupported-media diagnostic (the
+// `ParserAdapter.parse` contract is synchronous and cannot await the OCR result). The async
+// `parseAsync` method is the real entry point for callers that can await: when OCR succeeds
+// it emits one `ParsedUnit { kind: "page" }` per recognised page; when OCR fails it fires
+// the standard unsupported-media diagnostic consistent with unsupported-parser.ts (#266).
+//
+// No multi-page splitter ships yet — until a real splitter exists the input bytes are treated
+// as page 1. That assumption is isolated here and collapses when a splitter is added.
+import { diagnostic, emptyResult, oversizeDiagnostic, shouldStop } from "../_internal.js";
+const PARSER_ID = "ocr-pipeline";
+const PARSER_VERSION = "1";
+const OCR_EXTENSIONS = new Set([
+    "pdf",
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "bmp",
+    "tif",
+    "tiff",
+    "webp",
+]);
+const OCR_MEDIA_PREFIXES = ["image/", "application/pdf"];
+// Magic-byte table for fallback detection when no extension / media type is present.
+const OCR_MAGIC = Object.freeze([
+    { prefix: [0x25, 0x50, 0x44, 0x46] }, // PDF: %PDF
+    { prefix: [0x89, 0x50, 0x4e, 0x47] }, // PNG
+    { prefix: [0xff, 0xd8, 0xff] }, // JPEG
+    { prefix: [0x47, 0x49, 0x46, 0x38] }, // GIF8
+    { prefix: [0x42, 0x4d] }, // BMP
+]);
+function matchesMagicBytes(bytes) {
+    for (const entry of OCR_MAGIC) {
+        if (bytes.length < entry.prefix.length)
+            continue;
+        let match = true;
+        for (let i = 0; i < entry.prefix.length; i += 1) {
+            if (bytes[i] !== entry.prefix[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return true;
+    }
+    return false;
+}
+function isOcrCandidate(input) {
+    if (OCR_EXTENSIONS.has(input.extension.toLowerCase()))
+        return true;
+    for (const prefix of OCR_MEDIA_PREFIXES) {
+        if (input.mediaType.toLowerCase().startsWith(prefix))
+            return true;
+    }
+    return matchesMagicBytes(input.bytes);
+}
+function unsupportedReason(input) {
+    if (input.extension.toLowerCase() === "pdf" ||
+        input.mediaType.toLowerCase() === "application/pdf")
+        return "pdf-not-implemented";
+    return "image-not-supported";
+}
+// Reads signal.aborted via function call to defeat TypeScript cross-await control-flow
+// narrowing that incorrectly marks the boolean as `false` after a prior check.
+function isAborted(signal) {
+    return signal?.aborted === true;
+}
+function cancelled(cap, input, options) {
+    return emptyResult(cap, input.documentId, options, [
+        diagnostic("PARSER_CANCELLED", "caller aborted parser", input.documentId, "info"),
+    ]);
+}
+function resultFromOcrOutcome(ocrResult, cap, input, options) {
+    if (!ocrResult.ok) {
+        const reason = ocrResult.reason === "ocr-not-configured"
+            ? unsupportedReason(input)
+            : `ocr-failed:${ocrResult.reason}`;
+        return emptyResult(cap, input.documentId, options, [
+            diagnostic("UNSUPPORTED_FORMAT", `ocr adapter returned ok:false (${ocrResult.reason})`, input.documentId, "info"),
+        ], [{ kind: "unsupported-media", documentId: input.documentId, reason }]);
+    }
+    const pageUnit = {
+        kind: "page",
+        documentId: input.documentId,
+        pageNumber: 1,
+        characterStart: 0,
+        characterEnd: ocrResult.text.length,
+    };
+    return emptyResult(cap, input.documentId, options, [], [pageUnit]);
+}
+function buildSyncParse(cap) {
+    return (input, options) => {
+        if (input.bytes.byteLength > options.maxBytes) {
+            return emptyResult(cap, input.documentId, options, [
+                oversizeDiagnostic(input.documentId, input.bytes.byteLength, options.maxBytes),
+            ]);
+        }
+        if (isAborted(options.signal))
+            return cancelled(cap, input, options);
+        const reason = unsupportedReason(input);
+        return emptyResult(cap, input.documentId, options, [
+            diagnostic("UNSUPPORTED_FORMAT", `ocr adapter present but sync parse called; use parseAsync (${reason})`, input.documentId, "info"),
+        ], [{ kind: "unsupported-media", documentId: input.documentId, reason }]);
+    };
+}
+function buildAsyncParse(cap, adapter) {
+    return async (input, options) => {
+        if (input.bytes.byteLength > options.maxBytes) {
+            return emptyResult(cap, input.documentId, options, [
+                oversizeDiagnostic(input.documentId, input.bytes.byteLength, options.maxBytes),
+            ]);
+        }
+        if (isAborted(options.signal))
+            return cancelled(cap, input, options);
+        const startedAt = options.now();
+        const preCheck = shouldStop(startedAt, options, 0);
+        if (preCheck.stop && preCheck.code !== undefined && preCheck.message !== undefined) {
+            return emptyResult(cap, input.documentId, options, [
+                diagnostic(preCheck.code, preCheck.message, input.documentId, "info"),
+            ]);
+        }
+        const ocrResult = await adapter.ocrPage({ bytes: input.bytes, pageNumber: 1 });
+        if (isAborted(options.signal))
+            return cancelled(cap, input, options);
+        const postCheck = shouldStop(startedAt, options, 0);
+        if (postCheck.stop && postCheck.code !== undefined && postCheck.message !== undefined) {
+            return emptyResult(cap, input.documentId, options, [
+                diagnostic(postCheck.code, postCheck.message, input.documentId, "info"),
+            ]);
+        }
+        return resultFromOcrOutcome(ocrResult, cap, input, options);
+    };
+}
+// ─── Factory ─────────────────────────────────────────────────────────────────
+export function createOcrPipelineParser(adapter) {
+    const capability = Object.freeze({
+        parserId: PARSER_ID,
+        parserVersion: PARSER_VERSION,
+        matches: isOcrCandidate,
+    });
+    return Object.freeze({
+        capability,
+        parse: buildSyncParse(capability),
+        parseAsync: buildAsyncParse(capability, adapter),
+    });
+}

package/dist/parsers/ocr/types.d.ts

@@ -0,0 +1,16 @@
+export type OcrPageResult = {
+    readonly ok: true;
+    readonly text: string;
+    readonly confidence: number;
+} | {
+    readonly ok: false;
+    readonly reason: "ocr-not-configured" | "timeout" | "unsupported-input";
+};
+export interface OcrAdapter {
+    readonly kind: "ocr";
+    readonly ocrPage: (input: {
+        readonly bytes: Uint8Array;
+        readonly pageNumber: number;
+    }) => Promise<OcrPageResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/parsers/ocr/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/parsers/ocr/types.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,aAAa,GACrB;IACE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAGlB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAKnB,QAAQ,CAAC,MAAM,EAAE,oBAAoB,GAAG,SAAS,GAAG,mBAAmB,CAAC;CACzE,CAAC;AAIN,MAAM,WAAW,UAAU;IAGzB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAIrB,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE;QACxB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;QAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;KAC7B,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;CAC9B"}

package/dist/parsers/ocr/types.js

@@ -0,0 +1,4 @@
+// OCR adapter port contract (Epic #189, Issue #202). Pure interface — no IO, no clock, no
+// FS. A real OCR implementation (Tesseract, cloud API, etc.) implements `OcrAdapter` and is
+// injected into `createOcrPipelineParser` without changing the parser registry.
+export {};

package/dist/parsers/parser-test-fixtures.d.ts

@@ -0,0 +1,28 @@
+import type { DocumentId } from "@oscharko-dev/keiko-contracts";
+import type { ParserSelectionInput } from "./types.js";
+export declare const FIXTURE_DOCUMENT_ID: DocumentId;
+export declare function encode(text: string): Uint8Array;
+export declare function selectionFromText(text: string, overrides?: Partial<ParserSelectionInput>): ParserSelectionInput;
+export declare function selectionFromBytes(bytes: Uint8Array, overrides?: Partial<ParserSelectionInput>): ParserSelectionInput;
+export declare const TEXT_PLAIN = "Hello, world.\nSecond paragraph here.\n";
+export declare const MARKDOWN_DOC: string;
+export declare const JSON_FLAT = "{\"name\":\"alpha\",\"count\":3,\"active\":true}";
+export declare const JSON_NESTED: string;
+export declare const CSV_SIMPLE = "a,b,c\n1,2,3\n4,5,6\n";
+export declare const CSV_QUOTED = "a,b,c\n\"x,1\",\"y\"\"2\",\"z\n3\"\n";
+export declare const TSV_SIMPLE = "a\tb\tc\n1\t2\t3\n";
+export declare const HTML_HEADINGS: string;
+export declare const HTML_DANGEROUS: string;
+export declare const PDF_MAGIC: Uint8Array;
+export declare const PDF_TEXT_LAYER: Uint8Array;
+export declare const PDF_NO_TEXT_LAYER: Uint8Array;
+export declare const DOCX_SIMPLE_BASE64 = "UEsDBBQAAAAIAC28xFzXeYTq8QAAALgBAAATAAAAW0NvbnRlbnRfVHlwZXNdLnhtbH2QzU7DMBCE730Ky9cqccoBIZSkB36OwKE8wMreJFb9J69b2rdn00KREOVozXwz62nXB+/EHjPZGDq5qhspMOhobBg7+b55ru6koALBgIsBO3lEkut+0W6OCUkwHKiTUynpXinSE3qgOiYMrAwxeyj8zKNKoLcworppmlulYygYSlXmDNkvhGgfcYCdK+LpwMr5loyOpHg4e+e6TkJKzmoorKt9ML+Kqq+SmsmThyabaMkGqa6VzOL1jh/0lSfK1qB4g1xewLNRfcRslIl65xmu/0/649o4DFbjhZ/TUo4aiXh77+qL4sGG71+06jR8/wlQSwMEFAAAAAgALbzEXCAbhuqyAAAALgEAAAsAAABfcmVscy8ucmVsc43Puw6CMBQG4J2naM4uBQdjDIXFmLAafICmPZRGeklbL7y9HRzEODie23fyN93TzOSOIWpnGdRlBQStcFJbxeAynDZ7IDFxK/nsLDJYMELXFs0ZZ57yTZy0jyQjNjKYUvIHSqOY0PBYOo82T0YXDE+5DIp6Lq5cId1W1Y6GTwPagpAVS3rJIPSyBjIsHv/h3ThqgUcnbgZt+vHlayPLPChMDB4uSCrf7TKzQHNKuorZvgBQSwMEFAAAAAgALbzEXGJ/vc/pAAAA5wEAABEAAAB3b3JkL2RvY3VtZW50LnhtbJWRwU7DMAyG73uKKPc13Q4IVU2mgTRxnAQ8QEjNWimxoySs9O1JWtAmDhOc8lv+f/uT0+4+nWVnCHEglHxT1ZwBGuoGPEn++nJY33MWk8ZOW0KQfILId2rVjk1H5sMBJpYnYGxGyfuUfCNEND04HSvygLn3TsHplMtwEiOFzgcyEGNe4KzY1vWdcHpArlaM5alv1E1FzoVf1KKPQZXnOU0W2NictZX8CXQh3XChWrF4LonZn9SR7GCm0k6z6dsy+682XQJ763vNCkh1nfod+Bva9hbaI2EKZOM/4B4g3WIrYjlhUT9fpL4AUEsBAhQDFAAAAAgALbzEXNd5hOrxAAAAuAEAABMAAAAAAAAAAAAAAIABAAAAAFtDb250ZW50X1R5cGVzXS54bWxQSwECFAMUAAAACAAtvMRcIBuG6rIAAAAuAQAACwAAAAAAAAAAAAAAgAEiAQAAX3JlbHMvLnJlbHNQSwECFAMUAAAACAAtvMRcYn+9z+kAAADnAQAAEQAAAAAAAAAAAAAAgAH9AQAAd29yZC9kb2N1bWVudC54bWxQSwUGAAAAAAMAAwC5AAAAFQMAAAAA";
+export declare const DOCX_SIMPLE: Uint8Array;
+export declare const DOCX_WITH_PREAMBLE_BASE64 = "UEsDBBQAAAAIANACxVxn4XsRxAAAAHcBAAATABwAW0NvbnRlbnRfVHlwZXNdLnhtbFVUCQADp/ohaqf6IWp1eAsAAQT1AQAABBQAAAB9kLkOwjAMhneeosqKqBEDA6IswAoMvICVum1ELsXmentSrgEBo/0fn+X5/hqJi4uznivVicQZAOuOHHIZIvmsNCE5lDymFiLqA7YEk/F4Cjp4IS8j6TvUYr6iBo9WivUlr9kEX6lEllWxfBh7VqUwRms0Stbh5OsPyuhJKHPy7uHORB5mg4KvhF75DXjmtidKydRU7DDJBl12wTmkGuqgjy4ny/81X+4MTWM0vfN9W0xBE7PxrbPlW3Fo/Ot+uL97MbgBUEsDBAoAAAAAANACxVwAAAAAAAAAAAAAAAAGABwAX3JlbHMvVVQJAAOn+iFqp/ohanV4CwABBPUBAAAEFAAAAFBLAwQUAAAACADQAsVcJnghCIsAAADzAAAACwAcAF9yZWxzLy5yZWxzVVQJAAOn+iFqp/ohanV4CwABBPUBAAAEFAAAAI3PPQ4CIRAF4N5TEA6ws1pYGKCy2XbjBQjMAnH5yYBRby+FxWosLGfe5HsZMeOqW8ip+lAqe8Q1Vcl9a+UEUI3HqOuQC6aeLJmibn0kB0Wbq3YIh3E8Am0NrsTWZJOVnCa75+zyLPiPnZclGDxnc4uY2o+Kr4sua3LYJL9nsmDf66GzHJSAjxfV7gVQSwMECgAAAAAA0ALFXAAAAAAAAAAAAAAAAAUAHAB3b3JkL1VUCQADp/ohaqf6IWp1eAsAAQT1AQAABBQAAABQSwMEFAAAAAgA0ALFXNON7KHUAAAAWAEAABEAHAB3b3JkL2RvY3VtZW50LnhtbFVUCQADp/ohaqf6IWp1eAsAAQT1AQAABBQAAAB1kE1PwzAMhu/7FZHvLN0OCFVtd0PsNgn4ASYxbaUkjpyw0n9PsvEhJLi8Vuwnrz+6w7t36kySZg497LYNKAqG7RzGHp6f7m/uQKWMwaLjQD2slOAwbLqltWzePIWsikNI7dLDlHNstU5mIo9py5FCqb2yeMzlKaNeWGwUNpRSaeCd3jfNrfY4BxiK5QvbtcZYRark4RiysIooOArGqdM1WVUuGr/5eLr8iI95daSW9oyuhwfCusoO9JW+Mp/WJ3azWf93/IWpOtwfrP4aW/+cZNh8AFBLAQIeAxQAAAAIANACxVxn4XsRxAAAAHcBAAATABgAAAAAAAEAAACkgQAAAABbQ29udGVudF9UeXBlc10ueG1sVVQFAAOn+iFqdXgLAAEE9QEAAAQUAAAAUEsBAh4DCgAAAAAA0ALFXAAAAAAAAAAAAAAAAAYAGAAAAAAAAAAQAO1BEQEAAF9yZWxzL1VUBQADp/ohanV4CwABBPUBAAAEFAAAAFBLAQIeAxQAAAAIANACxVwmeCEIiwAAAPMAAAALABgAAAAAAAEAAACkgVEBAABfcmVscy8ucmVsc1VUBQADp/ohanV4CwABBPUBAAAEFAAAAFBLAQIeAwoAAAAAANACxVwAAAAAAAAAAAAAAAAFABgAAAAAAAAAEADtQSECAAB3b3JkL1VUBQADp/ohanV4CwABBPUBAAAEFAAAAFBLAQIeAxQAAAAIANACxVzTjeyh1AAAAFgBAAARABgAAAAAAAEAAACkgWACAAB3b3JkL2RvY3VtZW50LnhtbFVUBQADp/ohanV4CwABBPUBAAAEFAAAAFBLBQYAAAAABQAFAJgBAAB/AwAAAAA=";
+export declare const DOCX_WITH_PREAMBLE: Uint8Array;
+export declare const XLSX_SIMPLE_BASE64 = "UEsDBBQAAAAIAAAAAADBChDqgQAAAKQAAAAPAAAAeGwvd29ya2Jvb2sueG1sNY7BDoMwDEN/pcoHLLDDDohy2S58RgfpWkEblARtnz80jZPtZ1ly/2ZZnsyL+5S1aicektnWIeqUqAS98Eb16CJLCXZEeSHHmCd68LQXqobXprmh0Bosc9WUN4Wh10Rk+ldXQyEPd64mvCq4Hx1nDy046fJhZJxbwKHHc4jns+ELUEsDBBQAAAAIAAAAAAAHfok7RgAAAGgAAAAaAAAAeGwvX3JlbHMvd29ya2Jvb2sueG1sLnJlbHOzCUrNSSzJzM8rzsgsKLazQeYqeKbYKhV5phgqKYRUFqTaKpXnF2UXZ6SmlgAFEovSU0uQhIr1wZShXkVujpK+nY0+qsEAUEsDBBQAAAAIAAAAAACCf1VtQAAAAGwAAAAUAAAAeGwvc2hhcmVkU3RyaW5ncy54bWyzKS4usbMpzrSzKbHzTq200Qfy9EFciFBYYk5pKrqgc35eSVF+jq6hObqMa15yUWVBiUJSYnJ2aUExQlofZA0AUEsDBBQAAAAIAAAAAAA2I5L5hAAAAPoAAAAYAAAAeGwvd29ya3NoZWV0cy9zaGVldDEueG1ssynPL8ouzkhNLbGzAVMuiSWJdjZF+eUKRbZKhkp2NskghqOhkkKJrVIxkF9mZ2CjX2Zno58MlXNCljOEy+kDzYAbZAQ3yAhJsRGaQchyxqhyzhC5zLyczLzU4JIioJrMYjubErtAEwW1xNwCa4XE0pTMEht9oD/0QTIIJ+gj+Usf4V0AUEsBAhQAFAAAAAgAAAAAAMEKEOqBAAAApAAAAA8AAAAAAAAAAAAAAAAAAAAAAHhsL3dvcmtib29rLnhtbFBLAQIUABQAAAAIAAAAAAAHfok7RgAAAGgAAAAaAAAAAAAAAAAAAAAAAK4AAAB4bC9fcmVscy93b3JrYm9vay54bWwucmVsc1BLAQIUABQAAAAIAAAAAACCf1VtQAAAAGwAAAAUAAAAAAAAAAAAAAAAACwBAAB4bC9zaGFyZWRTdHJpbmdzLnhtbFBLAQIUABQAAAAIAAAAAAA2I5L5hAAAAPoAAAAYAAAAAAAAAAAAAAAAAJ4BAAB4bC93b3Jrc2hlZXRzL3NoZWV0MS54bWxQSwUGAAAAAAQABAANAQAAWAIAAAAA";
+export declare const XLSX_SIMPLE: Uint8Array;
+export declare const ZIP_MAGIC: Uint8Array;
+export declare const GZIP_MAGIC: Uint8Array;
+export declare const PNG_MAGIC: Uint8Array;
+//# sourceMappingURL=parser-test-fixtures.d.ts.map

package/dist/parsers/parser-test-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser-test-fixtures.d.ts","sourceRoot":"","sources":["../../src/parsers/parser-test-fixtures.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,mBAAmB,EAAoB,UAAU,CAAC;AAE/D,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAE/C;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,OAAO,CAAC,oBAAoB,CAAM,GAC5C,oBAAoB,CAUtB;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,UAAU,EACjB,SAAS,GAAE,OAAO,CAAC,oBAAoB,CAAM,GAC5C,oBAAoB,CAUtB;AAID,eAAO,MAAM,UAAU,4CAA4C,CAAC;AAEpE,eAAO,MAAM,YAAY,QAiBb,CAAC;AAEb,eAAO,MAAM,SAAS,qDAA6C,CAAC;AAEpE,eAAO,MAAM,WAAW,QAMtB,CAAC;AAEH,eAAO,MAAM,UAAU,0BAA0B,CAAC;AAGlD,eAAO,MAAM,UAAU,yCAAiC,CAAC;AAEzD,eAAO,MAAM,UAAU,uBAAuB,CAAC;AAE/C,eAAO,MAAM,aAAa,QAUd,CAAC;AAEb,eAAO,MAAM,cAAc,QAQf,CAAC;AAGb,eAAO,MAAM,SAAS,EAAE,UAAiD,CAAC;AAE1E,eAAO,MAAM,cAAc,EAAE,UAqB5B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,UAmB/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,qzCACqxC,CAAC;AAErzC,eAAO,MAAM,WAAW,EAAE,UAAuE,CAAC;AAElG,eAAO,MAAM,yBAAyB,6uDACssD,CAAC;AAE7uD,eAAO,MAAM,kBAAkB,EAAE,UAEhC,CAAC;AAEF,eAAO,MAAM,kBAAkB,yqCACyoC,CAAC;AAEzqC,eAAO,MAAM,WAAW,EAAE,UAAuE,CAAC;AAGlG,eAAO,MAAM,SAAS,EAAE,UAEtB,CAAC;AAGH,eAAO,MAAM,UAAU,EAAE,UAAqD,CAAC;AAG/E,eAAO,MAAM,SAAS,EAAE,UAEtB,CAAC"}

package/dist/parsers/parser-test-fixtures.js

@@ -0,0 +1,139 @@
+// Synthetic byte fixtures for the parser adapters (Epic #189, Issue #266). Pure strings
+// only — no FS, no shell, no network. Kept in a `*-fixtures.ts` (NOT `_support`) file so the
+// architecture rules treat it as production source but the trust-8 rule still excludes it
+// from publication when callers stick to the `parsers/index.ts` barrel.
+import { Buffer } from "node:buffer";
+export const FIXTURE_DOCUMENT_ID = "doc-fixture";
+export function encode(text) {
+    return new TextEncoder().encode(text);
+}
+export function selectionFromText(text, overrides = {}) {
+    const base = {
+        documentId: FIXTURE_DOCUMENT_ID,
+        bytes: encode(text),
+        extension: overrides.extension ?? "txt",
+        mediaType: overrides.mediaType ?? "text/plain",
+    };
+    return overrides.languageHint !== undefined
+        ? { ...base, languageHint: overrides.languageHint }
+        : base;
+}
+export function selectionFromBytes(bytes, overrides = {}) {
+    const base = {
+        documentId: FIXTURE_DOCUMENT_ID,
+        bytes,
+        extension: overrides.extension ?? "",
+        mediaType: overrides.mediaType ?? "",
+    };
+    return overrides.languageHint !== undefined
+        ? { ...base, languageHint: overrides.languageHint }
+        : base;
+}
+// ─── Format fixtures ─────────────────────────────────────────────────────────
+export const TEXT_PLAIN = "Hello, world.\nSecond paragraph here.\n";
+export const MARKDOWN_DOC = [
+    "# Title",
+    "",
+    "Intro paragraph.",
+    "",
+    "## Subhead A",
+    "",
+    "Body of A.",
+    "",
+    "### Deep heading",
+    "",
+    "Deep body.",
+    "",
+    "## Subhead B",
+    "",
+    "Body of B.",
+    "",
+].join("\n");
+export const JSON_FLAT = '{"name":"alpha","count":3,"active":true}';
+export const JSON_NESTED = JSON.stringify({
+    meta: { id: "doc-1", version: 2 },
+    items: [
+        { sku: "A1", price: 10 },
+        { sku: "B2", price: 20 },
+    ],
+});
+export const CSV_SIMPLE = "a,b,c\n1,2,3\n4,5,6\n";
+// RFC 4180 adversarial fixture — quoted comma, embedded quote escape, embedded newline.
+export const CSV_QUOTED = 'a,b,c\n"x,1","y""2","z\n3"\n';
+export const TSV_SIMPLE = "a\tb\tc\n1\t2\t3\n";
+export const HTML_HEADINGS = [
+    "<!DOCTYPE html>",
+    "<html><body>",
+    "<h1>Top</h1>",
+    "<p>Intro text.</p>",
+    "<h2>Sub</h2>",
+    "<p>Sub body.</p>",
+    "<h3>Deeper</h3>",
+    "<p>Deeper body.</p>",
+    "</body></html>",
+].join("\n");
+export const HTML_DANGEROUS = [
+    "<html><body>",
+    "<h1>Safe</h1>",
+    "<script>alert('pwn');</script>",
+    "<style>body{display:none}</style>",
+    "<noscript>fallback</noscript>",
+    "<p>After script.</p>",
+    "</body></html>",
+].join("\n");
+// Synthetic PDF marker — only the leading magic bytes are required for sniffing.
+export const PDF_MAGIC = encode("%PDF-1.4\n%binary marker\n");
+export const PDF_TEXT_LAYER = encode(`%PDF-1.4
+1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj
+2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj
+3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 300 144] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >> endobj
+4 0 obj << /Length 44 >> stream
+BT /F1 24 Tf 72 72 Td (Hello PDF) Tj ET
+endstream endobj
+5 0 obj << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >> endobj
+xref
+0 6
+0000000000 65535 f 
+0000000010 00000 n 
+0000000063 00000 n 
+0000000122 00000 n 
+0000000248 00000 n 
+0000000342 00000 n 
+trailer << /Root 1 0 R /Size 6 >>
+startxref
+412
+%%EOF`);
+export const PDF_NO_TEXT_LAYER = encode(`%PDF-1.4
+1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj
+2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj
+3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 300 144] /Contents 4 0 R >> endobj
+4 0 obj << /Length 0 >> stream
+
+endstream endobj
+xref
+0 5
+0000000000 65535 f
+0000000010 00000 n
+0000000063 00000 n
+0000000122 00000 n
+0000000210 00000 n
+trailer << /Root 1 0 R /Size 5 >>
+startxref
+260
+%%EOF`);
+export const DOCX_SIMPLE_BASE64 = "UEsDBBQAAAAIAC28xFzXeYTq8QAAALgBAAATAAAAW0NvbnRlbnRfVHlwZXNdLnhtbH2QzU7DMBCE730Ky9cqccoBIZSkB36OwKE8wMreJFb9J69b2rdn00KREOVozXwz62nXB+/EHjPZGDq5qhspMOhobBg7+b55ru6koALBgIsBO3lEkut+0W6OCUkwHKiTUynpXinSE3qgOiYMrAwxeyj8zKNKoLcworppmlulYygYSlXmDNkvhGgfcYCdK+LpwMr5loyOpHg4e+e6TkJKzmoorKt9ML+Kqq+SmsmThyabaMkGqa6VzOL1jh/0lSfK1qB4g1xewLNRfcRslIl65xmu/0/649o4DFbjhZ/TUo4aiXh77+qL4sGG71+06jR8/wlQSwMEFAAAAAgALbzEXCAbhuqyAAAALgEAAAsAAABfcmVscy8ucmVsc43Puw6CMBQG4J2naM4uBQdjDIXFmLAafICmPZRGeklbL7y9HRzEODie23fyN93TzOSOIWpnGdRlBQStcFJbxeAynDZ7IDFxK/nsLDJYMELXFs0ZZ57yTZy0jyQjNjKYUvIHSqOY0PBYOo82T0YXDE+5DIp6Lq5cId1W1Y6GTwPagpAVS3rJIPSyBjIsHv/h3ThqgUcnbgZt+vHlayPLPChMDB4uSCrf7TKzQHNKuorZvgBQSwMEFAAAAAgALbzEXGJ/vc/pAAAA5wEAABEAAAB3b3JkL2RvY3VtZW50LnhtbJWRwU7DMAyG73uKKPc13Q4IVU2mgTRxnAQ8QEjNWimxoySs9O1JWtAmDhOc8lv+f/uT0+4+nWVnCHEglHxT1ZwBGuoGPEn++nJY33MWk8ZOW0KQfILId2rVjk1H5sMBJpYnYGxGyfuUfCNEND04HSvygLn3TsHplMtwEiOFzgcyEGNe4KzY1vWdcHpArlaM5alv1E1FzoVf1KKPQZXnOU0W2NictZX8CXQh3XChWrF4LonZn9SR7GCm0k6z6dsy+682XQJ763vNCkh1nfod+Bva9hbaI2EKZOM/4B4g3WIrYjlhUT9fpL4AUEsBAhQDFAAAAAgALbzEXNd5hOrxAAAAuAEAABMAAAAAAAAAAAAAAIABAAAAAFtDb250ZW50X1R5cGVzXS54bWxQSwECFAMUAAAACAAtvMRcIBuG6rIAAAAuAQAACwAAAAAAAAAAAAAAgAEiAQAAX3JlbHMvLnJlbHNQSwECFAMUAAAACAAtvMRcYn+9z+kAAADnAQAAEQAAAAAAAAAAAAAAgAH9AQAAd29yZC9kb2N1bWVudC54bWxQSwUGAAAAAAMAAwC5AAAAFQMAAAAA";
+export const DOCX_SIMPLE = Uint8Array.from(Buffer.from(DOCX_SIMPLE_BASE64, "base64"));
+export const DOCX_WITH_PREAMBLE_BASE64 = "UEsDBBQAAAAIANACxVxn4XsRxAAAAHcBAAATABwAW0NvbnRlbnRfVHlwZXNdLnhtbFVUCQADp/ohaqf6IWp1eAsAAQT1AQAABBQAAAB9kLkOwjAMhneeosqKqBEDA6IswAoMvICVum1ELsXmentSrgEBo/0fn+X5/hqJi4uznivVicQZAOuOHHIZIvmsNCE5lDymFiLqA7YEk/F4Cjp4IS8j6TvUYr6iBo9WivUlr9kEX6lEllWxfBh7VqUwRms0Stbh5OsPyuhJKHPy7uHORB5mg4KvhF75DXjmtidKydRU7DDJBl12wTmkGuqgjy4ny/81X+4MTWM0vfN9W0xBE7PxrbPlW3Fo/Ot+uL97MbgBUEsDBAoAAAAAANACxVwAAAAAAAAAAAAAAAAGABwAX3JlbHMvVVQJAAOn+iFqp/ohanV4CwABBPUBAAAEFAAAAFBLAwQUAAAACADQAsVcJnghCIsAAADzAAAACwAcAF9yZWxzLy5yZWxzVVQJAAOn+iFqp/ohanV4CwABBPUBAAAEFAAAAI3PPQ4CIRAF4N5TEA6ws1pYGKCy2XbjBQjMAnH5yYBRby+FxWosLGfe5HsZMeOqW8ip+lAqe8Q1Vcl9a+UEUI3HqOuQC6aeLJmibn0kB0Wbq3YIh3E8Am0NrsTWZJOVnCa75+zyLPiPnZclGDxnc4uY2o+Kr4sua3LYJL9nsmDf66GzHJSAjxfV7gVQSwMECgAAAAAA0ALFXAAAAAAAAAAAAAAAAAUAHAB3b3JkL1VUCQADp/ohaqf6IWp1eAsAAQT1AQAABBQAAABQSwMEFAAAAAgA0ALFXNON7KHUAAAAWAEAABEAHAB3b3JkL2RvY3VtZW50LnhtbFVUCQADp/ohaqf6IWp1eAsAAQT1AQAABBQAAAB1kE1PwzAMhu/7FZHvLN0OCFVtd0PsNgn4ASYxbaUkjpyw0n9PsvEhJLi8Vuwnrz+6w7t36kySZg497LYNKAqG7RzGHp6f7m/uQKWMwaLjQD2slOAwbLqltWzePIWsikNI7dLDlHNstU5mIo9py5FCqb2yeMzlKaNeWGwUNpRSaeCd3jfNrfY4BxiK5QvbtcZYRark4RiysIooOArGqdM1WVUuGr/5eLr8iI95daSW9oyuhwfCusoO9JW+Mp/WJ3azWf93/IWpOtwfrP4aW/+cZNh8AFBLAQIeAxQAAAAIANACxVxn4XsRxAAAAHcBAAATABgAAAAAAAEAAACkgQAAAABbQ29udGVudF9UeXBlc10ueG1sVVQFAAOn+iFqdXgLAAEE9QEAAAQUAAAAUEsBAh4DCgAAAAAA0ALFXAAAAAAAAAAAAAAAAAYAGAAAAAAAAAAQAO1BEQEAAF9yZWxzL1VUBQADp/ohanV4CwABBPUBAAAEFAAAAFBLAQIeAxQAAAAIANACxVwmeCEIiwAAAPMAAAALABgAAAAAAAEAAACkgVEBAABfcmVscy8ucmVsc1VUBQADp/ohanV4CwABBPUBAAAEFAAAAFBLAQIeAwoAAAAAANACxVwAAAAAAAAAAAAAAAAFABgAAAAAAAAAEADtQSECAAB3b3JkL1VUBQADp/ohanV4CwABBPUBAAAEFAAAAFBLAQIeAxQAAAAIANACxVzTjeyh1AAAAFgBAAARABgAAAAAAAEAAACkgWACAAB3b3JkL2RvY3VtZW50LnhtbFVUBQADp/ohanV4CwABBPUBAAAEFAAAAFBLBQYAAAAABQAFAJgBAAB/AwAAAAA=";
+export const DOCX_WITH_PREAMBLE = Uint8Array.from(Buffer.from(DOCX_WITH_PREAMBLE_BASE64, "base64"));
+export const XLSX_SIMPLE_BASE64 = "UEsDBBQAAAAIAAAAAADBChDqgQAAAKQAAAAPAAAAeGwvd29ya2Jvb2sueG1sNY7BDoMwDEN/pcoHLLDDDohy2S58RgfpWkEblARtnz80jZPtZ1ly/2ZZnsyL+5S1aicektnWIeqUqAS98Eb16CJLCXZEeSHHmCd68LQXqobXprmh0Bosc9WUN4Wh10Rk+ldXQyEPd64mvCq4Hx1nDy046fJhZJxbwKHHc4jns+ELUEsDBBQAAAAIAAAAAAAHfok7RgAAAGgAAAAaAAAAeGwvX3JlbHMvd29ya2Jvb2sueG1sLnJlbHOzCUrNSSzJzM8rzsgsKLazQeYqeKbYKhV5phgqKYRUFqTaKpXnF2UXZ6SmlgAFEovSU0uQhIr1wZShXkVujpK+nY0+qsEAUEsDBBQAAAAIAAAAAACCf1VtQAAAAGwAAAAUAAAAeGwvc2hhcmVkU3RyaW5ncy54bWyzKS4usbMpzrSzKbHzTq200Qfy9EFciFBYYk5pKrqgc35eSVF+jq6hObqMa15yUWVBiUJSYnJ2aUExQlofZA0AUEsDBBQAAAAIAAAAAAA2I5L5hAAAAPoAAAAYAAAAeGwvd29ya3NoZWV0cy9zaGVldDEueG1ssynPL8ouzkhNLbGzAVMuiSWJdjZF+eUKRbZKhkp2NskghqOhkkKJrVIxkF9mZ2CjX2Zno58MlXNCljOEy+kDzYAbZAQ3yAhJsRGaQchyxqhyzhC5zLyczLzU4JIioJrMYjubErtAEwW1xNwCa4XE0pTMEht9oD/0QTIIJ+gj+Usf4V0AUEsBAhQAFAAAAAgAAAAAAMEKEOqBAAAApAAAAA8AAAAAAAAAAAAAAAAAAAAAAHhsL3dvcmtib29rLnhtbFBLAQIUABQAAAAIAAAAAAAHfok7RgAAAGgAAAAaAAAAAAAAAAAAAAAAAK4AAAB4bC9fcmVscy93b3JrYm9vay54bWwucmVsc1BLAQIUABQAAAAIAAAAAACCf1VtQAAAAGwAAAAUAAAAAAAAAAAAAAAAACwBAAB4bC9zaGFyZWRTdHJpbmdzLnhtbFBLAQIUABQAAAAIAAAAAAA2I5L5hAAAAPoAAAAYAAAAAAAAAAAAAAAAAJ4BAAB4bC93b3Jrc2hlZXRzL3NoZWV0MS54bWxQSwUGAAAAAAQABAANAQAAWAIAAAAA";
+export const XLSX_SIMPLE = Uint8Array.from(Buffer.from(XLSX_SIMPLE_BASE64, "base64"));
+// Synthetic zip marker — PK\x03\x04 prefix. We never decompress this.
+export const ZIP_MAGIC = new Uint8Array([
+    0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x00, 0x00,
+]);
+// Synthetic gzip marker — 0x1f 0x8b prefix.
+export const GZIP_MAGIC = new Uint8Array([0x1f, 0x8b, 0x08, 0x00]);
+// Synthetic PNG marker.
+export const PNG_MAGIC = new Uint8Array([
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+]);