@thinletterio/vqweb 0.1.0

package/dist/vqweb.js

@@ -0,0 +1,4121 @@
+/* @thinletterio/vqweb 0.1.0 — vector-quantised query encoders in the browser on WebGPU. Apache-2.0, https://thinletter.io
+ * Bundles: client/vqweb runtime (thinletter, Apache-2.0), @huggingface/tokenizers 0.2.0 (Apache-2.0), a Q2_K decoder ported from llama.cpp gguf-py (MIT). See NOTICE. */
+
+// ../../client/vqweb/embed.js
+var F16_TABLE = (() => {
+  const t = new Float32Array(65536);
+  for (let h = 0; h < 65536; h++) {
+    const s = h & 32768 ? -1 : 1, e = h >> 10 & 31, m = h & 1023;
+    let v;
+    if (e === 0) v = m * 2 ** -24;
+    else if (e === 31) v = m ? NaN : Infinity;
+    else v = (1 + m / 1024) * 2 ** (e - 15);
+    t[h] = s * v;
+  }
+  return t;
+})();
+function f16ArrayToF32(u16) {
+  const out = new Float32Array(u16.length);
+  for (let i = 0; i < u16.length; i++) out[i] = F16_TABLE[u16[i]];
+  return out;
+}
+var _f32 = new Float32Array(1);
+var _u32 = new Uint32Array(_f32.buffer);
+function f32ToF16(x) {
+  _f32[0] = x;
+  const b = _u32[0];
+  const sign = b >>> 16 & 32768;
+  let e = b >>> 23 & 255, m = b & 8388607;
+  if (e === 255) return sign | 31744 | (m ? 512 : 0);
+  let ne = e - 127 + 15;
+  if (ne >= 31) return sign | 31744;
+  if (ne <= 0) {
+    if (ne < -10) return sign;
+    m |= 8388608;
+    const shift = 14 - ne;
+    let half2 = m >>> shift;
+    const rem2 = m & (1 << shift) - 1, halfway = 1 << shift - 1;
+    if (rem2 > halfway || rem2 === halfway && half2 & 1) half2++;
+    return sign | half2;
+  }
+  let half = ne << 10 | m >>> 13;
+  const rem = m & 8191;
+  if (rem > 4096 || rem === 4096 && half & 1) half++;
+  return sign | half;
+}
+var Q2K_BLOCK = 256;
+var Q2K_BYTES = 84;
+var fround = Math.fround;
+function decodeQ2KBlock(src, off, out, outOff) {
+  const d = F16_TABLE[src[off + 80] | src[off + 81] << 8];
+  const dmin = F16_TABLE[src[off + 82] | src[off + 83] << 8];
+  for (let sb = 0; sb < 16; sb++) {
+    const sc = src[off + sb];
+    const dl = fround(d * (sc & 15)), ml = fround(dmin * (sc >> 4));
+    const n0 = sb * 16;
+    const half = n0 >> 7, shift = n0 >> 5 & 3;
+    const qbase = off + 16 + half * 32;
+    for (let j = 0; j < 16; j++) {
+      const n = n0 + j;
+      const q = src[qbase + (n & 31)] >> 2 * shift & 3;
+      out[outOff + n] = fround(fround(dl * q) - ml);
+    }
+  }
+}
+function decodeQ2KRow(src, off, cols, out, outOff) {
+  for (let b = 0; b < cols / Q2K_BLOCK; b++) decodeQ2KBlock(src, off + b * Q2K_BYTES, out, outOff + b * Q2K_BLOCK);
+}
+var TokenTable = class {
+  /**
+   * @param {Uint8Array} q2kBytes  raw `token_embd` bytes, [rows, cols/256*84]
+   * @param {Uint32Array} ids      `token_embd.ids`
+   * @param {number} hidden        cols (1024)
+   */
+  constructor(q2kBytes, ids, hidden) {
+    this.bytes = q2kBytes;
+    this.ids = ids;
+    this.hidden = hidden;
+    this.rowBytes = hidden / Q2K_BLOCK * Q2K_BYTES;
+    if (q2kBytes.length !== ids.length * this.rowBytes) throw new Error(`token table: ${q2kBytes.length} bytes != ${ids.length} rows x ${this.rowBytes}`);
+    this.rowOf = /* @__PURE__ */ new Map();
+    for (let i = 0; i < ids.length; i++) this.rowOf.set(ids[i], i);
+  }
+  get rows() {
+    return this.ids.length;
+  }
+  /** decoded row i (stored index) as Float32Array[hidden]. */
+  row(i, out = new Float32Array(this.hidden), outOff = 0) {
+    decodeQ2KRow(this.bytes, i * this.rowBytes, this.hidden, out, outOff);
+    return out;
+  }
+  /** token ids (already re-tokenised onto the trimmed vocabulary) -> Float32Array [T, hidden]. */
+  lookup(tokenIds) {
+    const T = tokenIds.length, out = new Float32Array(T * this.hidden);
+    for (let t = 0; t < T; t++) {
+      const r = this.rowOf.get(tokenIds[t]);
+      if (r === void 0) throw new Error(`token id ${tokenIds[t]} is not in the trimmed table (re-tokenise with VqwTokenizer first)`);
+      this.row(r, out, t * this.hidden);
+    }
+    return out;
+  }
+  /** the same as f16 bits (Uint16Array [T, hidden]) for an f16 residual stream. */
+  lookupF16(tokenIds) {
+    const f = this.lookup(tokenIds), out = new Uint16Array(f.length);
+    for (let i = 0; i < f.length; i++) out[i] = f32ToF16(f[i]);
+    return out;
+  }
+};
+
+// ../../client/vqweb/container.js
+var MAGIC = "VQW1";
+var TYPED = { f16: Uint16Array, f32: Float32Array, u8: Uint8Array, i8: Int8Array, u16: Uint16Array, u32: Uint32Array, i32: Int32Array };
+var LIN = ["q", "k", "v", "o", "gate", "up", "down"];
+var NORMS = ["attn_norm", "ffn_norm", "attn_q_norm", "attn_k_norm"];
+function parseVqw(data) {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3]) !== MAGIC) throw new Error("not a .vqw file (bad magic)");
+  const L = dv.getUint32(8, true);
+  const header = JSON.parse(new TextDecoder("utf-8").decode(bytes.subarray(12, 12 + L)));
+  const dataStart = 12 + L;
+  if (dataStart % 64) throw new Error(`data start ${dataStart} is not 64-byte aligned`);
+  const raw = (name) => {
+    const t = header.tensors[name];
+    if (!t) throw new Error(`tensor ${name} not in container`);
+    return bytes.subarray(dataStart + t.offset, dataStart + t.offset + t.nbytes);
+  };
+  const view = (name) => {
+    const t = header.tensors[name], r = raw(name);
+    if (t.dtype === "q2_k" || t.dtype === "u8") return r;
+    const C = TYPED[t.dtype];
+    if (!C) throw new Error(`unknown dtype ${t.dtype} of ${name}`);
+    if (r.byteOffset % C.BYTES_PER_ELEMENT !== 0) return new C(r.slice().buffer);
+    return new C(r.buffer, r.byteOffset, r.byteLength / C.BYTES_PER_ELEMENT);
+  };
+  return { header, dataStart, bytes, raw, view };
+}
+async function fetchVqw(url, onProgress) {
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`fetch ${url}: ${r.status}`);
+  const total = Number(r.headers.get("Content-Length") || 0);
+  if (!r.body || !onProgress) return await r.arrayBuffer();
+  const reader = r.body.getReader();
+  const chunks = [];
+  let loaded = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    loaded += value.byteLength;
+    onProgress(loaded, total);
+  }
+  const out = new Uint8Array(loaded);
+  let o = 0;
+  for (const c of chunks) {
+    out.set(c, o);
+    o += c.byteLength;
+  }
+  return out.buffer;
+}
+var align4 = (n) => n + 3 & ~3;
+var VqwContainer = class _VqwContainer {
+  /**
+   * @param {ReturnType<parseVqw>} parsed
+   * @param {GPUDevice} device
+   */
+  constructor(parsed, device) {
+    this.parsed = parsed;
+    this.header = parsed.header;
+    this.device = device;
+    const m = this.header.model;
+    this.model = {
+      arch: m.arch,
+      hidden: m.hidden,
+      layers: m.layers,
+      heads: m.heads,
+      kvHeads: m.kv_heads,
+      headDim: m.head_dim,
+      intermediate: m.intermediate,
+      ropeTheta: m.rope_theta,
+      rmsEps: m.rms_eps,
+      pooling: m.pooling,
+      maxLen: m.max_len ?? 512,
+      prompt: m.prompt ?? "",
+      addEos: !!m.add_eos,
+      eosId: m.eosId ?? m.eos_id ?? null,
+      teacher: m.teacher,
+      truncated: !!m.truncated
+    };
+    this.rotation = { rounds: this.header.rotation.rounds, block: this.header.rotation.block, sizes: this.header.rotation.sizes, side: this.header.rotation.side ?? "in" };
+    this.quant = this.header.quant;
+    this.gpu = /* @__PURE__ */ new Map();
+    this.gpuBytes = 0;
+    this.tokens = new TokenTable(parsed.view("token_embd"), parsed.view("token_embd.ids"), this.model.hidden);
+    this._upload();
+  }
+  static async load(url, device, { onProgress } = {}) {
+    const buf = await fetchVqw(url, onProgress);
+    return new _VqwContainer(parseVqw(buf), device);
+  }
+  _buffer(name, bytes, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST) {
+    const size = align4(bytes.byteLength);
+    const b = this.device.createBuffer({ label: name, size, usage, mappedAtCreation: true });
+    new Uint8Array(b.getMappedRange()).set(bytes);
+    b.unmap();
+    this.gpu.set(name, b);
+    this.gpuBytes += size;
+    return b;
+  }
+  _upload() {
+    const p = this.parsed, T = this.header.tensors;
+    for (let li = 0; li < this.model.layers; li++) {
+      for (const nm of LIN) for (const part of ["codebook", "idx", "scale"]) {
+        const n = `blk.${li}.${nm}.${part}`;
+        this._buffer(n, p.raw(n));
+      }
+      for (const nm of NORMS) {
+        const n = `blk.${li}.${nm}`;
+        this._buffer(n, p.raw(n));
+      }
+    }
+    this._buffer("output_norm", p.raw("output_norm"));
+    this.prefix = null;
+    if (T["prefix.ids"]) {
+      const ids = Array.from(p.view("prefix.ids"));
+      const P = ids.length, KD = this.model.kvHeads * this.model.headDim, L = this.model.layers;
+      const k16 = p.view("prefix.k"), v16 = p.view("prefix.v");
+      if (k16.length !== L * P * KD || v16.length !== L * P * KD) throw new Error(`prefix.k/v size ${k16.length} != ${L}x${P}x${KD}`);
+      const k32 = f16ArrayToF32(k16), v32 = f16ArrayToF32(v16);
+      for (let li = 0; li < L; li++) {
+        this._buffer(`prefix.k.${li}`, new Uint8Array(k32.buffer, li * P * KD * 4, P * KD * 4));
+        this._buffer(`prefix.v.${li}`, new Uint8Array(v32.buffer, li * P * KD * 4, P * KD * 4));
+      }
+      this.prefix = { ids, tokens: P, text: this.header.prefix?.text ?? "" };
+    }
+    for (const n of this.rotation.sizes) {
+      const s = p.view(`rot.${n}.signs`), q = p.view(`rot.${n}.perm`);
+      this._buffer(`rot.${n}.signs`, new Uint8Array(Float32Array.from(s).buffer));
+      this._buffer(`rot.${n}.perm`, new Uint8Array(Uint32Array.from(q).buffer));
+      const blk = T[`rot.${n}.signs`].block ?? this.rotation.block;
+      if (blk !== this.rotation.block) throw new Error(`rotation block ${blk} != header block ${this.rotation.block}`);
+    }
+  }
+  /** Metadata + buffers of one linear (`blk.3.gate`). */
+  linear(prefix) {
+    const meta = this.header.tensors[`${prefix}.idx`];
+    const cb = this.header.tensors[`${prefix}.codebook`];
+    const bits = meta.bits_per_index, k = meta.k ?? cb.shape[1];
+    if (1 << bits !== k) throw new Error(`${prefix}: ${bits}-bit indices but K=${k}`);
+    const dim = meta.dim ?? 4;
+    if (![2, 4].includes(dim) || (meta.blocksize ?? 256) !== 256) throw new Error(`${prefix}: dim ${meta.dim} / blocksize ${meta.blocksize} unsupported (kernel: dim 2 or 4, blocksize 256)`);
+    if (dim === 2 && bits > 12) throw new Error(`${prefix}: dim 2 with ${bits}-bit indices unsupported (two indices must fit 24 bits)`);
+    return {
+      prefix,
+      rows: meta.rows,
+      cols: meta.cols,
+      groups: meta.groups,
+      words: meta.shape[1],
+      k,
+      bits,
+      dim,
+      nblk: cb.shape[0],
+      codebook: this.gpu.get(`${prefix}.codebook`),
+      idx: this.gpu.get(`${prefix}.idx`),
+      scale: this.gpu.get(`${prefix}.scale`)
+    };
+  }
+  norm(name) {
+    const b = this.gpu.get(name);
+    if (!b) throw new Error(`norm ${name} missing`);
+    return b;
+  }
+  /** Stored prefix K / V buffers of block li (M6), or null when the container has no prefix. */
+  prefixKV(li) {
+    return this.prefix ? { k: this.gpu.get(`prefix.k.${li}`), v: this.gpu.get(`prefix.v.${li}`) } : null;
+  }
+  rot(n) {
+    const signs = this.gpu.get(`rot.${n}.signs`), perms = this.gpu.get(`rot.${n}.perm`);
+    if (!signs) throw new Error(`no rotation of size ${n} in the container`);
+    return { n, rounds: this.rotation.rounds, block: this.rotation.block, signs, perms };
+  }
+  /** Forget the file's ArrayBuffer after the upload: the token table (the only CPU-side tensor) is copied out first, so
+   *  a caller that holds no other reference lets the ~100 MiB file be garbage-collected (memory after load, spec section 1). */
+  release() {
+    if (!this.parsed) return;
+    const p = this.parsed;
+    this.tokens = new TokenTable(p.view("token_embd").slice(), Uint32Array.from(p.view("token_embd.ids")), this.model.hidden);
+    this.parsed = null;
+  }
+  destroy() {
+    for (const b of this.gpu.values()) b.destroy();
+    this.gpu.clear();
+  }
+};
+
+// ../../client/vqweb/runtime.js
+var KERNEL_FILES = ["rmsnorm", "fwht_rotate", "vq_matmul", "vq_matmul_v1", "qk_norm_rope", "attention", "swiglu", "pool_normalize"];
+var U = "uniform";
+var RO = "read-only-storage";
+var RW = "storage";
+async function requestDevice({ powerPreference = "low-power", label = "vqweb" } = {}) {
+  if (!navigator.gpu) throw new Error("WebGPU is not available (navigator.gpu missing)");
+  const adapter = await navigator.gpu.requestAdapter({ powerPreference });
+  if (!adapter) throw new Error("no WebGPU adapter");
+  if (!adapter.features.has("shader-f16")) throw new Error("adapter has no shader-f16");
+  const info = {
+    vendor: adapter.info?.vendor,
+    architecture: adapter.info?.architecture,
+    device: adapter.info?.device,
+    description: adapter.info?.description,
+    shader_f16: true,
+    subgroups: adapter.features.has("subgroups"),
+    timestamp_query: adapter.features.has("timestamp-query"),
+    maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,
+    maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
+    maxBufferSize: adapter.limits.maxBufferSize,
+    maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup
+  };
+  const requiredFeatures = ["shader-f16"];
+  if (adapter.features.has("timestamp-query")) requiredFeatures.push("timestamp-query");
+  const requiredLimits = {};
+  if (adapter.limits.maxComputeWorkgroupStorageSize > 16384) requiredLimits.maxComputeWorkgroupStorageSize = adapter.limits.maxComputeWorkgroupStorageSize;
+  const device = await adapter.requestDevice({ label, requiredFeatures, requiredLimits });
+  return { adapter, device, info };
+}
+async function loadKernelSources(baseUrl = new URL("./kernels/", import.meta.url)) {
+  const out = {};
+  await Promise.all(KERNEL_FILES.map(async (n) => {
+    const r = await fetch(new URL(`${n}.wgsl`, baseUrl));
+    if (!r.ok) throw new Error(`kernel ${n}.wgsl: ${r.status}`);
+    out[n] = await r.text();
+  }));
+  return out;
+}
+function fill(src, vars) {
+  return src.replace(/\{\{(\w+)\}\}/g, (m, k) => {
+    if (!(k in vars)) throw new Error(`template variable ${k} missing`);
+    return String(vars[k]);
+  });
+}
+var f32lit = (x) => {
+  const s = String(x);
+  return /[.eE]/.test(s) ? s : s + ".0";
+};
+var VqwRuntime = class _VqwRuntime {
+  /**
+   * @param {import('./container.js').VqwContainer} container
+   * @param {GPUDevice} device
+   * @param {object} opts  resid: 'f32' | 'f16'; tmax: max tokens (default model.max_len); tile: vq_matmul tile
+   *                       {rwg, tt, cb, mr, mt} (M4 kernel, default 64,32,64,4,4) or {kernel: 'v1', rwg, lanes, tpt} (M2 kernel);
+   *                       sources: kernel sources (default: fetched next to this module)
+   */
+  constructor(container, device, opts = {}) {
+    this.c = container;
+    this.device = device;
+    this.m = container.model;
+    this.resid = opts.resid ?? "f32";
+    this.tmax = opts.tmax ?? this.m.maxLen;
+    this.P = (opts.usePrefix ?? true) && container.prefix ? container.prefix.tokens : 0;
+    this.prefixIds = this.P ? container.prefix.ids : null;
+    const t = opts.tile || {};
+    this.tile = t.kernel === "v1" ? Object.assign({ kernel: "v1", rwg: 32, lanes: 8, tpt: 2 }, t) : Object.assign({ kernel: "v2", rwg: 64, tt: 32, cb: 64, mr: 4, mt: 4 }, t);
+    if (this.tile.kernel === "v2") {
+      const { rwg, tt, cb, mr, mt } = this.tile;
+      const wgs = rwg / mr * (tt / mt), gs = cb / 4;
+      if (256 % cb || cb % 4 || rwg % mr || tt % mt || wgs > 1024 || wgs % rwg || gs % (wgs / rwg)) throw new Error(`bad vq_matmul tile ${JSON.stringify(this.tile)}`);
+    }
+    this.sources = opts.sources || null;
+    this.pipelines = /* @__PURE__ */ new Map();
+    this.layouts = /* @__PURE__ */ new Map();
+    this.dispatchesPerBlock = 17;
+    if (this.m.headDim % 2 || this.m.heads % this.m.kvHeads) throw new Error("unsupported head configuration");
+  }
+  static async create(container, device, opts = {}) {
+    const rt = new _VqwRuntime(container, device, opts);
+    if (!rt.sources) rt.sources = await loadKernelSources(opts.kernelBase);
+    rt._buildPipelines();
+    rt._allocate();
+    rt._bindAll();
+    await device.queue.onSubmittedWorkDone();
+    return rt;
+  }
+  // ---------------------------------------------------------------------------------------------- pipelines
+  _layout(key, kinds) {
+    let l = this.layouts.get(key);
+    if (!l) {
+      l = this.device.createBindGroupLayout({ label: key, entries: kinds.map((type, binding) => ({ binding, visibility: GPUShaderStage.COMPUTE, buffer: { type } })) });
+      this.layouts.set(key, l);
+    }
+    return l;
+  }
+  _pipeline(key, file, vars, kinds) {
+    let p = this.pipelines.get(key);
+    if (p) return p;
+    const code = fill(this.sources[file], vars);
+    const module = this.device.createShaderModule({ label: key, code });
+    const layout = this._layout(kinds.join(","), kinds);
+    p = { pipeline: this.device.createComputePipeline({ label: key, layout: this.device.createPipelineLayout({ bindGroupLayouts: [layout] }), compute: { module, entryPoint: "main" } }), layout, key, module };
+    this.pipelines.set(key, p);
+    return p;
+  }
+  _buildPipelines() {
+    const m = this.m, R = this.resid;
+    this.pRms = this._pipeline(`rmsnorm/${R}`, "rmsnorm", { N: m.hidden, EPS: f32lit(m.rmsEps), IN_T: R }, [U, RO, RO, RW]);
+    this.pRot = {};
+    for (const n of this.c.rotation.sizes) {
+      const B = this.c.rotation.block;
+      this.pRot[n] = this._pipeline(`fwht/${n}`, "fwht_rotate", { N: n, B, R: this.c.rotation.rounds, INV_SQRT_B: f32lit(1 / Math.sqrt(B)) }, [U, RO, RO, RO, RW]);
+    }
+    this.pQk = this._qkPipeline(true, true);
+    this.pAttn = this._attnPipeline(false);
+    this.pSwiglu = this._pipeline("swiglu", "swiglu", { I: m.intermediate }, [U, RO, RO, RW]);
+    this.pPool = this._pipeline("pool", "pool_normalize", { N: m.hidden }, [U, RO, RW]);
+  }
+  _matmulPipeline(lin, add) {
+    const { rows, cols, k, bits, words } = lin;
+    const dim = lin.dim || 4;
+    const t = this.tile;
+    const OUT_T = add ? this.resid : "f32";
+    const CBT = dim === 4 ? "vec4<f16>" : "vec2<f16>";
+    const DECODE = dim === 4 ? "ws[(g * MR + di) * NTR + dtr] = vec4<f32>(cbs[v & MASK]);" : "let hi = select(0u, iw[min(base + wi + 1u, RWG * WPB - 1u)], sh > 0u) << ((32u - sh) & 31u); let v2 = (iw[base + wi] >> sh) | hi; let i0 = v2 & MASK; let i1 = (v2 >> W) & MASK; ws[(g * MR + di) * NTR + dtr] = vec4<f32>(vec4<f16>(cbs[i0], cbs[i1]));";
+    const common = { ROWS: rows, COLS: cols, K: k, W: bits, MASK: (1 << bits) - 1, WORDS: words, OUT_T, DIM: dim, CBT, DECODE };
+    if (t.kernel === "v1") {
+      if (dim !== 4) throw new Error("vq_matmul v1 kernel supports dim 4 only");
+      const key2 = `vq_matmul/${rows}x${cols}/k${k}/${add ? "add-" + this.resid : "store"}/v1-${t.rwg}x${t.lanes}x${t.tpt}`;
+      const OUT_STMT2 = add ? `y[t * ROWS + r] = ${OUT_T}(f32(y[t * ROWS + r]) + acc[k]);` : "y[t * ROWS + r] = acc[k];";
+      return this._pipeline(key2, "vq_matmul_v1", { ...common, RWG: t.rwg, LANES: t.lanes, TPT: t.tpt, WGS: t.rwg * t.lanes, OUT_STMT: OUT_STMT2 }, [U, RO, RO, RO, RO, RW]);
+    }
+    if (rows % t.rwg) throw new Error(`vq_matmul: ${rows} rows not a multiple of rwg=${t.rwg}`);
+    const key = `vq_matmul/${rows}x${cols}/k${k}/d${dim}/${add ? "add-" + this.resid : "store"}/${t.rwg}x${t.tt}x${t.cb}x${t.mr}x${t.mt}`;
+    const OUT_STMT = add ? `y[t * ROWS + r] = ${OUT_T}(f32(y[t * ROWS + r]) + acc[i][j]);` : "y[t * ROWS + r] = acc[i][j];";
+    return this._pipeline(key, "vq_matmul", { ...common, RWG: t.rwg, TT: t.tt, CB: t.cb, MR: t.mr, MT: t.mt, WGS: t.rwg / t.mr * (t.tt / t.mt), OUT_STMT }, [U, RO, RO, RO, RO, RW]);
+  }
+  _qkPipeline(rope, inplace) {
+    const m = this.m;
+    const vars = { NH: m.heads, NKV: m.kvHeads, HD: m.headDim, HALF: m.headDim / 2, EPS: f32lit(m.rmsEps), DO_ROPE: rope ? "true" : "false" };
+    const kinds = [U, RW, RW, RO, RO, RO, RO];
+    if (inplace) {
+      vars.OUT_BINDINGS = "";
+      vars.OUT_STMT = "if (isq) { q[base + i] = an; q[base + i + HALF] = bn; } else { k[base + i] = an; k[base + i + HALF] = bn; }";
+    } else {
+      vars.OUT_BINDINGS = "@group(0) @binding(7) var<storage, read_write> qo: array<f32>;\n@group(0) @binding(8) var<storage, read_write> ko: array<f32>;";
+      vars.OUT_STMT = "if (isq) { qo[base + i] = an; qo[base + i + HALF] = bn; } else { ko[base + i] = an; ko[base + i + HALF] = bn; }";
+      kinds.push(RW, RW);
+    }
+    return this._pipeline(`qk/${rope ? "rope" : "norm"}/${inplace ? "inplace" : "out"}`, "qk_norm_rope", vars, kinds);
+  }
+  _attnPipeline(probs) {
+    const m = this.m;
+    const vars = {
+      NH: m.heads,
+      NKV: m.kvHeads,
+      HD: m.headDim,
+      PMAX: Math.max(this.P, 1),
+      TMAX: this.P + this.tmax,
+      SCALE: f32lit(Math.pow(m.headDim, -0.5)),
+      WRITE_PROBS: probs ? "true" : "false",
+      PROBS_BINDING: probs ? "@group(0) @binding(7) var<storage, read_write> probs: array<f32>;" : "",
+      PROBS_STMT: probs ? "probs[(h * T + t) * W + j] = select(0.0, sc[j] * inv, j <= last);" : ""
+    };
+    const kinds = [U, RO, RO, RO, RW, RO, RO];
+    if (probs) kinds.push(RW);
+    return this._pipeline(`attention/${probs ? "probs" : "plain"}/P${this.P}`, "attention", vars, kinds);
+  }
+  // ---------------------------------------------------------------------------------------------- buffers
+  _buf(label, bytes, extra = 0) {
+    const b = this.device.createBuffer({ label, size: Math.max(16, bytes + 3 & ~3), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | extra });
+    this.actBytes += b.size;
+    return b;
+  }
+  _allocate() {
+    const m = this.m, T = this.tmax, rb = this.resid === "f16" ? 2 : 4;
+    this.actBytes = 0;
+    const H = m.hidden, QD = m.heads * m.headDim, KD = m.kvHeads * m.headDim, I = m.intermediate;
+    this.b = {
+      uni: this.device.createBuffer({ label: "params", size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST }),
+      x: this._buf("x (residual)", T * H * rb),
+      h: this._buf("h (norm out)", T * H * 4),
+      hr: this._buf("hr (rot, f16)", T * H * 2),
+      q: this._buf("q", T * QD * 4),
+      k: this._buf("k", T * KD * 4),
+      v: this._buf("v", T * KD * 4),
+      attn: this._buf("attn_out", T * QD * 4),
+      orot: this._buf("o_rot (f16)", T * QD * 2),
+      g: this._buf("gate", T * I * 4),
+      u: this._buf("up", T * I * 4),
+      a: this._buf("swiglu", T * I * 4),
+      ar: this._buf("down_rot (f16)", T * I * 2),
+      emb: this._buf("embedding", H * 4),
+      cos: this._buf("rope cos", T * (m.headDim / 2) * 4),
+      sin: this._buf("rope sin", T * (m.headDim / 2) * 4),
+      stage: this.device.createBuffer({ label: "readback", size: H * 4, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST })
+    };
+    if (!this.P) {
+      this.b.kp0 = this._buf("prefix k (none)", 16);
+      this.b.vp0 = this._buf("prefix v (none)", 16);
+    }
+    this.ropeRows = 0;
+    this.ropeOffset = -1;
+  }
+  _bg(p, buffers, label) {
+    return this.device.createBindGroup({ label, layout: p.layout, entries: buffers.map((buffer, binding) => ({ binding, resource: { buffer } })) });
+  }
+  /** [prefix K, prefix V] buffers of block li for the attention bind group (dummies when the runtime uses no prefix). */
+  _prefixPair(li) {
+    if (!this.P) return [this.b.kp0, this.b.vp0];
+    const pk = this.c.prefixKV(li);
+    return [pk.k, pk.v];
+  }
+  _bindAll() {
+    const c = this.c, b = this.b, m = this.m;
+    const rotBG = (n, src, dst) => {
+      const r = c.rot(n);
+      return this._bg(this.pRot[n], [b.uni, src, r.signs, r.perms, dst], `rot${n}`);
+    };
+    this.blocks = [];
+    for (let li = 0; li < m.layers; li++) {
+      const lin = (nm) => c.linear(`blk.${li}.${nm}`);
+      const mm = (nm, src, dst, add) => {
+        const l = lin(nm);
+        const p = this._matmulPipeline(l, add);
+        return { p, bg: this._bg(p, [b.uni, src, l.codebook, l.idx, l.scale, dst], `blk.${li}.${nm}`), rows: l.rows };
+      };
+      const blk = {
+        attnNorm: this._bg(this.pRms, [b.uni, b.x, c.norm(`blk.${li}.attn_norm`), b.h], `blk.${li}.attn_norm`),
+        rot1024: rotBG(m.hidden, b.h, b.hr),
+        q: mm("q", b.hr, b.q, false),
+        k: mm("k", b.hr, b.k, false),
+        v: mm("v", b.hr, b.v, false),
+        qk: this._bg(this.pQk, [b.uni, b.q, b.k, c.norm(`blk.${li}.attn_q_norm`), c.norm(`blk.${li}.attn_k_norm`), b.cos, b.sin], `blk.${li}.qk`),
+        attn: this._bg(this.pAttn, [b.uni, b.q, b.k, b.v, b.attn, ...this._prefixPair(li)], `blk.${li}.attn`),
+        rot2048: rotBG(m.heads * m.headDim, b.attn, b.orot),
+        o: mm("o", b.orot, b.x, true),
+        ffnNorm: this._bg(this.pRms, [b.uni, b.x, c.norm(`blk.${li}.ffn_norm`), b.h], `blk.${li}.ffn_norm`),
+        gate: mm("gate", b.hr, b.g, false),
+        up: mm("up", b.hr, b.u, false),
+        swiglu: this._bg(this.pSwiglu, [b.uni, b.g, b.u, b.a], `blk.${li}.swiglu`),
+        rot3072: rotBG(m.intermediate, b.a, b.ar),
+        down: mm("down", b.ar, b.x, true),
+        li
+      };
+      this.blocks.push(blk);
+    }
+    this.outNorm = this._bg(this.pRms, [b.uni, b.x, c.norm("output_norm"), b.h], "output_norm");
+    this.pool = this._bg(this.pPool, [b.uni, b.h, b.emb], "pool");
+  }
+  _debugSetup() {
+    if (this.dbg) return;
+    const m = this.m, T = this.tmax, b = this.b;
+    const qn = this._buf("q_norm (debug)", T * m.heads * m.headDim * 4), kn = this._buf("k_norm (debug)", T * m.kvHeads * m.headDim * 4);
+    const probs = this._buf("attn_probs (debug)", m.heads * T * (this.P + T) * 4);
+    const pQkNorm = this._qkPipeline(false, false), pAttnP = this._attnPipeline(true);
+    this.dbg = { qn, kn, probs, pQkNorm, pAttnP, blocks: this.blocks.map((blk) => ({
+      qkNorm: this._bg(pQkNorm, [b.uni, b.q, b.k, this.c.norm(`blk.${blk.li}.attn_q_norm`), this.c.norm(`blk.${blk.li}.attn_k_norm`), b.cos, b.sin, qn, kn], `dbg qk ${blk.li}`),
+      attn: this._bg(pAttnP, [b.uni, b.q, b.k, b.v, b.attn, ...this._prefixPair(blk.li), probs], `dbg attn ${blk.li}`)
+    })) };
+  }
+  // ---------------------------------------------------------------------------------------------- per query
+  /** RoPE cos/sin rows 0..T-1 as f32, mimicking the reference's fp32 evaluation order (inv_freq, t*inv_freq, cos) with Math.fround. */
+  _ropeTable(T, offset = 0) {
+    if (T <= this.ropeRows && offset === this.ropeOffset) return;
+    const m = this.m, half = m.headDim / 2, fr = Math.fround;
+    const cos = new Float32Array(T * half), sin = new Float32Array(T * half);
+    const inv = new Float32Array(half);
+    for (let j = 0; j < half; j++) inv[j] = fr(1 / fr(Math.pow(m.ropeTheta, fr(2 * j / m.headDim))));
+    for (let t = 0; t < T; t++) for (let j = 0; j < half; j++) {
+      const a = fr((offset + t) * inv[j]);
+      cos[t * half + j] = Math.cos(a);
+      sin[t * half + j] = Math.sin(a);
+    }
+    this.device.queue.writeBuffer(this.b.cos, 0, cos);
+    this.device.queue.writeBuffer(this.b.sin, 0, sin);
+    this.ropeRows = T;
+    this.ropeOffset = offset;
+  }
+  /** M6: ids that start with the stored prefix are cut; returns {ids: query tokens, PP: prefix length used (0 = plain path)}. */
+  _splitPrefix(ids) {
+    const pre = this.prefixIds;
+    if (!pre || ids.length <= pre.length) return { ids, PP: 0 };
+    for (let i = 0; i < pre.length; i++) if (ids[i] !== pre[i]) return { ids, PP: 0 };
+    return { ids: ids.slice(pre.length), PP: pre.length };
+  }
+  /**
+   * Embed one token-id sequence (already re-tokenised onto the trimmed table).
+   * @returns {Promise<{embedding: Float32Array, ms: number, T: number, captures?: Map<string, {data: Float32Array, shape: number[]}>}>}
+   */
+  async embed(idsIn, { debug = false, profile = false } = {}) {
+    const t0 = performance.now();
+    const { ids, PP } = this._splitPrefix(idsIn);
+    const T = ids.length, m = this.m, b = this.b, dev = this.device;
+    if (T < 1 || T > this.tmax) throw new Error(`T=${T} outside 1..${this.tmax}`);
+    profile = profile && dev.features.has("timestamp-query");
+    const nDispatch = m.layers * (this.dispatchesPerBlock + (debug ? 2 : 0)) + 2;
+    const qset = profile ? dev.createQuerySet({ type: "timestamp", count: 2 * nDispatch }) : null;
+    const kinds = [];
+    const x0 = this.resid === "f16" ? this.c.tokens.lookupF16(ids) : this.c.tokens.lookup(ids);
+    dev.queue.writeBuffer(b.x, 0, x0);
+    this._ropeTable(T, PP);
+    dev.queue.writeBuffer(b.uni, 0, new Uint32Array([T, debug ? 1 : 0, PP, 0]));
+    if (debug) this._debugSetup();
+    const H = m.hidden, QD = m.heads * m.headDim, KD = m.kvHeads * m.headDim, I = m.intermediate;
+    const enc = dev.createCommandEncoder({ label: "query" });
+    const caps = [];
+    let pass = null;
+    const capture = (name, buffer, dtype, shape) => {
+      if (!debug) return;
+      const n = shape.reduce((p, q) => p * q, 1), bytes = n * (dtype === "f16" ? 2 : 4);
+      const stage = dev.createBuffer({ label: `capture ${name}`, size: Math.max(16, bytes + 3 & ~3), usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+      enc.copyBufferToBuffer(buffer, 0, stage, 0, bytes + 3 & ~3);
+      caps.push({ name, dtype, shape, bytes, stage });
+    };
+    const run = (p, bg, gx, gy = 1) => {
+      if (!pass) {
+        const i = kinds.length;
+        pass = enc.beginComputePass(profile ? { timestampWrites: { querySet: qset, beginningOfPassWriteIndex: 2 * i, endOfPassWriteIndex: 2 * i + 1 } } : {});
+      }
+      kinds.push(p.key.split("/")[0]);
+      pass.setPipeline(p.pipeline);
+      pass.setBindGroup(0, bg);
+      pass.dispatchWorkgroups(gx, gy);
+      if (debug || profile) {
+        pass.end();
+        pass = null;
+      }
+    };
+    const tokTile = this.tile.kernel === "v1" ? this.tile.lanes * this.tile.tpt : this.tile.tt;
+    const mm = (op) => run(op.p, op.bg, op.rows / this.tile.rwg, Math.ceil(T / tokTile));
+    const rT = this.resid === "f16" ? "f16" : "f32";
+    capture("embed", b.x, rT, [T, H]);
+    for (const blk of this.blocks) {
+      const pre = `blk.${blk.li}.`;
+      run(this.pRms, blk.attnNorm, T);
+      capture(pre + "attn_norm", b.h, "f32", [T, H]);
+      run(this.pRot[H], blk.rot1024, T);
+      capture(pre + "attn_rot", b.hr, "f16", [T, H]);
+      mm(blk.q);
+      capture(pre + "q", b.q, "f32", [T, QD]);
+      mm(blk.k);
+      capture(pre + "k", b.k, "f32", [T, KD]);
+      mm(blk.v);
+      capture(pre + "v", b.v, "f32", [T, KD]);
+      if (debug) {
+        run(this.dbg.pQkNorm, this.dbg.blocks[blk.li].qkNorm, T, m.heads + m.kvHeads);
+        capture(pre + "q_norm", this.dbg.qn, "f32", [T, m.heads, m.headDim]);
+        capture(pre + "k_norm", this.dbg.kn, "f32", [T, m.kvHeads, m.headDim]);
+      }
+      run(this.pQk, blk.qk, T, m.heads + m.kvHeads);
+      capture(pre + "q_rope", b.q, "f32", [T, m.heads, m.headDim]);
+      capture(pre + "k_rope", b.k, "f32", [T, m.kvHeads, m.headDim]);
+      if (debug) {
+        run(this.dbg.pAttnP, this.dbg.blocks[blk.li].attn, T, m.heads);
+        capture(pre + "attn_probs", this.dbg.probs, "f32", [m.heads, T, PP + T]);
+      } else run(this.pAttn, blk.attn, T, m.heads);
+      capture(pre + "attn_out", b.attn, "f32", [T, QD]);
+      run(this.pRot[QD], blk.rot2048, T);
+      capture(pre + "o_rot", b.orot, "f16", [T, QD]);
+      mm(blk.o);
+      capture(pre + "resid_attn", b.x, rT, [T, H]);
+      run(this.pRms, blk.ffnNorm, T);
+      capture(pre + "ffn_norm", b.h, "f32", [T, H]);
+      run(this.pRot[H], blk.rot1024, T);
+      capture(pre + "ffn_rot", b.hr, "f16", [T, H]);
+      mm(blk.gate);
+      capture(pre + "gate", b.g, "f32", [T, I]);
+      mm(blk.up);
+      capture(pre + "up", b.u, "f32", [T, I]);
+      run(this.pSwiglu, blk.swiglu, Math.ceil(T * I / 256));
+      capture(pre + "swiglu", b.a, "f32", [T, I]);
+      run(this.pRot[I], blk.rot3072, T);
+      capture(pre + "down_rot", b.ar, "f16", [T, I]);
+      mm(blk.down);
+      capture(pre + "resid_ffn", b.x, rT, [T, H]);
+    }
+    run(this.pRms, this.outNorm, T);
+    capture("output_norm", b.h, "f32", [T, H]);
+    run(this.pPool, this.pool, 1);
+    capture("embedding", b.emb, "f32", [H]);
+    if (pass) {
+      pass.end();
+      pass = null;
+    }
+    enc.copyBufferToBuffer(b.emb, 0, b.stage, 0, H * 4);
+    let qbuf = null, qstage = null;
+    if (profile) {
+      qbuf = dev.createBuffer({ label: "timestamps", size: 16 * nDispatch, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC });
+      qstage = dev.createBuffer({ label: "timestamps readback", size: 16 * nDispatch, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+      enc.resolveQuerySet(qset, 0, 2 * kinds.length, qbuf, 0);
+      enc.copyBufferToBuffer(qbuf, 0, qstage, 0, 16 * kinds.length);
+    }
+    dev.queue.submit([enc.finish()]);
+    await b.stage.mapAsync(GPUMapMode.READ);
+    const embedding = new Float32Array(b.stage.getMappedRange().slice(0));
+    b.stage.unmap();
+    const out = { embedding, T, PP, ms: performance.now() - t0, dispatches: kinds.length };
+    if (profile) {
+      await qstage.mapAsync(GPUMapMode.READ);
+      const ts = new BigUint64Array(qstage.getMappedRange().slice(0));
+      qstage.unmap();
+      qstage.destroy();
+      qbuf.destroy();
+      qset.destroy();
+      const byKind = {};
+      let total = 0;
+      kinds.forEach((k, i) => {
+        const ms = Number(ts[2 * i + 1] - ts[2 * i]) / 1e6;
+        byKind[k] = (byKind[k] || 0) + ms;
+        total += ms;
+      });
+      out.profile = { by_kind_ms: byKind, gpu_total_ms: total, span_ms: Number(ts[2 * kinds.length - 1] - ts[0]) / 1e6 };
+    }
+    if (debug) {
+      await Promise.all(caps.map((cp) => cp.stage.mapAsync(GPUMapMode.READ)));
+      out.captures = /* @__PURE__ */ new Map();
+      for (const cp of caps) {
+        const all = cp.stage.getMappedRange();
+        const data = cp.dtype === "f16" ? f16ArrayToF32(new Uint16Array(all, 0, cp.bytes / 2)) : new Float32Array(all.slice(0, cp.bytes));
+        out.captures.set(cp.name, { data, shape: cp.shape, dtype: cp.dtype });
+        cp.stage.unmap();
+        cp.stage.destroy();
+      }
+    }
+    return out;
+  }
+  destroy() {
+    for (const v of Object.values(this.b)) v.destroy();
+  }
+};
+
+// ../../client/vqweb/vendor/tokenizers/tokenizers.mjs
+var DictionarySplitter = class {
+  /**
+   * @param dictionary The dictionary of words to use for splitting.
+   */
+  constructor(dictionary) {
+    this.trie = this._build_trie(dictionary);
+  }
+  /**
+   * Builds a trie from the given dictionary.
+   * @param dictionary The dictionary of words to build the trie from.
+   * @returns The root node of the trie.
+   * @private
+   */
+  _build_trie(dictionary) {
+    const trie = /* @__PURE__ */ Object.create(null);
+    for (const word of dictionary) {
+      let node = trie;
+      for (let i = 0; i < word.length; ++i) {
+        const char = word[i];
+        node = node[char] ??= /* @__PURE__ */ Object.create(null);
+      }
+      node.end = word;
+    }
+    return trie;
+  }
+  /**
+   * Splits the input text into tokens based on the dictionary.
+   * @param text The input text to split.
+   * @returns An array of tokens.
+   */
+  split(text) {
+    const result = [];
+    const n = text.length;
+    let start = 0;
+    let i = 0;
+    while (i < n) {
+      let node = this.trie;
+      let match = null;
+      let j = i;
+      while (j < n && (node = node[text[j]])) {
+        if (node.end) {
+          match = node.end;
+        }
+        ++j;
+      }
+      if (match) {
+        if (i > start) {
+          result.push(text.slice(start, i));
+        }
+        result.push(match);
+        i += match.length;
+        start = i;
+      } else {
+        ++i;
+      }
+    }
+    if (start < n) {
+      result.push(text.slice(start));
+    }
+    return result;
+  }
+};
+var DictionarySplitter_default = DictionarySplitter;
+var AddedToken = class {
+  /**
+   * Creates a new instance of AddedToken.
+   * @param config Added token configuration object.
+   */
+  constructor(config) {
+    this.content = config.content;
+    this.id = config.id;
+    this.single_word = config.single_word ?? false;
+    this.lstrip = config.lstrip ?? false;
+    this.rstrip = config.rstrip ?? false;
+    this.special = config.special ?? false;
+    this.normalized = config.normalized ?? !this.special;
+  }
+};
+var AddedToken_default = AddedToken;
+var compile_unicode_regexp = (source, flags) => {
+  try {
+    return new RegExp(source, flags);
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    const property_names = /* @__PURE__ */ new Map();
+    const rewritten = source.replace(
+      /(\\[pP])\{([^}=]+)\}/g,
+      (text, p, n, offset) => {
+        let preceding_backslashes = 0;
+        for (let i = offset - 1; i >= 0 && source[i] === "\\"; --i) {
+          ++preceding_backslashes;
+        }
+        if (preceding_backslashes % 2 === 1) return text;
+        let property_name = property_names.get(n);
+        if (property_name === void 0) {
+          try {
+            new RegExp(`\\p{${n}}`, "u");
+            property_name = n;
+          } catch {
+            property_name = `Script=${n}`;
+          }
+          property_names.set(n, property_name);
+        }
+        return `${p}{${property_name}}`;
+      }
+    );
+    if (rewritten === source) throw error;
+    try {
+      return new RegExp(rewritten, flags);
+    } catch {
+      throw error;
+    }
+  }
+};
+var clean_up_tokenization = (text) => text.replace(/ \./g, ".").replace(/ \?/g, "?").replace(/ \!/g, "!").replace(/ ,/g, ",").replace(/ \' /g, "'").replace(/ n't/g, "n't").replace(/ 'm/g, "'m").replace(/ 's/g, "'s").replace(/ 've/g, "'ve").replace(/ 're/g, "'re");
+var create_pattern = (pattern, invert = true) => {
+  if (pattern.Regex !== void 0) {
+    const regex = rewrite_oniguruma_to_js(
+      normalize_bloom_split_char_class(pattern.Regex)
+    );
+    return compile_unicode_regexp(regex, "gu");
+  } else if (pattern.String !== void 0) {
+    const escaped = escape_reg_exp(pattern.String);
+    return new RegExp(invert ? escaped : `(${escaped})`, "gu");
+  } else {
+    console.warn("Unknown pattern type:", pattern);
+    return null;
+  }
+};
+var UNICODE_WORD_CHARS_IN_CLASS = "\\p{Alphabetic}\\p{M}\\p{Nd}\\p{Pc}";
+var UNICODE_WORD_CHARS = `${UNICODE_WORD_CHARS_IN_CLASS}\\u00B2\\u00B3\\u00B9\\u00BC-\\u00BE`;
+var UNICODE_WORD_CLASS = `[${UNICODE_WORD_CHARS}]`;
+var UNICODE_NON_WORD_CLASS = `[^${UNICODE_WORD_CHARS}]`;
+var UNICODE_WORD_BOUNDARY = `(?:(?<!${UNICODE_WORD_CLASS})(?=${UNICODE_WORD_CLASS})|(?<=${UNICODE_WORD_CLASS})(?!${UNICODE_WORD_CLASS}))`;
+var UNICODE_NON_WORD_BOUNDARY = `(?:(?<!${UNICODE_WORD_CLASS})(?!${UNICODE_WORD_CLASS})|(?<=${UNICODE_WORD_CLASS})(?=${UNICODE_WORD_CLASS}))`;
+var LINE_START_ANCHOR = "(?:(?<![\\s\\S])|(?<=\\n))";
+var LINE_END_ANCHOR = "(?:(?=\\n)|(?![\\s\\S]))";
+var HEX_DIGIT_CHARS = "0-9A-Fa-f";
+var ESCAPE_REWRITES = /* @__PURE__ */ new Map([
+  ["A", "(?<![\\s\\S])"],
+  ["z", "(?![\\s\\S])"],
+  ["Z", "(?=\\n?(?![\\s\\S]))"],
+  // \Z permits a single optional final \n (not \r\n)
+  ["h", `[${HEX_DIGIT_CHARS}]`],
+  ["H", `[^${HEX_DIGIT_CHARS}]`],
+  ["w", UNICODE_WORD_CLASS],
+  ["W", UNICODE_NON_WORD_CLASS],
+  ["d", "\\p{Nd}"],
+  ["D", "\\P{Nd}"],
+  ["s", "\\p{White_Space}"],
+  // JS \s wrongly adds U+FEFF and misses \x85
+  ["S", "\\P{White_Space}"],
+  ["b", UNICODE_WORD_BOUNDARY],
+  ["B", UNICODE_NON_WORD_BOUNDARY],
+  ["a", "\\x07"],
+  ["e", "\\x1B"]
+]);
+var CLASS_ESCAPE_REWRITES = /* @__PURE__ */ new Map([
+  ["h", HEX_DIGIT_CHARS],
+  ["w", UNICODE_WORD_CHARS_IN_CLASS],
+  ["d", "\\p{Nd}"],
+  ["D", "\\P{Nd}"],
+  ["s", "\\p{White_Space}"],
+  ["S", "\\P{White_Space}"],
+  ["a", "\\x07"],
+  ["e", "\\x1B"]
+]);
+var CLASS_COMPLEMENT_ALTERNATIVES = /* @__PURE__ */ new Map([
+  ["W", `[^${UNICODE_WORD_CHARS_IN_CLASS}]`],
+  ["H", `[^${HEX_DIGIT_CHARS}]`]
+]);
+var RAW_WHITESPACE_ESCAPES = /* @__PURE__ */ new Map([
+  ["\n", "\\n"],
+  ["\r", "\\r"],
+  ["	", "\\t"],
+  ["\f", "\\f"],
+  ["\v", "\\v"]
+]);
+var POSIX_CLASS_FRAGMENTS = /* @__PURE__ */ new Map([
+  ["alpha", "\\p{Alphabetic}"],
+  ["alnum", "\\p{Alphabetic}\\p{Nd}"],
+  ["digit", "\\p{Nd}"],
+  ["lower", "\\p{Lowercase}"],
+  ["upper", "\\p{Uppercase}"],
+  ["space", "\\p{White_Space}"],
+  ["blank", "\\t\\p{Zs}"],
+  ["punct", "\\p{P}\\p{S}"],
+  ["cntrl", "\\p{Cc}"],
+  ["word", UNICODE_WORD_CHARS_IN_CLASS],
+  ["xdigit", HEX_DIGIT_CHARS]
+]);
+var JS_SYNTAX_CHARS = "^$\\.*+?()[]{}|/";
+var GROUP_PREFIX_RE = /^\(\?(?:<[=!]|<[A-Za-z_][A-Za-z0-9_]*>|[:=!>])/;
+var BRACED_ESCAPE_RE = /^\\([pPxu])\{([^}]*)\}/;
+var QUANTIFIER_BRACE_RE = /^\{(\d+(?:,\d*)?|,\d+)\}/;
+var POSIX_BRACKET_RE = /^\[:(\^?)(\p{Alphabetic}+):\]/u;
+var EMPTY_NEGATED_POSIX_BRACKET_RE = /^\[:\^:\]/;
+var UNSUPPORTED_POSIX_BRACKET_RE = /^\[(?:\.[^\]]*\.\]|=[^\]]*=\])/;
+var FIXED_WIDTH_ESCAPE_RE = /^(?:\\x[0-9A-Fa-f]{2}|\\u[0-9A-Fa-f]{4}|\\c[A-Za-z])/;
+var is_ascii_letter = (char) => char >= "A" && char <= "Z" || char >= "a" && char <= "z";
+var character_at = (text, index) => String.fromCodePoint(text.codePointAt(index));
+var get_ascii_folded_hex_atom = (hex) => {
+  if (!/^[0-9A-Fa-f]{1,8}$/.test(hex)) return null;
+  const code_point = Number.parseInt(hex, 16);
+  if (code_point > 127) return null;
+  const letter = String.fromCharCode(code_point);
+  return is_ascii_letter(letter) ? `[${letter.toLowerCase()}${letter.toUpperCase()}]` : null;
+};
+var normalize_bloom_split_char_class = (regex) => regex.replace(/\[\^\(\\s\|\[([^\]]+)\]\)\]/g, "[^()|\\s$1]");
+var ANY_CODE_POINT = "[\\s\\S]";
+var MAX_CHARACTER_CLASS_NESTING_DEPTH = 256;
+var create_character_class_operand = () => ({
+  fragment: "",
+  alternatives: [],
+  tail: null,
+  contains_complex_set: false
+});
+var throw_character_class_range_error = (index) => {
+  throw new SyntaxError(
+    `Unsupported range with a set-valued character-class operand at index ${index}`
+  );
+};
+var add_character_class_atom = (operand, atom, index, contains_complex_set = true) => {
+  if (operand.tail === "range") throw_character_class_range_error(index);
+  operand.alternatives.push(atom);
+  operand.tail = "set";
+  operand.contains_complex_set = operand.contains_complex_set || contains_complex_set;
+};
+var append_character_class_fragment = (operand, fragment, set_valued = false, index = -1) => {
+  if (set_valued && operand.tail === "range") {
+    throw_character_class_range_error(index);
+  }
+  if (operand.tail === "range") {
+    operand.fragment += fragment;
+    operand.tail = "complete_range";
+    return;
+  }
+  operand.fragment += fragment;
+  operand.tail = set_valued ? "set" : "scalar";
+  operand.contains_complex_set = operand.contains_complex_set || set_valued;
+};
+var rewrite_character_class_escape = (regex, index, operand) => {
+  const braced = BRACED_ESCAPE_RE.exec(regex.slice(index));
+  if (braced) {
+    const [text, kind, body] = braced;
+    if (kind === "P" && body === "Word") {
+      add_character_class_atom(
+        operand,
+        `[^${UNICODE_WORD_CHARS_IN_CLASS}]`,
+        index
+      );
+    } else {
+      const replacement2 = kind === "x" ? `\\u{${body}}` : kind === "p" && body === "Word" ? UNICODE_WORD_CHARS_IN_CLASS : text;
+      append_character_class_fragment(
+        operand,
+        replacement2,
+        kind === "p" || kind === "P",
+        index
+      );
+    }
+    return index + text.length;
+  }
+  const fixed_width = FIXED_WIDTH_ESCAPE_RE.exec(regex.slice(index));
+  if (fixed_width) {
+    append_character_class_fragment(operand, fixed_width[0]);
+    return index + fixed_width[0].length;
+  }
+  if (index + 1 >= regex.length) {
+    throw new SyntaxError(
+      `Unterminated escape in character class at index ${index}`
+    );
+  }
+  const next = character_at(regex, index + 1);
+  const next_end = index + 1 + next.length;
+  const raw_whitespace = RAW_WHITESPACE_ESCAPES.get(next);
+  if (raw_whitespace !== void 0) {
+    append_character_class_fragment(operand, raw_whitespace);
+    return next_end;
+  }
+  const complement = CLASS_COMPLEMENT_ALTERNATIVES.get(next);
+  if (complement !== void 0) {
+    add_character_class_atom(operand, complement, index);
+    return next_end;
+  }
+  const rewrite = CLASS_ESCAPE_REWRITES.get(next);
+  let replacement;
+  let set_valued = false;
+  if (rewrite !== void 0) {
+    replacement = rewrite;
+    set_valued = next !== "a" && next !== "e";
+  } else if (/[A-Za-z0-9]/.test(next)) {
+    replacement = `\\${next}`;
+  } else if (JS_SYNTAX_CHARS.includes(next) || next === "-") {
+    replacement = `\\${next}`;
+  } else {
+    replacement = next;
+  }
+  append_character_class_fragment(operand, replacement, set_valued, index);
+  return next_end;
+};
+var compile_character_set_union = (pieces) => {
+  if (pieces.length === 1) return pieces[0];
+  return `(?:(?=(?:${pieces.join("|")}))${ANY_CODE_POINT})`;
+};
+var compile_character_class_operand = (operand) => {
+  const pieces = operand.fragment.length === 0 ? operand.alternatives : [`[${operand.fragment}]`, ...operand.alternatives];
+  return compile_character_set_union(pieces);
+};
+var get_ascii_fold_additions = (positive_atom) => {
+  const membership = compile_unicode_regexp(`^(?:${positive_atom})$`, "u");
+  let additions = "";
+  for (let offset = 0; offset < 26; ++offset) {
+    const upper = String.fromCharCode(65 + offset);
+    const lower = String.fromCharCode(97 + offset);
+    const has_upper = membership.test(upper);
+    const has_lower = membership.test(lower);
+    if (has_upper !== has_lower) additions += has_upper ? lower : upper;
+  }
+  return additions;
+};
+var parse_character_class = (regex, start, ascii_fold, apply_ascii_fold = true, nesting_depth = 1) => {
+  if (nesting_depth > MAX_CHARACTER_CLASS_NESTING_DEPTH) {
+    throw new SyntaxError(
+      `Maximum character-class nesting depth of ${MAX_CHARACTER_CLASS_NESTING_DEPTH} exceeded at index ${start}`
+    );
+  }
+  let i = start + 1;
+  const negated = regex[i] === "^";
+  if (negated) ++i;
+  const first_content_index = i;
+  const operands = [create_character_class_operand()];
+  let operand = operands[0];
+  let contains_nested_negated_complex_set = false;
+  while (i < regex.length) {
+    const char = character_at(regex, i);
+    if (char === "\\") {
+      i = rewrite_character_class_escape(regex, i, operand);
+      continue;
+    }
+    if (char === "]") {
+      if (i === first_content_index) {
+        append_character_class_fragment(operand, "\\]");
+        ++i;
+        continue;
+      }
+      if (operand.tail === null) {
+        if (operands.length > 1) {
+          throw new SyntaxError(
+            `Malformed character-class intersection with an empty operand at index ${i}`
+          );
+        }
+        throw new SyntaxError(`Empty character class at index ${start}`);
+      }
+      const contains_complex_set = operands.some(
+        (candidate) => candidate.contains_complex_set
+      );
+      if (negated && operands.length > 1 && contains_nested_negated_complex_set) {
+        throw new SyntaxError(
+          `Unsupported outer-negated character-class intersection with a nested negated class containing a Unicode property, POSIX class, or shorthand at index ${start}`
+        );
+      }
+      const first_atom = compile_character_class_operand(operands[0]);
+      let positive_atom = first_atom;
+      if (operands.length > 1) {
+        let lookaheads = "";
+        for (let j = 1; j < operands.length; ++j) {
+          lookaheads += `(?=${compile_character_class_operand(operands[j])})`;
+        }
+        positive_atom = `(?:${lookaheads}${first_atom})`;
+      }
+      const is_direct_class = operands.length === 1 && operand.alternatives.length === 0;
+      let direct_fragment = operand.fragment;
+      if (ascii_fold && apply_ascii_fold) {
+        const additions = get_ascii_fold_additions(positive_atom);
+        if (additions.length > 0) {
+          if (is_direct_class) {
+            direct_fragment += additions;
+            positive_atom = `[${direct_fragment}]`;
+          } else {
+            positive_atom = compile_character_set_union([
+              positive_atom,
+              `[${additions}]`
+            ]);
+          }
+        }
+      }
+      const atom = negated ? is_direct_class ? `[^${direct_fragment}]` : `(?:(?!${positive_atom})${ANY_CODE_POINT})` : positive_atom;
+      return {
+        atom,
+        end: i + 1,
+        negated,
+        contains_complex_set,
+        contains_nested_negated_complex_set
+      };
+    }
+    if (regex.startsWith("&&", i)) {
+      if (operand.tail === null) {
+        throw new SyntaxError(
+          `Malformed character-class intersection with an empty operand at index ${i}`
+        );
+      }
+      operand = create_character_class_operand();
+      operands.push(operand);
+      i += 2;
+      continue;
+    }
+    if (char === "[") {
+      const suffix = regex.slice(i);
+      if (EMPTY_NEGATED_POSIX_BRACKET_RE.test(suffix)) {
+        throw new SyntaxError(
+          `Malformed empty negated POSIX character class at index ${i}`
+        );
+      }
+      const posix = POSIX_BRACKET_RE.exec(suffix);
+      if (posix) {
+        const [, posix_negated, name] = posix;
+        const fragment = POSIX_CLASS_FRAGMENTS.get(name);
+        if (fragment === void 0) {
+          throw new SyntaxError(
+            `Unsupported POSIX character class "${name}" at index ${i}`
+          );
+        }
+        if (ascii_fold && posix_negated && (name === "lower" || name === "upper")) {
+          throw new SyntaxError(
+            `Unsupported negated POSIX ${name} class inside an inline case-insensitive group`
+          );
+        }
+        if (posix_negated) {
+          add_character_class_atom(operand, `[^${fragment}]`, i);
+        } else {
+          append_character_class_fragment(operand, fragment, true, i);
+        }
+        i += posix[0].length;
+        continue;
+      }
+      if (UNSUPPORTED_POSIX_BRACKET_RE.test(suffix)) {
+        throw new SyntaxError(
+          `Unsupported POSIX collating or equivalence bracket expression at index ${i}`
+        );
+      }
+      const nested = parse_character_class(
+        regex,
+        i,
+        ascii_fold,
+        false,
+        nesting_depth + 1
+      );
+      add_character_class_atom(
+        operand,
+        nested.atom,
+        i,
+        nested.contains_complex_set
+      );
+      contains_nested_negated_complex_set ||= nested.contains_nested_negated_complex_set || nested.negated && nested.contains_complex_set;
+      i = nested.end;
+      continue;
+    }
+    if (char === "-") {
+      const is_terminal_literal = regex[i + 1] === "]" || regex.startsWith("&&", i + 1);
+      if (operand.tail === "set" && !is_terminal_literal) {
+        throw_character_class_range_error(i);
+      }
+      if (operand.tail === null || operand.tail === "range" || operand.tail === "complete_range" || is_terminal_literal) {
+        append_character_class_fragment(operand, "\\-");
+      } else {
+        operand.fragment += "-";
+        operand.tail = "range";
+      }
+      ++i;
+      continue;
+    }
+    append_character_class_fragment(
+      operand,
+      char === "^" && operand.fragment.length === 0 ? "\\^" : char
+    );
+    i += char.length;
+  }
+  throw new SyntaxError(
+    `${operands.length > 1 ? "Unterminated character-class intersection" : "Unterminated character class"} at index ${start}`
+  );
+};
+var rewrite_oniguruma_to_js = (regex) => {
+  let out = "";
+  let atom_start = -1;
+  let last_was_quantifier = false;
+  let ascii_fold = false;
+  const group_states = [];
+  const emit_atom = (text) => {
+    atom_start = out.length;
+    out += text;
+    last_was_quantifier = false;
+  };
+  for (let i = 0; i < regex.length; ) {
+    const char = character_at(regex, i);
+    if (char === "\\") {
+      const braced = BRACED_ESCAPE_RE.exec(regex.slice(i));
+      if (braced) {
+        const [text, kind, body] = braced;
+        let replacement2 = text;
+        if (kind === "x") {
+          const code_point_escape = `\\u{${body}}`;
+          replacement2 = ascii_fold ? get_ascii_folded_hex_atom(body) ?? code_point_escape : code_point_escape;
+        } else if (body === "Word") {
+          replacement2 = kind === "p" ? UNICODE_WORD_CLASS : UNICODE_NON_WORD_CLASS;
+        }
+        emit_atom(replacement2);
+        i += text.length;
+        continue;
+      }
+      const fixed_width = FIXED_WIDTH_ESCAPE_RE.exec(regex.slice(i));
+      if (fixed_width) {
+        const text = fixed_width[0];
+        const replacement2 = ascii_fold && text[1] !== "c" ? get_ascii_folded_hex_atom(text.slice(2)) ?? text : text;
+        emit_atom(replacement2);
+        i += text.length;
+        continue;
+      }
+      if (i + 1 >= regex.length) {
+        out += char;
+        break;
+      }
+      const next = character_at(regex, i + 1);
+      i += 1 + next.length;
+      if (next === "G") {
+        continue;
+      }
+      const raw_whitespace = RAW_WHITESPACE_ESCAPES.get(next);
+      if (raw_whitespace !== void 0) {
+        emit_atom(raw_whitespace);
+        continue;
+      }
+      const rewrite = ESCAPE_REWRITES.get(next);
+      let replacement;
+      if (rewrite !== void 0) {
+        replacement = rewrite;
+      } else if (/[A-Za-z0-9]/.test(next)) {
+        replacement = `\\${next}`;
+      } else if (JS_SYNTAX_CHARS.includes(next)) {
+        replacement = `\\${next}`;
+      } else {
+        replacement = next;
+      }
+      emit_atom(replacement);
+      continue;
+    }
+    switch (char) {
+      case "[": {
+        const parsed = parse_character_class(regex, i, ascii_fold);
+        emit_atom(parsed.atom);
+        i = parsed.end;
+        continue;
+      }
+      case "]":
+        emit_atom("\\]");
+        ++i;
+        continue;
+      case ".":
+        emit_atom("[^\\n]");
+        ++i;
+        continue;
+      case "^":
+        emit_atom(LINE_START_ANCHOR);
+        ++i;
+        continue;
+      case "$":
+        emit_atom(LINE_END_ANCHOR);
+        ++i;
+        continue;
+      case "(": {
+        const inline_case_insensitive = regex.startsWith("(?i:", i);
+        const source_prefix = inline_case_insensitive ? "(?i:" : GROUP_PREFIX_RE.exec(regex.slice(i))?.[0] ?? "(";
+        const output_prefix = inline_case_insensitive ? "(?:" : source_prefix === "(?>" ? "(?:" : source_prefix;
+        group_states.push([out.length, ascii_fold]);
+        if (inline_case_insensitive) ascii_fold = true;
+        out += output_prefix;
+        last_was_quantifier = false;
+        i += source_prefix.length;
+        continue;
+      }
+      case ")":
+        out += char;
+        [atom_start, ascii_fold] = group_states.pop() ?? [-1, false];
+        last_was_quantifier = false;
+        ++i;
+        continue;
+      case "|":
+        out += char;
+        atom_start = -1;
+        last_was_quantifier = false;
+        ++i;
+        continue;
+      case "{": {
+        const quant = QUANTIFIER_BRACE_RE.exec(regex.slice(i));
+        if (!quant || atom_start < 0) {
+          emit_atom("\\{");
+          ++i;
+          continue;
+        }
+        const body = quant[1].startsWith(",") ? `0${quant[1]}` : quant[1];
+        i += quant[0].length;
+        const following = regex[i];
+        if (following === "+" || following === "*") {
+          out = `${out.slice(0, atom_start)}(?:${out.slice(atom_start)}{${body}})${following}`;
+          ++i;
+        } else {
+          out += `{${body}}`;
+        }
+        last_was_quantifier = true;
+        continue;
+      }
+      case "}":
+        emit_atom("\\}");
+        ++i;
+        continue;
+      case "+":
+        if (last_was_quantifier) {
+          ++i;
+          continue;
+        }
+        out += char;
+        last_was_quantifier = true;
+        ++i;
+        continue;
+      case "*":
+      case "?":
+        out += char;
+        last_was_quantifier = true;
+        ++i;
+        continue;
+      default:
+        emit_atom(
+          ascii_fold && is_ascii_letter(char) ? `[${char.toLowerCase()}${char.toUpperCase()}]` : char
+        );
+        i += char.length;
+        continue;
+    }
+  }
+  return out;
+};
+var escape_reg_exp = (string) => string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var fuse_unk = (arr, tokens_to_ids, unk_token_id) => {
+  const fused = [];
+  let i = 0;
+  while (i < arr.length) {
+    fused.push(arr[i]);
+    const token_id = tokens_to_ids.get(arr[i]) ?? unk_token_id;
+    if (token_id !== unk_token_id) {
+      ++i;
+      continue;
+    }
+    while (++i < arr.length && (tokens_to_ids.get(arr[i]) ?? unk_token_id) === unk_token_id) {
+      if (tokens_to_ids.get(fused.at(-1)) !== unk_token_id) {
+        fused[fused.length - 1] += arr[i];
+      }
+    }
+  }
+  return fused;
+};
+var is_chinese_char = (cp) => cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 131072 && cp <= 173791 || cp >= 173824 && cp <= 177983 || cp >= 177984 && cp <= 178207 || cp >= 178208 && cp <= 183983 || cp >= 63744 && cp <= 64255 || cp >= 194560 && cp <= 195103;
+var is_integral_number = (x) => Number.isInteger(x) || typeof x === "bigint";
+var len = (s) => {
+  let length = 0;
+  for (const c of s) ++length;
+  return length;
+};
+var lowercase_and_remove_accents = (text) => remove_accents(text.toLowerCase());
+var merge_arrays = (...arrs) => Array.prototype.concat.apply([], arrs);
+var object_to_map = (obj) => new Map(Object.entries(obj));
+var regex_split = (text, regex) => {
+  const result = [];
+  let prev = 0;
+  for (const match of text.matchAll(regex)) {
+    const full_match = match[0];
+    if (prev < match.index) {
+      result.push(text.slice(prev, match.index));
+    }
+    if (full_match.length > 0) {
+      result.push(full_match);
+    }
+    prev = match.index + full_match.length;
+  }
+  if (prev < text.length) {
+    result.push(text.slice(prev));
+  }
+  return result;
+};
+var remove_accents = (text) => text.replace(/\p{M}/gu, "");
+var validate_object = (obj, name, required_keys = []) => {
+  if (!obj || Array.isArray(obj) || typeof obj !== "object") {
+    return `${name} must be a valid object`;
+  }
+  for (const key of required_keys) {
+    if (!(key in obj)) {
+      return `${name} must contain a "${key}" property`;
+    }
+  }
+  return null;
+};
+var whitespace_split = (text) => text.match(/\S+/g) || [];
+var Callable = class {
+  /**
+   * Creates a new instance of the Callable class.
+   */
+  constructor() {
+    const closure = function(...args) {
+      return closure._call(...args);
+    };
+    return Object.setPrototypeOf(closure, new.target.prototype);
+  }
+};
+var Callable_default = Callable;
+var Normalizer = class extends Callable_default {
+  /**
+   * @param config The configuration object for the normalizer.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  /**
+   * Alias for {@link Normalizer#normalize}.
+   * @param text The text to normalize.
+   * @returns The normalized text.
+   */
+  _call(text) {
+    return this.normalize(text);
+  }
+};
+var Normalizer_default = Normalizer;
+var BertNormalizer = class extends Normalizer_default {
+  /**
+   * Adds whitespace around any CJK (Chinese, Japanese, or Korean) character in the input text.
+   *
+   * @param text The input text to tokenize.
+   * @returns The tokenized text with whitespace added around CJK characters.
+   */
+  tokenize_chinese_chars(text) {
+    const output = [];
+    for (let i = 0; i < text.length; ++i) {
+      const char = text[i];
+      const cp = char.charCodeAt(0);
+      if (is_chinese_char(cp)) {
+        output.push(" ");
+        output.push(char);
+        output.push(" ");
+      } else {
+        output.push(char);
+      }
+    }
+    return output.join("");
+  }
+  /**
+   * Strips accents from the given text.
+   * @param text The text to strip accents from.
+   * @returns The text with accents removed.
+   */
+  strip_accents(text) {
+    return text.normalize("NFD").replace(/\p{Mn}/gu, "");
+  }
+  /**
+   * Checks whether `char` is a control character.
+   * @param char The character to check.
+   * @returns Whether `char` is a control character.
+   */
+  is_control(char) {
+    switch (char) {
+      case "	":
+      case "\n":
+      case "\r":
+        return false;
+      default:
+        return /^\p{Cc}|\p{Cf}|\p{Co}|\p{Cs}$/u.test(char);
+    }
+  }
+  /**
+   * Performs invalid character removal and whitespace cleanup on text.
+   * @param text The text to clean.
+   * @returns The cleaned text.
+   */
+  clean_text(text) {
+    const output = [];
+    for (const char of text) {
+      const cp = char.charCodeAt(0);
+      if (cp === 0 || cp === 65533 || this.is_control(char)) {
+        continue;
+      }
+      if (/^\s$/.test(char)) {
+        output.push(" ");
+      } else {
+        output.push(char);
+      }
+    }
+    return output.join("");
+  }
+  /**
+   * Normalizes the given text based on the configuration.
+   * @param text The text to normalize.
+   * @returns The normalized text.
+   */
+  normalize(text) {
+    if (this.config.clean_text) {
+      text = this.clean_text(text);
+    }
+    if (this.config.handle_chinese_chars) {
+      text = this.tokenize_chinese_chars(text);
+    }
+    if (this.config.lowercase) {
+      text = text.toLowerCase();
+      if (this.config.strip_accents !== false) {
+        text = this.strip_accents(text);
+      }
+    } else if (this.config.strip_accents) {
+      text = this.strip_accents(text);
+    }
+    return text;
+  }
+};
+var BertNormalizer_default = BertNormalizer;
+var Precompiled = class extends Normalizer_default {
+  /**
+   * Create a new instance of Precompiled normalizer.
+   * @param config The configuration object.
+   */
+  constructor(config) {
+    super(config);
+    this.charsmap = config.precompiled_charsmap ?? null;
+  }
+  /**
+   * Normalizes the given text by applying the precompiled charsmap.
+   * @param text The text to normalize.
+   * @returns The normalized text.
+   */
+  normalize(text) {
+    text = text.replace(
+      /[\u0001-\u0008\u000B\u000E-\u001F\u007F\u008F\u009F]/gm,
+      ""
+    );
+    text = text.replace(
+      /[\u0009\u000A\u000C\u000D\u00A0\u1680\u2000-\u200F\u2028\u2029\u202F\u205F\u2581\u3000\uFEFF\uFFFD]/gm,
+      " "
+    );
+    if (text.includes("\uFF5E")) {
+      const parts = text.split("\uFF5E");
+      text = parts.map((part) => part.normalize("NFKC")).join("\uFF5E");
+    } else {
+      text = text.normalize("NFKC");
+    }
+    return text;
+  }
+};
+var Precompiled_default = Precompiled;
+var Sequence = class extends Normalizer_default {
+  /**
+   * Create a new instance of NormalizerSequence.
+   * @param config The configuration object.
+   */
+  constructor(config) {
+    super(config);
+    this.normalizers = (config.normalizers ?? []).map(
+      (x) => create_normalizer_default(x)
+    );
+  }
+  /**
+   * Apply a sequence of Normalizers to the input text.
+   * @param text The text to normalize.
+   * @returns The normalized text.
+   */
+  normalize(text) {
+    return this.normalizers.reduce((t, normalizer) => {
+      return normalizer ? normalizer.normalize(t) : t;
+    }, text);
+  }
+};
+var Sequence_default = Sequence;
+var Replace = class extends Normalizer_default {
+  /**
+   * @param config The configuration object for the normalizer.
+   */
+  constructor(config) {
+    super(config);
+    this.pattern = create_pattern(this.config.pattern ?? {});
+  }
+  /**
+   * Normalize the input text by replacing the pattern with the content.
+   * @param text The input text to be normalized.
+   * @returns The normalized text after replacing the pattern with the content.
+   */
+  normalize(text) {
+    return this.pattern === null ? text : text.replaceAll(this.pattern, this.config.content ?? "");
+  }
+};
+var Replace_default = Replace;
+var UnicodeNormalizer = class extends Normalizer_default {
+  constructor() {
+    super(...arguments);
+    this.form = "NFC";
+  }
+  /**
+   * Normalize the input text by applying Unicode normalization.
+   * @param text The input text to be normalized.
+   * @returns The normalized text.
+   */
+  normalize(text) {
+    text = text.normalize(this.form);
+    return text;
+  }
+};
+var UnicodeNormalizer_default = UnicodeNormalizer;
+var NFC = class extends UnicodeNormalizer_default {
+  constructor() {
+    super(...arguments);
+    this.form = "NFC";
+  }
+};
+var NFC_default = NFC;
+var NFD = class extends UnicodeNormalizer_default {
+  constructor() {
+    super(...arguments);
+    this.form = "NFD";
+  }
+};
+var NFD_default = NFD;
+var NFKC = class extends UnicodeNormalizer_default {
+  constructor() {
+    super(...arguments);
+    this.form = "NFKC";
+  }
+};
+var NFKC_default = NFKC;
+var NFKD = class extends UnicodeNormalizer_default {
+  constructor() {
+    super(...arguments);
+    this.form = "NFKD";
+  }
+};
+var NFKD_default = NFKD;
+var Strip = class extends Normalizer_default {
+  /**
+   * Strip leading and/or trailing whitespace from the input text.
+   * @param text The input text.
+   * @returns The normalized text.
+   */
+  normalize(text) {
+    if (this.config.strip_left && this.config.strip_right) {
+      text = text.trim();
+    } else {
+      if (this.config.strip_left) {
+        text = text.trimStart();
+      }
+      if (this.config.strip_right) {
+        text = text.trimEnd();
+      }
+    }
+    return text;
+  }
+};
+var Strip_default = Strip;
+var StripAccents = class extends Normalizer_default {
+  /**
+   * Remove all accents from the text.
+   * @param text The input text.
+   * @returns The normalized text without accents.
+   */
+  normalize(text) {
+    return remove_accents(text);
+  }
+};
+var StripAccents_default = StripAccents;
+var Lowercase = class extends Normalizer_default {
+  /**
+   * Lowercases the input string.
+   * @param {string} text The text to normalize.
+   * @returns {string} The normalized text.
+   */
+  normalize(text) {
+    return text.toLowerCase();
+  }
+};
+var Lowercase_default = Lowercase;
+var Prepend = class extends Normalizer_default {
+  /**
+   * Prepends the input string.
+   * @param text The text to normalize.
+   * @returns The normalized text.
+   */
+  normalize(text) {
+    text = this.config.prepend + text;
+    return text;
+  }
+};
+var Prepend_default = Prepend;
+function create_normalizer(config) {
+  if (config === null) return null;
+  switch (config.type) {
+    case "BertNormalizer":
+      return new BertNormalizer_default(config);
+    case "Precompiled":
+      return new Precompiled_default(config);
+    case "Sequence":
+      return new Sequence_default(config);
+    case "Replace":
+      return new Replace_default(config);
+    case "NFC":
+      return new NFC_default(config);
+    case "NFD":
+      return new NFD_default(config);
+    case "NFKC":
+      return new NFKC_default(config);
+    case "NFKD":
+      return new NFKD_default(config);
+    case "Strip":
+      return new Strip_default(config);
+    case "StripAccents":
+      return new StripAccents_default(config);
+    case "Lowercase":
+      return new Lowercase_default(config);
+    case "Prepend":
+      return new Prepend_default(config);
+    default:
+      throw new Error(`Unknown Normalizer type: ${config.type}`);
+  }
+}
+var create_normalizer_default = create_normalizer;
+var PreTokenizer = class extends Callable_default {
+  /**
+   * Tokenizes the given text into pre-tokens.
+   * @param text The text or array of texts to pre-tokenize.
+   * @param options Additional options for the pre-tokenization logic.
+   * @returns An array of pre-tokens.
+   */
+  pre_tokenize(text, options) {
+    return (Array.isArray(text) ? text.map((x) => this.pre_tokenize_text(x, options)) : this.pre_tokenize_text(text, options)).flat();
+  }
+  /**
+   * Alias for {@link PreTokenizer#pre_tokenize}.
+   * @param text The text or array of texts to pre-tokenize.
+   * @param options Additional options for the pre-tokenization logic.
+   * @returns An array of pre-tokens.
+   */
+  _call(text, options) {
+    return this.pre_tokenize(text, options);
+  }
+};
+var PreTokenizer_default = PreTokenizer;
+var BYTES_TO_UNICODE = (() => {
+  const bs = [
+    ...Array.from(
+      { length: "~".charCodeAt(0) - "!".charCodeAt(0) + 1 },
+      (_, i) => i + "!".charCodeAt(0)
+    ),
+    ...Array.from(
+      { length: "\xAC".charCodeAt(0) - "\xA1".charCodeAt(0) + 1 },
+      (_, i) => i + "\xA1".charCodeAt(0)
+    ),
+    ...Array.from(
+      { length: "\xFF".charCodeAt(0) - "\xAE".charCodeAt(0) + 1 },
+      (_, i) => i + "\xAE".charCodeAt(0)
+    )
+  ];
+  const cs = bs.slice();
+  let n = 0;
+  for (let b = 0; b < 256; ++b) {
+    if (!bs.includes(b)) {
+      bs.push(b);
+      cs.push(256 + n);
+      n += 1;
+    }
+  }
+  const ccs = cs.map((n2) => String.fromCharCode(n2));
+  return Object.fromEntries(bs.map((b, i) => [b, ccs[i]]));
+})();
+var reverse_dictionary = (data) => Object.fromEntries(Object.entries(data).map(([key, value]) => [value, key]));
+var UNICODE_TO_BYTES = reverse_dictionary(BYTES_TO_UNICODE);
+var PUNCTUATION_REGEX = "\\p{P}\\u0021-\\u002F\\u003A-\\u0040\\u005B-\\u0060\\u007B-\\u007E";
+var ByteLevel = class extends PreTokenizer_default {
+  /**
+   * Creates a new instance of the `ByteLevelPreTokenizer` class.
+   * @param config The configuration object.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+    this.add_prefix_space = this.config.add_prefix_space ?? false;
+    this.trim_offsets = this.config.trim_offsets ?? false;
+    this.use_regex = this.config.use_regex ?? true;
+    this.pattern = /'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+/gu;
+    this.byte_encoder = BYTES_TO_UNICODE;
+    this.text_encoder = new TextEncoder();
+  }
+  /**
+   * Tokenizes a single piece of text using byte-level tokenization.
+   * @param text The text to tokenize.
+   * @param options Additional options for the pre-tokenization logic.
+   * @returns An array of tokens.
+   */
+  pre_tokenize_text(text, options) {
+    if (this.add_prefix_space && !text.startsWith(" ")) {
+      text = " " + text;
+    }
+    const tokens = this.use_regex ? text.match(this.pattern) || [] : [text];
+    return tokens.map(
+      (token) => Array.from(
+        this.text_encoder.encode(token),
+        (byte) => this.byte_encoder[byte]
+      ).join("")
+    );
+  }
+};
+var ByteLevel_default = ByteLevel;
+var Whitespace = class extends PreTokenizer_default {
+  /**
+   * Pre-tokenizes the input text by splitting it on word boundaries.
+   * @param text The text to be pre-tokenized.
+   * @param options Additional options for the pre-tokenization logic.
+   * @returns An array of tokens produced by splitting the input text on whitespace.
+   */
+  pre_tokenize_text(text, options) {
+    return text.match(/\w+|[^\w\s]+/g) || [];
+  }
+};
+var Whitespace_default = Whitespace;
+var Metaspace = class extends PreTokenizer_default {
+  /**
+   * @param config The configuration object for the MetaspacePreTokenizer.
+   */
+  constructor(config) {
+    super();
+    this.replacement = config.replacement ?? "\u2581";
+    this.str_rep = config.str_rep || this.replacement;
+    this.prepend_scheme = config.prepend_scheme ?? "always";
+  }
+  /**
+   * This method takes a string, replaces spaces with the replacement character,
+   * adds a prefix space if requested, and returns a new list of tokens.
+   * @param text The text to pre-tokenize.
+   * @param options The options for the pre-tokenization.
+   * @returns A new list of pre-tokenized tokens.
+   */
+  pre_tokenize_text(text, options) {
+    const { section_index = void 0 } = options ?? {};
+    let normalized = text.replaceAll(" ", this.str_rep);
+    if (
+      // We add a prefix space if:
+      //  (1) The normalized token does not already start with the replacement character.
+      !normalized.startsWith(this.replacement) && // and (2) either:
+      //  (a) prepend_scheme is 'always'
+      //  (b) prepend_scheme is 'first' and this is the first section
+      (this.prepend_scheme === "always" || this.prepend_scheme === "first" && section_index === 0)
+    ) {
+      normalized = this.str_rep + normalized;
+    }
+    return [normalized];
+  }
+};
+var Metaspace_default = Metaspace;
+var Split = class extends PreTokenizer_default {
+  /**
+   * @param config The configuration options for the pre-tokenizer.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+    this.pattern = create_pattern(
+      this.config.pattern ?? {},
+      this.config.invert ?? true
+    );
+  }
+  /**
+   * Tokenizes text by splitting it using the given pattern.
+   * @param text The text to tokenize.
+   * @returns An array of tokens.
+   */
+  pre_tokenize_text(text) {
+    if (this.pattern === null) {
+      return [];
+    }
+    if (this.config.invert) {
+      return (text.match(this.pattern) || []).filter((x) => x);
+    } else if (this.config.behavior?.toLowerCase() === "removed") {
+      return text.split(this.pattern).filter((x) => x);
+    } else {
+      return regex_split(text, this.pattern);
+    }
+  }
+};
+var Split_default = Split;
+var Punctuation = class extends PreTokenizer_default {
+  /**
+   * @param config The configuration options for the pre-tokenizer.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+    this.pattern = new RegExp(
+      `[^${PUNCTUATION_REGEX}]+|[${PUNCTUATION_REGEX}]+`,
+      "gu"
+    );
+  }
+  /**
+   * Tokenizes text by splitting it using the given pattern.
+   * @param text The text to tokenize.
+   * @returns An array of tokens.
+   */
+  pre_tokenize_text(text) {
+    return text.match(this.pattern) || [];
+  }
+};
+var Punctuation_default = Punctuation;
+var Digits = class extends PreTokenizer_default {
+  /**
+   * @param config The configuration options for the pre-tokenizer.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+    const digit_pattern = `[^\\d]+|\\d${this.config.individual_digits ? "" : "+"}`;
+    this.pattern = new RegExp(digit_pattern, "gu");
+  }
+  /**
+   * Tokenizes text by splitting it using the given pattern.
+   * @param text The text to tokenize.
+   * @returns An array of tokens.
+   */
+  pre_tokenize_text(text) {
+    return text.match(this.pattern) || [];
+  }
+};
+var Digits_default = Digits;
+var BertPreTokenizer = class extends PreTokenizer_default {
+  /**
+   * A PreTokenizer that splits text into wordpieces using a basic tokenization scheme
+   * similar to that used in the original implementation of BERT.
+   */
+  constructor() {
+    super();
+    this.pattern = new RegExp(
+      `[^\\s${PUNCTUATION_REGEX}]+|[${PUNCTUATION_REGEX}]`,
+      "gu"
+    );
+  }
+  /**
+   * Tokenizes a single text using the BERT pre-tokenization scheme.
+   *
+   * @param text The text to tokenize.
+   * @param options Additional options for the pre-tokenization logic.
+   * @returns An array of tokens.
+   */
+  pre_tokenize_text(text, options) {
+    return text.trim().match(this.pattern) || [];
+  }
+};
+var BertPreTokenizer_default = BertPreTokenizer;
+var Replace2 = class extends PreTokenizer_default {
+  /**
+   * @param config The configuration options for the pre-tokenizer.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+    this.pattern = create_pattern(this.config.pattern ?? {});
+    this.content = this.config.content ?? "";
+  }
+  /**
+   * Pre-tokenizes the input text by replacing certain characters.
+   * @param text The text to be pre-tokenized.
+   * @returns An array of tokens produced by replacing certain characters.
+   */
+  pre_tokenize_text(text) {
+    if (this.pattern === null) {
+      return [text];
+    }
+    return [text.replaceAll(this.pattern, this.config.content ?? "")];
+  }
+};
+var Replace_default2 = Replace2;
+var Sequence2 = class extends PreTokenizer_default {
+  /**
+   * Creates an instance of PreTokenizerSequence.
+   * @param config The configuration object for the pre-tokenizer sequence.
+   */
+  constructor(config) {
+    super();
+    this.tokenizers = (config.pretokenizers ?? []).map(
+      (x) => create_pre_tokenizer_default(x)
+    );
+  }
+  /**
+   * Applies each pre-tokenizer in the sequence to the input text in turn.
+   * @param text The text to pre-tokenize.
+   * @param options Additional options for the pre-tokenization logic.
+   * @returns The pre-tokenized text.
+   */
+  pre_tokenize_text(text, options) {
+    return this.tokenizers.reduce(
+      (pre_tokenized_text, tokenizer) => {
+        return tokenizer ? tokenizer.pre_tokenize(pre_tokenized_text, options) : pre_tokenized_text;
+      },
+      [text]
+    );
+  }
+};
+var Sequence_default2 = Sequence2;
+var WhitespaceSplit = class extends PreTokenizer_default {
+  /**
+   * Pre-tokenizes the input text by splitting it on whitespace characters.
+   * @param text The text to be pre-tokenized.
+   * @returns An array of tokens produced by splitting the input text on whitespace.
+   */
+  pre_tokenize_text(text) {
+    return whitespace_split(text);
+  }
+};
+var WhitespaceSplit_default = WhitespaceSplit;
+var FixedLength = class extends PreTokenizer_default {
+  /**
+   * @param config The configuration options for the pre-tokenizer.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+    this._length = config.length;
+  }
+  /**
+   * Pre-tokenizes the input text by splitting it into fixed-length tokens.
+   * @param text The text to be pre-tokenized.
+   * @returns An array of tokens produced by splitting the input text into fixed-length tokens.
+   */
+  pre_tokenize_text(text) {
+    const tokens = [];
+    for (let i = 0; i < text.length; i += this._length) {
+      tokens.push(text.slice(i, i + this._length));
+    }
+    return tokens;
+  }
+};
+var FixedLength_default = FixedLength;
+function create_pre_tokenizer(config) {
+  if (config === null) return null;
+  switch (config.type) {
+    case "BertPreTokenizer":
+      return new BertPreTokenizer_default();
+    case "Sequence":
+      return new Sequence_default2(config);
+    case "Whitespace":
+      return new Whitespace_default();
+    case "WhitespaceSplit":
+      return new WhitespaceSplit_default();
+    case "Metaspace":
+      return new Metaspace_default(config);
+    case "ByteLevel":
+      return new ByteLevel_default(config);
+    case "Split":
+      return new Split_default(config);
+    case "Punctuation":
+      return new Punctuation_default(config);
+    case "Digits":
+      return new Digits_default(config);
+    case "Replace":
+      return new Replace_default2(config);
+    case "FixedLength":
+      return new FixedLength_default(config);
+    default:
+      throw new Error(`Unknown PreTokenizer type: ${config.type}`);
+  }
+}
+var create_pre_tokenizer_default = create_pre_tokenizer;
+var TokenizerModel = class extends Callable_default {
+  /**
+   * Creates a new instance of TokenizerModel.
+   * @param config The configuration object for the TokenizerModel.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+    this.vocab = [];
+    this.tokens_to_ids = /* @__PURE__ */ new Map();
+    this.unk_token_id = void 0;
+    this.unk_token = void 0;
+    this.end_of_word_suffix = void 0;
+    this.fuse_unk = this.config.fuse_unk ?? false;
+  }
+  /**
+   * Internal function to call the TokenizerModel instance.
+   * @param tokens The tokens to encode.
+   * @returns The encoded tokens.
+   */
+  _call(tokens) {
+    let result = this.encode(tokens);
+    if (this.fuse_unk) {
+      result = fuse_unk(result, this.tokens_to_ids, this.unk_token_id);
+    }
+    return result;
+  }
+};
+var TokenizerModel_default = TokenizerModel;
+var WordPieceTokenizer = class extends TokenizerModel_default {
+  /**
+   * @param config The configuration object.
+   */
+  constructor(config) {
+    super(config);
+    this.max_input_chars_per_word = 100;
+    this.tokens_to_ids = object_to_map(config.vocab);
+    this.unk_token_id = this.tokens_to_ids.get(config.unk_token);
+    this.unk_token = config.unk_token;
+    this.max_input_chars_per_word = config.max_input_chars_per_word ?? 100;
+    this.vocab = new Array(this.tokens_to_ids.size);
+    for (const [key, value] of this.tokens_to_ids) {
+      this.vocab[value] = key;
+    }
+  }
+  /**
+   * Encodes an array of tokens using WordPiece encoding.
+   * @param tokens The tokens to encode.
+   * @returns An array of encoded tokens.
+   */
+  encode(tokens) {
+    const output_tokens = [];
+    for (const token of tokens) {
+      const chars = [...token];
+      if (chars.length > this.max_input_chars_per_word) {
+        output_tokens.push(this.unk_token);
+        continue;
+      }
+      let is_unknown = false;
+      let start = 0;
+      const sub_tokens = [];
+      while (start < chars.length) {
+        let end = chars.length;
+        let current_substring = null;
+        while (start < end) {
+          let substr = chars.slice(start, end).join("");
+          if (start > 0) {
+            substr = this.config.continuing_subword_prefix + substr;
+          }
+          if (this.tokens_to_ids.has(substr)) {
+            current_substring = substr;
+            break;
+          }
+          --end;
+        }
+        if (current_substring === null) {
+          is_unknown = true;
+          break;
+        }
+        sub_tokens.push(current_substring);
+        start = end;
+      }
+      if (is_unknown) {
+        output_tokens.push(this.unk_token);
+      } else {
+        output_tokens.push(...sub_tokens);
+      }
+    }
+    return output_tokens;
+  }
+};
+var WordPiece_default = WordPieceTokenizer;
+var CharTrieNode = class _CharTrieNode {
+  /**
+   * Create a new CharTrieNode.
+   * @param is_leaf Whether the node is a leaf node or not.
+   * @param children A map containing the node's children, where the key is a character and the value is a `CharTrieNode`.
+   */
+  constructor(is_leaf, children) {
+    this.is_leaf = is_leaf;
+    this.children = children;
+  }
+  /**
+   * Returns a new `CharTrieNode` instance with default values.
+   * @returns A new `CharTrieNode` instance with `is_leaf` set to `false` and an empty `children` map.
+   */
+  static default() {
+    return new _CharTrieNode(false, /* @__PURE__ */ new Map());
+  }
+};
+var CharTrie = class {
+  constructor() {
+    this.root = CharTrieNode.default();
+  }
+  /**
+   * Adds one or more `texts` to the trie.
+   * @param texts The strings to add to the trie.
+   */
+  extend(texts) {
+    for (const text of texts) {
+      this.push(text);
+    }
+  }
+  /**
+   * Adds text to the trie.
+   * @param text The string to add to the trie.
+   */
+  push(text) {
+    let node = this.root;
+    for (const ch of text) {
+      let child = node.children.get(ch);
+      if (child === void 0) {
+        child = CharTrieNode.default();
+        node.children.set(ch, child);
+      }
+      node = child;
+    }
+    node.is_leaf = true;
+  }
+  /**
+   * Searches the trie for stored strings that match `chars` starting at `start`.
+   * @param chars The input characters to search.
+   * @param start The index to start searching from.
+   * @yields Each stored string that is a prefix of `chars` starting at `start`.
+   */
+  *common_prefix_search(chars, start = 0) {
+    let node = this.root;
+    if (node === void 0) return;
+    let prefix = "";
+    for (let i = start; i < chars.length; ++i) {
+      const ch = chars[i];
+      prefix += ch;
+      node = node.children.get(ch);
+      if (node === void 0) return;
+      if (node.is_leaf) {
+        yield prefix;
+      }
+    }
+  }
+};
+var CharTrie_default = CharTrie;
+var TokenLatticeNode = class _TokenLatticeNode {
+  /**
+   * Represents a node in a token lattice for a given sentence.
+   * @param token_id The ID of the token associated with this node.
+   * @param node_id The ID of this node.
+   * @param pos The starting position of the token in the sentence.
+   * @param length The length of the token.
+   * @param score The score associated with the token.
+   */
+  constructor(token_id, node_id, pos, length, score) {
+    this.token_id = token_id;
+    this.node_id = node_id;
+    this.pos = pos;
+    this.length = length;
+    this.score = score;
+    this.prev = null;
+    this.backtrace_score = 0;
+  }
+  /**
+   * Returns a clone of this node.
+   * @returns A clone of this node.
+   */
+  clone() {
+    const n = new _TokenLatticeNode(
+      this.token_id,
+      this.node_id,
+      this.pos,
+      this.length,
+      this.score
+    );
+    n.prev = this.prev;
+    n.backtrace_score = this.backtrace_score;
+    return n;
+  }
+};
+var TokenLattice = class {
+  /**
+   * Creates a new TokenLattice instance.
+   *
+   * @param sentence The input sentence to be tokenized.
+   * @param bos_token_id The beginning-of-sequence token ID.
+   * @param eos_token_id The end-of-sequence token ID.
+   */
+  constructor(sentence, bos_token_id, eos_token_id) {
+    this.chars = Array.from(sentence);
+    this.len = this.chars.length;
+    this.bos_token_id = bos_token_id;
+    this.eos_token_id = eos_token_id;
+    this.nodes = [];
+    this.begin_nodes = Array.from(
+      { length: this.len + 1 },
+      () => []
+    );
+    this.end_nodes = Array.from({ length: this.len + 1 }, () => []);
+    const bos = new TokenLatticeNode(this.bos_token_id ?? 0, 0, 0, 0, 0);
+    const eos = new TokenLatticeNode(
+      this.eos_token_id ?? 0,
+      1,
+      this.len,
+      0,
+      0
+    );
+    this.nodes.push(bos.clone());
+    this.nodes.push(eos.clone());
+    this.begin_nodes[this.len].push(eos);
+    this.end_nodes[0].push(bos);
+  }
+  /**
+   * Inserts a new token node into the token lattice.
+   *
+   * @param pos The starting position of the token.
+   * @param length The length of the token.
+   * @param score The score of the token.
+   * @param token_id The token ID of the token.
+   */
+  insert(pos, length, score, token_id) {
+    const node_id = this.nodes.length;
+    const node = new TokenLatticeNode(token_id, node_id, pos, length, score);
+    this.begin_nodes[pos].push(node);
+    this.end_nodes[pos + length].push(node);
+    this.nodes.push(node);
+  }
+  /**
+   * Implements the Viterbi algorithm to compute the most likely sequence of tokens.
+   *
+   * @returns The most likely sequence of tokens.
+   */
+  viterbi() {
+    const len2 = this.len;
+    let pos = 0;
+    while (pos <= len2) {
+      if (this.begin_nodes[pos].length == 0) {
+        return [];
+      }
+      for (let rnode of this.begin_nodes[pos]) {
+        rnode.prev = null;
+        let best_score = 0;
+        let best_node = null;
+        for (let lnode of this.end_nodes[pos]) {
+          const score = lnode.backtrace_score + rnode.score;
+          if (best_node === null || score > best_score) {
+            best_node = lnode.clone();
+            best_score = score;
+          }
+        }
+        if (best_node !== null) {
+          rnode.prev = best_node;
+          rnode.backtrace_score = best_score;
+        } else {
+          return [];
+        }
+      }
+      ++pos;
+    }
+    const results = [];
+    const root = this.begin_nodes[len2][0];
+    const prev = root.prev;
+    if (prev === null) {
+      return [];
+    }
+    let node = prev.clone();
+    while (node.prev !== null) {
+      results.push(node.clone());
+      const n = node.clone();
+      node = n.prev.clone();
+    }
+    results.reverse();
+    return results;
+  }
+  /**
+   * Get the text piece for a given node.
+   * @param node The node to get the piece for.
+   * @returns The array of nodes representing the most likely sequence of tokens.
+   */
+  piece(node) {
+    return this.chars.slice(node.pos, node.pos + node.length).join("");
+  }
+  /**
+   * @returns The most likely sequence of tokens.
+   */
+  tokens() {
+    const nodes = this.viterbi();
+    return nodes.map((x) => this.piece(x));
+  }
+  /**
+   * @returns The most likely sequence of token ids.
+   */
+  token_ids() {
+    const nodes = this.viterbi();
+    return nodes.map((x) => x.token_id);
+  }
+};
+var TokenLattice_default = TokenLattice;
+function min(arr) {
+  if (arr.length === 0) throw new Error("Array must not be empty");
+  let min_value = arr[0];
+  let index_of_min = 0;
+  for (let i = 1; i < arr.length; ++i) {
+    if (arr[i] < min_value) {
+      min_value = arr[i];
+      index_of_min = i;
+    }
+  }
+  return [min_value, index_of_min];
+}
+var Unigram = class extends TokenizerModel_default {
+  /**
+   * Create a new Unigram tokenizer model.
+   * @param config The configuration object for the Unigram model.
+   * @param eos_token
+   */
+  constructor(config, eos_token) {
+    super(config);
+    const vocab_size = config.vocab.length;
+    this.vocab = new Array(vocab_size);
+    this.scores = new Array(vocab_size);
+    for (let i = 0; i < vocab_size; ++i) {
+      [this.vocab[i], this.scores[i]] = config.vocab[i];
+    }
+    this.unk_token_id = config.unk_id;
+    this.unk_token = this.vocab[config.unk_id];
+    this.tokens_to_ids = new Map(this.vocab.map((x, i) => [x, i]));
+    this.bos_token = " ";
+    this.bos_token_id = this.tokens_to_ids.get(this.bos_token);
+    this.eos_token = eos_token;
+    this.eos_token_id = this.tokens_to_ids.get(this.eos_token);
+    this.unk_token = this.vocab[this.unk_token_id];
+    this.min_score = min(this.scores)[0];
+    this.unk_score = this.min_score - 10;
+    this.scores[this.unk_token_id] = this.unk_score;
+    this.trie = new CharTrie_default();
+    this.trie.extend(this.vocab);
+    this.fuse_unk = true;
+  }
+  /**
+   * Populates lattice nodes.
+   * @param lattice The token lattice to populate with nodes.
+   */
+  populate_nodes(lattice) {
+    const chars = lattice.chars;
+    const mblen = 1;
+    let begin_pos = 0;
+    while (begin_pos < chars.length) {
+      let has_single_node = false;
+      const prefixed_tokens = this.trie.common_prefix_search(chars, begin_pos);
+      for (const token of prefixed_tokens) {
+        const token_id = this.tokens_to_ids.get(token);
+        const token_score = this.scores[token_id];
+        const n = len(token);
+        lattice.insert(begin_pos, n, token_score, token_id);
+        if (!has_single_node && n === mblen) {
+          has_single_node = true;
+        }
+      }
+      if (!has_single_node) {
+        lattice.insert(begin_pos, mblen, this.unk_score, this.unk_token_id);
+      }
+      begin_pos += mblen;
+    }
+  }
+  /**
+   * Encodes an array of tokens into an array of subtokens using the unigram model.
+   *
+   * @param normalized The normalized string.
+   * @returns An array of subtokens obtained by encoding the input tokens using the unigram model.
+   */
+  tokenize(normalized) {
+    const lattice = new TokenLattice_default(
+      normalized,
+      this.bos_token_id,
+      this.eos_token_id
+    );
+    this.populate_nodes(lattice);
+    return lattice.tokens();
+  }
+  /**
+   * Encodes an array of tokens using Unigram encoding.
+   * @param tokens The tokens to encode.
+   * @returns An array of encoded tokens.
+   */
+  encode(tokens) {
+    const to_return = [];
+    for (const token of tokens) {
+      const tokenized = this.tokenize(token);
+      to_return.push(...tokenized);
+    }
+    return to_return;
+  }
+};
+var Unigram_default = Unigram;
+var PriorityQueue = class {
+  /**
+   * Create a new PriorityQueue.
+   * @param comparator Comparator function to determine priority. Defaults to a MaxHeap.
+   * @param max_size Maximum size of the queue. Defaults to Infinity.
+   */
+  constructor(comparator = (a, b) => a > b, max_size = Infinity) {
+    this._heap = [];
+    this._comparator = comparator;
+    this._max_size = max_size;
+  }
+  /**
+   * The size of the queue
+   */
+  get size() {
+    return this._heap.length;
+  }
+  /**
+   * Check if the queue is empty.
+   * @returns `true` if the queue is empty, `false` otherwise.
+   */
+  is_empty() {
+    return this.size === 0;
+  }
+  /**
+   * Return the element with the highest priority in the queue.
+   * @returns The highest priority element in the queue.
+   */
+  peek() {
+    return this._heap[0];
+  }
+  /**
+   * Add one or more elements to the queue.
+   * @param values The values to push into the queue.
+   * @returns The new size of the queue.
+   */
+  push(...values) {
+    return this.extend(values);
+  }
+  /**
+   * Add multiple elements to the queue.
+   * @param values The values to push into the queue.
+   * @returns The new size of the queue.
+   */
+  extend(values) {
+    for (const value of values) {
+      if (this.size < this._max_size) {
+        this._heap.push(value);
+        this._sift_up();
+      } else {
+        const smallest = this._smallest();
+        if (this._comparator(value, this._heap[smallest])) {
+          this._heap[smallest] = value;
+          this._sift_up_from(smallest);
+        }
+      }
+    }
+    return this.size;
+  }
+  /**
+   * Remove and return the element with the highest priority in the queue.
+   * @returns The element with the highest priority in the queue.
+   */
+  pop() {
+    const popped_value = this.peek();
+    const bottom = this.size - 1;
+    if (bottom > 0) {
+      this._swap(0, bottom);
+    }
+    this._heap.pop();
+    this._sift_down();
+    return popped_value;
+  }
+  /**
+   * Replace the element with the highest priority in the queue with a new value.
+   * @param value The new value.
+   * @returns The replaced value.
+   */
+  replace(value) {
+    const replaced_value = this.peek();
+    this._heap[0] = value;
+    this._sift_down();
+    return replaced_value;
+  }
+  /**
+   * Compute the index for the parent of the node at index `i`.
+   * @param i The index of the node to get the parent of.
+   * @returns The index of the parent node.
+   * @private
+   */
+  _parent(i) {
+    return (i + 1 >>> 1) - 1;
+  }
+  /**
+   * Compute the index for the left child of the node at index `i`.
+   * @param i The index of the node to get the left child of.
+   * @returns The index of the left child.
+   * @private
+   */
+  _left(i) {
+    return (i << 1) + 1;
+  }
+  /**
+   * Compute the index for the right child of the node at index `i`.
+   * @param i The index of the node to get the right child of.
+   * @returns The index of the right child.
+   * @private
+   */
+  _right(i) {
+    return i + 1 << 1;
+  }
+  /**
+   * Check if the element at index `i` is greater than the element at index `j`.
+   * @param i The index of the first element to compare.
+   * @param j The index of the second element to compare.
+   * @returns `true` if the element at index `i` is greater than the element at index `j`, `false` otherwise.
+   * @private
+   */
+  _greater(i, j) {
+    return this._comparator(this._heap[i], this._heap[j]);
+  }
+  /**
+   * Swap the elements at indices `i` and `j`.
+   * @param i The index of the first element to swap.
+   * @param j The index of the second element to swap.
+   * @private
+   */
+  _swap(i, j) {
+    const temp = this._heap[i];
+    this._heap[i] = this._heap[j];
+    this._heap[j] = temp;
+  }
+  /**
+   * Maintain the heap property by updating positions in the heap,
+   * starting at the last element and moving up the heap.
+   * @private
+   */
+  _sift_up() {
+    this._sift_up_from(this.size - 1);
+  }
+  /**
+   * Helper function to sift up from a given node.
+   * @param node The index of the node to start sifting up from.
+   */
+  _sift_up_from(node) {
+    while (node > 0 && this._greater(node, this._parent(node))) {
+      this._swap(node, this._parent(node));
+      node = this._parent(node);
+    }
+  }
+  /**
+   * Maintain the heap property by updating positions in the heap,
+   * starting at the first element and moving down the heap.
+   * @private
+   */
+  _sift_down() {
+    let node = 0;
+    while (this._left(node) < this.size && this._greater(this._left(node), node) || this._right(node) < this.size && this._greater(this._right(node), node)) {
+      const max_child = this._right(node) < this.size && this._greater(this._right(node), this._left(node)) ? this._right(node) : this._left(node);
+      this._swap(node, max_child);
+      node = max_child;
+    }
+  }
+  /**
+   * Get the index of the smallest element in the heap. Since we use an array-based heap,
+   * the index can be computed without needing to traverse the heap.
+   * @private
+   */
+  _smallest() {
+    return 2 ** Math.floor(Math.log2(this.size)) - 1;
+  }
+};
+var PriorityQueue_default = PriorityQueue;
+var LRUCache = class {
+  /**
+   * Creates an LRUCache instance.
+   * @param capacity The maximum number of items the cache can hold.
+   */
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Retrieves the value associated with the given key and marks the key as recently used.
+   * @param key The key to retrieve.
+   * @returns The value associated with the key, or undefined if the key does not exist.
+   */
+  get(key) {
+    if (!this.cache.has(key)) return void 0;
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  /**
+   * Inserts or updates the key-value pair in the cache.
+   * If the key already exists, it is updated and marked as recently used.
+   * If the cache exceeds its capacity, the least recently used item is evicted.
+   * @param key The key to add or update.
+   * @param value The value to associate with the key.
+   */
+  put(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    this.cache.set(key, value);
+    if (this.cache.size > this.capacity) {
+      this.cache.delete(this.cache.keys().next().value);
+    }
+  }
+  /**
+   * Clears the cache.
+   */
+  clear() {
+    this.cache.clear();
+  }
+};
+var LRUCache_default = LRUCache;
+var BPE = class extends TokenizerModel_default {
+  /**
+   * Create a BPE instance.
+   * @param config The configuration object for BPE.
+   */
+  constructor(config) {
+    super(config);
+    this.tokens_to_ids = object_to_map(config.vocab);
+    this.unk_token_id = this.tokens_to_ids.get(config.unk_token);
+    this.unk_token = config.unk_token;
+    this.vocab = new Array(this.tokens_to_ids.size);
+    for (const [key, value] of this.tokens_to_ids) {
+      this.vocab[value] = key;
+    }
+    const use_new_merge_format = Array.isArray(config.merges[0]);
+    this.merges = use_new_merge_format ? config.merges : config.merges.map(
+      (x) => x.split(" ", 2)
+    );
+    this.bpe_ranks = new Map(this.merges.map((x, i) => [JSON.stringify(x), i]));
+    this.end_of_word_suffix = config.end_of_word_suffix;
+    this.continuing_subword_suffix = config.continuing_subword_suffix ?? null;
+    this.byte_fallback = this.config.byte_fallback ?? false;
+    if (this.byte_fallback) {
+      this.text_encoder = new TextEncoder();
+    }
+    this.ignore_merges = this.config.ignore_merges ?? false;
+    this.max_length_to_cache = 256;
+    this.cache_capacity = 1e4;
+    this.cache = new LRUCache_default(this.cache_capacity);
+  }
+  /**
+   * Clears the cache.
+   */
+  clear_cache() {
+    this.cache.clear();
+  }
+  /**
+   * Apply Byte-Pair-Encoding (BPE) to a given token. Efficient heap-based priority
+   * queue implementation adapted from https://github.com/belladoreai/llama-tokenizer-js.
+   * @param token The token to encode.
+   * @returns The BPE encoded tokens.
+   */
+  bpe(token) {
+    if (token.length === 0) {
+      return [];
+    }
+    const cached = this.cache.get(token);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const word = Array.from(token);
+    if (this.end_of_word_suffix) {
+      word[word.length - 1] += this.end_of_word_suffix;
+    }
+    let result = [];
+    if (word.length > 1) {
+      const queue = new PriorityQueue_default((a, b) => a.score < b.score);
+      let starting_node = {
+        token: word[0],
+        bias: 0,
+        prev: null,
+        next: null
+      };
+      let previous_node = starting_node;
+      for (let i = 1; i < word.length; ++i) {
+        const current_node = {
+          bias: i / word.length,
+          // Add fractional component to break ties
+          token: word[i],
+          prev: previous_node,
+          next: null
+        };
+        previous_node.next = current_node;
+        this.add_node(queue, previous_node);
+        previous_node = current_node;
+      }
+      while (!queue.is_empty()) {
+        const node = queue.pop();
+        if (node.deleted || !node.next || node.next.deleted) continue;
+        node.deleted = true;
+        node.next.deleted = true;
+        if (node.prev) {
+          const new_previous_node = { ...node.prev };
+          node.prev.deleted = true;
+          node.prev = new_previous_node;
+          if (new_previous_node.prev) {
+            new_previous_node.prev.next = new_previous_node;
+          } else {
+            starting_node = new_previous_node;
+          }
+        }
+        const merged = {
+          token: node.token + node.next.token,
+          bias: node.bias,
+          prev: node.prev,
+          next: node.next.next
+        };
+        if (merged.prev) {
+          merged.prev.next = merged;
+          this.add_node(queue, merged.prev);
+        } else {
+          starting_node = merged;
+        }
+        if (merged.next) {
+          merged.next.prev = merged;
+          this.add_node(queue, merged);
+        }
+      }
+      for (let current_node = starting_node; current_node !== null; current_node = current_node.next) {
+        result.push(current_node.token);
+      }
+    } else {
+      result = word;
+    }
+    if (this.continuing_subword_suffix) {
+      for (let i = 0; i < result.length - 1; ++i) {
+        result[i] += this.continuing_subword_suffix;
+      }
+    }
+    if (token.length < this.max_length_to_cache) {
+      this.cache.put(token, result);
+    }
+    return result;
+  }
+  /**
+   * Helper function to add a node to the priority queue.
+   * @param queue
+   * @param node
+   */
+  add_node(queue, node) {
+    const rank = this.bpe_ranks.get(
+      JSON.stringify([node.token, node.next.token])
+    );
+    if (rank !== void 0) {
+      node.score = rank + node.bias;
+      queue.push(node);
+    }
+  }
+  /**
+   * Encodes the input sequence of tokens using the BPE algorithm and returns the resulting subword tokens.
+   * @param tokens The input sequence of tokens to encode.
+   * @returns The resulting subword tokens after applying the BPE algorithm to the input sequence of tokens.
+   */
+  encode(tokens) {
+    const output_tokens = [];
+    for (const token of tokens) {
+      if (this.ignore_merges && this.tokens_to_ids.has(token)) {
+        output_tokens.push(token);
+        continue;
+      }
+      const bpe_token_list = this.bpe(token);
+      for (const t of bpe_token_list) {
+        if (this.tokens_to_ids.has(t)) {
+          output_tokens.push(t);
+        } else if (this.byte_fallback) {
+          const byte_tokens = Array.from(this.text_encoder.encode(t)).map(
+            (x) => `<0x${x.toString(16).toUpperCase().padStart(2, "0")}>`
+          );
+          if (byte_tokens.every((x) => this.tokens_to_ids.has(x))) {
+            output_tokens.push(...byte_tokens);
+          } else if (this.unk_token != null) {
+            output_tokens.push(this.unk_token);
+          }
+        } else if (this.unk_token != null) {
+          output_tokens.push(this.unk_token);
+        }
+      }
+    }
+    return output_tokens;
+  }
+};
+var BPE_default = BPE;
+var Legacy = class extends TokenizerModel_default {
+  /**
+   * Create a Legacy tokenizer model instance.
+   * @param config The configuration object for Legacy tokenizer model.
+   * @param more_config Additional configuration object for the Legacy tokenizer model.
+   */
+  constructor(config, more_config) {
+    super(config);
+    const vocab = config.vocab;
+    this.tokens_to_ids = object_to_map(
+      more_config.target_lang ? vocab[more_config.target_lang] : vocab
+    );
+    this.bos_token = more_config.bos_token;
+    this.bos_token_id = this.tokens_to_ids.get(this.bos_token);
+    this.eos_token = more_config.eos_token;
+    this.eos_token_id = this.tokens_to_ids.get(this.eos_token);
+    this.pad_token = more_config.pad_token;
+    this.pad_token_id = this.tokens_to_ids.get(this.pad_token);
+    this.unk_token = more_config.unk_token;
+    this.unk_token_id = this.tokens_to_ids.get(this.unk_token);
+    this.vocab = new Array(this.tokens_to_ids.size);
+    for (const [key, value] of this.tokens_to_ids) {
+      this.vocab[value] = key;
+    }
+  }
+  encode(tokens) {
+    return tokens;
+  }
+};
+var Legacy_default = Legacy;
+function create_tokenizer_model(model_config, config) {
+  switch (model_config.type) {
+    case "WordPiece":
+      return new WordPiece_default(model_config);
+    case "Unigram":
+      return new Unigram_default(model_config, config.eos_token);
+    case "BPE":
+      return new BPE_default(model_config);
+    default:
+      if (model_config.vocab) {
+        if (Array.isArray(model_config.vocab)) {
+          return new Unigram_default(model_config, config.eos_token);
+        } else if (Object.hasOwn(model_config, "continuing_subword_prefix") && Object.hasOwn(model_config, "unk_token")) {
+          if (Object.hasOwn(model_config, "merges")) {
+            return new BPE_default(model_config);
+          } else {
+            return new WordPiece_default(model_config);
+          }
+        } else {
+          return new Legacy_default(model_config, {
+            target_lang: config.target_lang,
+            bos_token: config.bos_token,
+            eos_token: config.eos_token,
+            pad_token: config.pad_token,
+            unk_token: config.unk_token
+          });
+        }
+      }
+      throw new Error(
+        `Unknown TokenizerModel type: ${model_config?.type}`
+      );
+  }
+}
+var create_tokenizer_model_default = create_tokenizer_model;
+var PostProcessor = class extends Callable_default {
+  /**
+   * @param config The configuration for the post-processor.
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  /**
+   * Alias for {@link PostProcessor#post_process}.
+   * @param tokens The text or array of texts to post-process.
+   * @param args Additional arguments required by the post-processing logic.
+   * @returns The post-processed tokens.
+   */
+  _call(tokens, ...args) {
+    return this.post_process(tokens, ...args);
+  }
+};
+var PostProcessor_default = PostProcessor;
+var TemplateProcessing = class extends PostProcessor_default {
+  /**
+   * Replaces special tokens in the template with actual tokens.
+   * @param tokens The list of tokens for the first sequence.
+   * @param tokens_pair The list of tokens for the second sequence (optional).
+   * @param add_special_tokens Whether to add the special tokens to the beginning and end of the input.
+   * @returns An object containing the list of tokens with the special tokens replaced with actual tokens.
+   */
+  post_process(tokens, tokens_pair = null, add_special_tokens = true) {
+    const type = tokens_pair === null ? this.config.single : this.config.pair;
+    let processed_tokens = [];
+    let types = [];
+    for (const item of type) {
+      if ("SpecialToken" in item) {
+        if (add_special_tokens) {
+          processed_tokens.push(item.SpecialToken.id);
+          types.push(item.SpecialToken.type_id);
+        }
+      } else if ("Sequence" in item) {
+        if (item.Sequence.id === "A") {
+          processed_tokens = merge_arrays(processed_tokens, tokens);
+          types = merge_arrays(
+            types,
+            new Array(tokens.length).fill(item.Sequence.type_id)
+          );
+        } else if (item.Sequence.id === "B") {
+          processed_tokens = merge_arrays(processed_tokens, tokens_pair);
+          types = merge_arrays(
+            types,
+            new Array(tokens_pair.length).fill(item.Sequence.type_id)
+          );
+        }
+      }
+    }
+    return { tokens: processed_tokens, token_type_ids: types };
+  }
+};
+var TemplateProcessing_default = TemplateProcessing;
+var ByteLevel2 = class extends PostProcessor_default {
+  /**
+   * Post process the given tokens.
+   * @param tokens The list of tokens for the first sequence.
+   * @param tokens_pair The list of tokens for the second sequence (optional).
+   * @returns An object containing the post-processed tokens.
+   */
+  post_process(tokens, tokens_pair = null) {
+    return { tokens, tokens_pair };
+  }
+};
+var ByteLevel_default2 = ByteLevel2;
+var BertProcessing = class extends PostProcessor_default {
+  /**
+   * @param config The configuration for the post-processor.
+   * @param config.cls The special tokens to add to the beginning of the input.
+   * @param config.sep The special tokens to add to the end of the input.
+   */
+  constructor(config) {
+    super(config);
+    this.sep = config.sep;
+    this.cls = config.cls;
+  }
+  /**
+   * Adds the special tokens to the beginning and end of the input.
+   * @param tokens The input tokens.
+   * @param tokens_pair An optional second set of input tokens.
+   * @param add_special_tokens Whether to add the special tokens to the beginning and end of the input.
+   * @returns The post-processed tokens with the special tokens added to the beginning and end.
+   */
+  post_process(tokens, tokens_pair = null, add_special_tokens = true) {
+    if (add_special_tokens) {
+      tokens = merge_arrays([this.cls[0]], tokens, [this.sep[0]]);
+    }
+    let token_type_ids = new Array(tokens.length).fill(0);
+    if (tokens_pair) {
+      const middle = [];
+      const after = add_special_tokens ? [this.sep[0]] : [];
+      tokens = merge_arrays(tokens, middle, tokens_pair, after);
+      token_type_ids = merge_arrays(
+        token_type_ids,
+        new Array(tokens_pair.length + middle.length + after.length).fill(1)
+      );
+    }
+    return { tokens, token_type_ids };
+  }
+};
+var BertProcessing_default = BertProcessing;
+var RobertaProcessing = class extends PostProcessor_default {
+  /**
+   * @param config The configuration for the post-processor.
+   * @param config.cls The special tokens to add to the beginning of the input.
+   * @param config.sep The special tokens to add to the end of the input.
+   */
+  constructor(config) {
+    super(config);
+    this.sep = config.sep;
+    this.cls = config.cls;
+  }
+  /**
+   * Adds the special tokens to the beginning and end of the input.
+   * @param tokens The input tokens.
+   * @param tokens_pair An optional second set of input tokens.
+   * @param add_special_tokens Whether to add the special tokens to the beginning and end of the input.
+   * @returns The post-processed tokens with the special tokens added to the beginning and end.
+   */
+  post_process(tokens, tokens_pair, add_special_tokens = true) {
+    if (add_special_tokens) {
+      tokens = merge_arrays([this.cls[0]], tokens, [this.sep[0]]);
+    }
+    let token_type_ids = new Array(tokens.length).fill(0);
+    if (tokens_pair) {
+      const middle = add_special_tokens ? [this.sep[0]] : [];
+      const after = add_special_tokens ? [this.sep[0]] : [];
+      tokens = merge_arrays(tokens, middle, tokens_pair, after);
+      token_type_ids = merge_arrays(
+        token_type_ids,
+        new Array(tokens_pair.length + middle.length + after.length).fill(1)
+      );
+    }
+    return { tokens, token_type_ids };
+  }
+};
+var RobertaProcessing_default = RobertaProcessing;
+var Sequence3 = class extends PostProcessor_default {
+  /**
+   * Creates a new instance of Sequence post-processor.
+   * @param config The configuration object.
+   */
+  constructor(config) {
+    super(config);
+    this.processors = (config.processors ?? []).map((x) => create_post_processor_default(x));
+  }
+  /**
+   * Post process the given tokens.
+   * @param tokens The list of tokens for the first sequence.
+   * @param tokens_pair The list of tokens for the second sequence (optional).
+   * @param add_special_tokens Whether to add the special tokens to the beginning and end of the input.
+   * @returns An object containing the post-processed tokens.
+   */
+  post_process(tokens, tokens_pair = null, add_special_tokens = true) {
+    let processed_tokens = { tokens, tokens_pair };
+    for (const processor of this.processors) {
+      processed_tokens = processor.post_process(
+        processed_tokens.tokens,
+        processed_tokens.tokens_pair,
+        add_special_tokens
+      );
+    }
+    return processed_tokens;
+  }
+};
+var Sequence_default3 = Sequence3;
+function create_post_processor(config) {
+  if (config === null) return null;
+  switch (config.type) {
+    case "TemplateProcessing":
+      return new TemplateProcessing_default(config);
+    case "ByteLevel":
+      return new ByteLevel_default2(config);
+    case "BertProcessing":
+      return new BertProcessing_default(config);
+    case "RobertaProcessing":
+      return new RobertaProcessing_default(config);
+    case "Sequence":
+      return new Sequence_default3(config);
+    default:
+      throw new Error(`Unknown PostProcessor type: ${config.type}`);
+  }
+}
+var create_post_processor_default = create_post_processor;
+var Decoder = class extends Callable_default {
+  /**
+   * Creates an instance of `Decoder`.
+   * @param config The configuration object.
+   **/
+  constructor(config) {
+    super();
+    this.config = config;
+    this.added_tokens = [];
+    this.end_of_word_suffix = null;
+    this.trim_offsets = "trim_offsets" in config ? config.trim_offsets : false;
+  }
+  /**
+   * Calls the `decode` method.
+   *
+   * @param tokens The list of tokens.
+   * @returns The decoded string.
+   */
+  _call(tokens) {
+    return this.decode(tokens);
+  }
+  /**
+   * Decodes a list of tokens.
+   * @param tokens The list of tokens.
+   * @returns The decoded string.
+   */
+  decode(tokens) {
+    return this.decode_chain(tokens).join("");
+  }
+};
+var Decoder_default = Decoder;
+var ByteLevel3 = class extends Decoder_default {
+  /**
+   * Create a `ByteLevelDecoder` object.
+   */
+  constructor(config) {
+    super(config);
+    this.byte_decoder = UNICODE_TO_BYTES;
+    this.text_decoder = new TextDecoder("utf-8", {
+      fatal: false,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      ignoreBOM: true
+    });
+    this.end_of_word_suffix = null;
+  }
+  /**
+   * Convert an array of tokens to string by decoding each byte.
+   * @param tokens Array of tokens to be decoded.
+   * @returns The decoded string.
+   */
+  convert_tokens_to_string(tokens) {
+    const text = tokens.join("");
+    const byte_array = new Uint8Array(
+      [...text].map((c) => this.byte_decoder[c])
+    );
+    return this.text_decoder.decode(byte_array);
+  }
+  decode_chain(tokens) {
+    const sub_texts = [];
+    let current_sub_text = [];
+    for (const token of tokens) {
+      if (this.added_tokens.find((x) => x.content === token) !== void 0) {
+        if (current_sub_text.length > 0) {
+          sub_texts.push(this.convert_tokens_to_string(current_sub_text));
+          current_sub_text = [];
+        }
+        sub_texts.push(token);
+      } else {
+        current_sub_text.push(token);
+      }
+    }
+    if (current_sub_text.length > 0) {
+      sub_texts.push(this.convert_tokens_to_string(current_sub_text));
+    }
+    return sub_texts;
+  }
+};
+var ByteLevel_default3 = ByteLevel3;
+var WordPiece = class extends Decoder_default {
+  /**
+   * Creates a new instance of WordPieceDecoder.
+   * @param config The configuration object.
+   */
+  constructor(config) {
+    super(config);
+    this.cleanup = config.cleanup;
+  }
+  decode_chain(tokens) {
+    return tokens.map((token, i) => {
+      if (i !== 0) {
+        const prefix = this.config.prefix;
+        if (prefix && token.startsWith(prefix)) {
+          token = token.replace(prefix, "");
+        } else {
+          token = " " + token;
+        }
+      }
+      if (this.cleanup) {
+        token = clean_up_tokenization(token);
+      }
+      return token;
+    });
+  }
+};
+var WordPiece_default2 = WordPiece;
+var Metaspace2 = class extends Decoder_default {
+  /**
+   * Constructs a new MetaspaceDecoder object.
+   * @param config The configuration object for the MetaspaceDecoder.
+   */
+  constructor(config) {
+    super(config);
+    this.replacement = config.replacement ?? "\u2581";
+  }
+  decode_chain(tokens) {
+    const result = [];
+    for (let i = 0; i < tokens.length; ++i) {
+      let normalized = tokens[i].replaceAll(this.replacement, " ");
+      if (i == 0 && normalized.startsWith(" ")) {
+        normalized = normalized.substring(1);
+      }
+      result.push(normalized);
+    }
+    return result;
+  }
+};
+var Metaspace_default2 = Metaspace2;
+var BPE2 = class extends Decoder_default {
+  constructor(config) {
+    super(config);
+    this.suffix = config.suffix ?? "";
+  }
+  decode_chain(tokens) {
+    return tokens.map((token, i) => {
+      return token.replaceAll(this.suffix, i === tokens.length - 1 ? "" : " ");
+    });
+  }
+};
+var BPE_default2 = BPE2;
+var CTC = class extends Decoder_default {
+  constructor(config) {
+    super(config);
+    this.pad_token = config.pad_token ?? "";
+    this.word_delimiter_token = config.word_delimiter_token ?? "";
+    this.cleanup = config.cleanup;
+  }
+  /**
+   * Converts a connectionist-temporal-classification (CTC) output tokens into a single string.
+   * @param tokens Array of tokens to be decoded.
+   * @returns The decoded string.
+   */
+  convert_tokens_to_string(tokens) {
+    if (tokens.length === 0) return "";
+    const grouped_tokens = [tokens[0]];
+    for (let i = 1; i < tokens.length; ++i) {
+      if (tokens[i] !== grouped_tokens.at(-1)) {
+        grouped_tokens.push(tokens[i]);
+      }
+    }
+    const filtered_tokens = grouped_tokens.filter(
+      (token) => token !== this.pad_token
+    );
+    let text = filtered_tokens.join("");
+    if (this.cleanup) {
+      text = clean_up_tokenization(text).replaceAll(this.word_delimiter_token, " ").trim();
+    }
+    return text;
+  }
+  decode_chain(tokens) {
+    return [this.convert_tokens_to_string(tokens)];
+  }
+};
+var CTC_default = CTC;
+var Sequence4 = class extends Decoder_default {
+  /**
+   * Creates a new instance of DecoderSequence.
+   * @param config The configuration object.
+   */
+  constructor(config) {
+    super(config);
+    this.decoders = (config.decoders ?? []).map((x) => create_decoder_default(x));
+  }
+  decode_chain(tokens) {
+    return this.decoders.reduce((toks, decoder) => {
+      return decoder.decode_chain(toks);
+    }, tokens);
+  }
+};
+var Sequence_default4 = Sequence4;
+var Replace3 = class extends Decoder_default {
+  /**
+   * @param config The configuration object for the decoder.
+   */
+  constructor(config) {
+    super(config);
+    this.pattern = create_pattern(this.config.pattern);
+  }
+  decode_chain(tokens) {
+    const content = this.config.content ?? "";
+    const pattern = this.pattern;
+    return pattern === null ? tokens : tokens.map((token) => token.replaceAll(pattern, content));
+  }
+};
+var Replace_default3 = Replace3;
+var Fuse = class extends Decoder_default {
+  decode_chain(tokens) {
+    return [tokens.join("")];
+  }
+};
+var Fuse_default = Fuse;
+var Strip2 = class extends Decoder_default {
+  constructor(config) {
+    super(config);
+    this.content = config.content ?? "";
+    this.start = config.start ?? 0;
+    this.stop = config.stop ?? 0;
+  }
+  decode_chain(tokens) {
+    return tokens.map((token) => {
+      let start_cut = 0;
+      for (let i = 0; i < this.start; ++i) {
+        if (token[i] === this.content) {
+          start_cut = i + 1;
+          continue;
+        } else {
+          break;
+        }
+      }
+      let stop_cut = token.length;
+      for (let i = 0; i < this.stop; ++i) {
+        const index = token.length - i - 1;
+        if (token[index] === this.content) {
+          stop_cut = index;
+          continue;
+        } else {
+          break;
+        }
+      }
+      return token.slice(start_cut, stop_cut);
+    });
+  }
+};
+var Strip_default2 = Strip2;
+var ByteFallback = class extends Decoder_default {
+  constructor(config) {
+    super(config);
+    this.text_decoder = new TextDecoder();
+  }
+  decode_chain(tokens) {
+    const new_tokens = [];
+    let previous_byte_tokens = [];
+    for (const token of tokens) {
+      let bytes = null;
+      if (token.length === 6 && token.startsWith("<0x") && token.endsWith(">")) {
+        const byte = parseInt(token.slice(3, 5), 16);
+        if (!isNaN(byte)) {
+          bytes = byte;
+        }
+      }
+      if (bytes !== null) {
+        previous_byte_tokens.push(bytes);
+      } else {
+        if (previous_byte_tokens.length > 0) {
+          const string = this.text_decoder.decode(
+            Uint8Array.from(previous_byte_tokens)
+          );
+          new_tokens.push(string);
+          previous_byte_tokens = [];
+        }
+        new_tokens.push(token);
+      }
+    }
+    if (previous_byte_tokens.length > 0) {
+      const string = this.text_decoder.decode(
+        Uint8Array.from(previous_byte_tokens)
+      );
+      new_tokens.push(string);
+      previous_byte_tokens = [];
+    }
+    return new_tokens;
+  }
+};
+var ByteFallback_default = ByteFallback;
+function create_decoder(config) {
+  if (config === null) return null;
+  switch (config.type) {
+    case "ByteLevel":
+      return new ByteLevel_default3(config);
+    case "WordPiece":
+      return new WordPiece_default2(config);
+    case "Metaspace":
+      return new Metaspace_default2(config);
+    case "BPEDecoder":
+      return new BPE_default2(config);
+    case "CTC":
+      return new CTC_default(config);
+    case "Sequence":
+      return new Sequence_default4(config);
+    case "Replace":
+      return new Replace_default3(config);
+    case "Fuse":
+      return new Fuse_default(config);
+    case "Strip":
+      return new Strip_default2(config);
+    case "ByteFallback":
+      return new ByteFallback_default(config);
+    default:
+      throw new Error(`Unknown Decoder type: ${config.type}`);
+  }
+}
+var create_decoder_default = create_decoder;
+var Tokenizer = class {
+  constructor(tokenizer, config) {
+    const tokenizer_error = validate_object(tokenizer, "Tokenizer", [
+      "model",
+      "decoder",
+      "post_processor",
+      "pre_tokenizer",
+      "normalizer"
+    ]);
+    if (tokenizer_error) {
+      throw new Error(tokenizer_error);
+    }
+    const config_error = validate_object(config, "Config");
+    if (config_error) {
+      throw new Error(config_error);
+    }
+    this.tokenizer = tokenizer;
+    this.config = config;
+    this.normalizer = create_normalizer_default(this.tokenizer.normalizer);
+    this.pre_tokenizer = create_pre_tokenizer_default(this.tokenizer.pre_tokenizer);
+    this.model = create_tokenizer_model_default(this.tokenizer.model, this.config);
+    this.post_processor = create_post_processor_default(this.tokenizer.post_processor);
+    this.decoder = create_decoder_default(this.tokenizer.decoder);
+    this.special_tokens = [];
+    this.all_special_ids = [];
+    this.added_tokens = [];
+    const unnormalized_contents = [];
+    const normalized_contents = [];
+    this.added_tokens_map = /* @__PURE__ */ new Map();
+    for (const added_token of this.tokenizer.added_tokens) {
+      const token = new AddedToken_default(added_token);
+      this.added_tokens.push(token);
+      this.model.tokens_to_ids.set(token.content, token.id);
+      this.model.vocab[token.id] = token.content;
+      if (token.special) {
+        this.special_tokens.push(token.content);
+        this.all_special_ids.push(token.id);
+      }
+      this.added_tokens_map.set(token.content, token);
+      if (token.normalized && this.normalizer !== null) {
+        const normalized_content = this.normalizer(token.content);
+        normalized_contents.push(normalized_content);
+        this.added_tokens_map.set(normalized_content, token);
+      } else {
+        unnormalized_contents.push(token.content);
+      }
+    }
+    (this.config.additional_special_tokens ?? []).forEach((token) => {
+      if (!this.special_tokens.includes(token)) this.special_tokens.push(token);
+    });
+    if (this.decoder) {
+      this.decoder.added_tokens = this.added_tokens;
+      this.decoder.end_of_word_suffix = this.model.end_of_word_suffix;
+    }
+    this.splitter_unnormalized = new DictionarySplitter_default(unnormalized_contents);
+    this.splitter_normalized = new DictionarySplitter_default(normalized_contents);
+    this.remove_space = this.config.remove_space;
+    this.clean_up_tokenization_spaces = this.config.clean_up_tokenization_spaces ?? true;
+    this.do_lowercase_and_remove_accent = this.config.do_lowercase_and_remove_accent ?? false;
+  }
+  // Implementation
+  encode(text, {
+    text_pair = null,
+    add_special_tokens = true,
+    return_token_type_ids = null
+  } = {}) {
+    const { tokens, token_type_ids } = this.tokenize_helper(text, {
+      text_pair,
+      add_special_tokens
+    });
+    const input_ids = tokens.map(
+      (t) => this.added_tokens_map.get(t)?.id ?? this.model.tokens_to_ids.get(t) ?? this.model.unk_token_id
+    );
+    const result = {
+      ids: input_ids,
+      tokens,
+      attention_mask: new Array(input_ids.length).fill(1)
+    };
+    if (return_token_type_ids && token_type_ids) {
+      result.token_type_ids = token_type_ids;
+    }
+    return result;
+  }
+  decode(token_ids, options = {}) {
+    if (!Array.isArray(token_ids) || token_ids.length === 0 || !is_integral_number(token_ids[0])) {
+      throw Error("token_ids must be a non-empty array of integers.");
+    }
+    let tokens = token_ids.map(
+      (i) => this.model.vocab[Number(i)] ?? this.model.unk_token
+    );
+    if (options.skip_special_tokens) {
+      tokens = tokens.filter((x) => !this.special_tokens.includes(x));
+    }
+    let decoded = this.decoder ? this.decoder(tokens) : tokens.join(" ");
+    if (this.decoder && this.decoder.end_of_word_suffix) {
+      decoded = decoded.replaceAll(this.decoder.end_of_word_suffix, " ");
+      if (options.skip_special_tokens) {
+        decoded = decoded.trim();
+      }
+    }
+    if (options.clean_up_tokenization_spaces ?? this.clean_up_tokenization_spaces) {
+      decoded = clean_up_tokenization(decoded);
+    }
+    return decoded;
+  }
+  /**
+   * Converts a string into a sequence of tokens.
+   * @param text The sequence to be encoded.
+   * @param options An optional object containing the following properties:
+   * @returns The list of tokens.
+   */
+  tokenize(text, { text_pair = null, add_special_tokens = false } = {}) {
+    return this.tokenize_helper(text, { text_pair, add_special_tokens }).tokens;
+  }
+  encode_text(text) {
+    if (text === null) {
+      return null;
+    }
+    const sections = this.splitter_unnormalized.split(text);
+    sections.forEach((section, i) => {
+      const added_token = this.added_tokens_map.get(section);
+      if (added_token) {
+        if (added_token.lstrip && i > 0) {
+          sections[i - 1] = sections[i - 1].trimEnd();
+        }
+        if (added_token.rstrip && i < sections.length - 1) {
+          sections[i + 1] = sections[i + 1].trimStart();
+        }
+      }
+    });
+    return sections.flatMap((processed_text, section_index) => {
+      if (processed_text.length === 0) {
+        return [];
+      }
+      if (this.added_tokens_map.has(processed_text)) {
+        return [processed_text];
+      }
+      if (this.remove_space === true) {
+        processed_text = processed_text.trim().split(/\s+/).join(" ");
+      }
+      if (this.do_lowercase_and_remove_accent) {
+        processed_text = lowercase_and_remove_accents(processed_text);
+      }
+      if (this.normalizer !== null) {
+        processed_text = this.normalizer(processed_text);
+      }
+      if (processed_text.length === 0) {
+        return [];
+      }
+      const subsections = this.splitter_normalized.split(processed_text);
+      subsections.forEach((subsection, j) => {
+        const added_token = this.added_tokens_map.get(subsection);
+        if (added_token) {
+          if (added_token.lstrip && j > 0) {
+            subsections[j - 1] = subsections[j - 1].trimEnd();
+          }
+          if (added_token.rstrip && j < subsections.length - 1) {
+            subsections[j + 1] = subsections[j + 1].trimStart();
+          }
+        }
+      });
+      return subsections.flatMap((subsection) => {
+        if (subsection.length === 0) {
+          return [];
+        }
+        if (this.added_tokens_map.has(subsection)) {
+          return [subsection];
+        }
+        const section_tokens = this.pre_tokenizer !== null ? this.pre_tokenizer(subsection, {
+          section_index
+        }) : [subsection];
+        return this.model(section_tokens);
+      });
+    });
+  }
+  tokenize_helper(text, { text_pair = null, add_special_tokens = true }) {
+    const tokens1 = this.encode_text(text);
+    const tokens2 = this.encode_text(text_pair || null);
+    return this.post_processor ? this.post_processor(tokens1, tokens2, add_special_tokens) : { tokens: merge_arrays(tokens1 ?? [], tokens2 ?? []) };
+  }
+  /**
+   * Converts a token string to its corresponding token ID.
+   * @param token The token string to convert.
+   * @returns The token ID, or undefined if the token is not in the vocabulary.
+   */
+  token_to_id(token) {
+    return this.model.tokens_to_ids.get(token);
+  }
+  /**
+   * Converts a token ID to its corresponding token string.
+   * @param id The token ID to convert.
+   * @returns The token string, or undefined if the ID is not in the vocabulary.
+   */
+  id_to_token(id) {
+    return this.model.vocab[id];
+  }
+  /**
+   * Returns a mapping of token IDs to AddedToken objects for all added tokens.
+   * @returns A Map where keys are token IDs and values are AddedToken objects.
+   */
+  get_added_tokens_decoder() {
+    const decoder = /* @__PURE__ */ new Map();
+    for (const token of this.added_tokens) {
+      decoder.set(token.id, token);
+    }
+    return decoder;
+  }
+  /**
+   * Get the underlying vocabulary
+   * @param with_added_tokens Whether to include the added tokens
+   * @returns The vocabulary
+   */
+  get_vocab(with_added_tokens = true) {
+    const vocab = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.model.vocab.length; ++i) {
+      const token = this.model.vocab[i];
+      if (with_added_tokens || !this.added_tokens_map.has(token)) {
+        vocab.set(token, i);
+      }
+    }
+    return vocab;
+  }
+};
+var Tokenizer_default = Tokenizer;
+
+// ../../client/vqweb/tokenizer.js
+var VqwTokenizer = class {
+  /**
+   * @param {object} tokenizerJSON   parsed tokenizer.json
+   * @param {object} tokenizerConfig parsed tokenizer_config.json
+   * @param {object} header          the .vqw JSON header (model.prompt / max_len / add_eos / eos_id, tokenizer.byte_ids / unk_id)
+   * @param {Iterable<number>} keptIds  token ids present in the trimmed table (tensor token_embd.ids)
+   */
+  constructor(tokenizerJSON, tokenizerConfig, header, keptIds) {
+    this.tok = new Tokenizer_default(tokenizerJSON, tokenizerConfig);
+    this.prompt = header.model.prompt ?? "";
+    this.maxLen = header.model.max_len ?? 512;
+    this.addEos = !!header.model.add_eos;
+    this.eosId = header.model.eos_id ?? null;
+    this.byteIds = header.tokenizer.byte_ids;
+    this.unkId = header.tokenizer.unk_id ?? null;
+    this.allowed = new Set(keptIds);
+    this.utf8 = new TextEncoder();
+    this.decodeCache = /* @__PURE__ */ new Map();
+  }
+  /** HF `tok(text, truncation=True, max_length=max_len)["input_ids"]` (special tokens added by the post-processor). */
+  encodeFull(text) {
+    let ids = this.tok.encode(text, { add_special_tokens: true }).ids;
+    if (ids.length > this.maxLen) {
+      ids = this.addEos ? ids.slice(0, this.maxLen - 1).concat([this.eosId]) : ids.slice(0, this.maxLen);
+    }
+    return ids;
+  }
+  /** Python `tok.decode([id])`: no special-token skipping, no clean-up (tokenizer_config says clean_up_tokenization_spaces=false). */
+  decodeOne(id) {
+    let s = this.decodeCache.get(id);
+    if (s === void 0) {
+      s = this.tok.decode([id], { skip_special_tokens: false, clean_up_tokenization_spaces: false });
+      this.decodeCache.set(id, s);
+    }
+    return s;
+  }
+  /** vocab_trim.retokenize: every id outside the table -> byte tokens of its surface string. */
+  retokenize(ids) {
+    const out = [];
+    for (const id of ids) {
+      if (this.allowed.has(id)) {
+        out.push(id);
+        continue;
+      }
+      const bytes = this.utf8.encode(this.decodeOne(id));
+      const fb = [];
+      for (const b of bytes) {
+        const t = this.byteIds[b];
+        if (t != null) fb.push(t);
+      }
+      if (fb.length) out.push(...fb);
+      else out.push(this.unkId ?? id);
+    }
+    return out;
+  }
+  /** query text (WITHOUT the prompt) -> token ids for the model. */
+  encode(query) {
+    return this.retokenize(this.encodeFull(this.prompt + query));
+  }
+};
+
+// src/kernels.js
+var KERNELS = {
+  "rmsnorm": "// RMSNorm over the last axis with an f16 weight:  y = w * (x * rsqrt(mean(x^2) + eps))   (scripts/vq_reference.py: rmsnorm)\n// One workgroup (256 threads) per token, N = {{N}} values per token (4 per thread), f32 reduction in workgroup memory.\n// Input dtype {{IN_T}} (f32 or f16 residual stream), output f32 (feeds fwht_rotate, which produces the f16 matmul input).\nenable f16;\nstruct Params { T: u32, debug: u32, pad0: u32, pad1: u32 };\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read> x: array<{{IN_T}}>;       // [T, N]\n@group(0) @binding(2) var<storage, read> w: array<f16>;            // [N]\n@group(0) @binding(3) var<storage, read_write> y: array<f32>;      // [T, N]\nconst N: u32 = {{N}}u;\nconst EPS: f32 = {{EPS}};\nconst WG: u32 = 256u;\nconst PER: u32 = N / WG;\nvar<workgroup> red: array<f32, WG>;\n\n@compute @workgroup_size(256)\nfn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n  let t = wg.x; let i = lid.x;\n  if (t >= P.T) { return; }\n  var v: array<f32, PER>;\n  var s: f32 = 0.0;\n  for (var k = 0u; k < PER; k++) { let val = f32(x[t * N + i * PER + k]); v[k] = val; s += val * val; }\n  red[i] = s;\n  workgroupBarrier();\n  for (var st = WG / 2u; st > 0u; st >>= 1u) { if (i < st) { red[i] += red[i + st]; } workgroupBarrier(); }\n  let inv = 1.0 / sqrt(red[0] / f32(N) + EPS);\n  for (var k = 0u; k < PER; k++) { y[t * N + i * PER + k] = f32(w[i * PER + k]) * (v[k] * inv); }\n}\n",
+  "fwht_rotate": "// Input-side structured rotation x @ M (scripts/fast_rotation.py: apply_MT with the STORED signs / permutations):\n//   for round r in 0..R-1:  x *= signs[r];  x = blockFWHT_B(x) / sqrt(B);  x = x[perm[r]]      (gather)\n// One workgroup (256 threads) per token, the whole N = {{N}} vector in workgroup memory (f32, N*4 bytes: 4 / 8 / 12 KB for\n// 1024 / 2048 / 3072): the Walsh-Hadamard butterflies run per B = {{B}} block, the permutation gathers across blocks.\n// Input f32 [T, N], output f16 [T, N] (the matmul input).  Butterfly order = the reference's fwht (stack(a+c, a-c)), the\n// 1/sqrt(B) scaling is applied once per round in the gather (exact for B a power of 4).\nenable f16;\nstruct Params { T: u32, debug: u32, pad0: u32, pad1: u32 };\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read> x: array<f32>;            // [T, N]\n@group(0) @binding(2) var<storage, read> signs: array<f32>;        // [R, N]  (+-1)\n@group(0) @binding(3) var<storage, read> perms: array<u32>;        // [R, N]\n@group(0) @binding(4) var<storage, read_write> y: array<f16>;      // [T, N]\nconst N: u32 = {{N}}u;\nconst B: u32 = {{B}}u;\nconst R: u32 = {{R}}u;\nconst WG: u32 = 256u;\nconst PER: u32 = N / WG;             // values per thread\nconst HALF: u32 = B / 2u;            // butterfly pairs per block\nconst PPT: u32 = (N / 2u) / WG;      // pairs per thread\nconst INV_SQRT_B: f32 = {{INV_SQRT_B}};\nvar<workgroup> buf: array<f32, N>;\n\n@compute @workgroup_size(256)\nfn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n  let t = wg.x; let i = lid.x;\n  if (t >= P.T) { return; }\n  for (var k = 0u; k < PER; k++) { let j = i + k * WG; buf[j] = x[t * N + j] * signs[j]; }\n  workgroupBarrier();\n  for (var r = 0u; r < R; r++) {\n    // butterflies: h = 1, 2, ..., B/2;  pair (a, a + h) with a = block*B + (w >> lh) << (lh + 1) | (w & (h - 1))\n    var lh = 0u;\n    for (var h = 1u; h < B; h <<= 1u) {\n      for (var k = 0u; k < PPT; k++) {\n        let p = i + k * WG;\n        let blk = p / HALF; let w = p % HALF;\n        let a = blk * B + ((w >> lh) << (lh + 1u)) + (w & (h - 1u));\n        let b = a + h;\n        let u = buf[a]; let v = buf[b];\n        buf[a] = u + v; buf[b] = u - v;\n      }\n      lh++;\n      workgroupBarrier();\n    }\n    // permutation gather (P^T), 1/sqrt(B), and the next round's signs; in place via registers\n    var reg: array<f32, PER>;\n    for (var k = 0u; k < PER; k++) { let j = i + k * WG; reg[k] = buf[perms[r * N + j]] * INV_SQRT_B; }\n    workgroupBarrier();\n    for (var k = 0u; k < PER; k++) {\n      let j = i + k * WG;\n      var v = reg[k];\n      if (r + 1u < R) { v = v * signs[(r + 1u) * N + j]; }\n      buf[j] = v;\n    }\n    workgroupBarrier();\n  }\n  for (var k = 0u; k < PER; k++) { let j = i + k * WG; y[t * N + j] = f16(buf[j]); }\n}\n",
+  "vq_matmul": "// VQ linear in the rotated basis:  y[t, r] = sum_c W[r, c] * f32(x[t, c]),  W[r, c] = f32(codebook[c/256][idx[r, c/4]][c%4]) * f32(scale[r, c/256])\n// (scripts/vqw_format.py: dequant_vq; the product of two f16 numbers is exact in f32, so W here equals the reference's W bit\n// for bit).  Shapes are compile-time: ROWS x COLS, K-entry codebooks of dimension DIM (4 = the released format; 2 = the 3-3.5 bpw\n// points, two indices per 4-column quad, the vec4 below is the concatenation of two codebook vec2 entries) per 256-column block, W-bit indices packed\n// little-endian into WORDS uint32 words per row (bit j of group g at bit g*W + j; a 6/7-bit index may straddle two words).\n//\n// M4 tiling (decode once per workgroup, reuse across every token of the tile): a workgroup owns RWG rows x TT tokens and walks\n// the columns CB at a time.  Per 256-column block the codebook and the block's packed index words of the RWG rows are staged\n// (one coalesced load: whole cache lines, so the 110 MiB of indices stream from memory exactly once per query for T <= TT).\n// Per step the threads (1) decode the RWG x CB/4 indices of the step from the staged words into ws (vec4<f32> codebook values),\n// (2) convert the TT x CB/4 x vec4<f16> x tile into xs (f32), and (3) each thread accumulates an MR x MT micro-tile of outputs\n// with dot(vec4<f32>, vec4<f32>): part += dot(cb, x) over the 64 groups of the block, then acc += scale * part at the block's\n// end -- the M2 kernel's summation order per output element, so the results are the same to the bit.  Layouts: ws [group][row]\n// interleaved so the lanes of a subgroup (consecutive rows) read consecutive vec4s; xs [token][group] (reads are subgroup\n// broadcasts, the staging loads coalesced).  Subgroups whose tokens are beyond T skip the FMAs (rows are the fast lane index).\n// Grid: (ROWS / RWG, ceil(T / TT)).\n// OUT_MODE store: y f32 [T, ROWS];  add: y[t, r] += acc (the residual stream, dtype RESID_T) -- o_proj and down_proj.\nenable f16;\nstruct Params { T: u32, debug: u32, pad0: u32, pad1: u32 };\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read> x: array<vec4<f16>>;      // [T, COLS/4]\n@group(0) @binding(2) var<storage, read> cb: array<{{CBT}}>;     // [NBLK, K], vec4<f16> (dim 4) or vec2<f16> (dim 2)\n@group(0) @binding(3) var<storage, read> idx: array<u32>;          // [ROWS, WORDS]\n@group(0) @binding(4) var<storage, read> sc: array<f16>;           // [ROWS, NBLK]\n@group(0) @binding(5) var<storage, read_write> y: array<{{OUT_T}}>;   // [T, ROWS]\nconst ROWS: u32 = {{ROWS}}u;\nconst COLS: u32 = {{COLS}}u;\nconst K: u32 = {{K}}u;\nconst W: u32 = {{W}}u;\nconst MASK: u32 = {{MASK}}u;\nconst WORDS: u32 = {{WORDS}}u;\nconst NBLK: u32 = COLS / 256u;\nconst DIM: u32 = {{DIM}}u;            // codebook dimension (4 or 2)\nconst GPQ: u32 = 4u / DIM;            // index groups per 4-column quad (1 or 2)\nconst GPB: u32 = 64u;                 // quads (of 4 columns) per 256-column block\nconst RWG: u32 = {{RWG}}u;            // rows per workgroup\nconst TT: u32 = {{TT}}u;              // tokens per workgroup\nconst CB: u32 = {{CB}}u;              // columns per staging step (divides 256)\nconst GS: u32 = CB / 4u;              // quads per step\nconst MR: u32 = {{MR}}u;              // micro-tile rows per thread\nconst MT: u32 = {{MT}}u;              // micro-tile tokens per thread\nconst NTR: u32 = RWG / MR;            // threads along rows (the fast index: a subgroup shares its tokens, so whole\nconst NTC: u32 = TT / MT;             // subgroups skip the FMAs when their tokens are beyond T)\nconst WGS: u32 = NTR * NTC;\nconst GPT: u32 = GS / (WGS / RWG);    // consecutive quads decoded per thread and step (WGS is a multiple of RWG)\nconst WPB: u32 = GPB * GPQ * W / 32u; // packed index words per row and 256-column block (a block's bits are word-aligned)\nvar<workgroup> cbs: array<{{CBT}}, K>;\nvar<workgroup> iw: array<u32, RWG * WPB>;        // the block's packed indices of the workgroup's rows (one coalesced load per block)\nvar<workgroup> ws: array<vec4<f32>, GS * RWG>;   // [group][i][tr] = row tr*MR + i, codebook value (exact), scale applied at the block fold\nvar<workgroup> xs: array<vec4<f32>, TT * GS>;    // [token][group] (reads are subgroup broadcasts, writes / global loads coalesced)\n\n@compute @workgroup_size({{WGS}})\nfn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n  let tr = lid.x % NTR;               // this thread's rows: tr*MR + i (within the workgroup)\n  let t0 = (lid.x / NTR) * MT;        // first token\n  let rbase = wg.x * RWG;\n  let tbase = wg.y * TT;\n  let live = tbase + t0 < P.T;        // any real token in this micro-tile\n  var acc: array<array<f32, MT>, MR>;    // sum over the finished 256-column blocks\n  var part: array<array<f32, MT>, MR>;   // the current block (two-level summation as in the M2 kernel / the reference's blocked GEMM)\n  for (var i = 0u; i < MR; i++) { for (var j = 0u; j < MT; j++) { acc[i][j] = 0.0; part[i][j] = 0.0; } }\n  var blk = 0xffffffffu;\n  for (var g0 = 0u; g0 < COLS / 4u; g0 += GS) {\n    let b = g0 / GPB;\n    workgroupBarrier();                                // previous step's reads are done before the tiles are overwritten\n    if (b != blk) {                                    // new 256-column block: its codebook and its packed index words\n      for (var e = lid.x; e < K; e += WGS) { cbs[e] = cb[b * K + e]; }\n      for (var e = lid.x; e < RWG * WPB; e += WGS) { iw[e] = idx[(rbase + e / WPB) * WORDS + b * WPB + e % WPB]; }\n      blk = b;\n      workgroupBarrier();\n    }\n    // (1) decode from iw: thread -> one row (dtr, di) and GPT consecutive groups; ws entry (g*MR + di)*NTR + dtr\n    //     (consecutive threads write consecutive entries)\n    {\n      let dtr = lid.x % NTR; let di = (lid.x / NTR) % MR; let gslot = lid.x / RWG;\n      let base = (dtr * MR + di) * WPB;\n      for (var m = 0u; m < GPT; m++) {\n        let g = gslot * GPT + m;                       // quad within the step\n        let p = (g0 - b * GPB + g) * GPQ * W;          // bit position of the quad's first index within the block's words\n        let wi = p >> 5u; let sh = p & 31u;\n        var v = iw[base + wi] >> sh;\n        if (sh + W > 32u) { v |= iw[base + wi + 1u] << (32u - sh); }\n        {{DECODE}}\n      }\n    }\n    // (2) x tile [token][group]: consecutive threads = consecutive groups of one token row; tokens beyond T read as zero\n    for (var e = lid.x; e < TT * GS; e += WGS) {\n      let t = tbase + e / GS; let g = e % GS;\n      if (t < P.T) { xs[e] = vec4<f32>(x[t * (COLS / 4u) + g0 + g]); } else { xs[e] = vec4<f32>(0.0); }\n    }\n    workgroupBarrier();\n    // (3) micro-tile FMAs\n    if (live) {\n      for (var g = 0u; g < GS; g++) {\n        var xv: array<vec4<f32>, MT>;\n        for (var j = 0u; j < MT; j++) { xv[j] = xs[(t0 + j) * GS + g]; }\n        for (var i = 0u; i < MR; i++) {\n          let wv = ws[(g * MR + i) * NTR + tr];\n          for (var j = 0u; j < MT; j++) { part[i][j] += dot(wv, xv[j]); }\n        }\n      }\n      if ((g0 + GS) % GPB == 0u) {                       // block finished: scale and fold (the M2 kernel's order: acc += s * sum_block)\n        for (var i = 0u; i < MR; i++) {\n          let s = f32(sc[(rbase + tr * MR + i) * NBLK + b]);\n          for (var j = 0u; j < MT; j++) { acc[i][j] += s * part[i][j]; part[i][j] = 0.0; }\n        }\n      }\n    }\n  }\n  for (var j = 0u; j < MT; j++) {\n    let t = tbase + t0 + j;\n    if (t < P.T) {\n      for (var i = 0u; i < MR; i++) { let r = rbase + tr * MR + i; {{OUT_STMT}} }\n    }\n  }\n}\n",
+  "vq_matmul_v1": "// VQ linear in the rotated basis:  y[t, r] = sum_b f32(scale[r, b]) * sum_{c in block b} f32(codebook[b][idx[r, c/4]][c%4]) * f32(x[t, c])\n// (scripts/vqw_format.py: dequant_vq, without ever materialising W).  Shapes are compile-time: ROWS x COLS, K-entry\n// codebooks of dimension 4 per 256-column block (NBLK = COLS/256 blocks, GPB = 64 groups per block), W-bit indices packed\n// little-endian into WORDS uint32 words per row (bit j of group g at bit g*W + j; a 6/7-bit index may straddle two words).\n//\n// Tiling: a workgroup owns RWG rows x TT = LANES*TPT tokens; thread = (row, lane), TPT tokens per thread (f32 accumulators).\n// Per column block: the block's codebook (K x vec4<f16>, <= 2 KB) and the x tile (TT x 64 vec4<f16>, TT*512 bytes) are staged\n// in workgroup memory, then each thread streams its row's 64 indices and does TPT dot(vec4) FMAs per index.  Inputs f16,\n// products / sums f32.  Grid: (ROWS / RWG, ceil(T / TT)) -- every token of the query is in flight in one dispatch.\n// OUT_MODE store: y f32 [T, ROWS];  add: y[t, r] += acc (the residual stream, dtype RESID_T) -- o_proj and down_proj.\nenable f16;\nstruct Params { T: u32, debug: u32, pad0: u32, pad1: u32 };\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read> x: array<vec4<f16>>;      // [T, COLS/4]\n@group(0) @binding(2) var<storage, read> cb: array<vec4<f16>>;     // [NBLK, K]\n@group(0) @binding(3) var<storage, read> idx: array<u32>;          // [ROWS, WORDS]\n@group(0) @binding(4) var<storage, read> sc: array<f16>;           // [ROWS, NBLK]\n@group(0) @binding(5) var<storage, read_write> y: array<{{OUT_T}}>;   // [T, ROWS]\nconst ROWS: u32 = {{ROWS}}u;\nconst COLS: u32 = {{COLS}}u;\nconst K: u32 = {{K}}u;\nconst W: u32 = {{W}}u;\nconst MASK: u32 = {{MASK}}u;\nconst WORDS: u32 = {{WORDS}}u;\nconst NBLK: u32 = COLS / 256u;\nconst GPB: u32 = 64u;\nconst RWG: u32 = {{RWG}}u;\nconst LANES: u32 = {{LANES}}u;\nconst TPT: u32 = {{TPT}}u;\nconst TT: u32 = LANES * TPT;\nconst WGS: u32 = RWG * LANES;\nvar<workgroup> cbs: array<vec4<f16>, K>;\nvar<workgroup> xs: array<vec4<f16>, TT * GPB>;\n\n@compute @workgroup_size({{WGS}})\nfn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n  let lr = lid.x / LANES; let lane = lid.x % LANES;\n  let r = wg.x * RWG + lr;\n  let t0 = wg.y * TT;\n  let base = r * WORDS;\n  var acc: array<f32, TPT>;\n  for (var k = 0u; k < TPT; k++) { acc[k] = 0.0; }\n  for (var b = 0u; b < NBLK; b++) {\n    workgroupBarrier();\n    for (var e = lid.x; e < K; e += WGS) { cbs[e] = cb[b * K + e]; }\n    for (var e = lid.x; e < TT * GPB; e += WGS) {\n      let tk = e / GPB; let g = e % GPB; let t = t0 + tk;\n      if (t < P.T) { xs[e] = x[t * (COLS / 4u) + b * GPB + g]; } else { xs[e] = vec4<f16>(0.0h); }\n    }\n    workgroupBarrier();\n    var part: array<f32, TPT>;\n    for (var k = 0u; k < TPT; k++) { part[k] = 0.0; }\n    var p = b * GPB * W;                                  // bit position of this block's first index in the row stream\n    for (var g = 0u; g < GPB; g++) {\n      let wi = p >> 5u; let sh = p & 31u;\n      var v = idx[base + wi] >> sh;\n      if (sh + W > 32u) { v |= idx[base + wi + 1u] << (32u - sh); }\n      let c = vec4<f32>(cbs[v & MASK]);\n      for (var k = 0u; k < TPT; k++) { part[k] += dot(c, vec4<f32>(xs[(lane * TPT + k) * GPB + g])); }\n      p += W;\n    }\n    let s = f32(sc[r * NBLK + b]);\n    for (var k = 0u; k < TPT; k++) { acc[k] += s * part[k]; }\n  }\n  for (var k = 0u; k < TPT; k++) {\n    let t = t0 + lane * TPT + k;\n    if (t < P.T) { {{OUT_STMT}} }\n  }\n}\n",
+  "qk_norm_rope": "// Qwen3 per-head q/k RMSNorm (weight [HD] shared by all heads) fused with RoPE (HF rotate_half convention):\n//   xn = w * (x * rsqrt(mean_d(x^2) + eps));   out[i] = xn[i]*cos[i] - xn[i+HD/2]*sin[i];  out[i+HD/2] = xn[i+HD/2]*cos[i] + xn[i]*sin[i]\n// cos/sin [T, HD/2] are computed on the CPU in double precision (positions 0..T-1, inv_freq_j = theta^(-2j/HD)).\n// One workgroup of HD/2 = {{HALF}} threads per (token, head); grid (T, NH + NKV): workgroups 0..NH-1 are q heads, the rest k heads.\n// DO_ROPE = 0 is the debug variant that materialises the normalised q/k (reference names q_norm / k_norm);\n// INPLACE = 1 writes back into the input buffers (production), else into qo / ko.\nenable f16;\nstruct Params { T: u32, debug: u32, pad0: u32, pad1: u32 };\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read_write> q: array<f32>;      // [T, NH*HD]\n@group(0) @binding(2) var<storage, read_write> k: array<f32>;      // [T, NKV*HD]\n@group(0) @binding(3) var<storage, read> wq: array<f16>;           // [HD]\n@group(0) @binding(4) var<storage, read> wk: array<f16>;           // [HD]\n@group(0) @binding(5) var<storage, read> cosT: array<f32>;         // [T, HD/2]\n@group(0) @binding(6) var<storage, read> sinT: array<f32>;         // [T, HD/2]\n{{OUT_BINDINGS}}\nconst NH: u32 = {{NH}}u;\nconst NKV: u32 = {{NKV}}u;\nconst HD: u32 = {{HD}}u;\nconst HALF: u32 = HD / 2u;\nconst EPS: f32 = {{EPS}};\nconst DO_ROPE: bool = {{DO_ROPE}};\nvar<workgroup> red: array<f32, HALF>;\n\n@compute @workgroup_size({{HALF}})\nfn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n  let t = wg.x; let hh = wg.y; let i = lid.x;\n  if (t >= P.T) { return; }\n  let isq = hh < NH;\n  let head = select(hh - NH, hh, isq);\n  let nheads = select(NKV, NH, isq);\n  let base = (t * nheads + head) * HD;\n  var a: f32; var b: f32; var wa: f32; var wb: f32;\n  if (isq) { a = q[base + i]; b = q[base + i + HALF]; wa = f32(wq[i]); wb = f32(wq[i + HALF]); }\n  else     { a = k[base + i]; b = k[base + i + HALF]; wa = f32(wk[i]); wb = f32(wk[i + HALF]); }\n  red[i] = a * a + b * b;\n  workgroupBarrier();\n  for (var st = HALF / 2u; st > 0u; st >>= 1u) { if (i < st) { red[i] += red[i + st]; } workgroupBarrier(); }\n  let inv = 1.0 / sqrt(red[0] / f32(HD) + EPS);\n  var an = wa * (a * inv); var bn = wb * (b * inv);\n  if (DO_ROPE) {\n    let c = cosT[t * HALF + i]; let s = sinT[t * HALF + i];\n    let oa = an * c - bn * s;\n    let ob = bn * c + an * s;\n    an = oa; bn = ob;\n  }\n  {{OUT_STMT}}\n}\n",
+  "attention": "// Causal GQA attention, all tokens of the query at once, f32 throughout, with an optional stored prefix (M6):\n//   keys / values 0..PP-1 come from the container's prefix.k / prefix.v (the prompt, computed by the fp model, already normed + RoPE'd),\n//   keys / values PP.. are the query tokens of this pass (k / v buffers, row j - PP).  The query token t sits at position PP + t:\n//   s[j] = (q[t,h,:] . key_j[h / (NH/NKV), :]) * HD^-0.5  for j <= PP + t;   p = softmax_j(s);   o[t,h,:] = sum_j p[j] value_j\n// PP = 0 (uniform) is the plain path (no prefix, or ids that do not start with it).  PMAX = {{PMAX}} is the stored prefix length,\n// TMAX = {{TMAX}} the score array size (PMAX + max query tokens).\n// One workgroup of HD = {{HD}} threads per (query token t, head h); scores in workgroup memory; max / sum reductions in f32\n// (the reference: torch.softmax on fp32 scores with the -inf mask over the query part).\n// WRITE_PROBS = 1 (debug) also stores the probabilities as [NH, T, PP + T] f32 (zeros above the diagonal; reference attn_probs).\nenable f16;\nstruct Params { T: u32, debug: u32, PP: u32, pad1: u32 };\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read> q: array<f32>;            // [T, NH*HD]  (after q-norm + RoPE at positions PP..PP+T-1)\n@group(0) @binding(2) var<storage, read> k: array<f32>;            // [T, NKV*HD]\n@group(0) @binding(3) var<storage, read> v: array<f32>;            // [T, NKV*HD]\n@group(0) @binding(4) var<storage, read_write> o: array<f32>;      // [T, NH*HD]\n@group(0) @binding(5) var<storage, read> kp: array<f32>;           // [PMAX, NKV*HD] stored prefix keys (f32 on the GPU)\n@group(0) @binding(6) var<storage, read> vp: array<f32>;           // [PMAX, NKV*HD] stored prefix values\n{{PROBS_BINDING}}\nconst NH: u32 = {{NH}}u;\nconst NKV: u32 = {{NKV}}u;\nconst HD: u32 = {{HD}}u;\nconst PMAX: u32 = {{PMAX}}u;\nconst TMAX: u32 = {{TMAX}}u;\nconst SCALE: f32 = {{SCALE}};\nconst WRITE_PROBS: bool = {{WRITE_PROBS}};\nvar<workgroup> qs: array<f32, HD>;\nvar<workgroup> sc: array<f32, TMAX>;\nvar<workgroup> red: array<f32, HD>;\n\nfn key_at(j: u32, kvh: u32, d: u32, PP: u32) -> f32 {\n  if (j < PP) { return kp[(j * NKV + kvh) * HD + d]; }\n  return k[((j - PP) * NKV + kvh) * HD + d];\n}\nfn val_at(j: u32, kvh: u32, d: u32, PP: u32) -> f32 {\n  if (j < PP) { return vp[(j * NKV + kvh) * HD + d]; }\n  return v[((j - PP) * NKV + kvh) * HD + d];\n}\n\n@compute @workgroup_size({{HD}})\nfn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n  let t = wg.x; let h = wg.y; let i = lid.x;\n  let T = P.T; let PP = P.PP;\n  if (t >= T) { return; }\n  let kvh = h / (NH / NKV);\n  let last = PP + t;                       // last visible key index\n  qs[i] = q[(t * NH + h) * HD + i];\n  workgroupBarrier();\n  // scores (thread i owns j = i, i + HD, ...)\n  var m: f32 = -3.0e38;\n  for (var j = i; j <= last; j += HD) {\n    var s: f32 = 0.0;\n    for (var d = 0u; d < HD; d++) { s += qs[d] * key_at(j, kvh, d, PP); }\n    s = s * SCALE;\n    sc[j] = s;\n    m = max(m, s);\n  }\n  red[i] = m;\n  workgroupBarrier();\n  for (var st = HD / 2u; st > 0u; st >>= 1u) { if (i < st) { red[i] = max(red[i], red[i + st]); } workgroupBarrier(); }\n  let mx = red[0];\n  workgroupBarrier();\n  var sum: f32 = 0.0;\n  for (var j = i; j <= last; j += HD) { let e = exp(sc[j] - mx); sc[j] = e; sum += e; }\n  red[i] = sum;\n  workgroupBarrier();\n  for (var st = HD / 2u; st > 0u; st >>= 1u) { if (i < st) { red[i] += red[i + st]; } workgroupBarrier(); }\n  let inv = 1.0 / red[0];\n  if (WRITE_PROBS) {\n    let W = PP + T;\n    for (var j = i; j < W; j += HD) { {{PROBS_STMT}} }\n  }\n  // output: thread i = dimension d\n  var acc: f32 = 0.0;\n  for (var j = 0u; j <= last; j++) { acc += (sc[j] * inv) * val_at(j, kvh, i, PP); }\n  o[(t * NH + h) * HD + i] = acc;\n}\n",
+  "swiglu": "// SwiGLU gate:  a = silu(g) * u = (g / (1 + exp(-g))) * u,  elementwise over [T, I], f32.\nstruct Params { T: u32, debug: u32, pad0: u32, pad1: u32 };\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read> g: array<f32>;\n@group(0) @binding(2) var<storage, read> u: array<f32>;\n@group(0) @binding(3) var<storage, read_write> a: array<f32>;\nconst I: u32 = {{I}}u;\n\n@compute @workgroup_size(256)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let n = gid.x;\n  if (n >= P.T * I) { return; }\n  let x = g[n];\n  a[n] = (x / (1.0 + exp(-x))) * u[n];\n}\n",
+  "pool_normalize": "// Last-token pooling + L2 normalisation:  e = x[T-1] / max(||x[T-1]||, 1e-12)   (torch.nn.functional.normalize), N = {{N}}.\n// One workgroup of 256 threads; the input is the output of the final RMSNorm, f32 [T, N].\nstruct Params { T: u32, debug: u32, pad0: u32, pad1: u32 };\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read> x: array<f32>;            // [T, N]\n@group(0) @binding(2) var<storage, read_write> e: array<f32>;      // [N]\nconst N: u32 = {{N}}u;\nconst WG: u32 = 256u;\nconst PER: u32 = N / WG;\nvar<workgroup> red: array<f32, WG>;\n\n@compute @workgroup_size(256)\nfn main(@builtin(local_invocation_id) lid: vec3<u32>) {\n  let i = lid.x;\n  let base = (P.T - 1u) * N;\n  var v: array<f32, PER>;\n  var s: f32 = 0.0;\n  for (var k = 0u; k < PER; k++) { let val = x[base + i * PER + k]; v[k] = val; s += val * val; }\n  red[i] = s;\n  workgroupBarrier();\n  for (var st = WG / 2u; st > 0u; st >>= 1u) { if (i < st) { red[i] += red[i + st]; } workgroupBarrier(); }\n  let inv = 1.0 / max(sqrt(red[0]), 1e-12);\n  for (var k = 0u; k < PER; k++) { e[i * PER + k] = v[k] * inv; }\n}\n"
+};
+
+// src/loader.js
+var basename = (url) => {
+  const u = new URL(url, typeof location !== "undefined" ? location.href : "http://localhost/");
+  return decodeURIComponent(u.pathname.split("/").filter(Boolean).pop() || "model");
+};
+async function opfsRoot() {
+  try {
+    if (typeof navigator === "undefined" || !navigator.storage?.getDirectory) return null;
+    return await navigator.storage.getDirectory();
+  } catch (e) {
+    return null;
+  }
+}
+async function opfsGet(name, size) {
+  try {
+    const root = await opfsRoot();
+    if (!root) return null;
+    const f = await (await root.getFileHandle(name)).getFile();
+    return size == null || f.size === size ? f : null;
+  } catch (e) {
+    return null;
+  }
+}
+async function opfsPut(name, parts) {
+  try {
+    const root = await opfsRoot();
+    if (!root) return null;
+    const fh = await root.getFileHandle(name, { create: true });
+    const w = await fh.createWritable();
+    for (const p of parts) await w.write(p);
+    await w.close();
+    return await fh.getFile();
+  } catch (e) {
+    return null;
+  }
+}
+async function opfsRemove(name) {
+  const root = await opfsRoot();
+  if (!root) return false;
+  try {
+    await root.removeEntry(`${name}.meta.json`);
+  } catch (e) {
+  }
+  try {
+    await root.removeEntry(name);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function fetchWithProgress(url, onProgress, expectedBytes = null) {
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`fetch ${url}: HTTP ${r.status}`);
+  const total = expectedBytes ?? Number(r.headers.get("Content-Length") || 0) ?? 0;
+  if (!r.body) {
+    const b = new Uint8Array(await r.arrayBuffer());
+    onProgress?.(b.byteLength, total || b.byteLength);
+    return b;
+  }
+  const reader = r.body.getReader();
+  const chunks = [];
+  let loaded = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    loaded += value.byteLength;
+    onProgress?.(loaded, total || loaded);
+  }
+  const out = new Uint8Array(loaded);
+  let o = 0;
+  for (const c of chunks) {
+    out.set(c, o);
+    o += c.byteLength;
+  }
+  return out;
+}
+var isManifest = (url) => /\.chunks\.json(\?.*)?$/i.test(String(url));
+async function loadModelBytes(url, { cache = "opfs", onProgress } = {}) {
+  const useCache = cache === "opfs";
+  if (isManifest(url)) {
+    const r = await fetch(url);
+    if (!r.ok) throw new Error(`manifest ${url}: HTTP ${r.status}`);
+    const manifest = await r.json();
+    const name2 = manifest.file, total = manifest.size_bytes;
+    if (useCache) {
+      const f = await opfsGet(name2, total);
+      if (f) {
+        onProgress?.(total, total);
+        return { buffer: await f.arrayBuffer(), bytes: total, cached: true, persisted: true, name: name2 };
+      }
+    }
+    const parts = [];
+    let loaded = 0;
+    const one = async (c) => {
+      const b = await fetchWithProgress(new URL(c.url, url).href, (l) => onProgress?.(loaded + l, total), c.bytes);
+      if (b.byteLength !== c.bytes) throw new Error(`chunk ${c.url}: got ${b.byteLength} bytes, expected ${c.bytes}`);
+      loaded += b.byteLength;
+      return b;
+    };
+    const pending = [];
+    let next = 0;
+    for (let i = 0; i < manifest.chunks.length; i++) {
+      while (pending.length < 3 && next < manifest.chunks.length) pending.push(one(manifest.chunks[next++]));
+      parts.push(await pending.shift());
+    }
+    const out = new Uint8Array(total);
+    let o = 0;
+    for (const p of parts) {
+      out.set(p, o);
+      o += p.byteLength;
+    }
+    if (o !== total) throw new Error(`assembled ${o} bytes, expected ${total}`);
+    const persisted2 = useCache ? !!await opfsPut(name2, [out]) : false;
+    return { buffer: out.buffer, bytes: total, cached: false, persisted: persisted2, name: name2 };
+  }
+  const name = basename(url), metaName = `${name}.meta.json`;
+  if (useCache) {
+    const meta = await opfsGet(metaName, null).then((f) => f ? f.text() : null).then((t) => t ? JSON.parse(t) : null).catch(() => null);
+    if (meta && meta.url === String(url) && meta.bytes > 0) {
+      const f = await opfsGet(name, meta.bytes);
+      if (f) {
+        onProgress?.(f.size, f.size);
+        return { buffer: await f.arrayBuffer(), bytes: f.size, cached: true, persisted: true, name };
+      }
+    }
+  }
+  const bytes = await fetchWithProgress(url, onProgress);
+  let persisted = false;
+  if (useCache) {
+    persisted = !!await opfsPut(name, [bytes]);
+    if (persisted) await opfsPut(metaName, [JSON.stringify({ url: String(url), bytes: bytes.byteLength, stored: (/* @__PURE__ */ new Date()).toISOString() })]);
+  }
+  return { buffer: bytes.buffer, bytes: bytes.byteLength, cached: false, persisted, name };
+}
+async function loadJsonCached(url, { cache = "opfs", cacheName = null } = {}) {
+  const name = cacheName ?? basename(url);
+  if (cache === "opfs") {
+    const f = await opfsGet(name, null);
+    if (f) {
+      try {
+        return JSON.parse(await f.text());
+      } catch (e) {
+        await opfsRemove(name);
+      }
+    }
+  }
+  const r = await fetch(url);
+  if (r.status === 404) return null;
+  if (!r.ok) throw new Error(`fetch ${url}: HTTP ${r.status}`);
+  const text = await r.text();
+  if (cache === "opfs") await opfsPut(name, [text]);
+  return JSON.parse(text);
+}
+async function loadTokenizerFiles(containerUrl, header, { tokenizerUrl, tokenizerConfigUrl, cache = "opfs" } = {}) {
+  const base = new URL(containerUrl, typeof location !== "undefined" ? location.href : "http://localhost/");
+  const tokName = header.tokenizer?.file ?? "tokenizer.json", cfgName = header.tokenizer?.config ?? "tokenizer_config.json";
+  const teacher = header.model?.teacher ?? "model";
+  const tokUrl = tokenizerUrl ?? new URL(tokName, base).href, cfgUrl = tokenizerConfigUrl ?? new URL(cfgName, base).href;
+  let [tj, tc] = await Promise.all([loadJsonCached(tokUrl, { cache, cacheName: `tokenizer-${teacher}.json` }), loadJsonCached(cfgUrl, { cache, cacheName: `tokenizer_config-${teacher}.json` })]);
+  let fallback = false;
+  if (!tj && !tokenizerUrl && tokName !== "tokenizer.json") {
+    tj = await loadJsonCached(new URL("tokenizer.json", base).href, { cache, cacheName: `tokenizer-${teacher}.json` });
+    fallback = true;
+  }
+  if (!tc && !tokenizerConfigUrl && cfgName !== "tokenizer_config.json") {
+    tc = await loadJsonCached(new URL("tokenizer_config.json", base).href, { cache, cacheName: `tokenizer_config-${teacher}.json` });
+    fallback = true;
+  }
+  if (!tj) throw new Error(`tokenizer file ${tokUrl} not found (the container header names ${tokName}; pass tokenizerUrl)`);
+  if (!tc) throw new Error(`tokenizer config ${cfgUrl} not found (the container header names ${cfgName}; pass tokenizerConfigUrl)`);
+  return { tokenizerJSON: tj, tokenizerConfig: tc, fallback };
+}
+
+// src/index.js
+var VERSION = "0.1.0";
+var now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+function l2normalize(v) {
+  let s = 0;
+  for (let i = 0; i < v.length; i++) s += v[i] * v[i];
+  const inv = s > 0 ? 1 / Math.sqrt(s) : 0;
+  const out = new Float32Array(v.length);
+  for (let i = 0; i < v.length; i++) out[i] = v[i] * inv;
+  return out;
+}
+async function probeWebGPU({ powerPreference = "low-power" } = {}) {
+  const out = { ok: false, reason: null, adapter: null, shaderF16: null };
+  if (typeof navigator === "undefined" || !navigator.gpu) {
+    out.reason = "WebGPU is not available in this browser (navigator.gpu is missing)";
+    return out;
+  }
+  let ad;
+  try {
+    ad = await navigator.gpu.requestAdapter({ powerPreference });
+  } catch (e) {
+    out.reason = `requestAdapter failed: ${e?.message ?? e}`;
+    return out;
+  }
+  if (!ad) {
+    out.reason = "no WebGPU adapter (GPU blocklisted or WebGPU disabled)";
+    return out;
+  }
+  const info = ad.info ?? {};
+  out.adapter = { vendor: info.vendor, architecture: info.architecture, device: info.device, description: info.description };
+  out.shaderF16 = ad.features.has("shader-f16");
+  if (!out.shaderF16) {
+    out.reason = "the WebGPU adapter has no shader-f16 (the kernels need 16-bit floats)";
+    return out;
+  }
+  out.ok = true;
+  return out;
+}
+var VqwClient = class {
+  constructor({ device, ownsDevice, adapter, container, runtime, tokenizer, file, timing, tokenizerFallback }) {
+    this.device = device;
+    this._ownsDevice = ownsDevice;
+    this.container = container;
+    this.runtime = runtime;
+    this.tokenizer = tokenizer;
+    const m = container.model, q = container.quant, h = container.header;
+    this.info = {
+      file: { url: file.url, name: file.name, bytes: file.bytes, cached: file.cached, persisted: file.persisted },
+      model: {
+        teacher: m.teacher,
+        hf: h.model?.hf ?? null,
+        arch: m.arch,
+        layers: m.layers,
+        hidden: m.hidden,
+        prompt: m.prompt,
+        addEos: m.addEos,
+        maxLen: m.maxLen,
+        prefixTokens: container.prefix ? container.prefix.tokens : 0,
+        pooling: m.pooling
+      },
+      quant: { method: q.method, bits: q.bits, k: q.k, dim: q.dim ?? 4, bpwBlocks: q.bpw_blocks ?? null, calib: q.calib ?? null, blocksize: q.blocksize ?? 256 },
+      tokenizer: { rows: container.tokens.rows, full: h.tokenizer?.vocab_full ?? null, file: h.tokenizer?.file ?? "tokenizer.json", fallback: tokenizerFallback },
+      adapter,
+      gpuBytes: container.gpuBytes + runtime.actBytes,
+      weightBytes: container.gpuBytes,
+      activationBytes: runtime.actBytes,
+      timing,
+      version: VERSION
+    };
+    this._disposed = false;
+  }
+  /** query text (without the prompt: the container applies its own) -> token ids on the container's table. */
+  tokenize(text) {
+    this._check();
+    return this.tokenizer.encode(text);
+  }
+  /** Raw runtime call on token ids: {embedding (not normalised), T, ms, ...}. opts.profile adds GPU timestamps where supported. */
+  embedTokens(ids, opts = {}) {
+    this._check();
+    return this.runtime.embed(ids, opts);
+  }
+  /** One query -> L2-normalised Float32Array(hidden). */
+  async embed(text) {
+    const r = await this.embedTokens(this.tokenize(String(text)));
+    return l2normalize(r.embedding);
+  }
+  /** Several queries, one after another (the runtime is batch 1). */
+  async embedMany(texts) {
+    const out = [];
+    for (const t of texts) out.push(await this.embed(t));
+    return out;
+  }
+  /** Like embed() but also returns the token count and the wall-clock milliseconds of the GPU pass. */
+  async embedWithStats(text) {
+    const t0 = now(), ids = this.tokenize(String(text));
+    const r = await this.embedTokens(ids);
+    return { embedding: l2normalize(r.embedding), tokens: ids.length, ms: now() - t0, gpuMs: r.ms };
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  _check() {
+    if (this._disposed) throw new Error("VqwClient is disposed");
+  }
+  /** Free the GPU buffers (and the device when this client created it). */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    try {
+      this.runtime.destroy();
+    } catch (e) {
+    }
+    try {
+      this.container.destroy();
+    } catch (e) {
+    }
+    if (this._ownsDevice) {
+      try {
+        this.device.destroy();
+      } catch (e) {
+      }
+    }
+  }
+};
+async function loadVqwClient(url, opts = {}) {
+  const { cache = "opfs", onProgress, tokenizerUrl, tokenizerConfigUrl, powerPreference = "low-power", warmup = true } = opts;
+  const progress = (phase, loaded, total) => {
+    try {
+      onProgress?.({ phase, loaded, total });
+    } catch (e) {
+    }
+  };
+  const t0 = now();
+  let device = opts.device, adapter = null, ownsDevice = false;
+  if (!device) {
+    const r = await requestDevice({ powerPreference, label: "vqweb" });
+    device = r.device;
+    adapter = r.info;
+    ownsDevice = true;
+  } else if (!device.features.has("shader-f16")) throw new Error("the given GPUDevice has no shader-f16");
+  const file = await loadModelBytes(url, { cache, onProgress: (l, t) => progress("download", l, t) });
+  const tDown = now();
+  progress("upload", 0, 1);
+  let buffer = file.buffer;
+  const container = new VqwContainer(parseVqw(buffer), device);
+  const tUp = now();
+  progress("tokenizer", 0, 1);
+  const tf = await loadTokenizerFiles(url, container.header, { tokenizerUrl, tokenizerConfigUrl, cache });
+  const tokenizer = new VqwTokenizer(tf.tokenizerJSON, tf.tokenizerConfig, container.header, container.tokens.ids);
+  const tTok = now();
+  progress("pipelines", 0, 1);
+  const runtime = await VqwRuntime.create(container, device, { sources: KERNELS, ...opts.runtime || {} });
+  const tPipe = now();
+  container.release();
+  buffer = null;
+  const timing = { download_s: file.cached ? 0 : (tDown - t0) / 1e3, upload_s: (tUp - tDown) / 1e3, tokenizer_s: (tTok - tUp) / 1e3, pipelines_s: (tPipe - tTok) / 1e3, warmup_s: 0 };
+  const client = new VqwClient({ device, ownsDevice, adapter, container, runtime, tokenizer, file: { ...file, url }, timing, tokenizerFallback: tf.fallback });
+  if (warmup) {
+    progress("warmup", 0, 1);
+    await client.embed("warm-up");
+    timing.warmup_s = (now() - tPipe) / 1e3;
+  }
+  progress("ready", 1, 1);
+  return client;
+}
+async function clearCache(urlOrName) {
+  const name = decodeURIComponent(String(urlOrName).split("?")[0].split("/").filter(Boolean).pop() || "").replace(/\.chunks\.json$/, "");
+  return opfsRemove(name);
+}
+export {
+  KERNELS,
+  VERSION,
+  VqwClient,
+  VqwContainer,
+  VqwRuntime,
+  VqwTokenizer,
+  clearCache,
+  fetchVqw,
+  fetchWithProgress,
+  l2normalize,
+  loadModelBytes,
+  loadTokenizerFiles,
+  loadVqwClient,
+  opfsGet,
+  opfsPut,
+  opfsRemove,
+  parseVqw,
+  probeWebGPU,
+  requestDevice
+};