mlx-bun 0.5.0 → 1.0.0

package/src/train/forward.ts

@@ -1,266 +0,0 @@
-// Training forward pass: full-sequence logits with no KV reuse.
-//
-// B=1 (no padding): trainForward runs the model's stock forwardHidden over a
-// fresh cache exactly as before — bit-identical to the single-example trainer.
-//
-// B>1 (padded batch): every row in the batch is padded to a common length L,
-// but the rows have different *true* lengths. A plain causal mask would let a
-// real query attend to padded keys (and let padded queries pollute the cache
-// view), so for batched forwards we build an explicit [B, 1, L, L] boolean
-// mask that is the causal mask AND-ed with a per-row "key is within this row's
-// valid length" mask, and route it through the model's attention via a cache
-// wrapper whose makeMask returns it. The wrapper delegates every KV operation
-// to a real cache (KVCache/RotatingKVCache are already shape-generic over B),
-// so only the mask differs from the stock path. Window/offset handling is
-// preserved: training always runs offset-0 full-sequence forwards, so the
-// causal-with-window mask is built at offset 0, exactly matching what the
-// underlying cache's makeMask would have produced for the unpadded case.
-
-import { MlxArray } from "../mlx/array";
-import { Dtype } from "../mlx/ffi";
-import * as ops from "../mlx/ops";
-import { createCausalMask, type Cache, type Mask } from "../model/gemma4-base";
-import { SSMCache } from "../model/qwen3-delta";
-import type { RuntimeModel } from "../model/factory";
-
-/** Stateless cache for the training forward. Training is always a single
- *  offset-0 full-sequence pass, so `updateAndFetch` is a pure pass-through (no
- *  buffer, no state mutation) and `makeMask` is the offset-0 causal/windowed
- *  mask — identical to KVCache at offset 0. The statelessness is REQUIRED for
- *  gradient checkpointing: mlx_checkpoint re-runs the layer closure during the
- *  backward recompute, and a stateful (appending) cache would corrupt on the
- *  second run. */
-export class TrainingCache implements Cache {
-  /** Training-only adapter; never admitted, merged, or persisted. */
-  signature(): string { return "train:training"; }
-  offset = 0;
-  updateAndFetch(k: MlxArray, v: MlxArray): [MlxArray, MlxArray] {
-    // Return fresh views: the caller disposes its input k/v right after (its
-    // contract with the real KVCache, which returns buffer slices). A
-    // full-range slice is a cheap view node; mlx keeps the source alive
-    // through it, so disposing the inputs is safe.
-    return [k.slice([0, 0, 0, 0], k.shape), v.slice([0, 0, 0, 0], v.shape)];
-  }
-  makeMask(N: number, windowSize: number | null): Mask {
-    if (N === 1) return { mode: "", arr: null };
-    if (windowSize === null || N <= windowSize) return { mode: "causal", arr: null };
-    return { mode: "array", arr: createCausalMask(N, 0, windowSize) };
-  }
-  state(): MlxArray[] {
-    return [];
-  }
-  isTrimmable(): boolean {
-    return true;
-  }
-  trim(_n: number): void {
-    /* offset is pinned at 0 */
-  }
-  dispose(): void {
-    /* owns no arrays */
-  }
-}
-
-/** Stateless DeltaNet stand-in (same re-runnability contract as
- *  TrainingCache): state WRITES are discarded immediately, so a gradient-
- *  checkpoint recompute re-enters with the identical null-state conditions;
- *  reads always yield null (zeros inside the kernel) — a full-sequence
- *  forward from t=0, exactly the training/perplexity semantics. Before this
- *  existed, qwen3_5 routed its DeltaNet layers into plain TrainingCache and
- *  threw on the missing conv/recurrent/advance surface (the recorded
- *  "mlx-bun perplexity cannot score qwen3_5" gap). */
-export class TrainingSSMCache implements Cache {
-  /** Training-only adapter; never admitted, merged, or persisted. */
-  signature(): string { return "train:training-ssm"; }
-  offset = 0;
-  specRound: null = null;
-  get conv(): MlxArray | null { return null; }
-  set conv(v: MlxArray | null) { v?.dispose(); }
-  get recurrent(): MlxArray | null { return null; }
-  set recurrent(v: MlxArray | null) { v?.dispose(); }
-  advance(_n: number): void { /* offset pinned at 0 */ }
-  rowOffset(_i: number): number { return 0; }
-  updateAndFetch(): [MlxArray, MlxArray] {
-    throw new Error("TrainingSSMCache: DeltaNet layers do not use the KV path");
-  }
-  makeMask(_N: number, _w: number | null): Mask {
-    return { mode: "", arr: null }; // ssm_mask is None at B=1 (SSMCache parity)
-  }
-  state(): MlxArray[] { return []; }
-  isTrimmable(): boolean { return true; }
-  trim(_n: number): void { /* stateless */ }
-  dispose(): void { /* owns no arrays */ }
-}
-
-/** Run a full-sequence forward for training.
- *  @param ids int32 array [B, L].
- *  @returns logits [B, L, V] (caller owns; dispose when done).
- *
- *  When `validLengths` is omitted (or every row is full-length L) the batch
- *  has no padding and the model's stock mask path is used unchanged — the
- *  B=1 result is bit-identical to the original trainer. When some row is
- *  shorter than L, a padding-aware batched mask is injected. */
-export function trainForwardHidden(
-  model: RuntimeModel,
-  ids: MlxArray,
-  validLengths?: number[],
-): MlxArray {
-  const [B, L] = ids.shape as [number, number];
-  const needsPadMask =
-    validLengths !== undefined && validLengths.some((v) => v < L);
-
-  if (needsPadMask) {
-    // B>1 padded path: dense cache wrapped with the per-row padding mask
-    // (unchanged; not yet checkpointed — B=1 is the checkpointing target).
-    const realCache = model.makeCache();
-    const cache = wrapWithBatchedMask(realCache, B, L, validLengths!);
-    try {
-      return model.forwardHidden(ids, cache);
-    } finally {
-      for (const c of realCache) c.dispose();
-      for (const c of cache) (c as BatchedMaskCache).disposeOwnMask();
-    }
-  }
-
-  // B=1 / no padding: stateless offset-0 caches (one per donor layer), so the
-  // forward is pure and safe to recompute under gradient checkpointing.
-  const probe = model.makeCache();
-  const cache: Cache[] = probe.map((c) =>
-    c instanceof SSMCache ? new TrainingSSMCache() : new TrainingCache());
-  for (const c of probe) c.dispose();
-  try {
-    return model.forwardHidden(ids, cache); // [B, L, hidden]
-  } finally {
-    for (const c of cache) c.dispose();
-  }
-}
-
-/** Full-sequence forward returning logits [B, L, V]. Convenience over
- *  trainForwardHidden + logitsFromHidden. The SFT B=1 path deliberately skips
- *  this and applies the LM head only at response positions (responseOnlyCe)
- *  to avoid materializing the [B, L, vocab] logits — the dominant training
- *  memory term at long context with a 262k vocab. */
-export function trainForward(
-  model: RuntimeModel,
-  ids: MlxArray,
-  validLengths?: number[],
-): MlxArray {
-  const h = trainForwardHidden(model, ids, validLengths);
-  const logits = model.logitsFromHidden(h);
-  h.dispose();
-  return logits;
-}
-
-/** Build the padding-aware additive-style boolean mask for one window type.
- *  Shape `[B, 1, L, L]`, true where query i may attend to key j:
- *    allow[b,0,i,j] = (j <= i)               (causal, offset 0)
- *                     AND (j < validLen[b])   (key within row b's true length)
- *                     [AND (i < j + window)   if a sliding window applies]
- *  Built from createCausalMask(L, 0, window) (the model's own [L, L] bool
- *  matrix) broadcast over B, masked by a per-row [B,1,1,L] key-validity mask.
- *  Caller owns the returned array. */
-export function buildBatchedPadMask(
-  B: number,
-  L: number,
-  validLengths: number[],
-  windowSize: number | null,
-): MlxArray {
-  // [L, L] bool causal (+window) matrix at offset 0 — exactly the model's.
-  const causal2d = createCausalMask(L, 0, windowSize); // [L, L] bool
-  const causal4d = ops.reshape(causal2d, [1, 1, L, L]);
-  causal2d.dispose();
-
-  // Per-row key validity: keyValid[b, 0, 0, j] = j < validLengths[b].
-  // Build as int32 {0,1} then compare to get bool, broadcasting over q (i).
-  const keyValidData = new Int32Array(B * L);
-  for (let b = 0; b < B; b++) {
-    const vlen = validLengths[b]!;
-    for (let j = 0; j < L; j++) keyValidData[b * L + j] = j < vlen ? 1 : 0;
-  }
-  const keyValidI = MlxArray.fromInt32(keyValidData, [B, 1, 1, L]);
-  const zero = MlxArray.fromInt32(new Int32Array([0]), []);
-  const keyValid = ops.less(zero, keyValidI); // 0 < x  → bool true where x==1
-  zero.dispose();
-  keyValidI.dispose();
-
-  const allow = ops.logicalAnd(causal4d, keyValid); // broadcasts [1,1,L,L] & [B,1,1,L]
-  causal4d.dispose();
-  keyValid.dispose();
-  return allow; // [B, 1, L, L] bool
-}
-
-/** Cache wrapper that forwards every KV op to a real cache but overrides
- *  makeMask to return a precomputed padding-aware batched mask. One mask is
- *  built per distinct window size (null = full attention, else the sliding
- *  window) and shared across all caches of that type; ownership of the mask
- *  arrays stays with the wrapper (disposeOwnMask), NOT the model — the model's
- *  forwardLayers only disposes the mask it pulled from makeMask, so makeMask
- *  hands back a fresh view each call and keeps the canonical copy itself. */
-class BatchedMaskCache implements Cache {
-  /** Training-only adapter; never admitted, merged, or persisted. */
-  signature(): string { return "train:batched-mask"; }
-  constructor(
-    private readonly inner: Cache,
-    private readonly window: number | null,
-    private readonly maskStore: Map<number | null, MlxArray>,
-  ) {}
-
-  get offset(): number {
-    return this.inner.offset;
-  }
-
-  updateAndFetch(k: MlxArray, v: MlxArray): [MlxArray, MlxArray] {
-    return this.inner.updateAndFetch(k, v);
-  }
-
-  makeMask(N: number, _windowSize: number | null): Mask {
-    const canonical = this.maskStore.get(this.window)!;
-    // Hand back a fresh full-range view so the model can dispose it without
-    // touching our canonical copy. slice over all 4 axes = cheap view node.
-    const [B, , L] = canonical.shape as [number, number, number, number];
-    const view = canonical.slice([0, 0, 0, 0], [B, 1, L, L]);
-    return { mode: "array", arr: view };
-  }
-
-  state(): MlxArray[] {
-    return this.inner.state();
-  }
-  isTrimmable(): boolean {
-    return this.inner.isTrimmable();
-  }
-  trim(n: number): void {
-    this.inner.trim(n);
-  }
-  dispose(): void {
-    this.inner.dispose();
-  }
-  /** Dispose the canonical mask copies (shared store; idempotent via clear). */
-  disposeOwnMask(): void {
-    for (const m of this.maskStore.values()) m.dispose();
-    this.maskStore.clear();
-  }
-}
-
-/** Wrap each real cache in a BatchedMaskCache, precomputing one padding-aware
- *  mask per distinct window. Caches without a sliding window get the
- *  full-attention (null) mask. */
-function wrapWithBatchedMask(
-  realCache: Cache[],
-  B: number,
-  L: number,
-  validLengths: number[],
-): Cache[] {
-  const windows = realCache.map((c) => cacheWindow(c));
-  const distinct = new Set(windows);
-  const store = new Map<number | null, MlxArray>();
-  for (const w of distinct) store.set(w, buildBatchedPadMask(B, L, validLengths, w));
-  return realCache.map((c, i) => new BatchedMaskCache(c, windows[i]!, store));
-}
-
-/** The sliding-window size a cache enforces, or null for full attention.
- *  RotatingKVCache stores its window as `maxSize`; KVCache has none. Mirrors
- *  gemma4 forwardLayers, where sliding layers use windowSize == the rotating
- *  cache's maxSize. (Quantized KV caches are not used on the training path.) */
-function cacheWindow(c: Cache): number | null {
-  const maxSize = (c as { maxSize?: number }).maxSize;
-  return typeof maxSize === "number" ? maxSize : null;
-}

package/src/train/fuse.ts

@@ -1,243 +0,0 @@
-// Fuse a LoRA adapter into base model weights → a standalone model snapshot
-// (mlx_lm.fuse counterpart, minus GGUF/de-quantize export).
-//
-// Math (matches mlx-lm's LoRALinear.fuse and our QuantizedLinear.forward):
-//   forward:  y = x @ W_dequantᵀ + scale · ((x @ A) @ B)
-//   fused:    W'[out,in] = W + (scale · B)ᵀ.astype(bf16) @ Aᵀ.astype(bf16)
-// mlx-lm casts the (scaled) LoRA factors to the base dtype BEFORE the matmul,
-// then re-quantizes with the module's OWN source spec (bits/group unchanged) —
-// we do the same, so the output config.json is the source config verbatim.
-//
-// Everything runs on the CPU stream (same discipline as src/quantize/quantizer:
-// the safetensors loader lives there, and one module is materialized, fused,
-// and disposed at a time). Modules the adapter does not touch pass through
-// bit-identical (no dequant→requant round trip).
-
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { clearCache, Dtype } from "../mlx/ffi";
-import { cpuStream, type MlxArray } from "../mlx/array";
-import * as ops from "../mlx/ops";
-import { Weights } from "../weights";
-import { loadModelConfig, quantFor } from "../config";
-import { loadAdapterTensors, readAdapterScale, adapterWeightsFile } from "../lora";
-import { writeShardedSafetensors, type NamedTensor } from "../quantize/safetensors-writer";
-import { copyAuxFiles } from "../quantize/config-writer";
-
-/** Quantize the allocator cache this often (in modules processed). */
-const CACHE_CLEAR_EVERY = 16;
-
-export interface FuseStats {
-  outDir: string;
-  /** Modules whose weights had an adapter delta folded in. */
-  fusedModules: number;
-  /** Adapter tensors that matched no base weight (skipped). */
-  skippedAdapterTensors: number;
-  totalTensors: number;
-}
-
-export interface FuseProgress {
-  stage: string;
-  message: string;
-  /** 0..1 fraction of modules processed. */
-  progress: number;
-}
-
-/** Resolve the adapter safetensors file: `<dir>/adapters.safetensors`,
- *  `<dir>/best/adapters.safetensors`, `adapter_model.safetensors`, or an
- *  explicit file path. */
-function resolveAdapterFile(dir: string): string {
-  const best = join(dir, "best");
-  if (existsSync(join(best, "adapters.safetensors"))) return join(best, "adapters.safetensors");
-  if (dir.endsWith(".safetensors") && existsSync(dir)) return dir;
-  return adapterWeightsFile(dir);
-}
-
-/** Group adapter tensors into (modulePath → {a, b}); disposes non-LoRA
- *  tensors and returns how many were skipped. */
-function groupPairs(tensors: Map<string, MlxArray>): {
-  pairs: Map<string, { a?: MlxArray; b?: MlxArray }>;
-  skipped: number;
-} {
-  const pairs = new Map<string, { a?: MlxArray; b?: MlxArray }>();
-  let skipped = 0;
-  for (const [name, arr] of tensors) {
-    const m = name.match(/^(.*)\.(lora_a|lora_A|lora_b|lora_B)(\.weight)?$/);
-    if (!m) { skipped++; arr.dispose(); continue; }
-    const slot = pairs.get(m[1]!) ?? {};
-    if (m[2]!.toLowerCase() === "lora_a") slot.a = arr; else slot.b = arr;
-    pairs.set(m[1]!, slot);
-  }
-  return { pairs, skipped };
-}
-
-/**
- * Fuse the adapter at `adapterDir` into the base model at `modelDir` and
- * write a complete, loadable snapshot to `outDir` (weights + config.json +
- * tokenizer aux files). Quantization layout is preserved verbatim: fused
- * modules are dequantized, updated, and re-quantized with their own source
- * spec; untouched modules pass through bit-identical.
- */
-export async function fuseAdapter(
-  modelDir: string,
-  adapterDir: string,
-  outDir: string,
-  onProgress?: (e: FuseProgress) => void,
-): Promise<FuseStats> {
-  const progress = (stage: string, message: string, frac: number) =>
-    onProgress?.({ stage, message, progress: frac });
-
-  progress("loading", `Reading ${modelDir}`, 0);
-  const config = await loadModelConfig(modelDir);
-  const weights = await Weights.open(modelDir);
-
-  const adapterFile = resolveAdapterFile(adapterDir);
-  const { scale, rsLora } = await readAdapterScale(adapterDir);
-  const { pairs, skipped } = groupPairs(loadAdapterTensors(adapterFile));
-
-  // Map each adapter module path to the base weight-file module path,
-  // probing the VLM-wrapped/unwrapped `language_model.` prefixes both ways
-  // (same normalization as AdapterManager.mount).
-  const weightNames = new Set(weights.tensorNames);
-  const byModule = new Map<string, { a: MlxArray; b: MlxArray }>();
-  let unmatched = 0;
-  const disposeAll = () => {
-    for (const { a, b } of pairs.values()) { a?.dispose(); b?.dispose(); }
-  };
-  try {
-    for (const [path, { a, b }] of pairs) {
-      if (!a || !b) throw new Error(`${path}: adapter has only one of lora_a/lora_b`);
-      const candidates = [
-        path,
-        `language_model.${path}`,
-        path.startsWith("language_model.") ? path.slice("language_model.".length) : null,
-      ].filter((c): c is string => c !== null);
-      const hit = candidates.find((c) => weightNames.has(`${c}.weight`));
-      if (!hit) { unmatched++; continue; }
-      byModule.set(hit, { a, b });
-    }
-    if (byModule.size === 0)
-      throw new Error(
-        `no adapter tensors match the base model's weights — was ` +
-        `${adapterFile} trained for a different base?`,
-      );
-  } catch (e) {
-    disposeAll();
-    weights.dispose();
-    throw e;
-  }
-
-  mkdirSync(outDir, { recursive: true });
-
-  // Walk tensors in source order (diff-friendly like the quantizer): group
-  // names into module bases so a fused module's weight/scales/biases are
-  // regenerated together.
-  const names = weights.tensorNames;
-  const moduleSuffixes = new Map<string, Set<string>>();
-  const passthroughNames: string[] = [];
-  for (const name of names) {
-    const m = /^(.*)\.(weight|scales|biases)$/.exec(name);
-    if (!m) { passthroughNames.push(name); continue; }
-    let set = moduleSuffixes.get(m[1]!);
-    if (!set) { set = new Set(); moduleSuffixes.set(m[1]!, set); }
-    set.add(m[2]!);
-  }
-
-  const out: NamedTensor[] = [];
-  let fusedModules = 0;
-  let processed = 0;
-  const totalModules = moduleSuffixes.size;
-
-  try {
-    for (const [base, suffixes] of moduleSuffixes) {
-      processed++;
-      if (processed % CACHE_CLEAR_EVERY === 0) clearCache();
-      const pair = suffixes.has("weight") ? byModule.get(base) : undefined;
-      if (!pair) {
-        for (const suf of suffixes) {
-          const n = `${base}.${suf}`;
-          out.push({ name: n, array: weights.tensor(n) });
-        }
-        continue;
-      }
-      progress("fusing", `Module ${processed}/${totalModules}: ${base}`, processed / totalModules);
-
-      // Materialize the full-precision weight [out, in].
-      const srcSpec = suffixes.has("scales") ? quantFor(config.quantization, base) : null;
-      let w: MlxArray;
-      if (srcSpec) {
-        const packed = weights.tensor(`${base}.weight`);
-        const scales = weights.tensor(`${base}.scales`);
-        const biases = suffixes.has("biases") ? weights.tensor(`${base}.biases`) : null;
-        w = ops.dequantize(packed, scales, biases, srcSpec, cpuStream);
-      } else {
-        w = weights.tensor(`${base}.weight`);
-      }
-      const [outF, inF] = w.shape as [number, number];
-      const { a, b } = pair;
-      const [aIn, rank] = a.shape as [number, number];
-      const [bRank, bOut] = b.shape as [number, number];
-      if (aIn !== inF || bRank !== rank || bOut !== outF)
-        throw new Error(
-          `${base}: shape mismatch — lora_a [${a.shape}] / lora_b [${b.shape}] ` +
-          `vs base [out ${outF}, in ${inF}]`,
-        );
-
-      // delta[out,in] = (scale·B)ᵀ.astype(bf16) @ Aᵀ.astype(bf16)
-      // (rsLoRA: effective per-layer scale is α/√rank, matching mount/training.)
-      const effScale = rsLora ? scale / Math.sqrt(rank) : scale;
-      const bScaled = ops.mulScalar(b, effScale, cpuStream);
-      const bT = ops.transposeAxes(bScaled, [1, 0], cpuStream);
-      bScaled.dispose();
-      const bT16 = bT.astype(Dtype.bfloat16, cpuStream);
-      bT.dispose();
-      const aT = ops.transposeAxes(a, [1, 0], cpuStream);
-      const aT16 = aT.astype(Dtype.bfloat16, cpuStream);
-      aT.dispose();
-      const delta = ops.matmul(bT16, aT16, cpuStream);
-      bT16.dispose();
-      aT16.dispose();
-
-      const w16 = w.dtype === Dtype.bfloat16 ? w : w.astype(Dtype.bfloat16, cpuStream);
-      if (w16 !== w) w.dispose();
-      const fusedW = ops.add(w16, delta, cpuStream);
-      w16.dispose();
-      delta.dispose();
-
-      if (srcSpec) {
-        const q = ops.quantize(fusedW, srcSpec.groupSize, srcSpec.bits, srcSpec.mode, cpuStream);
-        fusedW.dispose();
-        out.push({ name: `${base}.weight`, array: q.packed });
-        out.push({ name: `${base}.scales`, array: q.scales });
-        out.push({ name: `${base}.biases`, array: q.biases });
-      } else {
-        out.push({ name: `${base}.weight`, array: fusedW });
-      }
-      fusedModules++;
-    }
-    for (const name of passthroughNames) out.push({ name, array: weights.tensor(name) });
-
-    progress("writing", `Writing ${out.length} tensors to ${outDir}`, 1);
-    writeShardedSafetensors(outDir, out);
-
-    // Config is unchanged (same quantization layout) — copy it and the aux
-    // files (tokenizer, chat template, …) verbatim for a loadable snapshot.
-    await Bun.write(join(outDir, "config.json"), Bun.file(join(modelDir, "config.json")));
-    await copyAuxFiles(modelDir, outDir);
-
-    progress("done", `Fused ${fusedModules} module(s) → ${outDir}`, 1);
-    return {
-      outDir,
-      fusedModules,
-      skippedAdapterTensors: skipped + unmatched * 2,
-      totalTensors: out.length,
-    };
-  } finally {
-    for (const t of out) {
-      try { t.array.dispose(); } catch {}
-    }
-    disposeAll();
-    weights.dispose();
-    clearCache();
-  }
-}

package/src/train/index.ts

@@ -1,46 +0,0 @@
-// Public surface for native LoRA + DPO fine-tuning.
-
-export { ValueAndGrad } from "../mlx/autograd";
-
-export {
-  loadSftDataset, iterateSftBatches, encodeSftRow, sftRowFormat,
-  loadDpoDataset, iterateDpoBatches, encodeDpoRow, tokenizePair,
-  probeFormat, rowLength, dpoChosenLength, dpoRejectedLength, PAD_TO,
-  type SftExample, type SftBatch, type SftRowFormat,
-  type DpoExample, type DpoBatch, type DatasetFormat,
-} from "./dataset";
-
-export { trainForward, buildBatchedPadMask } from "./forward";
-
-export {
-  sftLoss, dpoLoss, dpoRefLogps, dpoMetrics,
-  orpoLoss, orpoMetrics, type SftScope,
-} from "./loss";
-
-export {
-  AdamW, warmupCosineSchedule, type AdamWOptions,
-} from "./optimizer";
-
-export {
-  buildTrainableLora, attachForTraining, detachTraining, setLoraScale,
-  flatA, flatB, flatParams, saveAdapter, disposeLora,
-  type TrainableLora, type TrainableTarget, type SaveAdapterConfig,
-} from "./lora-params";
-
-export {
-  resolveRanks, DEFAULT_TARGET_MODULES,
-  type RankScaling, type ResolveRanksOptions,
-} from "./rank";
-
-export {
-  trainLora, DEFAULT_TRAIN_CONFIG,
-  type TrainConfig, type TrainResult,
-} from "./trainer";
-
-export { mergeAdapters, type MergeStats } from "./merge";
-
-export { fuseAdapter, type FuseStats, type FuseProgress } from "./fuse";
-
-export { exportAdapter, type ExportManifest } from "./export";
-
-export { finetuneRunner, inspectDataset } from "./job";