@seanhogg/builderforce-memory-engine 2026.7.14 → 2026.9.27

package/src/kernels/slice.ts

@@ -0,0 +1,64 @@
+/**
+ * slice.ts — strided COLUMN slice of a row-major (rows, stride) tensor.
+ *
+ * Every block in this engine projects into one fused tensor and then splits it:
+ * Mamba-1 into (x, z) and (Δ, B, C), Mamba-2/3 into (x, Δ) and (x, B, C),
+ * attention into (Q, K, V). `LINEAR_FORWARD_WGSL` writes its output `(M, N)`
+ * ROW-major, so each of those parts is a contiguous range of COLUMNS **within
+ * every row** — not a contiguous range of the buffer.
+ *
+ * Splitting them with `copyBufferToBuffer` therefore took whole ROWS instead: it
+ * is only the right answer when `M == 1` (batch × seq_len), and for any real
+ * sequence it silently handed the block the wrong tensor. This kernel is the one
+ * correct implementation; every block uses it.
+ */
+
+import { createBindGroup, createUniformBuffer, dispatchKernel, cdiv } from '../utils/gpu_utils.js';
+
+export const COL_SLICE_WGSL: string = /* wgsl */`
+struct SliceParams {
+    rows   : u32,
+    stride : u32,   // source row width
+    offset : u32,   // first column to take
+    width  : u32,   // number of columns to take
+};
+@group(0) @binding(0) var<uniform>             p   : SliceParams;
+@group(0) @binding(1) var<storage, read>       src : array<f32>;
+@group(0) @binding(2) var<storage, read_write> dst : array<f32>;
+
+// Dispatch: (ceil(rows * width / 256), 1, 1)
+@compute @workgroup_size(256)
+fn col_slice(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i >= p.rows * p.width) { return; }
+    let r = i / p.width;
+    let c = i % p.width;
+    dst[i] = src[r * p.stride + p.offset + c];
+}
+`;
+
+/** Entry point name of {@link COL_SLICE_WGSL}. */
+export const COL_SLICE_ENTRY = 'col_slice';
+
+/**
+ * `dst[r, 0..width) = src[r, offset..offset+width)` for every row.
+ *
+ * @param pipeline a pipeline built from {@link COL_SLICE_WGSL} / {@link COL_SLICE_ENTRY}
+ * @param rows     batch * seqLen
+ * @param stride   source row width (the fused projection's output features)
+ */
+export function dispatchColumnSlice(
+    device: GPUDevice,
+    pipeline: GPUComputePipeline,
+    src: GPUBuffer,
+    dst: GPUBuffer,
+    rows: number,
+    stride: number,
+    offset: number,
+    width: number,
+): void {
+    const pBuf = createUniformBuffer(device, new Uint32Array([rows, stride, offset, width]).buffer);
+    const bg = createBindGroup(device, pipeline, [pBuf, src, dst]);
+    dispatchKernel(device, pipeline, bg, [cdiv(rows * width, 256), 1, 1]);
+    pBuf.destroy();
+}

package/src/kernels/weight_update.ts

@@ -79,6 +79,20 @@ fn adamw_update(
 
 // Gradient clipping kernel – clips global gradient norm to max_norm.
 // Run before weight updates.  Two-pass: first compute squared norm, then scale.
+//
+// The accumulator is a REAL atomic. It used to be a plain `array<f32>` written as
+// `norm_sq[0] = norm_sq[0] + local_sq[0]` by the lane-0 invocation of every
+// workgroup — a read-modify-write with no synchronisation, so with more than one
+// workgroup (i.e. any tensor above 256 elements) concurrent workgroups lost each
+// other's contributions and the norm came out too SMALL, under-clipping exactly
+// when clipping matters most. WGSL has no `atomic<f32>`, so the accumulator is an
+// `atomic<u32>` holding the f32 bit pattern and updated with a
+// compare-exchange loop — the standard portable float-atomic-add.
+//
+// Summation ORDER across workgroups is not deterministic (floating-point addition
+// is not associative), so the norm can differ in the last ulp or two between runs.
+// That is fine for a clip threshold and is the accepted trade for correctness;
+// nothing downstream depends on a bit-exact norm.
 export const GRAD_CLIP_WGSL: string = /* wgsl */`
 
 struct ClipParams {
@@ -88,10 +102,23 @@ struct ClipParams {
 
 @group(0) @binding(0) var<uniform>             clip_p  : ClipParams;
 @group(0) @binding(1) var<storage, read_write> grad    : array<f32>;
-@group(0) @binding(2) var<storage, read_write> norm_sq : array<f32>;  // size 1, atomic accumulator
+// size 1 – the f32 bit pattern of the accumulated sum of squares, updated
+// atomically. Zero-initialise it by writing 0.0f (bit pattern 0x00000000).
+@group(0) @binding(2) var<storage, read_write> norm_sq : array<atomic<u32>>;
 
 var<workgroup> local_sq : array<f32, 256>;
 
+// Portable atomic add on an f32 stored as its u32 bit pattern.
+fn atomic_add_f32(value: f32) {
+    var old_bits : u32 = atomicLoad(&norm_sq[0]);
+    loop {
+        let new_bits = bitcast<u32>(bitcast<f32>(old_bits) + value);
+        let res = atomicCompareExchangeWeak(&norm_sq[0], old_bits, new_bits);
+        if (res.exchanged) { break; }
+        old_bits = res.old_value;
+    }
+}
+
 // Pass 1: reduce sum of squares into norm_sq[0]
 @compute @workgroup_size(256, 1, 1)
 fn grad_norm_reduce(
@@ -117,8 +144,7 @@ fn grad_norm_reduce(
     }
 
     if (lid == 0u) {
-        // Non-atomic accumulation (single workgroup assumption for small models)
-        norm_sq[0] = norm_sq[0] + local_sq[0];
+        atomic_add_f32(local_sq[0]);
     }
 }
 
@@ -130,7 +156,7 @@ fn grad_clip_scale(
     let i = gid.x;
     if (i >= clip_p.num_elements) { return; }
 
-    let ns = norm_sq[0];
+    let ns = bitcast<f32>(atomicLoad(&norm_sq[0]));
     if (ns > clip_p.max_norm_sq) {
         let scale = sqrt(clip_p.max_norm_sq / ns);
         grad[i] = grad[i] * scale;

package/src/lm/evermind_lm.ts

@@ -102,9 +102,37 @@ export interface LMGenerateOptions {
   stopToken?: number;
 }
 
+/**
+ * Incremental decode state — everything a continuation needs from the prefix.
+ *
+ * The model's only cross-position dependency is the depthwise causal conv, whose
+ * receptive field is `convKernel` positions, so the entire "KV cache" is the
+ * trailing `convKernel - 1` normalised conv inputs per layer. That makes an exact
+ * prefix cache cheap: process a prompt once, then extend it with each candidate
+ * continuation for the cost of the candidate alone.
+ */
+export interface EvermindLMDecodeState {
+  /** [layer][slot] the trailing `convKernel - 1` RMSNormed conv inputs, oldest first. */
+  convWindow: Float32Array[][];
+  /** Positions consumed so far. */
+  length: number;
+  /** Logits at the LAST consumed position — what predicts the next token. */
+  lastLogits: Float32Array | null;
+}
+
 export class EvermindLM {
   readonly config: Required<Omit<EvermindLMConfig, "seed">>;
 
+  /**
+   * Token-positions pushed through a block since the last {@link resetStats}.
+   *
+   * The cost metric that matters for the tool-calling path: scoring N candidate
+   * tool names used to replay the WHOLE prompt N times, so this counted
+   * N x (prompt + candidate) x layers. With {@link stepDecode} the prompt is paid
+   * for once. Exposed so a benchmark can assert the saving rather than assume it.
+   */
+  private _positionsEvaluated = 0;
+
   /** Tied token embedding / output head: vocabSize × dModel (row-major). */
   emb: Float32Array;
   private gEmb: Float32Array;
@@ -201,48 +229,81 @@ export class EvermindLM {
    * instead of retaining every layer's cache at once.
    */
   private _forwardLayer(l: number, layerIn: Float32Array[]): { afterMoe: Float32Array[]; cache: LayerCache } {
-    const { dModel, convKernel } = this.config;
     const T = layerIn.length;
-    const ker = this.conv[l]!;
-    const nConv = this.nConv[l]!;
-    const nMoe = this.nMoe[l]!;
+    const window: Float32Array[] = [];
 
     const normedConv: Float32Array[] = [];
     const rmsConv: number[] = [];
-    for (let t = 0; t < T; t++) {
-      const { y, r } = rmsNorm(layerIn[t]!, nConv);
-      normedConv.push(y);
-      rmsConv.push(r);
-    }
     const afterConv: Float32Array[] = [];
-    for (let t = 0; t < T; t++) {
-      const out = Float32Array.from(layerIn[t]!); // residual base
-      for (let c = 0; c < dModel; c++) {
-        let acc = 0;
-        for (let j = 0; j < convKernel; j++) {
-          const ti = t - j;
-          if (ti >= 0) acc += ker[c * convKernel + j]! * normedConv[ti]![c]!;
-        }
-        out[c] = out[c]! + acc;
-      }
-      afterConv.push(out);
-    }
-
     const rmsMoe: number[] = [];
     const moeCache: MoECacheLike[] = [];
     const afterMoe: Float32Array[] = [];
+
     for (let t = 0; t < T; t++) {
-      const { y, r } = rmsNorm(afterConv[t]!, nMoe);
-      rmsMoe.push(r);
-      const out = Float32Array.from(afterConv[t]!); // residual base
-      const mr = this.moe[l]!.forward(y);
-      for (let c = 0; c < dModel; c++) out[c] = out[c]! + mr.output[c]!;
-      afterMoe.push(out);
-      moeCache.push(mr.cache as unknown as MoECacheLike);
+      const st = this._stepLayerPosition(l, layerIn[t]!, window);
+      normedConv.push(st.normed);
+      rmsConv.push(st.rmsConv);
+      afterConv.push(st.afterConv);
+      rmsMoe.push(st.rmsMoe);
+      moeCache.push(st.moeCache);
+      afterMoe.push(st.out);
     }
     return { afterMoe, cache: { layerIn, normedConv, rmsConv, afterConv, rmsMoe, moeCache } };
   }
 
+  /**
+   * ONE position through one (conv + MoE) block, given the trailing conv window.
+   *
+   * The single place the block's maths lives: the batch path
+   * ({@link _forwardLayer}, which needs the full activation cache for backward)
+   * and the incremental path ({@link stepDecode}, which needs none of it) both
+   * run this, so they cannot drift apart. `window` holds the previous
+   * `convKernel - 1` RMSNormed conv inputs, OLDEST FIRST, and is advanced in
+   * place — a shorter window is exactly the causal zero-padding at the start of
+   * a sequence.
+   */
+  private _stepLayerPosition(
+    l: number,
+    xt: Float32Array,
+    window: Float32Array[],
+  ): { normed: Float32Array; rmsConv: number; afterConv: Float32Array; rmsMoe: number; moeCache: MoECacheLike; out: Float32Array } {
+    const { dModel, convKernel } = this.config;
+    const ker = this.conv[l]!;
+
+    const { y: normed, r: rConv } = rmsNorm(xt, this.nConv[l]!);
+    const afterConv = Float32Array.from(xt); // residual base
+    for (let c = 0; c < dModel; c++) {
+      let acc = ker[c * convKernel]! * normed[c]!;
+      for (let j = 1; j < convKernel; j++) {
+        const prev = window[window.length - j];   // position t - j, or undefined before the start
+        if (prev) acc += ker[c * convKernel + j]! * prev[c]!;
+      }
+      afterConv[c] = afterConv[c]! + acc;
+    }
+    window.push(normed);
+    while (window.length > convKernel - 1) window.shift();
+
+    const { y: normedMoe, r: rMoe } = rmsNorm(afterConv, this.nMoe[l]!);
+    const out = Float32Array.from(afterConv); // residual base
+    const mr = this.moe[l]!.forward(normedMoe);
+    for (let c = 0; c < dModel; c++) out[c] = out[c]! + mr.output[c]!;
+
+    this._positionsEvaluated++;
+    return {
+      normed, rmsConv: rConv, afterConv, rmsMoe: rMoe,
+      moeCache: mr.cache as unknown as MoECacheLike, out,
+    };
+  }
+
+  /** One token's embedding row (a copy — callers write into it). */
+  private _embedOne(tok: number): Float32Array {
+    const { dModel } = this.config;
+    const row = new Float32Array(dModel);
+    const off = tok * dModel;
+    for (let c = 0; c < dModel; c++) row[c] = this.emb[off + c]!;
+    return row;
+  }
+
   /** Tied output head: logits_t[v] = x_t · emb[v]. */
   private _head(x: Float32Array[]): Float32Array[] {
     const { dModel, vocabSize } = this.config;
@@ -270,6 +331,61 @@ export class EvermindLM {
     return { logits: this._head(x), cache: { tokens, layers, finalX: x } };
   }
 
+  /**
+   * Produces a single fixed-length embedding vector for a token sequence — the
+   * CPU counterpart of `HybridMambaModel.embed()`, to the same contract.
+   *
+   * Runs the full block stack and takes the final hidden state — i.e. exactly the
+   * state the tied LM head consumes in {@link forward} — then mean-pools across
+   * sequence positions and L2-normalises. The result has length `dModel`, so
+   * cosine similarity between two embeddings reduces to a dot product.
+   *
+   * Like the GPU path it skips the (expensive) head projection: it only needs the
+   * `dModel`-wide hidden state, not `vocabSize` logits. Unlike the GPU path it
+   * needs no WebGPU device at all, which is what lets a headless host (the stdio
+   * MCP server) rank recall by SSM embedding instead of word overlap.
+   *
+   * Streamed one position at a time through the SHARED block implementation
+   * ({@link _stepLayerPosition}, the same routine {@link forward} and
+   * {@link stepDecode} run), so it can never drift from them and it retains no
+   * per-position activation cache.
+   *
+   * The embedding reflects whatever the model currently knows — an untrained
+   * model behaves like a random projection of the token embeddings (still
+   * lexically discriminative), and the representation sharpens as the model is
+   * adapted/distilled.
+   */
+  embed(tokenIds: number[] | Uint32Array): Float32Array {
+    const { dModel, numLayers } = this.config;
+    const out = new Float32Array(dModel);
+    const seqLen = tokenIds.length;
+    if (seqLen === 0) return out;
+
+    // One rolling conv window per layer — a shorter window at the start of the
+    // sequence IS the causal zero-padding, exactly as in stepDecode.
+    const windows: Float32Array[][] = Array.from({ length: numLayers }, () => [] as Float32Array[]);
+    for (let t = 0; t < seqLen; t++) {
+      let x = this._embedOne(tokenIds[t]!);
+      for (let l = 0; l < numLayers; l++) x = this._stepLayerPosition(l, x, windows[l]!).out;
+      for (let c = 0; c < dModel; c++) out[c] = out[c]! + x[c]!;
+    }
+
+    // Mean-pool across positions.
+    for (let c = 0; c < dModel; c++) out[c] = out[c]! / seqLen;
+
+    // L2-normalise so cosine similarity reduces to a dot product.
+    let norm = 0;
+    for (let c = 0; c < dModel; c++) norm += out[c]! * out[c]!;
+    norm = Math.sqrt(norm) || 1;
+    for (let c = 0; c < dModel; c++) out[c] = out[c]! / norm;
+    return out;
+  }
+
+  /** Text-level embedding: encode with `codec`, then {@link embed}. */
+  embedText(text: string, codec: TextCodec): Float32Array {
+    return this.embed(codec.encode(text));
+  }
+
   // ── Loss + backward ──────────────────────────────────────────────────────────
 
   /**
@@ -405,6 +521,80 @@ export class EvermindLM {
     return loss;
   }
 
+  // ── Incremental decoding (prefix cache) ──────────────────────────────────────
+
+  /** Positions pushed through a block since the last {@link resetStats}. */
+  get positionsEvaluated(): number { return this._positionsEvaluated; }
+  resetStats(): void { this._positionsEvaluated = 0; }
+
+  /** An empty decode state — the start of a sequence. */
+  newDecodeState(): EvermindLMDecodeState {
+    return {
+      convWindow: Array.from({ length: this.config.numLayers }, () => [] as Float32Array[]),
+      length: 0,
+      lastLogits: null,
+    };
+  }
+
+  /** Deep copy, so one prefix state can seed many independent continuations. */
+  cloneDecodeState(state: EvermindLMDecodeState): EvermindLMDecodeState {
+    return {
+      convWindow: state.convWindow.map((w) => w.map((v) => Float32Array.from(v))),
+      length: state.length,
+      lastLogits: state.lastLogits ? Float32Array.from(state.lastLogits) : null,
+    };
+  }
+
+  /**
+   * Consume `tokens` from `state`, returning the per-position logits and the
+   * ADVANCED state. `state` is not mutated — pass {@link cloneDecodeState} output
+   * or a fresh state; this clones internally so the caller's prefix stays reusable.
+   *
+   * Numerically identical to {@link forward} over the concatenated sequence: the
+   * shared {@link _stepLayerPosition} is the only implementation of the block.
+   */
+  stepDecode(state: EvermindLMDecodeState, tokens: number[]): { logits: Float32Array[]; state: EvermindLMDecodeState } {
+    const next = this.cloneDecodeState(state);
+    const logits: Float32Array[] = [];
+    for (const tok of tokens) {
+      let x = this._embedOne(tok);
+      for (let l = 0; l < this.config.numLayers; l++) {
+        x = this._stepLayerPosition(l, x, next.convWindow[l]!).out;
+      }
+      const lg = this._head([x])[0]!;
+      logits.push(lg);
+      next.lastLogits = lg;
+      next.length++;
+    }
+    return { logits, state: next };
+  }
+
+  /** Run a prompt once and keep the state, so continuations are cheap. */
+  prefixState(tokens: number[]): EvermindLMDecodeState {
+    return this.stepDecode(this.newDecodeState(), tokens).state;
+  }
+
+  /**
+   * Mean log-probability the model assigns to `continuation` following a cached
+   * prefix — the tool-decision vote, without replaying the prompt.
+   *
+   * Returns `-Infinity` for an empty continuation, and requires a prefix with at
+   * least one position (there must be a position to predict the first
+   * continuation token FROM).
+   */
+  scoreContinuation(prefix: EvermindLMDecodeState, continuation: number[]): number {
+    if (continuation.length === 0) return -Infinity;
+    if (!prefix.lastLogits) return -Infinity;
+    // The last prefix position predicts continuation[0]; each continuation
+    // position then predicts the next one, so the final one is never scored.
+    const { logits } = this.stepDecode(prefix, continuation.slice(0, -1));
+    let total = logProbOfToken(prefix.lastLogits, continuation[0]!);
+    for (let i = 1; i < continuation.length; i++) {
+      total += logProbOfToken(logits[i - 1]!, continuation[i]!);
+    }
+    return total / continuation.length;
+  }
+
   // ── Generation ───────────────────────────────────────────────────────────────
 
   /**
@@ -417,19 +607,24 @@ export class EvermindLM {
     return codec.decode(this.generate(codec.encode(prompt), opts));
   }
 
-  /** Greedy / temperature-sampled autoregressive generation. Returns NEW token ids. */
+  /**
+   * Greedy / temperature-sampled autoregressive generation. Returns NEW token ids.
+   *
+   * Carries an incremental decode state, so the prompt is processed ONCE and each
+   * new token costs one position. The previous implementation re-ran the whole
+   * sequence per token, making generation quadratic in the prompt length.
+   */
   generate(prompt: number[], opts: LMGenerateOptions): number[] {
     const temperature = opts.temperature ?? 0;
     const rng = temperature > 0 ? new SeededRng((opts.seed ?? 1) >>> 0 || 1) : null;
-    const tokens = [...prompt];
+    let state = this.stepDecode(this.newDecodeState(), prompt.length > 0 ? prompt : [0]).state;
     const produced: number[] = [];
     for (let n = 0; n < opts.maxNewTokens; n++) {
-      const { logits } = this.forward(tokens.length > 0 ? tokens : [0]);
-      const last = logits[logits.length - 1]!;
+      const last = state.lastLogits!;
       const next = rng ? sampleTemperature(last, temperature, rng) : argmax(last);
       produced.push(next);
-      tokens.push(next);
       if (opts.stopToken !== undefined && next === opts.stopToken) break;
+      state = this.stepDecode(state, [next]).state;
     }
     return produced;
   }
@@ -745,3 +940,18 @@ function sampleTemperature(logits: Float32Array, temperature: number, rng: Seede
   }
   return probs.length - 1;
 }
+
+/**
+ * Log-probability the model assigned to `id` at a position, from that position's
+ * raw logits. Log-softmax computed max-shifted so a long-tail logit cannot
+ * overflow `exp`.
+ */
+export function logProbOfToken(row: Float32Array, id: number): number {
+  let max = -Infinity;
+  for (let i = 0; i < row.length; i++) { const v = row[i]!; if (v > max) max = v; }
+  if (!Number.isFinite(max)) return -Infinity;
+  let sum = 0;
+  for (let i = 0; i < row.length; i++) sum += Math.exp(row[i]! - max);
+  const logit = id >= 0 && id < row.length ? row[id]! : -Infinity;
+  return logit - (max + Math.log(sum));
+}

package/src/lm/index.ts

@@ -2,8 +2,12 @@
  * EvermindLM — the generative language model (the runnable "AI").
  */
 
-export { EvermindLM, EvermindLMTrainer, DEFAULT_LM_CONFIG, DEFAULT_LM_SEED } from "./evermind_lm.js";
-export type { EvermindLMConfig, LMGenerateOptions, TextCodec, EvermindLMTrainOptions } from "./evermind_lm.js";
+export { EvermindLM, EvermindLMTrainer, DEFAULT_LM_CONFIG, DEFAULT_LM_SEED, logProbOfToken } from "./evermind_lm.js";
+export type { EvermindLMConfig, LMGenerateOptions, TextCodec, EvermindLMTrainOptions, EvermindLMDecodeState } from "./evermind_lm.js";
+
+// CPU text→vector embedder (semantic recall with no GPU).
+export { EvermindTextEmbedder } from "./text_embedder.js";
+export type { TextEmbedder, EmbedderCodec } from "./text_embedder.js";
 
 // PEFT / efficient-training toolkit (LoRA, QLoRA, mixed precision).
 export { LoRAAdapter, EvermindLMLoRA, quantizeBase } from "../training/lora.js";

package/src/lm/text_embedder.ts

@@ -0,0 +1,84 @@
+/**
+ * lm/text_embedder.ts — text → vector, on the CPU, from an `EvermindLM`.
+ *
+ * `EvermindLM.embed()` turns TOKENS into a `dModel` vector. Every consumer that
+ * wants SEMANTIC RECALL wants it over TEXT, and needs the vector to be stable
+ * across processes, so it also needs (a) the tokenizer that produced those ids
+ * and (b) a way to tell whether a cached vector came from this exact model. This
+ * class is that pairing, in one place, so no consumer re-derives it.
+ *
+ * It deliberately satisfies the SAME structural shape the memory runtime's
+ * `embed(text)` seam expects (`MemoryStore.recallRanked(query, k, runtime)`
+ * accepts anything with an async `embed(text): Float32Array`), so a headless host
+ * can hand one of these straight to the memory layer and get embedding-ranked
+ * recall with NO GPU — the CPU LM is the whole dependency.
+ */
+
+import type { EvermindLM, TextCodec } from "./evermind_lm.js";
+import { crc32 } from "../utils/crc32.js";
+
+/** The minimal text-embedder seam the memory/recall layers consume. */
+export interface TextEmbedder {
+  /** Embed `text` as an L2-normalised vector of length {@link dimensions}. */
+  embed(text: string): Promise<Float32Array>;
+  /** Vector width (the model's `dModel`). */
+  readonly dimensions: number;
+  /**
+   * Identity of the model+tokenizer that produces these vectors. Vectors are only
+   * comparable within one fingerprint, so a persistent cache MUST discard entries
+   * stamped with a different one.
+   */
+  readonly fingerprint: string;
+}
+
+/** A tokenizer this embedder can encode through (the engine's `BPETokenizer` fits). */
+export type EmbedderCodec = Pick<TextCodec, "encode">;
+
+/**
+ * Pairs an `EvermindLM` with the tokenizer whose ids it was trained on.
+ *
+ * Pure compute and stateless: caching belongs to whoever owns a lifetime (the
+ * memory store's in-process LRU, or a host's on-disk vector cache), not here.
+ */
+export class EvermindTextEmbedder implements TextEmbedder {
+  readonly dimensions: number;
+  readonly fingerprint: string;
+
+  constructor(
+    private readonly model: EvermindLM,
+    private readonly codec: EmbedderCodec,
+    /** Override the derived fingerprint (e.g. with a published model version). */
+    fingerprint?: string,
+  ) {
+    this.dimensions = model.config.dModel;
+    this.fingerprint = fingerprint ?? derivedFingerprint(model);
+  }
+
+  /**
+   * Embed `text`. Async only to match the seam — the work is synchronous CPU, so
+   * a caller that wants the vector without a microtask can use
+   * {@link embedSync}.
+   */
+  async embed(text: string): Promise<Float32Array> {
+    return this.embedSync(text);
+  }
+
+  /** The synchronous form — encode with the codec, then run the CPU LM. */
+  embedSync(text: string): Float32Array {
+    return this.model.embedText(text, this.codec as TextCodec);
+  }
+}
+
+/**
+ * Model identity: architecture plus a CRC-32 over the tied embedding table.
+ *
+ * The embedding table is the one tensor every position's vector flows through, so
+ * an adapted checkpoint (which is what a delta merge produces) always changes it —
+ * making this a cheap but honest "are these vectors still comparable?" stamp.
+ */
+function derivedFingerprint(model: EvermindLM): string {
+  const c = model.config;
+  const bytes = new Uint8Array(model.emb.buffer, model.emb.byteOffset, model.emb.byteLength);
+  const arch = [c.vocabSize, c.dModel, c.numLayers, c.convKernel, c.hiddenDim, c.numExperts, c.topK].join("-");
+  return `evermind-lm/${arch}/${crc32(bytes).toString(16)}`;
+}

package/src/model/attention_block.ts

@@ -36,6 +36,7 @@ import {
 import { LINEAR_FORWARD_WGSL } from '../kernels/linear_projection.js';
 import { gaussianArray } from '../utils/rng.js';
 import { ACTIVATIONS_WGSL }    from '../kernels/activations.js';
+import { COL_SLICE_WGSL, COL_SLICE_ENTRY, dispatchColumnSlice } from '../kernels/slice.js';
 
 import type { SequenceLayer, LayerForwardResult, LayerParam } from './sequence_layer.js';
 
@@ -147,6 +148,7 @@ export class AttentionBlock implements SequenceLayer {
             attn_fwd: createComputePipeline(d, ATTENTION_FORWARD_WGSL,  'attention_forward'),
             attn_val: createComputePipeline(d, ATTENTION_FORWARD_WGSL,  'attention_value'),
             softmax : createComputePipeline(d, SOFTMAX_WGSL,            'softmax_forward'),
+            colSlice: createComputePipeline(d, COL_SLICE_WGSL,          COL_SLICE_ENTRY),
             elAdd   : createComputePipeline(d, ADD_SHADER,              'main'),
         };
 
@@ -194,11 +196,13 @@ export class AttentionBlock implements SequenceLayer {
         const KBuf = createEmptyStorageBuffer(d, M * dModel * 4, true);
         const VBuf = createEmptyStorageBuffer(d, M * dModel * 4, true);
         {
-            const enc = d.createCommandEncoder();
-            enc.copyBufferToBuffer(qkvOut, 0,               QBuf, 0, M * dModel * 4);
-            enc.copyBufferToBuffer(qkvOut, M * dModel * 4,   KBuf, 0, M * dModel * 4);
-            enc.copyBufferToBuffer(qkvOut, 2 * M * dModel * 4, VBuf, 0, M * dModel * 4);
-            d.queue.submit([enc.finish()]);
+            // COLUMN split. `linear_forward` writes (M, 3*dModel) ROW-major, so Q, K
+            // and V are ranges of columns WITHIN every row — a strided gather, not a
+            // contiguous copy (which only coincides for M == 1).
+            const slice = this.pipelines['colSlice']!;
+            dispatchColumnSlice(d, slice, qkvOut, QBuf, M, 3 * dModel, 0, dModel);
+            dispatchColumnSlice(d, slice, qkvOut, KBuf, M, 3 * dModel, dModel, dModel);
+            dispatchColumnSlice(d, slice, qkvOut, VBuf, M, 3 * dModel, 2 * dModel, dModel);
         }
         qkvOut.destroy();