diskformer 0.5.2 → 0.5.4

package/engines/qwen3_moe_ssd.js

@@ -66,10 +66,13 @@ export function configFromGguf(kv) {
 }
 
 // The engine's OPFS layout, derived from the header alone (ingest and load agree on it).
+// Q8_0 experts: an int8 plane and an f16 scale plane per projection. Q4_0 experts (the qwen35moe Q4_0 files): a
+// nibble plane (16 B per 32 values) and an f16 scale plane, as Gemma 4's. Dense tensors keep their GGUF type.
 export function planLayout(gguf) {
   const cfg = configFromGguf(gguf.kv);
   const H = cfg.hidden, F = cfg.expertFf;
-  const qBytes = F * H;                  // one projection's int8 plane
+  const q4 = gguf.tensors.find((t) => /_exps\.weight$/.test(t.name))?.type === GGML.Q4_0;
+  const qBytes = q4 ? F * H / 2 : F * H; // one projection's int8 or nibble plane
   const sBytes = (F * H / 32) * 2;       // its f16 scale plane
   const parts = {
     guQ: { off: 0, bytes: 2 * qBytes },               // gate rows 0..F-1, up rows F..2F-1
@@ -86,6 +89,10 @@ export function planLayout(gguf) {
     const n = t.dims.reduce((a, b) => a * b, 1);
     if (t.type === GGML.Q8_0) {
       dense[t.name] = { type: 'q8', dims: t.dims, q: { off: take(n), bytes: n }, s: { off: take(n / 16), bytes: n / 16 } };
+    } else if (t.type === GGML.Q4_0) {
+      dense[t.name] = { type: 'q4', dims: t.dims, q: { off: take(n / 2), bytes: n / 2 }, s: { off: take(n / 16), bytes: n / 16 } };
+    } else if (t.type === GGML.Q6_K) {
+      dense[t.name] = { type: 'q6k', dims: t.dims, raw: { off: take(tensorBytes(t)), bytes: tensorBytes(t) } };
     } else if (t.type === GGML.F32) {
       dense[t.name] = { type: 'f32', dims: t.dims, raw: { off: take(n * 4), bytes: n * 4 } };
     } else throw new Error(`dense tensor ${t.name}: unsupported type ${t.type}`);
@@ -100,7 +107,7 @@ export function planLayout(gguf) {
 // ── Ingest: GGUF (over HTTP Range) → OPFS, in the engine layout ─────────────
 // Every byte range of the GGUF the engine keeps, as units small enough to transform in
 // memory: one unit per expert slice, row bands for dense Q8_0, whole F32 tensors.
-function planUnits(gguf, layout) {
+export function planUnits(gguf, layout) {
   const units = [];
   const { record, parts, perLayer } = layout.experts;
   const qBytes = parts.dQ.bytes, sBytes = parts.dS.bytes;
@@ -109,23 +116,25 @@ function planUnits(gguf, layout) {
     const m = /^blk\.(\d+)\.ffn_(gate|up|down)_exps\.weight$/.exec(t.name);
     if (m) {
       const layer = Number(m[1]), which = m[2];
-      if (t.type !== GGML.Q8_0) throw new Error(`${t.name}: experts must be Q8_0`);
+      if (t.type !== GGML.Q8_0 && t.type !== GGML.Q4_0) throw new Error(`${t.name}: experts must be Q8_0 or Q4_0`);
+      const kind = t.type === GGML.Q4_0 ? { kind: 'q4' } : {};
       const slice = tensorBytes(t) / perLayer;
       const qOff = which === 'gate' ? parts.guQ.off : which === 'up' ? parts.guQ.off + qBytes : parts.dQ.off;
       const sOff = which === 'gate' ? parts.guS.off : which === 'up' ? parts.guS.off + sBytes : parts.dS.off;
       for (let e = 0; e < perLayer; e++) {
         const rec = (layer * perLayer + e) * record;
-        units.push({ src: abs + e * slice, len: slice, file: 'experts', q: rec + qOff, s: rec + sOff });
+        units.push({ ...kind, src: abs + e * slice, len: slice, file: 'experts', q: rec + qOff, s: rec + sOff });
       }
       continue;
     }
     const d = layout.dense.tensors[t.name];
-    if (d.type === 'f32') { units.push({ src: abs, len: d.raw.bytes, file: 'dense', raw: d.raw.off }); continue; }
-    const cols = t.dims[0], rows = d.q.bytes / cols, rowBytes = (cols / 32) * Q8_BLOCK;
+    if (d.raw) { units.push({ src: abs, len: d.raw.bytes, file: 'dense', raw: d.raw.off }); continue; }
+    const q4 = d.type === 'q4', cols = t.dims[0], rows = (q4 ? 2 * d.q.bytes : d.q.bytes) / cols;
+    const rowBytes = (cols / 32) * (q4 ? Q4_BLOCK : Q8_BLOCK), qRow = q4 ? cols / 2 : cols;
     const band = Math.max(1, Math.floor((8 << 20) / rowBytes));
     for (let r = 0; r < rows; r += band) {
       const nr = Math.min(band, rows - r);
-      units.push({ src: abs + r * rowBytes, len: nr * rowBytes, file: 'dense', q: d.q.off + r * cols, s: d.s.off + r * cols / 16 });
+      units.push({ ...(q4 ? { kind: 'q4' } : {}), src: abs + r * rowBytes, len: nr * rowBytes, file: 'dense', q: d.q.off + r * qRow, s: d.s.off + r * cols / 16 });
     }
   }
   units.sort((a, b) => a.src - b.src);
@@ -533,6 +542,295 @@ var<workgroup> bi: array<u32, 256>;
 }`,
 };
 
+// ── Q4_0 / Q6_K kernels (Gemma 4 26B-A4B's, shared: Gemma 4, LFM2.5 24B-A2B and the qwen35moe Q4_0 files) ──
+// Q4_0 as two planes (ingest's splitQ4): nibbles, 16 bytes per 32 values (byte j holds values j and j + 16),
+// and one f16 scale per 32. Value = (nibble − 8) · scale, as ggml dequantizes it. Each thread reads one u32 of
+// nibbles: values 4m..4m+3 (low nibbles) and 16+4m..16+4m+3 (high nibbles) of block b.
+export const Q4DOT = `
+fn q4dot(wd: u32, d: f32, xb: u32) -> f32 {
+  let lo = (f32(wd & 15u) - 8.0) * xin[xb] + (f32((wd >> 8u) & 15u) - 8.0) * xin[xb + 1u]
+         + (f32((wd >> 16u) & 15u) - 8.0) * xin[xb + 2u] + (f32((wd >> 24u) & 15u) - 8.0) * xin[xb + 3u];
+  let hi = (f32((wd >> 4u) & 15u) - 8.0) * xin[xb + 16u] + (f32((wd >> 12u) & 15u) - 8.0) * xin[xb + 17u]
+         + (f32((wd >> 20u) & 15u) - 8.0) * xin[xb + 18u] + (f32((wd >> 28u) & 15u) - 8.0) * xin[xb + 19u];
+  return d * (lo + hi);
+}`;
+// Q6_K (ggml block_q6_K: ql[128], qh[64], int8 scales[16], f16 d per 256 values). The GGUF's 210-byte blocks
+// sit at 2-byte alignment, so at load q6kPlanes splits the table on the GPU into aligned planes: ql (32 words
+// per block), qh (16), scales (4) and d as f32. q6v reads value t of block bi exactly as dequantize_row_q6_K
+// forms it: (d · scale) · (q − 32).
+export const Q6P = `
+@group(0) @binding(0) var<storage, read> ql: array<u32>;
+@group(0) @binding(1) var<storage, read> qh: array<u32>;
+@group(0) @binding(2) var<storage, read> sc: array<u32>;
+@group(0) @binding(3) var<storage, read> dd: array<f32>;
+fn sc8(bi: u32, si: u32) -> f32 { let s8 = (sc[bi * 4u + (si >> 2u)] >> ((si & 3u) * 8u)) & 0xffu; return f32(select(i32(s8), i32(s8) - 256, s8 >= 128u)); }
+fn q6v(bi: u32, t: u32) -> f32 {
+  let n = t >> 7u; let r = t & 127u; let qd = r >> 5u; let l = r & 31u;
+  let qb = n * 64u + l + (qd & 1u) * 32u;
+  let lo = (ql[bi * 32u + (qb >> 2u)] >> ((qb & 3u) * 8u)) & 0xffu;
+  let q4 = select(lo & 15u, lo >> 4u, qd >= 2u);
+  let hb = n * 32u + l;
+  let h = (qh[bi * 16u + (hb >> 2u)] >> ((hb & 3u) * 8u + qd * 2u)) & 3u;
+  return dd[bi] * sc8(bi, n * 8u + (l >> 4u) + qd * 2u) * f32(i32(q4 | (h << 4u)) - 32);
+}`;
+// ── Subgroup Q4_0 GEMVs (decode) ─────────────────────────────────────────────────
+// One 32-lane subgroup per output row, 4 rows per 128-thread workgroup (the scalar kernels' dispatch
+// geometry). A lane takes whole blocks: one vec4<u32> of nibbles, unpack4xU8 of the low and high nibble
+// masks, vec4 dot products against the activations, the block scale once; subgroupAdd reduces the row.
+// Used only when the adapter's subgroups are exactly 32 wide.
+const Q4BLK = `
+fn q4blk(w: vec4<u32>, xb: u32) -> f32 {
+  let m = 0x0f0f0f0fu;
+  return dot(vec4<f32>(unpack4xU8(w.x & m)) - 8.0, x[xb]) + dot(vec4<f32>(unpack4xU8((w.x >> 4u) & m)) - 8.0, x[xb + 4u])
+       + dot(vec4<f32>(unpack4xU8(w.y & m)) - 8.0, x[xb + 1u]) + dot(vec4<f32>(unpack4xU8((w.y >> 4u) & m)) - 8.0, x[xb + 5u])
+       + dot(vec4<f32>(unpack4xU8(w.z & m)) - 8.0, x[xb + 2u]) + dot(vec4<f32>(unpack4xU8((w.z >> 4u) & m)) - 8.0, x[xb + 6u])
+       + dot(vec4<f32>(unpack4xU8(w.w & m)) - 8.0, x[xb + 3u]) + dot(vec4<f32>(unpack4xU8((w.w >> 4u) & m)) - 8.0, x[xb + 7u]);
+}`;
+const QB4 = 'struct Q { T: u32, pos0: u32, S: u32, pad: u32 }';
+export const Q4_KERNELS = {
+  // The GGUF's Q6_K bytes (raw) → aligned planes; one thread per block.
+  q6kPlanes: `
+struct P { blocks: u32 }
+@group(0) @binding(0) var<storage, read> raw: array<u32>;
+@group(0) @binding(1) var<storage, read_write> ql: array<u32>;
+@group(0) @binding(2) var<storage, read_write> qh: array<u32>;
+@group(0) @binding(3) var<storage, read_write> sc: array<u32>;
+@group(0) @binding(4) var<storage, read_write> dd: array<f32>;
+@group(0) @binding(5) var<uniform> p: P;
+fn byteAt(i: u32) -> u32 { return (raw[i >> 2u] >> ((i & 3u) * 8u)) & 0xffu; }
+fn wordAt(i: u32) -> u32 { return byteAt(i) | (byteAt(i + 1u) << 8u) | (byteAt(i + 2u) << 16u) | (byteAt(i + 3u) << 24u); }
+@compute @workgroup_size(256) fn main(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) ng: vec3<u32>) {
+  let b = g.y * ng.x * 256u + g.x; if (b >= p.blocks) { return; }
+  let o = b * 210u;
+  for (var i = 0u; i < 32u; i++) { ql[b * 32u + i] = wordAt(o + 4u * i); }
+  for (var i = 0u; i < 16u; i++) { qh[b * 16u + i] = wordAt(o + 128u + 4u * i); }
+  for (var i = 0u; i < 4u; i++) { sc[b * 4u + i] = wordAt(o + 192u + 4u * i); }
+  dd[b] = unpack2x16float(byteAt(o + 208u) | (byteAt(o + 209u) << 8u)).x;
+}`,
+  embedQ6K: `
+${TOK}
+struct P { n: u32, nb: u32, scale: f32 }
+${Q6P}
+@group(0) @binding(4) var<storage, read_write> y: array<f32>;
+@group(0) @binding(5) var<uniform> tok: Tok;
+@group(0) @binding(6) var<uniform> p: P;
+@compute @workgroup_size(256) fn main(@builtin(global_invocation_id) g: vec3<u32>) {
+  let i = g.x; if (i >= p.n) { return; }
+  y[i] = q6v(tok.token * p.nb + (i >> 8u), i & 255u) * p.scale;
+}`,
+  // Logits over the Q6_K planes: 4 rows per 256-thread workgroup, 64 threads per row; thread j takes quad j
+  // (4 consecutive values: one ql word, one qh word, one scale) of every block of the row.
+  matmulQ6K: `
+struct P { M: u32, N: u32 }
+${Q6P}
+@group(0) @binding(4) var<storage, read> x: array<vec4<f32>>;
+@group(0) @binding(5) var<storage, read_write> y: array<f32>;
+@group(0) @binding(6) var<uniform> p: P;
+var<workgroup> part: array<f32, 256>;
+@compute @workgroup_size(256) fn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) ng: vec3<u32>, @builtin(local_invocation_id) l: vec3<u32>) {
+  let j = l.x & 63u; let m = (wg.y * ng.x + wg.x) * 4u + (l.x >> 6u); let mr = min(m, p.M - 1u);
+  let nb = p.N / 256u; let n = j >> 5u; let w = j & 31u; let qd = w >> 3u; let k = w & 7u;
+  var acc = 0.0;
+  for (var bb = 0u; bb < nb; bb++) {
+    let bi = mr * nb + bb;
+    let lo = unpack4xU8(ql[bi * 32u + n * 16u + (qd & 1u) * 8u + k]);
+    let q4 = select(lo & vec4<u32>(15u), lo >> vec4<u32>(4u), qd >= 2u);
+    let h = (unpack4xU8(qh[bi * 16u + n * 8u + k]) >> vec4<u32>(qd * 2u)) & vec4<u32>(3u);
+    let q = vec4<f32>(vec4<i32>(q4 | (h << vec4<u32>(4u))) - vec4<i32>(32));
+    acc += (dd[bi] * sc8(bi, n * 8u + (k >> 2u) + qd * 2u)) * dot(q, x[bb * 64u + j]);
+  }
+  part[l.x] = acc; workgroupBarrier();
+  for (var s = 32u; s > 0u; s >>= 1u) { if (j < s) { part[l.x] += part[l.x + s]; } workgroupBarrier(); }
+  if (j == 0u && m < p.M) { y[m] = part[l.x]; }
+}`,
+  // Dense Q4_0 GEMV, 4 output rows per workgroup (2-D dispatch ok).
+  matmulQ4: `enable f16;
+struct P { M: u32, N: u32 }
+@group(0) @binding(0) var<storage, read> xin: array<f32>;
+@group(0) @binding(1) var<storage, read> qw: array<u32>;
+@group(0) @binding(2) var<storage, read> qs: array<f16>;
+@group(0) @binding(3) var<storage, read_write> y: array<f32>;
+@group(0) @binding(4) var<uniform> p: P;
+${Q4DOT}
+var<workgroup> part: array<f32, 1024>;
+@compute @workgroup_size(256) fn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) ng: vec3<u32>, @builtin(local_invocation_id) l: vec3<u32>) {
+  let m0 = (wg.y * ng.x + wg.x) * 4u; let t = l.x; let M = p.M; let nw = p.N / 8u; let nb = p.N / 32u;
+  if (m0 >= M) { return; }
+  let r0 = min(m0, M - 1u); let r1 = min(m0 + 1u, M - 1u); let r2 = min(m0 + 2u, M - 1u); let r3 = min(m0 + 3u, M - 1u);
+  var a0 = 0.0; var a1 = 0.0; var a2 = 0.0; var a3 = 0.0;
+  for (var w = t; w < nw; w += 256u) {
+    let b = w >> 2u; let xb = b * 32u + (w & 3u) * 4u;
+    a0 += q4dot(qw[r0 * nw + w], f32(qs[r0 * nb + b]), xb);
+    a1 += q4dot(qw[r1 * nw + w], f32(qs[r1 * nb + b]), xb);
+    a2 += q4dot(qw[r2 * nw + w], f32(qs[r2 * nb + b]), xb);
+    a3 += q4dot(qw[r3 * nw + w], f32(qs[r3 * nb + b]), xb);
+  }
+  part[t] = a0; part[256u + t] = a1; part[512u + t] = a2; part[768u + t] = a3;
+  workgroupBarrier();
+  for (var s = 128u; s > 0u; s >>= 1u) {
+    if (t < s) { part[t] += part[t + s]; part[256u + t] += part[256u + t + s]; part[512u + t] += part[512u + t + s]; part[768u + t] += part[768u + t + s]; }
+    workgroupBarrier();
+  }
+  if (t < 4u && m0 + t < M) { y[m0 + t] = part[t * 256u]; }
+}`,
+  // Routed experts, all k at once (workgroup z = top-k position); slots[z] picks the expert's rows in the pool.
+  expertQ4: `enable f16;
+struct P { M: u32, N: u32, rowsPerExpert: u32, inputPerSlot: u32 }
+@group(0) @binding(0) var<storage, read> xin: array<f32>;
+@group(0) @binding(1) var<storage, read> qw: array<u32>;
+@group(0) @binding(2) var<storage, read> qs: array<f16>;
+@group(0) @binding(3) var<storage, read_write> y: array<f32>;
+@group(0) @binding(4) var<uniform> p: P;
+@group(0) @binding(5) var<storage, read> slots: array<u32>;
+${Q4DOT}
+var<workgroup> part: array<f32, 1024>;
+@compute @workgroup_size(256) fn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) ng: vec3<u32>, @builtin(local_invocation_id) l: vec3<u32>) {
+  let z = wg.z; let m0 = (wg.y * ng.x + wg.x) * 4u; let t = l.x; let M = p.M; let nw = p.N / 8u; let nb = p.N / 32u;
+  if (m0 >= M) { return; }
+  let rb = slots[z] * p.rowsPerExpert;
+  let xo = select(0u, z * p.N, p.inputPerSlot == 1u);
+  let r0 = rb + min(m0, M - 1u); let r1 = rb + min(m0 + 1u, M - 1u); let r2 = rb + min(m0 + 2u, M - 1u); let r3 = rb + min(m0 + 3u, M - 1u);
+  var a0 = 0.0; var a1 = 0.0; var a2 = 0.0; var a3 = 0.0;
+  for (var w = t; w < nw; w += 256u) {
+    let b = w >> 2u; let xb = xo + b * 32u + (w & 3u) * 4u;
+    a0 += q4dot(qw[r0 * nw + w], f32(qs[r0 * nb + b]), xb);
+    a1 += q4dot(qw[r1 * nw + w], f32(qs[r1 * nb + b]), xb);
+    a2 += q4dot(qw[r2 * nw + w], f32(qs[r2 * nb + b]), xb);
+    a3 += q4dot(qw[r3 * nw + w], f32(qs[r3 * nb + b]), xb);
+  }
+  part[t] = a0; part[256u + t] = a1; part[512u + t] = a2; part[768u + t] = a3;
+  workgroupBarrier();
+  for (var s = 128u; s > 0u; s >>= 1u) {
+    if (t < s) { part[t] += part[t + s]; part[256u + t] += part[256u + t + s]; part[512u + t] += part[512u + t + s]; part[768u + t] += part[768u + t + s]; }
+    workgroupBarrier();
+  }
+  if (t < 4u && m0 + t < M) { y[z * M + m0 + t] = part[t * 256u]; }
+}`,
+};
+export const Q4_SG_KERNELS = {
+  matmulQ4: `enable f16;
+enable subgroups;
+struct P { M: u32, N: u32 }
+@group(0) @binding(0) var<storage, read> x: array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read> qw: array<vec4<u32>>;
+@group(0) @binding(2) var<storage, read> qs: array<f16>;
+@group(0) @binding(3) var<storage, read_write> y: array<f32>;
+@group(0) @binding(4) var<uniform> p: P;
+${Q4BLK}
+@compute @workgroup_size(128) fn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) ng: vec3<u32>, @builtin(local_invocation_id) l: vec3<u32>) {
+  let m = (wg.y * ng.x + wg.x) * 4u + l.x / 32u; let lane = l.x % 32u;
+  let nb = p.N / 32u; let rb = min(m, p.M - 1u) * nb;
+  var acc = 0.0;
+  for (var b = lane; b < nb; b += 32u) { acc += q4blk(qw[rb + b], b * 8u) * f32(qs[rb + b]); }
+  let total = subgroupAdd(acc);
+  if (lane == 0u && m < p.M) { y[m] = total; }
+}`,
+  expertQ4: `enable f16;
+enable subgroups;
+struct P { M: u32, N: u32, rowsPerExpert: u32, inputPerSlot: u32 }
+@group(0) @binding(0) var<storage, read> x: array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read> qw: array<vec4<u32>>;
+@group(0) @binding(2) var<storage, read> qs: array<f16>;
+@group(0) @binding(3) var<storage, read_write> y: array<f32>;
+@group(0) @binding(4) var<uniform> p: P;
+@group(0) @binding(5) var<storage, read> slots: array<u32>;
+${Q4BLK}
+@compute @workgroup_size(128) fn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) ng: vec3<u32>, @builtin(local_invocation_id) l: vec3<u32>) {
+  let z = wg.z; let m = (wg.y * ng.x + wg.x) * 4u + l.x / 32u; let lane = l.x % 32u;
+  let nb = p.N / 32u; let rb = (slots[z] * p.rowsPerExpert + min(m, p.M - 1u)) * nb;
+  let xo = select(0u, z * p.N / 4u, p.inputPerSlot == 1u);
+  var acc = 0.0;
+  for (var b = lane; b < nb; b += 32u) { acc += q4blk(qw[rb + b], xo + b * 8u) * f32(qs[rb + b]); }
+  let total = subgroupAdd(acc);
+  if (lane == 0u && m < p.M) { y[z * p.M + m] = total; }
+}`,
+};
+export const Q4_BATCH_KERNELS = {
+  embedQ6KB: `
+struct P { n: u32, nb: u32, scale: f32 }
+${QB4}
+${Q6P}
+@group(0) @binding(4) var<storage, read> ids: array<u32>;
+@group(0) @binding(5) var<storage, read_write> y: array<f32>;
+@group(0) @binding(6) var<uniform> p: P;
+@group(0) @binding(7) var<uniform> qd: Q;
+@compute @workgroup_size(256) fn main(@builtin(global_invocation_id) g: vec3<u32>) {
+  let i = g.x; let t = g.y; if (i >= p.n || t >= qd.T) { return; }
+  y[t * p.n + i] = q6v(ids[t] * p.nb + (i >> 8u), i & 255u) * p.scale;
+}`,
+  // Tiled Q4_0 GEMM: y[t·M + m] = Σ_k x[t·N + k]·W[m][k]. 16 rows × 16 tokens per workgroup; each 32-wide
+  // block of W (decoded from its nibbles) and of x goes through shared memory, so a weight serves 16 tokens.
+  // Dispatch (ceil(M/16), ceil(T/16)).
+  matmulQ4T: `enable f16;
+struct P { M: u32, N: u32 }
+${QB4}
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read> qw: array<u32>;
+@group(0) @binding(2) var<storage, read> qs: array<f16>;
+@group(0) @binding(3) var<storage, read_write> y: array<f32>;
+@group(0) @binding(4) var<uniform> p: P;
+@group(0) @binding(5) var<uniform> qd: Q;
+var<workgroup> ws: array<f32, 512>;
+var<workgroup> xs: array<f32, 512>;
+@compute @workgroup_size(256) fn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) l: vec3<u32>) {
+  let m0 = wg.x * 16u; let t0 = wg.y * 16u; let r = l.x / 16u; let c = l.x % 16u;
+  let nb = p.N / 32u; let nw = p.N / 8u; var acc = 0.0;
+  for (var b = 0u; b < nb; b++) {
+    for (var i = l.x; i < 512u; i += 256u) {
+      let rr = i / 32u; let kk = i % 32u;
+      let m = m0 + rr; var wv = 0.0;
+      if (m < p.M) {
+        let wd = qw[m * nw + b * 4u + ((kk & 15u) >> 2u)];
+        wv = (f32((wd >> ((kk & 3u) * 8u + (kk >> 4u) * 4u)) & 15u) - 8.0) * f32(qs[m * nb + b]);
+      }
+      ws[i] = wv;
+      let t = t0 + rr; var xv = 0.0;
+      if (t < qd.T) { xv = x[t * p.N + b * 32u + kk]; }
+      xs[i] = xv;
+    }
+    workgroupBarrier();
+    for (var kk = 0u; kk < 32u; kk++) { acc += ws[r * 32u + kk] * xs[c * 32u + kk]; }
+    workgroupBarrier();
+  }
+  let m = m0 + r; let t = t0 + c;
+  if (m < p.M && t < qd.T) { y[t * p.M + m] = acc; }
+}`,
+  // Routed experts for every (token, pick) pair: z = t·K + j, slots[z] its pool slot. Input: the token's row
+  // (gate/up, inputMode 0) or the pair's own row (down, inputMode 1).
+  expertQ4B: `enable f16;
+struct P { M: u32, N: u32, rowsPerExpert: u32, inputMode: u32, K: u32 }
+@group(0) @binding(0) var<storage, read> xin: array<f32>;
+@group(0) @binding(1) var<storage, read> qw: array<u32>;
+@group(0) @binding(2) var<storage, read> qs: array<f16>;
+@group(0) @binding(3) var<storage, read_write> y: array<f32>;
+@group(0) @binding(4) var<uniform> p: P;
+@group(0) @binding(5) var<storage, read> slots: array<u32>;
+${Q4DOT}
+var<workgroup> part: array<f32, 1024>;
+@compute @workgroup_size(256) fn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) ng: vec3<u32>, @builtin(local_invocation_id) l: vec3<u32>) {
+  let z = wg.z; let m0 = (wg.y * ng.x + wg.x) * 4u; let t = l.x; let M = p.M; let nw = p.N / 8u; let nb = p.N / 32u;
+  if (m0 >= M) { return; }
+  let rb = slots[z] * p.rowsPerExpert;
+  let xo = select((z / p.K) * p.N, z * p.N, p.inputMode == 1u);
+  let r0 = rb + min(m0, M - 1u); let r1 = rb + min(m0 + 1u, M - 1u); let r2 = rb + min(m0 + 2u, M - 1u); let r3 = rb + min(m0 + 3u, M - 1u);
+  var a0 = 0.0; var a1 = 0.0; var a2 = 0.0; var a3 = 0.0;
+  for (var w = t; w < nw; w += 256u) {
+    let b = w >> 2u; let xb = xo + b * 32u + (w & 3u) * 4u;
+    a0 += q4dot(qw[r0 * nw + w], f32(qs[r0 * nb + b]), xb);
+    a1 += q4dot(qw[r1 * nw + w], f32(qs[r1 * nb + b]), xb);
+    a2 += q4dot(qw[r2 * nw + w], f32(qs[r2 * nb + b]), xb);
+    a3 += q4dot(qw[r3 * nw + w], f32(qs[r3 * nb + b]), xb);
+  }
+  part[t] = a0; part[256u + t] = a1; part[512u + t] = a2; part[768u + t] = a3;
+  workgroupBarrier();
+  for (var s = 128u; s > 0u; s >>= 1u) {
+    if (t < s) { part[t] += part[t + s]; part[256u + t] += part[256u + t + s]; part[512u + t] += part[512u + t + s]; part[768u + t] += part[768u + t + s]; }
+    workgroupBarrier();
+  }
+  if (t < 4u && m0 + t < M) { y[z * M + m0 + t] = part[t * 256u]; }
+}`,
+};
+
 export const STORAGE = 0x80, COPY_SRC = 0x04, COPY_DST = 0x08, UNIFORM = 0x40, MAP_READ = 0x01;
 
 // ── Engine ──────────────────────────────────────────────────────────────────
@@ -839,10 +1137,10 @@ export class Qwen3MoeSsd {
   }
   // The token's embedding into a.x, and the head (final norm, logits, argmax when wanted): a subclass
   // with another embedding or head format overrides these two.
-  encodeEmbed(pass) { this.dispatch(pass, 'embedQ8', this.g.embed, Math.ceil(this.cfg.hidden / 256)); }
+  encodeEmbed(pass) { this.dispatch(pass, this.qk ? this.qk.emb : 'embedQ8', this.g.embed, Math.ceil(this.cfg.hidden / 256)); }
   encodeHead(pass, want) {
     this.dispatch(pass, 'rmsnorm', this.g.rmsOut, 1);
-    this.dispatch(pass, 'matmulQ8', this.g.lm, Math.ceil(this.cfg.vocab / 4));
+    this.dispatch(pass, this.qk ? this.qk.lm : 'matmulQ8', this.g.lm, Math.ceil(this.cfg.vocab / 4));
     if (want === 'argmax') this.dispatch(pass, 'argmax', this.g.am, 1);
   }
   encodeExperts(pass, l) {

package/ggml/dist/BUILD.md

@@ -4,7 +4,7 @@
 because diskformer.naklitechie.com and the HF Space serve them and their CI has no Emscripten; the npm package ships them
 as `diskformer/llama`.
 
-Built from the fork `NakliTechie/llama.cpp` branch `webgpu-diskformer` at `377491df7` (upstream master of 2026-10-14 merged in), Emscripten 6.0.1 (Homebrew),
+Built from the fork `NakliTechie/llama.cpp` branch `webgpu-diskformer` at `ecaa47b29` (upstream master of 2026-10-22 merged in, which adds Flint), Emscripten 6.0.13 (Homebrew),
 emdawnwebgpu from the fork's `emdawnwebgpu_pkg`, all C++ with `-fwasm-exceptions`. Rebuild (copies here as a
 post-build step):
 
@@ -12,7 +12,7 @@ post-build step):
 
 sha256 (check a copy with `shasum -a 256`):
 
-    701e17b9dca2fa6c86853daf724c08a217f16ad91ce10b3bce711ccf63f9172c  df-chat.wasm
-    2267afb7b9ee76149748956cc2418202526e4f2144784268cf7bdabf5127e062  df-chat.mjs
+    cc2d43b6fbf5f9fe0848ebc42deb79365b5765f99a973eeadeb11fbbc6b0b4d8  df-chat.wasm
+    43dea00df2a5345efc65c6521b825032670447bac854d2d346aa82132b3b37f9  df-chat.mjs
 
 Update the fork commit and the checksums whenever the build changes.