albex 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -5,6 +5,229 @@ All notable changes to Albex are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and Albex follows [Semantic Versioning](https://semver.org/).
 
+## [Unreleased]
+
+## [0.7.0] — 2026-06-26
+
+### Changed
+
+- **Zero-config in every bundler — the core WASM is now embedded by default.**
+  `import { AlbexEngine } from 'albex'` resolves to a new entry
+  (`dist/index.js`) that base64-embeds the ~47 KB baseline core in the JS
+  (~19 KB gzipped over the wire, decoded once and cached) and instantiates it
+  with **no `fetch` and no `new URL('…wasm', import.meta.url)`** asset
+  resolution. This removes the long-standing friction on **esbuild / Angular /
+  many Webpack** setups, which never rewrote that pattern and left integrators
+  copying binaries by hand. The URL-based path is unchanged and still used
+  whenever you set `wasmUrl` / `wasmBaseUrl` (CDN / SIMD), so existing configs
+  keep working — only the no-option default changed (baseline core, no SIMD;
+  set `wasmBaseUrl` for the SIMD variant). WASM-load failures now throw an
+  `AlbexInitError` whose message names the URL it tried and the one-line exit
+  (drop the option to fall back to the embedded core); `instantiateStreaming`
+  also falls back to a buffered compile when the host serves the `.wasm` with
+  the wrong MIME type (a common esbuild/static-server pitfall). The npm
+  `description` was corrected — it advertised "zero-config" while the default
+  actually depended on bundler asset resolution.
+- **IDF-aware relevance scoring — exact matches no longer saturate.** The old
+  `rich_score` set `base = 1000 − avg_errors·200`, so every 0-error hit hit the
+  1000 ceiling and `.min(1000)` discarded *all* the relevance bonuses (term
+  frequency, proximity, location, word-boundary AND idf). The practical effect:
+  on a real corpus every exact match tied at 1000 and the final ordering among
+  them was arbitrary — the chunk holding the rare, decisive query term was no
+  more likely to rank first than dozens that merely shared a common word.
+  Scores are now laid out as **error tiers with relevance ranking inside each
+  tier** (0 errors → `[750,1000]`, 1 → `[500,750]`, 2 → `[250,500]`, 3 →
+  `[0,250]`): a cleaner match still always beats a noisier one, but within a
+  tier the **IDF bonus (now the largest, up to 150)** lifts rare-term matches
+  decisively above common-term ones. Measured downstream (the Noesis hybrid-RAG
+  eval over a 293-doc / 12.4k-chunk corpus): lexical-leg MRR **0.19 → 0.40**,
+  R@5 **23% → 53%**, and end-to-end hybrid MRR **0.42 → 0.53** — with no change
+  on small corpora. `SearchResult.score` keeps its `0..=1000` range, so
+  `setThreshold` is unaffected for typical values; very weak 3-error fuzzy
+  matches (bonus-starved, score < the default threshold 250) are now filtered
+  where they previously slipped through.
+- **Fixed a latent result-ordering bug** exposed by the scoring change. The
+  heap-sort already left `RESULTS` in descending order; a trailing reverse then
+  flipped it to *ascending*. It was invisible while all exact scores tied at
+  1000 and was masked from API consumers by the TypeScript-side re-sort, but the
+  WASM ABI now returns correctly descending results on its own.
+
+### Added
+
+- **`wasmBytes` / `pdfWasmBytes` options.** Hand the engine raw core/PDF bytes
+  (`BufferSource`) you loaded yourself; when present, no network fetch happens
+  and `wasmUrl`/`wasmBaseUrl`/SIMD auto-selection are bypassed. The escape
+  hatch for bundlers that can't serve the binary: import the `.wasm` as an
+  asset through your own pipeline and pass the bytes. `pdfWasmBytes` does the
+  same for the on-demand PDF module (which is too large to embed).
+- **`albex/inline` subpath + `albexWasmBytes()` helper.** `albex/inline` is now
+  an alias of the default entry (kept so existing `from 'albex/inline'` imports
+  keep resolving); `albexWasmBytes()` returns the embedded baseline core as
+  decoded, cached bytes — e.g. to seed a worker with the same core.
+- **`albex/wasm/pkg/*.wasm` subpath export.** The raw binaries are reachable as
+  package assets for bundler asset-imports (used by the `pdfWasmBytes` recipe
+  in the README's Advanced section).
+- **Dynamic capacity (ABI 7, decision A16 executed).** The compile-time
+  capacity tiers are gone for good: the engine pools (chunk table, trigram
+  signatures, text pool, doc table, content hashes, name pool, tombstone
+  bitset, GPU candidate mask) moved from BSS `static mut` arrays to heap
+  allocations sized at runtime by the new export
+  `initWithCapacity(maxDocs, maxChunks, textPoolBytes, namePoolBytes) → 1|0`.
+  - `init()` is now a wrapper over `initWithCapacity` with the historical
+    std defaults (128 docs · 100k chunks · 16 MB text · 32 KB names) —
+    default behaviour is identical to every previous release.
+  - Hard ceilings (validated, return 0 — never trap): 65 536 docs, 4 M
+    chunks, 1 GiB text, 16 MiB names; allocation failure (memory.grow
+    refused) also returns 0 cleanly with the engine in a safe empty state.
+  - Re-init with the same capacities is a plain reset (no realloc);
+    different capacities free + re-allocate (no leak; the linear-memory
+    high-water mark stays, as WASM memory never shrinks).
+  - **Snapshots are admitted by CONTENT, not by writer capacity**: the
+    restore gate compares the snapshot's counters against the live runtime
+    capacities, so a snapshot saved by a `'large'` engine loads into a
+    `'std'` engine whenever its contents fit — and fails CLEANLY (previous
+    index intact) when they don't. v4 headers additionally record the
+    writer's capacities in the previously-reserved bytes [40..56], for
+    diagnostics only.
+  - **TS option `capacity`**: `'std'` (default) · `'large'`
+    (1 024 docs / 800k chunks / 128 MB text / 256 KB names — the old "pro"
+    tier) · custom `{ maxDocs?, maxChunks?, textPoolBytes?, namePoolBytes? }`
+    (partials completed from std scaled by std's ratios: chunks = docs×782,
+    text = chunks×168 B, names = docs×256 B, with floors; explicit
+    maxChunks below maxDocs is clamped up). Forwarded to workers and pool
+    shards (structured-clone-safe). `reset()` re-inits with the CONFIGURED
+    capacity, not the std defaults.
+  - `AlbexCapacityError` gains `max` — the runtime numeric limit of the
+    pool named by `limit` (e.g. `4` for `capacity: { maxDocs: 4 }`); it
+    survives the worker boundary.
+  - New large-scale bench (`bench/large.bench.ts`): 1 000 docs / 200k
+    chunks / 15.8 MB text in a `'large'` engine — search 141-769 ms
+    (rare-token → fuzzy), snapshot save 24 ms / restore 175 ms for a
+    ~20 MB snapshot. Numbers in `bench/README.md`. Binary cost of heap
+    pools: baseline 43 396 → 47 446 B (gate 48 KB still green).
+
+- **Batch frontier reads (ABI 6).** Three groups of exports collapse the
+  JS↔WASM call count on the hot read paths:
+  - `getResultsPtr()` + `getResultStride()`: `_collectResults` now reads every
+    numeric field of all results with ONE `DataView` pass over the
+    `#[repr(C)]` `RESULTS` array (layout documented in the export's
+    doc-comment and compile-time asserted with `offset_of!`) instead of
+    ~12-15 frontier calls per result. Doc names are resolved once per
+    distinct document via its table slot — the per-result
+    `getResultDocName` (O(doc_count) inside WASM) is no longer called.
+  - `getPatternBloomLo()/Hi()`: the query Bloom the GPU pre-filter needs is
+    now computed in `setPattern` through the exact pipeline `searchBegin`
+    uses (split → optional Spanish stemming → fold). The third TypeScript
+    copy of the fold (`computePatternBloom`) is deleted; with stemming on it
+    silently diverged from the CPU pattern.
+  - `listChunksBatch(slot, startOrd, maxChunks)`: packs consecutive chunk
+    records `[u32 text_len][u32 location][text]` into the scratchpad;
+    `listChunks` now makes ~1 frontier call per 64 KB batch instead of 2-3
+    per chunk (an embeddings pipeline over 100k chunks drops from ~300k
+    calls to ~1.3k).
+  `abiVersion()` bumped 5 → 6; host pin updated. Snapshot format unchanged.
+- **UTF-16 spans: `SearchResult.snippetStart/snippetEnd`.** The existing
+  `matchStart/matchEnd`/`matches[]` are UTF-8 BYTE offsets (now documented as
+  such) and mis-highlight as soon as the snippet contains accents. The new
+  fields are the primary span as UTF-16 code-unit indices over the decoded
+  snippet — safe for `snippet.slice()`. Byte fields are unchanged for
+  backwards compatibility.
+- **Worker parity: `replaceDocument` + `takeDiagnostics`** added to the
+  worker protocol and `AlbexEngineWorker`. The class JSDoc now documents that
+  `attachOcr` cannot exist in the worker (functions don't cross postMessage)
+  and that scanned PDFs index with 0 chunks there — with the diagnostic
+  explaining why readable through `takeDiagnostics`, and the recommendation
+  to OCR on the main-thread engine and `save()`/`load()` the snapshot.
+- **CI with teeth:** `cargo clippy -D warnings` for every crate (host pass
+  for core/ingest, wasm32 pass for the wasm and pdf crates), an advisory
+  `cargo fmt --check`, a hard 48 KB size gate on the baseline `.wasm`, a
+  build of the SIMD variant, and a manual-only (`workflow_dispatch`) bench
+  job with no thresholds.
+
+### Removed
+
+- **`tier` option and tier plumbing (breaking, pre-1.0).** The deprecated
+  `AlbexOptions.tier` (ignored since 0.5.0), `AlbexEngine.tier`,
+  `AlbexPool.tier`, `EngineStats.tier` and the WASM `getTier` export are
+  gone — superseded by the runtime `capacity` option (ABI 7, decision
+  A16). `EngineStats` now reports the real runtime capacities (`maxDocs`,
+  `maxChunks`, `textCapacity`, plus new `namePoolBytes`). The deprecated
+  `pickTier`/`Tier` re-exports from `profile.ts` remain for source
+  compatibility. The `tier-mini`/`tier-std`/`tier-pro` Cargo features are
+  deleted; the only build-time switch left is `simd`.
+
+### Changed
+
+- **Trigram windows no longer cross word boundaries.** `build_sig` /
+  `token_trigram_bits` only extend the sliding window on code points that
+  fold to an ASCII letter or digit; whitespace/punctuation/symbols break it
+  on BOTH the index and query sides (previously the fold passed ASCII
+  whitespace through, so signatures contained cross-word trigrams that
+  diluted selectivity — the doc-comment claimed otherwise). Sound under
+  fuzzy matching (same ≤3-windows-per-edit bound); signatures are rebuilt
+  on every restore/compact, so existing snapshots are unaffected.
+- **`wee_alloc` replaced (RUSTSEC-2022-0054).** The main no_std module now
+  uses `dlmalloc` (`global` feature) — baseline binary 36 732 → 42 654 bytes
+  (+5.8 KB, under the 48 KB gate). `pdf-wasm` drops its custom allocator and
+  uses std's default (also dlmalloc): 1 193 074 → 1 199 910 bytes (+6.8 KB on
+  1.2 MB). In pdf-wasm the allocator serves all of lopdf, so the known
+  wee_alloc leak surface was real there.
+
+### Fixed (this pass)
+
+- **`getSnippetWindow` can no longer open or close mid code point.** When the
+  word-boundary snap found no space within 20 bytes, the window edge could
+  land on a UTF-8 continuation byte → U+FFFD at the snippet border and every
+  span visually off. Both edges now back off continuation bytes to the
+  code-point lead (same pattern as the chunker's hard cut).
+
+### Added (previous pass)
+
+- **Authoritative chunk enumeration (ABI 4).** New `AlbexEngine.listChunks(docId)`
+  (and `AlbexEngineWorker.listChunks`) returns the exact chunks Albex indexed for
+  a document — `{ docId, location, ord, sub, text, byteLen, id }` — so a host can
+  mirror Albex's chunking for a parallel index (e.g. embeddings) keyed on the
+  `compact()`-stable id `"<docId>::<ord>"`. Backed by four read-only
+  WASM exports (`getDocChunkBase`, `getChunkLocationAt`, `getChunkByteLenAt`,
+  `getChunkTextAt`); `abiVersion()` bumped 3 → 4. No change to search, scoring or
+  snapshot formats; v3 snapshots still load.
+- **`SearchResult` now carries `docId` and `chunkId`.** `chunkId` (`"<docId>::<ord>"`)
+  is identical to the matching `AuthoritativeChunk.id`, so a host can fuse search
+  hits with a parallel index on a single stable key — no `(name, location)`
+  heuristics, and unambiguous when a long paragraph splits into sub-chunks.
+- **`maxFileBytes` option (default 256 MiB).** `indexFile` now rejects oversized
+  inputs with a typed `AlbexCapacityError` (`limit: 'file'`) by checking
+  `File.size` BEFORE reading — a 2 GB file no longer gets fully buffered and
+  hashed just to fail later. Enforced by the engine, the worker wrapper and the
+  pool coordinator.
+
+### Fixed
+
+- **GPU pre-filter no longer corrupts the search pattern.** `setCandidateMask`
+  pushes the candidate bitset through the scratchpad, overwriting the pattern
+  staged by `selectQueryBranch`; `searchBegin` then compiled garbage tokens out
+  of the mask bytes, so every GPU-assisted cooperative search silently returned
+  wrong results. The active branch is now re-selected after the pre-filter.
+- **GPU bloom upload invalidation is now mutation-driven.** The upload used to
+  be skipped when the chunk count matched the last upload — but `compact()` can
+  reorder chunks while keeping the count identical, leaving the GPU mask
+  filtering the wrong chunks (silent false negatives). A dirty flag set by every
+  index mutation (index/remove/compact/reset/load) now forces the re-upload.
+- **`AlbexEngineWorker.init` forwards all engine options.** Previously only
+  `wasmUrl` and `pdfWasmUrl` crossed the worker boundary; `wasmBaseUrl`, `simd`,
+  `gpu`, `gpuThreshold` and `maxFileBytes` were silently dropped, making the
+  SIMD variant and the GPU policy unreachable in workers.
+- **OR-branch dedup keyed on `chunkId`.** The previous
+  `(doc, location, matchStart)` key collided when two sub-chunks of the same
+  location hit at the same relative offset, dropping a legitimate result.
+- **`AlbexPool.search` now actually caps and dedups after the merge.** The doc
+  promised "capped to setMaxResults AFTER merge" but the coordinator returned
+  the raw flattened buckets. Results are now deduped, sorted and capped to the
+  last `setMaxResults` value (default 50); per-shard search stats are captured
+  race-free in the same posting batch as the search itself.
+- Corrected the `listChunks` docstring (and the entry above): the canonical
+  chunk id format is `"<docId>::<ord>"`, not `"<docId>::<location>.<sub>"`.
+
 ## [0.6.0] — 2026-05-31
 
 Release de auditoría algorítmica + robustez. Cierra los hallazgos #1–#8 de

package/README.md

@@ -14,14 +14,28 @@ start typing, get results in milliseconds.
 npm install albex
 ```
 
-The WASM binary ships inside the package. Bundlers that recognise the
-`new URL('…', import.meta.url)` pattern (Vite, Webpack 5+, esbuild, Rollup,
-Parcel 2) copy it to the output and rewrite the URL automatically.
+```ts
+import { AlbexEngine } from 'albex';
+
+const engine = new AlbexEngine();
+await engine.init();
+```
+
+That's it. The WASM core is **embedded in the package** (base64, ~19 KB
+gzipped over the wire, decoded once at startup), so there is nothing to
+serve and nothing to configure. It works the same in **every** bundler —
+Vite, Webpack, Rollup, Parcel, **esbuild and Angular included** — and in
+Node ≥ 18. No `assets` entries, no copying binaries, no `wasmUrl`.
 
 Matrix-tested in CI today: **Vite** and **Node** (via the test suite).
-Other bundlers and runtimes (Next SSR, Bun, Deno) should work through the
-same pattern but are not currently exercised by the test matrix — if you
-hit a problem, open an issue.
+Other bundlers and runtimes (Next SSR, Bun, Deno) ride the same embedded
+path; if you hit a problem, open an issue.
+
+> **PDFs** are the one exception: the PDF engine (~1.2 MB) is too large to
+> embed, so it loads on demand the first time you index a `.pdf`. In bundlers
+> that resolve `new URL('…', import.meta.url)` (Vite, Webpack 5+, Rollup,
+> Parcel) it just works; on esbuild/Angular, hand it the bytes once via
+> `pdfWasmBytes` (or a URL via `pdfWasmUrl`). See [Advanced](#advanced-configuration).
 
 ---
 
@@ -66,9 +80,10 @@ That's the entire onboarding. Read on for what else the engine can do.
 ## Features
 
 - **Zero server** — all text stays on the user's machine.
-- **Bundler-friendly default** — `new AlbexEngine()` works without extra
-  configuration in bundlers that recognise the `new URL(..., import.meta.url)`
-  asset pattern (see the "Install" section for the tested matrix).
+- **Install and use** — the WASM core ships embedded in the JS, so
+  `new AlbexEngine()` runs in **any** bundler (esbuild/Angular included) and
+  in Node with nothing to serve and nothing to configure. SIMD and CDN
+  hosting stay available as opt-in options (see [Advanced](#advanced-configuration)).
 - **Fuzzy matching** — finds `"contrato"` even if you type `"conttrato"` (Bitap with adaptive edit distance). Sound under a two-stage pre-filter (character Bloom for exact tokens, a 256-bit **trigram q-gram signature** for everything) that prunes the candidate set ~10× on prose without ever dropping a real approximate match.
 - **Accent-insensitive** — `"accion"` matches `"acción"`, `"espana"` matches `"España"`, plus Latin Extended (Polish, Czech, Slovak, Turkish…).
 - **11 formats with varying depth** — DOCX · XLSX · PDF · HTML · MD · JSON · CSV · EML · RTF · TXT · XML. See the support table below; several formats are deliberately "lite" (CSV is RFC-4180-lite, EML is MIME-lite, RTF is regex-stripped, etc.).
@@ -81,10 +96,11 @@ That's the entire onboarding. Read on for what else the engine can do.
 - **WebGPU pre-filter** — experimental, opt-in (`gpu: 'auto'`). Implemented for corpora over 20 k chunks; no reproducible speedup number yet — the bench in this repo runs on a 200-document synthetic corpus only.
 - **SIMD opportunistic** — picks a SIMD-accelerated variant when the host supports v128.
 - **Tiered storage** — `TieredStore` keeps recent docs hot, evicts cold ones to OPFS, promotes on demand.
-- **Capacity-safe** — when a pool fills (`docs`/`chunks`/`text`/`names`), `indexFile` throws `AlbexCapacityError` with a `limit` field instead of silently truncating the corpus.
+- **Runtime capacity** — one binary, pools sized at init: `capacity: 'std'` (default, 128 docs / 100k chunks / 16 MB text), `'large'` (1 024 docs / 800k chunks / 128 MB text) or a custom `{ maxDocs, maxChunks, textPoolBytes, namePoolBytes }`.
+- **Capacity-safe** — when a pool fills (`docs`/`chunks`/`text`/`names`), `indexFile` throws `AlbexCapacityError` with `limit` (which pool) and `max` (the runtime limit) instead of silently truncating the corpus.
 - **Re-entrancy-safe** — async operations on one engine serialize; sync `search`/`compact`/`reset` refuse to run mid-operation (`AlbexError` kind `busy`) rather than corrupting the shared WASM state. Use `searchCooperative` for overlapping search-as-you-type.
 - **Typed errors** — `AlbexParseError`, `AlbexUnsupportedFormatError`, `AlbexCapacityError`, `AlbexInitError`. All extend `AlbexError`.
-- **Tiny core** — main WASM 33 KB (37 KB SIMD). PDF module (~1.2 MB) loads on demand. The OCR companion (`@albex/ocr`) is a separate package and pulls Tesseract.js (~3.5 MB) only when you call `enableOcr()`.
+- **Tiny core** — main WASM ~47 KB (~19 KB gzipped); the SIMD build is ~54 KB (~21 KB gzipped). PDF module (~1.2 MB, ~510 KB gzipped) loads on demand. The OCR companion (`@albex/ocr`) is a separate package and pulls Tesseract.js (~3.5 MB) only when you call `enableOcr()`.
 
 ---
 
@@ -199,7 +215,7 @@ const results = await pool.search('contrato');  // map-reduce
 
 ## Big corpora — tiered storage
 
-For workloads that exceed the tier's RAM capacity:
+For workloads that exceed the engine's RAM capacity:
 
 ```ts
 import { AlbexEngine, TieredStore } from 'albex';
@@ -223,36 +239,75 @@ Hot tier = engine. Warm tier = original files in OPFS. LRU eviction is automatic
 `new AlbexEngine()` covers the default case. The options below address
 specific deployment needs:
 
-### Tier auto-selection (`mini` / `std` / `pro` based on `deviceMemory`)
+### Capacity (runtime, single binary)
 
-Albex ships **six** WASM variants of the main engine (3 tiers × baseline/SIMD).
-By default it loads the std-baseline binary that comes with the npm package.
-If you want runtime tier auto-selection, serve the variants yourself and
-pass `wasmBaseUrl`:
+Capacity is a **runtime** parameter — there is one engine binary (plus its
+SIMD variant) and the pools are heap-allocated at `init()` to the size you
+ask for. The old compile-time tiers (and the `tier` option) are gone:
 
 ```ts
 const engine = new AlbexEngine({
-  wasmBaseUrl: '/assets',          // directory containing the 6 .wasm files
-  tier: 'auto',                    // picks mini/std/pro by deviceMemory
+  capacity: 'large',               // or 'std' (default), or a custom object
   simd: 'auto',                    // picks baseline/simd by WASM probe
   gpu:  'auto',                    // engages WebGPU when corpus > 20k chunks
 });
 ```
 
-Tier capacities:
+Presets and cost (≈ `maxChunks × 64 B + textPool + namePool`; WASM memory
+never shrinks, so the largest capacity initialised stays committed):
 
-| Tier  | Max docs | Max chunks | Max text | Working set |
-|-------|---------:|-----------:|---------:|------------:|
-| mini  | 32       | 25 000     | 4 MB     | ~5 MB       |
-| std   | 128      | 100 000    | 16 MB    | ~20 MB      |
-| pro   | 1 024    | 800 000    | 128 MB   | ~160 MB     |
+| Capacity  | Max docs | Max chunks | Max text | Working set |
+|-----------|---------:|-----------:|---------:|------------:|
+| `'std'`   | 128      | 100 000    | 16 MB    | ~22 MB      |
+| `'large'` | 1 024    | 800 000    | 128 MB   | ~180 MB     |
+| custom    | ≤ 65 536 | ≤ 4 M      | ≤ 1 GiB  | as configured |
 
-### Custom CDN
+Custom objects may be partial — missing fields are completed from the std
+ratios (`maxChunks = maxDocs × 782`, `textPoolBytes = maxChunks × 168 B`,
+`namePoolBytes = maxDocs × 256 B`, with sane floors):
 
 ```ts
+const tiny = new AlbexEngine({ capacity: { maxDocs: 16 } });
+```
+
+Snapshots are admitted by **content**: a snapshot saved with `'large'`
+loads into a `'std'` engine whenever its counters fit, and fails cleanly
+(previous index intact) when they don't.
+
+### WASM source — SIMD, CDN, custom bytes
+
+The default embeds the **baseline** core, which is all most apps need. Three
+opt-in overrides, none required:
+
+```ts
+// SIMD on capable hosts: serve both binaries and let Albex probe.
+new AlbexEngine({ wasmBaseUrl: '/albex' }); // dir with albex_wasm.wasm + albex_wasm_simd.wasm
+
+// A single core from your CDN.
+new AlbexEngine({ wasmUrl: 'https://cdn.example.com/albex_wasm.wasm' });
+
+// Bytes you loaded yourself (skips all fetching).
+new AlbexEngine({ wasmBytes: myArrayBuffer });
+```
+
+Setting any of these bypasses the embedded core. If a fetch fails, the
+thrown `AlbexInitError` names the URL it tried and tells you the one-line
+exit (drop the option to fall back to the embedded core) — no guessing.
+
+### PDFs on esbuild / Angular
+
+The PDF engine (~1.2 MB) loads on demand and isn't embedded. Bundlers that
+resolve `new URL('…', import.meta.url)` serve it automatically; esbuild and
+Angular don't, so hand it the bytes once (the binary ships in the package at
+`albex/wasm/pkg/albex_pdf.wasm`):
+
+```ts
+import pdfWasmUrl from 'albex/wasm/pkg/albex_pdf.wasm';   // bundler asset URL
+
 const engine = new AlbexEngine({
-  wasmUrl: 'https://my-cdn.example.com/albex_wasm.wasm',
+  pdfWasmBytes: await fetch(pdfWasmUrl).then(r => r.arrayBuffer()),
 });
+// …or a plain URL you host: new AlbexEngine({ pdfWasmUrl: '/albex/albex_pdf.wasm' })
 ```
 
 ---
@@ -299,14 +354,13 @@ PDF support requires `albex_pdf.wasm` to be served with MIME type `application/w
 rustup target add wasm32-unknown-unknown
 
 npm install
-npm run build:all         # 6 main variants + PDF + TypeScript
+npm run build:all         # main (baseline + SIMD) + PDF + TypeScript
 ```
 
 Partial builds:
 
 ```bash
-npm run build:wasm        # std baseline only
-npm run build:wasm:tiers  # all 6 variants
+npm run build:wasm        # main module (baseline + SIMD)
 npm run build:pdf-wasm    # PDF module
 npm run build             # TypeScript only
 ```

package/dist/_generated/inline-wasm.d.ts

@@ -0,0 +1,2 @@
+export declare const ALBEX_WASM_BASE64: string;
+//# sourceMappingURL=inline-wasm.d.ts.map

package/dist/_generated/inline-wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-wasm.d.ts","sourceRoot":"","sources":["../../src/_generated/inline-wasm.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,iBAAiB,EAAE,MACg86D,CAAC"}

package/dist/_generated/inline-wasm.js

@@ -0,0 +1,9 @@
+// AUTO-GENERATED by scripts/gen-inline.mjs — DO NOT EDIT.
+// Source: wasm/pkg/albex_wasm_bg.wasm (baseline core, no SIMD).
+// Regenerated on every `npm run build`. 47205 raw bytes →
+// 62940 base64 chars (~61 KB text, ~46 KB raw).
+/* eslint-disable */
+// Typed as `string` (not the literal) so the emitted .d.ts stays a few bytes
+// instead of inlining the whole base64 blob as a literal type.
+export const ALBEX_WASM_BASE64 = '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';
+//# sourceMappingURL=inline-wasm.js.map

package/dist/_generated/inline-wasm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-wasm.js","sourceRoot":"","sources":["../../src/_generated/inline-wasm.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,gEAAgE;AAChE,0DAA0D;AAC1D,gDAAgD;AAChD,oBAAoB;AACpB,6EAA6E;AAC7E,+DAA+D;AAC/D,MAAM,CAAC,MAAM,iBAAiB,GAC5B,896DAA896D,CAAC"}