albex 0.3.0 → 0.6.1

package/dist/albex.d.ts

@@ -13,7 +13,6 @@
  * const results = engine.search('contrato marco');
  * ```
  */
-import { type Tier } from './profile.js';
 export { AlbexError, AlbexInitError, AlbexUnsupportedFormatError, AlbexParseError, AlbexCapacityError, } from './errors.js';
 export { listPersisted, deletePersisted } from './persistence.js';
 export { detectProfile, pickTier, pickWorkerCount, shouldUseGpu } from './profile.js';
@@ -25,27 +24,64 @@ export type { AlbexPoolOptions } from './pool/coordinator.js';
 export { BloomGpu, packBloomsFromChunks } from './gpu/bloom-runtime.js';
 export { TieredStore } from './tiered-store.js';
 export type { TieredStoreOptions } from './tiered-store.js';
+/**
+ * Explicit engine capacity configuration. All fields optional — anything
+ * missing is completed from the std defaults, scaled to keep the std
+ * ratios when a related field IS provided (documented per field).
+ *
+ * Estimated WASM memory ≈ `maxChunks × 64 B` (32 B descriptor + 32 B
+ * trigram signature) `+ textPoolBytes + namePoolBytes + maxDocs × 28 B`,
+ * on top of the engine's fixed ~80 KB of scratch buffers. The std preset
+ * is ~22 MB; `'large'` is ~180 MB. WASM linear memory never shrinks: the
+ * high-water mark of the largest capacity ever initialised in a given
+ * engine stays committed until the engine is disposed.
+ */
+export interface AlbexCapacityConfig {
+    /** Maximum number of live documents. Default 128. Range 1–65 536. */
+    maxDocs?: number;
+    /** Maximum number of indexed chunks (≈ paragraphs; long paragraphs split
+     * every 512 bytes). Default `max(maxDocs × 782, 1024)` — the std ratio
+     * (100 000 chunks / 128 docs). Range maxDocs–4 194 304. */
+    maxChunks?: number;
+    /** Text pool size in bytes (total UTF-8 text the index can hold).
+     * Default `max(maxChunks × 168, 64 KiB)` — the std ratio (16 MiB /
+     * 100 000 chunks). Range 4 KiB–1 GiB. */
+    textPoolBytes?: number;
+    /** Filename pool size in bytes. Default `max(maxDocs × 256, 4 KiB)` —
+     * the std ratio (32 KiB / 128 docs). Range 256 B–16 MiB. */
+    namePoolBytes?: number;
+}
+/**
+ * Engine capacity (decision A16 — runtime capacity, single binary):
+ *   `'std'`   — 128 docs · 100k chunks · 16 MB text · 32 KB names (~22 MB).
+ *               The default, identical to every previous release.
+ *   `'large'` — 1 024 docs · 800k chunks · 128 MB text · 256 KB names
+ *               (~180 MB) — the old compile-time "pro" tier.
+ *   object    — explicit {@link AlbexCapacityConfig}.
+ */
+export type AlbexCapacity = 'std' | 'large' | AlbexCapacityConfig;
 export interface AlbexOptions {
     /**
-     * Explicit URL to the main WASM binary.
-     *
-     * If you want automatic tier selection (mini/std/pro chosen from
-     * `deviceMemory`), pass `wasmBaseUrl` instead — the engine will fetch
-     * `albex_wasm_<tier>.wasm` from that directory.
+     * Explicit URL to the main WASM binary. If omitted, the baseline (or
+     * SIMD, when supported) binary packaged with albex is used.
      */
     wasmUrl?: string;
     /**
-     * Base directory containing tiered binaries (`albex_wasm_mini.wasm`,
-     * `_std.wasm`, `_pro.wasm`). Used when `wasmUrl` is omitted.
+     * Base directory containing the two binaries (`albex_wasm.wasm`,
+     * `albex_wasm_simd.wasm`). Used when `wasmUrl` is omitted.
      */
     wasmBaseUrl?: string;
     /** URL to albex_pdf.wasm. Required only if you call indexFile() with PDFs. */
     pdfWasmUrl?: string;
     /**
-     * Override the tier auto-detection. Pass `'auto'` (default), or an
-     * explicit tier when you know the constraints of your target environment.
+     * Engine capacity. `'std'` (default) keeps the historical limits;
+     * `'large'` raises them to 1 024 docs / 800k chunks / 128 MB text; an
+     * object configures each pool explicitly (see {@link AlbexCapacityConfig}
+     * for defaults, ranges and the memory cost model). Replaces the removed
+     * compile-time `tier` option — capacity is now a runtime parameter of a
+     * single binary (`initWithCapacity`, ABI 7).
      */
-    tier?: 'auto' | 'mini' | 'std' | 'pro';
+    capacity?: AlbexCapacity;
     /**
      * SIMD selection. When `'auto'` (default), Albex probes for v128 support
      * and fetches the `_simd.wasm` variant when available. Pass `'off'` to
@@ -66,6 +102,16 @@ export interface AlbexOptions {
      * the upload + dispatch overhead is bigger than the speedup. Default: 20_000.
      */
     gpuThreshold?: number;
+    /**
+     * Maximum size (in bytes) of a file accepted by `indexFile`. Checked
+     * against `File.size` BEFORE the file is read, so an oversized input is
+     * rejected with a typed `AlbexCapacityError` (`limit: 'file'`) without
+     * ever being buffered or hashed. Default: 256 MiB — above any default
+     * text pool (16 MB std / 128 MB large), so this only stops pathological
+     * inputs (e.g. a 2 GB log file) from exhausting tab memory. Raise it if
+     * you configure a custom `capacity` with a text pool beyond 256 MiB.
+     */
+    maxFileBytes?: number;
 }
 export interface IndexedDocument {
     name: string;
@@ -78,27 +124,77 @@ export interface IndexedDocument {
     /** 64-bit FNV-1a hex of the source file bytes. Stable across runs. */
     contentHash: string;
 }
+/**
+ * One authoritative chunk of an indexed document — the exact unit Albex
+ * indexed and searches over. Returned by {@link AlbexEngine.listChunks} so a
+ * host can mirror Albex's chunking (e.g. to build a parallel vector index over
+ * the same units). A long paragraph is split into several ≤512-byte chunks that
+ * share a `location` but differ in `sub`.
+ */
+export interface AuthoritativeChunk {
+    /** WASM-side stable document id (survives compact()). */
+    docId: number;
+    /** Paragraph index (DOCX/TXT) or page number (PDF, 1-based). */
+    location: number;
+    /** Ordinal of this chunk within its document (0-based, compact()-stable). */
+    ord: number;
+    /** Ordinal of this chunk within its `location` group (0-based, informational). */
+    sub: number;
+    /** The exact UTF-8 text Albex indexed for this chunk. */
+    text: string;
+    /** Byte length of `text`. */
+    byteLen: number;
+    /**
+     * Canonical shared id `"<docId>::<ord>"`. Identical to the matching
+     * {@link SearchResult.chunkId}, and stable across compact() and snapshot
+     * save/load — so it is safe to persist alongside parallel structures
+     * (unlike the absolute chunk index, which compact() renumbers).
+     */
+    id: string;
+}
 export interface MatchSpan {
-    /** Byte offset within `snippet` where this matched token begins. */
+    /** UTF-8 **byte** offset within `snippet` where this matched token begins.
+     * NOT a JS string index — for `snippet.slice()` use the UTF-16
+     * {@link SearchResult.snippetStart}/{@link SearchResult.snippetEnd} of the
+     * primary span instead. */
     start: number;
-    /** Byte offset within `snippet` where this matched token ends (exclusive). */
+    /** UTF-8 **byte** offset within `snippet` where this matched token ends
+     * (exclusive). See the note on `start`. */
     end: number;
 }
 export interface SearchResult {
     documentName: string;
+    /** WASM-side stable document id (survives compact()). Matches
+     * `AuthoritativeChunk.docId` from {@link AlbexEngine.listChunks}. */
+    docId: number;
     /** Paragraph index (DOCX/TXT) or page number (PDF, 1-based). */
     location: number;
+    /** Canonical chunk id `"<docId>::<ord>"` — identical to the matching
+     * {@link AuthoritativeChunk.id}, so a host can fuse search hits with a
+     * parallel index (e.g. embeddings) on this key. Stable across compact(). */
+    chunkId: string;
     /** Relevance score 0–1000. */
     score: number;
     /** Snippet text. With `windowed` search options this is a substring with
      *  ASCII ellipsis sentinels (`"... "` / `" ..."`) the UI should render
      *  as `…`. Without windowing, the full chunk text. */
     snippet: string;
-    /** Primary token match (kept for backwards compatibility). Equal to `matches[0]`. */
+    /** Primary token match as UTF-8 **byte** offsets within the encoded
+     * snippet (kept for backwards compatibility; equal to `matches[0]`).
+     * Byte offsets drift from JS string indices as soon as the snippet
+     * contains accents/ñ/emoji — use {@link snippetStart}/{@link snippetEnd}
+     * for `snippet.slice()` / UI highlighting. */
     matchStart: number;
     matchEnd: number;
-    /** All matched token spans within `snippet`, in query order. Length 1–4. */
+    /** All matched token spans within `snippet` as UTF-8 **byte** offsets,
+     * in query order. Length 1–4. */
     matches: MatchSpan[];
+    /** Primary token match start as a UTF-16 code-unit index into `snippet` —
+     * safe to pass directly to `snippet.slice(snippetStart, snippetEnd)`. */
+    snippetStart: number;
+    /** Primary token match end (exclusive) as a UTF-16 code-unit index into
+     * `snippet`. */
+    snippetEnd: number;
 }
 /**
  * Options that change how snippets are produced. Both fields are optional.
@@ -125,15 +221,17 @@ export interface SearchOptions {
 export interface EngineStats {
     documents: number;
     chunks: number;
+    /** Bytes of indexed text currently in the text pool. */
     textUsed: number;
+    /** RUNTIME text pool capacity in bytes (= resolved `textPoolBytes`). */
     textCapacity: number;
     wasmMemoryBytes: number;
-    /** Tier loaded at init time (mini/std/pro). */
-    tier: Tier | null;
-    /** Compile-time chunk capacity for the loaded tier. */
+    /** RUNTIME chunk capacity the engine was initialised with. */
     maxChunks: number;
-    /** Compile-time document capacity for the loaded tier. */
+    /** RUNTIME document capacity the engine was initialised with. */
     maxDocs: number;
+    /** RUNTIME filename pool capacity in bytes. */
+    namePoolBytes: number;
 }
 export interface SearchStats {
     query: string;
@@ -142,6 +240,33 @@ export interface SearchStats {
     bloomTested: number;
     bloomPassed: number;
     bitapMatched: number;
+    /** True if the query had more than 8 OR branches — the extras were
+     * discarded and did not contribute results. */
+    truncatedBranches?: boolean;
+    /** True if tokens were dropped (more than 4 per branch) or clipped
+     * (longer than 64 bytes). */
+    truncatedTokens?: boolean;
+    /** True if the raw query exceeded 1024 bytes and was cut. */
+    truncatedQuery?: boolean;
+}
+/**
+ * One structured warning recorded by the engine during indexFile or
+ * load. Replaces the pre-0.5.0 pattern of scattered `console.warn`
+ * calls. Inspect via `engine.takeDiagnostics()` after the operation.
+ */
+export interface AlbexDiagnostic {
+    /** Coarse kind. `'recovered'` means the engine handled the issue and
+     * kept going; `'skipped'` means content was dropped; `'fallback'` means
+     * an alternate code path was used (e.g. lopdf after pdf-extract trap). */
+    kind: 'recovered' | 'skipped' | 'fallback' | 'info';
+    /** Where in the pipeline this happened. Free-form short tag. */
+    stage: 'pdf' | 'ocr' | 'gpu' | 'persistence' | 'network';
+    /** Human-readable message safe to surface in a UI. */
+    message: string;
+    /** Optional file the issue belongs to. */
+    file?: string;
+    /** Optional page number (1-based for PDFs). */
+    page?: number;
 }
 /**
  * Result shape returned by an attached OCR module. Kept structural here so
@@ -157,6 +282,36 @@ export interface OcrAttachedOptions {
     lang?: string;
     hint?: string;
 }
+/**
+ * Contract the engine accepts from an OCR plugin. `@albex/ocr` is the
+ * canonical implementation, but any module that satisfies this interface
+ * can be attached via `engine.attachOcr(adapter)`.
+ */
+export interface OcrAdapter {
+    /** Invoked by the engine to OCR a single image. Receives whatever the
+     * caller passes (Blob, ArrayBuffer, etc.); the adapter is responsible
+     * for accepting that input. Must return text + confidence. */
+    recognize(image: unknown, opts?: OcrAttachedOptions): Promise<OcrAttachedResult>;
+    /** Engine-side switches the adapter wants honoured. The only one
+     * defined today is `alwaysExtractEmbeddedImages`, which turns on the
+     * hybrid PDF OCR pass. New flags can be added without breaking the
+     * adapter interface. */
+    options?: {
+        /** When true, every PDF (native or scanned) is walked for embedded
+         * images and each qualifying image is sent to `recognize`. Off by
+         * default to keep performance predictable on native PDFs. */
+        alwaysExtractEmbeddedImages?: boolean;
+    };
+}
+/** Returned by `attachOcr`. Holds the lifecycle handles for the plugin.
+ * Calling `dispose()` removes the adapter from the engine; subsequent
+ * `engine.ocrImage` access returns `undefined` again. */
+export interface OcrHandle {
+    /** Detach the plugin and tear down any resources it holds. After this,
+     * the engine reverts to "no OCR" — scanned PDFs go back to registering
+     * with zero chunks. */
+    dispose(): Promise<void>;
+}
 export declare class AlbexEngine {
     private _wasm;
     private _mem;
@@ -166,61 +321,83 @@ export declare class AlbexEngine {
      * runtime dependency on OCR — this is a structural slot that the optional
      * companion package fills.
      */
-    ocrImage?: (image: unknown, opts?: OcrAttachedOptions) => Promise<OcrAttachedResult>;
     /**
-     * Optional OCR-side configuration set by `@albex/ocr::enableOcr`. Read
-     * by the engine to decide whether to invoke OCR on top of the text it
-     * already extracted from a PDF (hybrid PDFs: native text + images that
-     * also contain text, like stamps, scanned annexes, or diagrams with
-     * labels).
-     *
-     * When `alwaysExtractEmbeddedImages` is true, every page of every PDF
-     * passes through `extractPageImages` after the normal text extraction;
-     * any image that meets the size filter (200×200 in Rust) is fed to
-     * `ocrImage`. Performance cost: 1–3 s per qualifying image.
-     *
-     * Off by default — set this opt-in via the OCR module's options.
+     * Public OCR entry point. Forwards to the attached OCR adapter installed
+     * via `attachOcr()`. Reading this property is a feature-detect for
+     * integrators: `if (engine.ocrImage) { ... OCR available ... }`. Writing
+     * to it directly is no longer supported in 0.5.0+ — use `attachOcr`.
      */
-    ocrConfig?: {
-        alwaysExtractEmbeddedImages?: boolean;
-    };
+    get ocrImage(): ((image: unknown, opts?: OcrAttachedOptions) => Promise<OcrAttachedResult>) | undefined;
+    /** Private adapter slot. Holds the OCR plugin contract installed by
+     * `attachOcr()`. The engine reads `recognize` and `options` here; the
+     * caller never gets a reference to this object directly. */
+    private _ocrAdapter;
     private _pdfWasm;
     private _pdfMem;
     private _docs;
     private _lastSearch;
-    private _tier;
+    /** Raw truncation bitflags from the most recent prepareQuery (ABI 5):
+     * 1 = branches dropped, 2 = tokens dropped/clipped, 4 = query bytes cut.
+     * Captured right after prepareQuery so every _lastSearch built for that
+     * query (including per-branch OR runs) reports the same flags. */
+    private _lastTruncFlags;
+    /** Structured diagnostics collected during the most recent operation.
+     * Drained by `takeDiagnostics()`. Capped at 256 entries to avoid
+     * unbounded memory growth in pathological cases (very corrupted
+     * corpora producing thousands of recovery warnings). */
+    private _diagnostics;
+    /** Resolved runtime capacity (set in init(); reused by reset()). */
+    private _capacity;
     private _simd;
     private _profile;
     private _resources;
     private _gpu;
-    private _gpuChunkCountUploaded;
+    /** True when the GPU-resident Bloom array no longer mirrors the WASM
+     * chunk array. Set by EVERY index mutation (indexFile, removeDocument,
+     * compact, reset, load) and cleared after a successful upload. A plain
+     * chunk-count comparison is NOT enough: compact() can reorder blooms
+     * while keeping the count identical, which would silently filter the
+     * wrong chunks (audit 1.5). */
+    private _gpuUploadDirty;
     private _unsubscribeResources;
     private readonly _opts;
-    constructor(opts: AlbexOptions);
-    /** Load and initialise the main WASM module. Must be called before any other method. */
+    private _opChain;
+    private _busy;
+    constructor(opts?: AlbexOptions);
+    /** Serialize an async engine operation behind any in-flight one. */
+    private _exclusive;
+    /** Guard a synchronous mutator/search: refuse to run mid-async-operation
+     * rather than silently corrupt the shared WASM state. */
+    private _assertIdle;
+    /** Compact opportunistically when tombstones pile up under text pressure,
+     * so repeated removeDocument/replaceDocument don't exhaust the pool. */
+    private _autoCompactIfNeeded;
+    /**
+     * Load and initialise the main WASM module. Must be called before any
+     * other method.
+     *
+     * Resolves `opts.capacity` ('std' default · 'large' · explicit object)
+     * and sizes the WASM pools accordingly via `initWithCapacity` (ABI 7).
+     * Memory cost ≈ `maxChunks × 64 B + textPoolBytes + namePoolBytes` —
+     * ~22 MB for 'std', ~180 MB for 'large'. Throws `AlbexInitError` if the
+     * requested capacity is out of range or the allocation fails.
+     */
     init(): Promise<void>;
     /**
      * Decide which `.wasm` binary to fetch. Order of precedence:
-     *   1. `opts.wasmUrl` if provided — used verbatim.
-     *   2. `opts.tier` if explicit — joined with `wasmBaseUrl`.
-     *   3. `opts.wasmBaseUrl` + tier picked from the device profile.
-     *
-     * Order of precedence:
      *   1. `opts.wasmUrl` literal               → use verbatim
-     *   2. `opts.wasmBaseUrl` + tier suffix     → fetched from that directory
+     *   2. `opts.wasmBaseUrl` + simd suffix     → fetched from that directory
      *   3. zero-config default                  → `albex_wasm_bg.wasm` packaged
      *                                             next to this file, resolved
      *                                             via `import.meta.url`
      *
-     * The zero-config default loads the std-baseline binary. Tier auto-detection
-     * is only active when `wasmBaseUrl` is given, because picking a tier in
-     * runtime would defeat any bundler's static asset rewriting. Users who want
-     * tier optimisation must serve the six variants themselves and pass the
-     * directory through `wasmBaseUrl`.
+     * There are exactly two main binaries (baseline + SIMD); capacity is a
+     * RUNTIME parameter since ABI 7, so it never affects which file is
+     * fetched. SIMD auto-detection is only active when `wasmBaseUrl` is
+     * given, because picking a URL at runtime would defeat any bundler's
+     * static asset rewriting.
      */
     private _resolveWasmUrl;
-    /** The tier that was actually loaded. `null` until `init()` resolves. */
-    get tier(): Tier | null;
     /** True if the SIMD-accelerated binary was loaded. */
     get simdEnabled(): boolean;
     /** True if a WebGPU device is acquired and the next search will use it. */
@@ -243,13 +420,33 @@ export declare class AlbexEngine {
      * No-op if the GPU device hasn't been acquired yet — first call attempts
      * `init()` lazily; if that fails, the candidate path is permanently
      * disabled for this engine instance.
+     *
+     * IMPORTANT: this method CLOBBERS the scratchpad (the candidate bitset
+     * is pushed through it via `setCandidateMask`). Any pattern previously
+     * staged by `selectQueryBranch` is destroyed — the caller MUST re-select
+     * the active branch before calling `searchBegin`, which snapshots the
+     * pattern from the scratchpad (audit 1.2).
      */
     private _gpuPreFilter;
     private _u8;
     private _writePad;
     private _writeStr;
     private _readPad;
+    /** Copy `n` scratchpad bytes out of WASM memory. The copy is private to
+     * JS, so it survives later WASM calls (and memory growth) — used when the
+     * caller needs both the raw bytes (UTF-16 span mapping) and the decoded
+     * string of the same payload. */
+    private _readPadBytes;
     private _feedText;
+    /**
+     * Compute the FNV-1a 64-bit content hash of `bytes` via the WASM
+     * streaming API. Returns a 16-character hex string identical in shape
+     * to what the TS implementation in 0.3.x returned, so all callers
+     * stay unchanged. Single source of truth — same hash whether we use
+     * it for indexFile dedup, for snapshot v2 persistence, or anywhere
+     * else. Large inputs are chunked at FEED_SIZE just like _feedText.
+     */
+    private _contentHash;
     private _feedXmlBytes;
     private _ensurePdfWasm;
     private _indexDocx;
@@ -336,10 +533,13 @@ export declare class AlbexEngine {
     private _indexRtf;
     private static readonly _INDEXERS;
     /**
-     * Index a file. Supported formats: DOCX, XLSX, PDF, TXT, XML.
+     * Index a file. Supported formats (11, with varying depth): DOCX, XLSX, PDF,
+     * HTML, MD, JSON, CSV, EML, RTF, TXT, XML. Several are deliberately "lite"
+     * (CSV is RFC-4180-lite, EML is MIME-lite, RTF is regex-stripped).
      * Throws for unsupported formats or parse errors.
      */
     indexFile(file: File): Promise<IndexedDocument>;
+    private _indexFileInner;
     /**
      * Mark a previously indexed document as removed. Searches no longer return
      * its chunks. Storage is reclaimed only after `compact()`.
@@ -348,6 +548,7 @@ export declare class AlbexEngine {
      * Returns `true` if a matching document was found and tombstoned.
      */
     removeDocument(id: string): boolean;
+    private _removeDocumentInner;
     /**
      * Replace a previously indexed document with new content. Equivalent to
      * `removeDocument(name)` + `indexFile(newFile)` but does not trigger the
@@ -362,6 +563,21 @@ export declare class AlbexEngine {
      * references (e.g. in a UI) remain valid.
      */
     compact(): void;
+    /**
+     * Enumerate the authoritative chunks Albex indexed for a document, in order.
+     * Lets a host mirror Albex's exact chunking — e.g. embed the same units for a
+     * parallel semantic index keyed on the same {@link AuthoritativeChunk.id}
+     * (`"<docId>::<ord>"`, identical to {@link SearchResult.chunkId}). `docId` is
+     * `IndexedDocument.docId` from {@link indexFile}; returns `[]` if no live
+     * document has that id.
+     *
+     * The returned `id`/`ord`/`sub` are stable across {@link compact} and
+     * snapshot save/load. Never key persistent structures on a search result's
+     * absolute `chunkIdx`, which {@link compact} renumbers.
+     */
+    listChunks(docId: number): AuthoritativeChunk[];
+    /** Doc-table slot (0..getDocCount) whose stable id is `docId`, or -1. */
+    private _docSlotOf;
     /**
      * Search the index. Supports:
      * - Simple queries:  `contrato`  (AND of tokens, accent-insensitive)
@@ -370,8 +586,17 @@ export declare class AlbexEngine {
      *
      * Pass `{ windowed: true }` to receive cropped snippets with ASCII ellipsis
      * markers instead of full chunk text. Defaults: 60 bytes before, 120 after.
+     *
+     * Note: this synchronous path never uses the GPU pre-filter — the WebGPU
+     * scan is asynchronous by nature. Only `searchCooperative` (the budgeted
+     * path) engages the GPU; `search()` always runs the CPU Bloom pre-filter,
+     * regardless of the `gpu` option.
      */
     search(query: string, opts?: SearchOptions): SearchResult[];
+    /** Read the WASM-compiled tokens of branch `i` for phrase post-filter.
+     * The bytes returned are exactly what the WASM tokenizer produced —
+     * no TS re-tokenization. */
+    private _branchTokens;
     /**
      * Cooperative search. Processes the corpus in slices, yielding to the
      * event loop between them so the host UI thread keeps a chance to paint
@@ -387,6 +612,9 @@ export declare class AlbexEngine {
      * Pass `opts.frameBudgetMs` to control the slice size (default 8 ms).
      */
     searchCooperative(query: string, opts?: SearchOptions): AsyncIterable<SearchResult>;
+    /** Materialise a cooperative search to a sorted result array. Runs inside
+     * the exclusivity lock. Frame-budget yielding lives in _runSearchBudgeted. */
+    private _searchCooperativeCollect;
     /**
      * @deprecated Renamed to `searchCooperative` in 0.3.0. The original name
      * was misleading — this method does not stream incremental results, it
@@ -404,11 +632,34 @@ export declare class AlbexEngine {
      * may eat the entire budget, which is also fine.
      */
     private _runSearchBudgeted;
-    /** Materialise results [0..count) into the public SearchResult shape. */
+    /** Truncation booleans for SearchStats, decoded from the flags the WASM
+     * reported for the most recent prepareQuery (audit 1.6 — the engine used
+     * to drop OR branches past 8 and tokens past 4 in silence). */
+    private _truncStats;
+    /** Materialise results [0..count) into the public SearchResult shape.
+     * When `phraseTokens` is given, each result is kept only if those tokens
+     * appear adjacently in the FULL chunk text — independent of any display
+     * windowing — so phrase queries stay correct under `{ windowed: true }`.
+     *
+     * Frontier discipline (audit 2.1): all numeric fields of every result are
+     * read in ONE DataView pass over the `#[repr(C)]` RESULTS array
+     * (`getResultsPtr`/`getResultStride`, ABI 6) — the old path made 12-15
+     * frontier calls per result. Strings still need calls, minimised to one
+     * snippet read per result plus one doc-name read per DISTINCT document
+     * (the old `getResultDocName` was additionally O(doc_count) inside WASM
+     * for every single result). */
     private _collectResults;
+    /** Run all OR branches and merge dedup-by-(chunkId, matchStart). The
+     * branches are already compiled inside the WASM (by prepareQuery); we
+     * iterate them with selectQueryBranch. The "rawQuery" param is kept
+     * only for the lastSearch.query field. */
     private _searchOr;
+    /** Execute a single search using whichever query branch is currently
+     * active (set via selectQueryBranch). Returns the materialised
+     * SearchResult[]. Caller is responsible for activating a branch first. */
     private _runSearch;
-    /** Returns current engine statistics. */
+    /** Returns current engine statistics (capacities are the RUNTIME values
+     * the engine was initialised with via the `capacity` option). */
     getStats(): EngineStats;
     /** Returns stats from the most recent search, or null. */
     getLastSearchStats(): SearchStats | null;
@@ -433,6 +684,57 @@ export declare class AlbexEngine {
     setLanguage(lang: 'off' | 'es'): void;
     /** Full reset — clears all indexed documents and chunks. */
     reset(): void;
+    private _resetInner;
+    /**
+     * Drain and return the diagnostics collected since the last call (or
+     * since the engine was created). Use this to surface recoverable
+     * issues to the caller after `indexFile`, `load`, or any other
+     * operation that may run into a "best-effort" path.
+     *
+     * Example diagnostics:
+     *   - `{kind:'fallback', stage:'pdf', message:'pdf-extract crashed,
+     *      attempting OCR-only fallback', file:'invoice.pdf'}`
+     *   - `{kind:'skipped', stage:'ocr', message:'Tesseract abort on page
+     *      3 image 1; remaining images on this page skipped', file:'...',
+     *      page:3}`
+     *   - `{kind:'fallback', stage:'gpu', message:'GPU pre-filter failed,
+     *      using CPU'}`
+     *
+     * The buffer is cleared on each call; callers should consume the
+     * returned array immediately (e.g. log to their telemetry, surface
+     * a UI banner). After `reset()` the buffer is also cleared.
+     */
+    takeDiagnostics(): AlbexDiagnostic[];
+    /** Internal: record a diagnostic. Capped at 256 to bound memory. */
+    private _diag;
+    /**
+     * Install an OCR adapter. Returns a handle whose `dispose()` removes the
+     * adapter from the engine.
+     *
+     * The contract: the adapter must provide `recognize(image, opts)` that
+     * returns `Promise<OcrAttachedResult>`. The engine validates the
+     * contract at attach time and refuses adapters that don't expose a
+     * recognise function. Only one adapter can be attached at a time; a
+     * second call to `attachOcr` while one is active throws — the caller
+     * must dispose the previous one first.
+     *
+     * @example
+     * ```ts
+     * import { enableOcr } from '@albex/ocr';
+     * const handle = enableOcr(engine);   // internally calls attachOcr
+     * // ... later ...
+     * await handle.dispose();
+     * ```
+     *
+     * Direct use without the companion package:
+     * ```ts
+     * const handle = engine.attachOcr({
+     *   recognize: async (blob) => myCustomOcr(blob),
+     *   options: { alwaysExtractEmbeddedImages: false },
+     * });
+     * ```
+     */
+    attachOcr(adapter: OcrAdapter): OcrHandle;
     /**
      * Persist the current index to OPFS (or IndexedDB as fallback) under `name`.
      *
@@ -441,12 +743,14 @@ export declare class AlbexEngine {
      * state in roughly O(total bytes), bypassing re-parsing.
      */
     save(name: string): Promise<void>;
+    private _saveInner;
     /**
      * Restore an index previously saved with `save(name)`. Returns `true` on
      * success, `false` if the snapshot is missing or has an incompatible
      * header (wrong magic, version, or struct sizes).
      */
     load(name: string): Promise<boolean>;
+    private _loadInner;
     /**
      * Convenience: load if the snapshot exists, otherwise leave the engine
      * empty. Returns whether a load actually happened.

package/dist/albex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"albex.d.ts","sourceRoot":"","sources":["../src/albex.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"albex.d.ts","sourceRoot":"","sources":["../src/albex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA2BH,OAAO,EACL,UAAU,EACV,cAAc,EACd,2BAA2B,EAC3B,eAAe,EACf,kBAAkB,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACtF,YAAY,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAwB5D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;+DAE2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;6CAEyC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;gEAC4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,OAAO,GAAG,mBAAmB,CAAC;AAElE,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC;IAC7B;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC;IAC5B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAmDD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,GAAG,EAAE,MAAM,CAAC;IACZ,kFAAkF;IAClF,GAAG,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,SAAS;IACxB;;;+BAG2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd;+CAC2C;IAC3C,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB;yEACqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB;;gFAE4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd;;0DAEsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB;;;;kDAI8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB;qCACiC;IACjC,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB;6EACyE;IACzE,YAAY,EAAE,MAAM,CAAC;IACrB;oBACgB;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB;mDAC+C;IAC/C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;iCAC6B;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,6DAA6D;IAC7D,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B;;8EAE0E;IAC1E,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;IACpD,gEAAgE;IAChE,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,GAAG,SAAS,CAAC;IACzD,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAoZD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB;;kEAE8D;IAC9D,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAEjF;;;4BAGwB;IACxB,OAAO,CAAC,EAAE;QACR;;qEAE6D;QAC7D,2BAA2B,CAAC,EAAE,OAAO,CAAC;KACvC,CAAC;CACH;AAED;;yDAEyD;AACzD,MAAM,WAAW,SAAS;IACxB;;2BAEuB;IACvB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,qBAAa,WAAW;IAEtB,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,IAAI,CAAsB;IAElC;;;;;OAKG;IACH;;;;;OAKG;IACH,IAAI,QAAQ,IAAI,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,kBAAkB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC,GAAG,SAAS,CAEtG;IAED;;gEAE4D;IAC5D,OAAO,CAAC,WAAW,CAA2B;IAG9C,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,OAAO,CAAmC;IAElD,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,WAAW,CAA4B;IAC/C;;;sEAGkE;IAClE,OAAO,CAAC,eAAe,CAAK;IAC5B;;;4DAGwD;IACxD,OAAO,CAAC,YAAY,CAAyB;IAC7C,oEAAoE;IACpE,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,IAAI,CAAyB;IACrC;;;;;mCAK+B;IAC/B,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,qBAAqB,CAA6B;IAC1D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IAQrC,OAAO,CAAC,QAAQ,CAAuC;IACvD,OAAO,CAAC,KAAK,CAAS;gBAEV,IAAI,GAAE,YAAiB;IAInC,oEAAoE;IACpE,OAAO,CAAC,UAAU;IAWlB;6DACyD;IACzD,OAAO,CAAC,WAAW;IAWnB;4EACwE;IACxE,OAAO,CAAC,oBAAoB;IAU5B;;;;;;;;;OASG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkC3B;;;;;;;;;;;;;OAaG;YACW,eAAe;IAsC7B,sDAAsD;IACtD,IAAI,WAAW,IAAI,OAAO,CAAuB;IAEjD,2EAA2E;IAC3E,IAAI,UAAU,IAAI,OAAO,CAAmC;IAI5D;;;;;;;;OAQG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;;;;;;;;;;;;OAcG;YACW,aAAa;IA4C3B,OAAO,CAAC,GAAG;IAIX,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,QAAQ;IAKhB;;;qCAGiC;IACjC,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,SAAS;IASjB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,aAAa;YAWP,cAAc;YA8Bd,UAAU;YAQV,UAAU;YAoBV,SAAS;IAkHvB;;;;;;;;;;;;;;;;;;;;;;OAsBG;YACW,gBAAgB;IAe9B;;;;;;;;;;;;;;;;;;;;OAoBG;YACW,sBAAsB;IAmEpC;;;;;;;;;;;;;OAaG;YACW,sBAAsB;YA6CtB,SAAS;YAWT,SAAS;YAkBT,QAAQ;YAgCR,UAAU;YA4BV,UAAU;YA4BV,SAAS;YAuDT,SAAS;IA8BvB;;;;;;;;OAQG;IACH,OAAO,CAAC,oBAAoB;YAqEd,SAAS;IAiGvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAc/B;IAIF;;;;;OAKG;IACG,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC;YAIvC,eAAe;IAwF7B;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAKnC,OAAO,CAAC,oBAAoB;IAW5B;;;;OAIG;IACG,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC;IAY5E;;;;;;OAMG;IACH,OAAO,IAAI,IAAI;IASf;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,EAAE;IAwC/C,yEAAyE;IACzE,OAAO,CAAC,UAAU;IASlB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,aAAkB,GAAG,YAAY,EAAE;IAuB/D;;gCAE4B;IAC5B,OAAO,CAAC,aAAa;IAOrB;;;;;;;;;;;;;OAaG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,aAAkB,GAAG,aAAa,CAAC,YAAY,CAAC;IAO9F;kFAC8E;YAChE,yBAAyB;IAoCvC;;;;;OAKG;IACI,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,aAAkB,GAAG,aAAa,CAAC,YAAY,CAAC;IAKzF;;;;;;;;OAQG;YACW,kBAAkB;IA6FhC;;mEAE+D;IAC/D,OAAO,CAAC,WAAW;IASnB;;;;;;;;;;;mCAW+B;IAC/B,OAAO,CAAC,eAAe;IAwIvB;;;8CAG0C;IAC1C,OAAO,CAAC,SAAS;IAoBjB;;8EAE0E;IAC1E,OAAO,CAAC,UAAU;IAoBlB;qEACiE;IACjE,QAAQ,IAAI,WAAW;IAavB,0DAA0D;IAC1D,kBAAkB,IAAI,WAAW,GAAG,IAAI;IAIxC,6CAA6C;IAC7C,IAAI,SAAS,IAAI,SAAS,eAAe,EAAE,CAE1C;IAED,iCAAiC;IACjC,MAAM,KAAK,mBAAmB,IAAI,MAAM,EAAE,CAEzC;IAED,oCAAoC;IACpC,YAAY,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI;IAIzC,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIhC;;;;;;;;;OASG;IACH,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI;IAIrC,4DAA4D;IAC5D,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,WAAW;IAYnB;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAAe,IAAI,eAAe,EAAE;IAMpC,oEAAoE;IACpE,OAAO,CAAC,KAAK;IAKb;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS;IAsBzC;;;;;;OAMG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAIzB,UAAU;IAqBxB;;;;OAIG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;YAI5B,UAAU;IA2FxB;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQhD,8CAA8C;IACxC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjD,+DAA+D;IACzD,aAAa,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIxC;;;;;;;;;;OAUG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAczB"}