@seanhogg/builderforce-memory-engine 2026.6.31 → 2026.6.34

package/src/bench/metrics.ts

@@ -0,0 +1,98 @@
+/**
+ * bench/metrics.ts — pure scoring primitives over per-position logits.
+ *
+ * These are the building blocks the harness composes. They are exact, allocation
+ * -light, and numerically stable (cross-entropy reuses the engine's stable
+ * log-sum-exp). Nothing here trains or mutates the model — benchmarking is a
+ * read-only forward pass over held-out data.
+ */
+
+import { crossEntropyLoss } from "../training/autograd.js";
+
+/** Natural log of 2 — used to convert nats → bits. */
+export const LN2 = Math.LN2;
+
+/**
+ * Indices of the `k` largest logits, descending. O(V·k) — fine for the small
+ * top-k used in accuracy scoring; avoids a full sort of the vocab per position.
+ */
+export function topKIndices(logits: Float32Array, k: number): number[] {
+  const n = logits.length;
+  const kk = Math.max(1, Math.min(k, n));
+  const idx: number[] = [];
+  const used = new Uint8Array(n);
+  for (let s = 0; s < kk; s++) {
+    let best = -1;
+    let bestVal = -Infinity;
+    for (let i = 0; i < n; i++) {
+      if (used[i]) continue;
+      const v = logits[i]!;
+      if (v > bestVal) {
+        bestVal = v;
+        best = i;
+      }
+    }
+    if (best < 0) break;
+    used[best] = 1;
+    idx.push(best);
+  }
+  return idx;
+}
+
+/** Index of the single largest logit (argmax). */
+export function argmax(logits: Float32Array): number {
+  let best = 0;
+  let bestVal = -Infinity;
+  for (let i = 0; i < logits.length; i++) {
+    if (logits[i]! > bestVal) {
+      bestVal = logits[i]!;
+      best = i;
+    }
+  }
+  return best;
+}
+
+/** Perplexity from a mean cross-entropy (nats). */
+export function perplexity(meanCrossEntropy: number): number {
+  return Math.exp(meanCrossEntropy);
+}
+
+/** Bits-per-token from a mean cross-entropy (nats). */
+export function bitsPerToken(meanCrossEntropy: number): number {
+  return meanCrossEntropy / LN2;
+}
+
+/** Accumulator over predicted positions — cross-entropy + top-1/top-k hits. */
+export interface ScoreAccumulator {
+  tokens: number;
+  ceSum: number;
+  top1Hits: number;
+  topKHits: number;
+}
+
+export function newAccumulator(): ScoreAccumulator {
+  return { tokens: 0, ceSum: 0, top1Hits: 0, topKHits: 0 };
+}
+
+/**
+ * Score one (logits, targets) pair into the accumulator. `logits[t]` predicts
+ * `targets[t]`; positions with an out-of-range target are skipped. The caller
+ * aligns logits/targets (next-token: logits[0..T-2] predict tokens[1..T-1]).
+ */
+export function scoreInto(
+  acc: ScoreAccumulator,
+  logits: Float32Array[],
+  targets: number[],
+  k: number,
+): void {
+  const n = Math.min(logits.length, targets.length);
+  for (let t = 0; t < n; t++) {
+    const target = targets[t]!;
+    const lg = logits[t]!;
+    if (target < 0 || target >= lg.length) continue;
+    acc.ceSum += crossEntropyLoss(lg, target);
+    if (argmax(lg) === target) acc.top1Hits++;
+    if (topKIndices(lg, k).includes(target)) acc.topKHits++;
+    acc.tokens++;
+  }
+}

package/src/bench/types.ts

@@ -0,0 +1,121 @@
+/**
+ * bench/types.ts — public types for the Evermind benchmarking harness.
+ *
+ * Benchmarking answers the question the marketplace (and the "beats a frozen
+ * LLM" thesis) actually rests on: *how good is this model?* The harness measures
+ * a trained model on held-out data with the standard language-model yardsticks —
+ * perplexity, bits-per-token, and next-token accuracy — plus generation
+ * throughput, and can A/B two models (e.g. a quantized vs full-precision build,
+ * or a freshly-adapted vs prior checkpoint).
+ *
+ * The metrics operate on any object that can produce per-position logits from a
+ * token sequence — the engine's `EvermindLM` satisfies {@link LogitsModel}
+ * directly — so the harness is model-agnostic and dependency-free.
+ */
+
+/** The minimal surface a model must expose to be benchmarked: per-position logits. */
+export interface LogitsModel {
+  /** Run the model over a token sequence; returns one logit vector per position. */
+  forward(tokens: number[]): { logits: Float32Array[] };
+}
+
+/** A model whose forward pass is asynchronous (e.g. a WebGPU backend). */
+export interface AsyncLogitsModel {
+  forward(tokens: number[]): Promise<{ logits: Float32Array[] }>;
+}
+
+/** Knobs for a benchmark run. */
+export interface BenchmarkOptions {
+  /** k for top-k next-token accuracy. Default 5. */
+  topK?: number;
+  /** Measure forward throughput (tokens/sec). Default true. */
+  measureLatency?: boolean;
+  /**
+   * Monotonic clock in milliseconds, injectable for deterministic tests.
+   * Defaults to `performance.now()` when available, else `Date.now()`.
+   */
+  now?: () => number;
+}
+
+/** The scorecard a benchmark run produces. */
+export interface BenchmarkReport {
+  /** Number of evaluated sequences. */
+  sequences: number;
+  /** Number of predicted positions (next-token targets) scored. */
+  tokens: number;
+  /** Mean next-token cross-entropy, in nats. Lower is better. */
+  crossEntropy: number;
+  /** Perplexity = exp(crossEntropy). Lower is better; 1.0 is perfect. */
+  perplexity: number;
+  /** Bits per token = crossEntropy / ln(2). Lower is better. */
+  bitsPerToken: number;
+  /** Fraction of positions where the argmax prediction was correct (0..1). */
+  top1Accuracy: number;
+  /** Fraction of positions where the true token was in the top-k (0..1). */
+  topKAccuracy: number;
+  /** The k used for {@link topKAccuracy}. */
+  topK: number;
+  /** Forward throughput in tokens/sec, when {@link BenchmarkOptions.measureLatency}. */
+  tokensPerSecond?: number;
+  /** Wall-clock spent in the forward passes (ms), when measured. */
+  elapsedMs?: number;
+}
+
+/** The result of A/B-ing two models on the same eval set. */
+export interface ComparisonReport {
+  candidate: BenchmarkReport;
+  baseline: BenchmarkReport;
+  /** candidate.perplexity − baseline.perplexity (negative = candidate better). */
+  perplexityDelta: number;
+  /** candidate.perplexity / baseline.perplexity (<1 = candidate better). */
+  perplexityRatio: number;
+  /** candidate.top1Accuracy − baseline.top1Accuracy (positive = candidate better). */
+  top1Delta: number;
+  /** Which model won on perplexity (the primary metric). */
+  winner: "candidate" | "baseline" | "tie";
+  /** Human-readable one-liner. */
+  summary: string;
+}
+
+/** Options for {@link trainAndBenchmark}: train a fresh EvermindLM, then score it. */
+export interface TrainAndBenchmarkOptions {
+  /** BPE merges to learn for the tokenizer. Default 100. */
+  numMerges?: number;
+  /** Model channel dimension. Default 32. */
+  dModel?: number;
+  /** Number of (conv + MoE) blocks. Default 2. */
+  numLayers?: number;
+  /** MoE expert FFN hidden width. Default 48. */
+  hiddenDim?: number;
+  /** Training epochs. Default 30. */
+  epochs?: number;
+  /** AdamW learning rate. Default 0.03. */
+  lr?: number;
+  /** Deterministic seed (model init + held-out split). Default 7. */
+  seed?: number;
+  /**
+   * Fraction of sequences reserved for evaluation (never trained on). Default
+   * 0.25. A real benchmark must score held-out data, so this is enforced > 0.
+   */
+  heldOutRatio?: number;
+  /** k for top-k accuracy. Default 5. */
+  topK?: number;
+  /** Prompt used to capture a qualitative generation sample. Default "The". */
+  prompt?: string;
+}
+
+/** {@link trainAndBenchmark} result: the held-out scorecard plus training context. */
+export interface TrainAndBenchmarkResult extends BenchmarkReport {
+  /** Sequences used for training. */
+  trainSequences: number;
+  /** Held-out sequences used for evaluation. */
+  evalSequences: number;
+  /** Final-epoch mean training loss (nats). */
+  finalTrainLoss: number;
+  /** First-epoch mean training loss (nats) — pairs with final to show the drop. */
+  initialTrainLoss: number;
+  /** Learned tokenizer vocabulary size. */
+  vocabSize: number;
+  /** A short greedy generation from {@link TrainAndBenchmarkOptions.prompt}. */
+  sample: string;
+}

package/src/export/gguf.ts

@@ -0,0 +1,168 @@
+/**
+ * export/gguf.ts — export weights to a GGUF v3 container (the llama.cpp format).
+ *
+ * Emits a spec-valid GGUF file: magic + version, KV metadata (architecture, dims,
+ * expert counts…), aligned tensor-info table, then aligned tensor data. ggml
+ * stores dimensions innermost-first, so row-major shapes are reversed here.
+ *
+ * NOTE: GGUF is a *container*. llama.cpp can only RUN a file whose
+ * `general.architecture` it has a graph for; "evermind" is custom, so this file
+ * is a valid, inspectable artifact (gguf tooling reads it) but won't execute in
+ * stock llama.cpp until the architecture is upstreamed. It exists so the same
+ * weights can travel through GGUF-native tooling. For an executable export use
+ * {@link ./onnx} or {@link ./safetensors}.
+ */
+
+import type { EvermindLM } from "../lm/evermind_lm.js";
+import { archOf, namedTensors, type NamedTensor } from "./tensors.js";
+import { floatToFp16 } from "../utils/quantization.js";
+
+const GGUF_MAGIC = 0x46554747; // "GGUF" little-endian
+const GGUF_VERSION = 3;
+const ALIGNMENT = 32;
+
+// GGUF metadata value types
+const T_UINT32 = 4;
+const T_STRING = 8;
+// ggml tensor types
+const GGML_F32 = 0;
+const GGML_F16 = 1;
+
+export interface GgufOptions {
+  name?: string;
+  /** Store tensors as float16 (ggml type F16). Default false (F32). */
+  fp16?: boolean;
+}
+
+/** A growable little-endian byte buffer. */
+class ByteBuf {
+  private buf = new Uint8Array(1024);
+  private len = 0;
+  private ensure(n: number): void {
+    if (this.len + n <= this.buf.length) return;
+    let cap = this.buf.length * 2;
+    while (cap < this.len + n) cap *= 2;
+    const next = new Uint8Array(cap);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+  }
+  u32(v: number): void {
+    this.ensure(4);
+    new DataView(this.buf.buffer).setUint32(this.len, v, true);
+    this.len += 4;
+  }
+  u64(v: number): void {
+    this.ensure(8);
+    new DataView(this.buf.buffer).setBigUint64(this.len, BigInt(v), true);
+    this.len += 8;
+  }
+  raw(bytes: Uint8Array): void {
+    this.ensure(bytes.length);
+    this.buf.set(bytes, this.len);
+    this.len += bytes.length;
+  }
+  /** Pad with zeros until the length is a multiple of `align`. */
+  alignTo(align: number): void {
+    const pad = (align - (this.len % align)) % align;
+    if (pad > 0) {
+      this.ensure(pad);
+      this.len += pad;
+    }
+  }
+  string(s: string): void {
+    const bytes = new TextEncoder().encode(s);
+    this.u64(bytes.length);
+    this.raw(bytes);
+  }
+  get length(): number {
+    return this.len;
+  }
+  bytes(): Uint8Array {
+    return this.buf.subarray(0, this.len);
+  }
+}
+
+function tensorBytes(data: Float32Array, fp16: boolean): Uint8Array {
+  if (!fp16) {
+    const out = new Uint8Array(data.length * 4);
+    const dv = new DataView(out.buffer);
+    for (let i = 0; i < data.length; i++) dv.setFloat32(i * 4, data[i]!, true);
+    return out;
+  }
+  const out = new Uint8Array(data.length * 2);
+  const dv = new DataView(out.buffer);
+  for (let i = 0; i < data.length; i++) dv.setUint16(i * 2, floatToFp16(data[i]!), true);
+  return out;
+}
+
+/** Export a trained LM to GGUF bytes. */
+export function exportGguf(lm: EvermindLM, opts: GgufOptions = {}): Uint8Array {
+  const fp16 = opts.fp16 ?? false;
+  const a = archOf(lm);
+  const tensors = namedTensors(lm);
+  const ggmlType = fp16 ? GGML_F16 : GGML_F32;
+  const bytesPer = fp16 ? 2 : 4;
+
+  const kvU32: [string, number][] = [
+    ["evermind.vocab_size", a.vocabSize],
+    ["evermind.embedding_length", a.dModel],
+    ["evermind.block_count", a.numLayers],
+    ["evermind.conv_kernel", a.convKernel],
+    ["evermind.feed_forward_length", a.hiddenDim],
+    ["evermind.expert_count", a.numExperts],
+    ["evermind.expert_used_count", a.topK],
+    ["general.alignment", ALIGNMENT],
+  ];
+  const kvStr: [string, string][] = [
+    ["general.architecture", "evermind"],
+    ["general.name", opts.name ?? "Evermind"],
+  ];
+
+  // Header: magic, version, tensor_count, metadata_kv_count, KVs.
+  const head = new ByteBuf();
+  head.u32(GGUF_MAGIC);
+  head.u32(GGUF_VERSION);
+  head.u64(tensors.length);
+  head.u64(kvU32.length + kvStr.length);
+  for (const [k, v] of kvStr) {
+    head.string(k);
+    head.u32(T_STRING);
+    head.string(v);
+  }
+  for (const [k, v] of kvU32) {
+    head.string(k);
+    head.u32(T_UINT32);
+    head.u32(v);
+  }
+
+  // Tensor-info table. Offsets are relative to the start of the (aligned) tensor
+  // data section; each tensor starts at an ALIGNMENT boundary within it.
+  const dims = (t: NamedTensor): number[] => [...t.shape].reverse(); // ggml: innermost first
+  let dataOffset = 0;
+  const offsets: number[] = [];
+  for (const t of tensors) {
+    offsets.push(dataOffset);
+    const nbytes = t.data.length * bytesPer;
+    dataOffset += nbytes;
+    dataOffset += (ALIGNMENT - (dataOffset % ALIGNMENT)) % ALIGNMENT;
+  }
+  tensors.forEach((t, i) => {
+    head.string(t.name);
+    const d = dims(t);
+    head.u32(d.length);
+    for (const dim of d) head.u64(dim);
+    head.u32(ggmlType);
+    head.u64(offsets[i]!);
+  });
+
+  // Pad header to the alignment boundary, then write aligned tensor data.
+  head.alignTo(ALIGNMENT);
+  const dataStart = head.length;
+  for (let i = 0; i < tensors.length; i++) {
+    // Re-establish alignment relative to the data section start.
+    const want = dataStart + offsets[i]!;
+    while (head.length < want) head.raw(new Uint8Array(1));
+    head.raw(tensorBytes(tensors[i]!.data, fp16));
+  }
+  return head.bytes();
+}

package/src/export/hf.ts

@@ -0,0 +1,155 @@
+/**
+ * export/hf.ts — the Hugging Face repository sidecar files.
+ *
+ * The JSON/markdown that turns raw weights into an ingestible HF model repo:
+ *   • config.json            — architecture config (model_type "evermind")
+ *   • generation_config.json — default decoding params
+ *   • tokenizer.json         — the byte-level BPE in HF `tokenizers` format
+ *   • README.md              — the model card (YAML front-matter + body)
+ *
+ * The tokenizer uses the same GPT-2 byte→unicode alphabet as {@link BPETokenizer}
+ * (a ByteLevel pre-tokenizer/decoder), so HF `tokenizers` / transformers.js
+ * reproduce our encode/decode.
+ */
+
+import type { EvermindLM } from "../lm/evermind_lm.js";
+import type { BPETokenizer } from "../tokenizer/bpe.js";
+import { archOf, paramCount } from "./tensors.js";
+
+export interface HfMeta {
+  name?: string;
+  version?: string;
+  license?: string;
+  author?: string;
+  description?: string;
+  tags?: string[];
+}
+
+/** HF `config.json` describing the Evermind architecture. */
+export function configJson(lm: EvermindLM): Record<string, unknown> {
+  const a = archOf(lm);
+  return {
+    model_type: "evermind",
+    architectures: ["EvermindForCausalLM"],
+    vocab_size: a.vocabSize,
+    d_model: a.dModel,
+    hidden_size: a.dModel,
+    num_hidden_layers: a.numLayers,
+    conv_kernel: a.convKernel,
+    intermediate_size: a.hiddenDim,
+    num_experts: a.numExperts,
+    num_experts_per_tok: a.topK,
+    rms_norm_eps: 1e-5,
+    tie_word_embeddings: true,
+    torch_dtype: "float32",
+    transformers_version: "4.0.0",
+  };
+}
+
+/** HF `generation_config.json` — greedy by default, matching the reference. */
+export function generationConfigJson(): Record<string, unknown> {
+  return { do_sample: false, temperature: 1.0, max_new_tokens: 64 };
+}
+
+/** HF `tokenizer.json` (the `tokenizers` fast-tokenizer format) for the BPE. */
+export function tokenizerJson(tok: BPETokenizer): Record<string, unknown> {
+  const vocab: Record<string, number> = {};
+  for (const [token, id] of tok.vocab) vocab[token] = id;
+  const merges = [...tok.merges.keys()]; // already "a b" space-separated pairs
+
+  const added: { id: number; content: string }[] = [];
+  for (const content of [tok.unkToken, tok.bosToken, tok.eosToken, tok.padToken]) {
+    const id = tok.vocab.get(content);
+    if (id !== undefined && !added.some((t) => t.id === id)) added.push({ id, content });
+  }
+
+  return {
+    version: "1.0",
+    truncation: null,
+    padding: null,
+    added_tokens: added.map((t) => ({
+      id: t.id,
+      content: t.content,
+      single_word: false,
+      lstrip: false,
+      rstrip: false,
+      normalized: false,
+      special: true,
+    })),
+    normalizer: null,
+    pre_tokenizer: { type: "ByteLevel", add_prefix_space: false, trim_offsets: true, use_regex: true },
+    post_processor: { type: "ByteLevel", add_prefix_space: true, trim_offsets: false, use_regex: true },
+    decoder: { type: "ByteLevel", add_prefix_space: true, trim_offsets: true, use_regex: true },
+    model: {
+      type: "BPE",
+      dropout: null,
+      unk_token: null,
+      continuing_subword_prefix: null,
+      end_of_word_suffix: null,
+      fuse_unk: false,
+      byte_fallback: false,
+      vocab,
+      merges,
+    },
+  };
+}
+
+/** HF model card (`README.md`) with YAML front-matter. */
+export function modelCardMarkdown(lm: EvermindLM, meta: HfMeta = {}): string {
+  const a = archOf(lm);
+  const params = paramCount(lm);
+  const name = meta.name ?? "Evermind";
+  const license = meta.license ?? "mit";
+  const tags = ["evermind", "ssm", "mixture-of-experts", "text-generation", ...(meta.tags ?? [])];
+  const front = [
+    "---",
+    `license: ${license}`,
+    "library_name: builderforce-memory",
+    "pipeline_tag: text-generation",
+    "tags:",
+    ...tags.map((t) => `  - ${t}`),
+    "---",
+  ].join("\n");
+
+  const body = `
+# ${name}
+
+${meta.description ?? "A self-updating SSM language model built with the BuilderForce Evermind engine."}
+
+An **Evermind** model: a shared-expert hybrid SSM (depthwise causal conv token-mixer
++ top-k Mixture-of-Experts channel-mixer, tied embeddings). Trained and run natively
+in TypeScript/WebGPU; this repository is an export for the Hugging Face ecosystem.
+
+## Architecture
+
+| field | value |
+| --- | --- |
+| vocab size | ${a.vocabSize} |
+| d_model | ${a.dModel} |
+| layers | ${a.numLayers} |
+| conv kernel | ${a.convKernel} |
+| FFN hidden | ${a.hiddenDim} |
+| experts (top-k) | ${a.numExperts} (${a.topK}) |
+| parameters | ${params.toLocaleString("en-US")} |
+
+## Files
+
+- \`model.safetensors\` — weights (HF-native, F32).
+- \`model.onnx\` — runnable graph (\`input_ids\` → \`logits\`); load with onnxruntime / transformers.js.
+- \`config.json\`, \`generation_config.json\`, \`tokenizer.json\` — HF sidecars.
+- \`model.gguf\` — GGUF container (custom architecture; for GGUF tooling).
+- \`model.evermind\` — the native package; runs in \`@seanhogg/builderforce-memory\` (full self-update).
+
+## Usage (ONNX, no KV-cache — re-run full context per step)
+
+\`\`\`js
+import * as ort from "onnxruntime-web";
+const session = await ort.InferenceSession.create("model.onnx");
+const ids = BigInt64Array.from([/* token ids */].map(BigInt));
+const input_ids = new ort.Tensor("int64", ids, [1, ids.length]);
+const { logits } = await session.run({ input_ids });
+\`\`\`
+${meta.author ? `\n## Author\n\n${meta.author}\n` : ""}`;
+
+  return `${front}\n${body}`;
+}

package/src/export/index.ts

@@ -0,0 +1,128 @@
+/**
+ * export/index.ts — the model-export registry.
+ *
+ * One entry point — {@link exportEvermind} — turns a trained {@link EvermindLM}
+ * (+ its tokenizer) into a named set of files in a requested format. The runtime
+ * is untouched: export reads the model through its public surface only. This is
+ * the *publishing* seam — training/serving stay in the WebGPU/TS runtime; export
+ * is offered as a separate step that emits portable artifacts (ONNX, safetensors,
+ * GGUF) and a complete Hugging Face repo bundle.
+ *
+ * Formats:
+ *   • "safetensors"  → model.safetensors
+ *   • "onnx"         → model.onnx
+ *   • "gguf"         → model.gguf
+ *   • "huggingface"  → a full HF repo (safetensors + onnx + gguf + config +
+ *                      tokenizer.json + generation_config + README), ready to push
+ */
+
+import type { EvermindLM } from "../lm/evermind_lm.js";
+import type { BPETokenizer } from "../tokenizer/bpe.js";
+import { paramCount } from "./tensors.js";
+import { exportSafetensors } from "./safetensors.js";
+import { exportOnnx } from "./onnx.js";
+import { exportGguf } from "./gguf.js";
+import { configJson, generationConfigJson, tokenizerJson, modelCardMarkdown, type HfMeta } from "./hf.js";
+
+export type ExportFormat = "safetensors" | "onnx" | "gguf" | "huggingface";
+
+/** One emitted file. `data` is bytes (binary) or a string (text). */
+export interface ExportFile {
+  path: string;
+  data: Uint8Array | string;
+  contentType: string;
+}
+
+export interface ExportResult {
+  format: ExportFormat;
+  files: ExportFile[];
+  /** Total trainable scalar parameters of the exported model. */
+  paramCount: number;
+}
+
+export interface ExportOptions extends HfMeta {
+  /** Store weights as float16 where the format supports it. Default false. */
+  fp16?: boolean;
+}
+
+/** Catalog of formats for UI pickers (id + human label + extension). */
+export const EXPORT_FORMATS: { id: ExportFormat; label: string; description: string; ext: string }[] = [
+  { id: "huggingface", label: "Hugging Face repo", description: "Full publishable repo: safetensors + ONNX + GGUF + config + tokenizer + model card", ext: "/" },
+  { id: "onnx", label: "ONNX", description: "Runnable graph for onnxruntime / transformers.js (input_ids → logits)", ext: ".onnx" },
+  { id: "safetensors", label: "Safetensors", description: "HF-native weight format (lossless F32 / half-size F16)", ext: ".safetensors" },
+  { id: "gguf", label: "GGUF", description: "llama.cpp container (custom architecture; for GGUF tooling)", ext: ".gguf" },
+];
+
+const JSON_CT = "application/json";
+
+function jsonFile(path: string, obj: unknown): ExportFile {
+  return { path, data: JSON.stringify(obj, null, 2), contentType: JSON_CT };
+}
+
+/**
+ * Export a trained model in the requested format. `tokenizer` is required for the
+ * "huggingface" bundle (to emit tokenizer.json); the weight-only formats ignore it.
+ */
+export function exportEvermind(
+  lm: EvermindLM,
+  format: ExportFormat,
+  opts: ExportOptions = {},
+  tokenizer?: BPETokenizer,
+): ExportResult {
+  const params = paramCount(lm);
+  const base = (): ExportResult => ({ format, files: [], paramCount: params });
+
+  switch (format) {
+    case "safetensors": {
+      const r = base();
+      r.files.push({
+        path: "model.safetensors",
+        data: exportSafetensors(lm, { fp16: opts.fp16 }),
+        contentType: "application/octet-stream",
+      });
+      return r;
+    }
+    case "onnx": {
+      const r = base();
+      r.files.push({
+        path: "model.onnx",
+        data: exportOnnx(lm, { producerVersion: opts.version }),
+        contentType: "application/octet-stream",
+      });
+      return r;
+    }
+    case "gguf": {
+      const r = base();
+      r.files.push({
+        path: "model.gguf",
+        data: exportGguf(lm, { name: opts.name, fp16: opts.fp16 }),
+        contentType: "application/octet-stream",
+      });
+      return r;
+    }
+    case "huggingface": {
+      if (!tokenizer) throw new Error("exportEvermind('huggingface'): a tokenizer is required for tokenizer.json");
+      const r = base();
+      r.files.push(
+        { path: "model.safetensors", data: exportSafetensors(lm, { fp16: opts.fp16 }), contentType: "application/octet-stream" },
+        { path: "model.onnx", data: exportOnnx(lm, { producerVersion: opts.version }), contentType: "application/octet-stream" },
+        { path: "model.gguf", data: exportGguf(lm, { name: opts.name, fp16: opts.fp16 }), contentType: "application/octet-stream" },
+        jsonFile("config.json", configJson(lm)),
+        jsonFile("generation_config.json", generationConfigJson()),
+        jsonFile("tokenizer.json", tokenizerJson(tokenizer)),
+        { path: "README.md", data: modelCardMarkdown(lm, opts), contentType: "text/markdown" },
+      );
+      return r;
+    }
+    default:
+      throw new Error(`exportEvermind: unknown format "${String(format)}"`);
+  }
+}
+
+export { exportSafetensors, tensorsToSafetensors } from "./safetensors.js";
+export { exportOnnx } from "./onnx.js";
+export { exportGguf } from "./gguf.js";
+export { configJson, generationConfigJson, tokenizerJson, modelCardMarkdown } from "./hf.js";
+export type { HfMeta } from "./hf.js";
+export { namedTensors, evermindTensorSpec, archOf, paramCount } from "./tensors.js";
+export type { NamedTensor, EvermindArch, TensorSpec } from "./tensors.js";