mlx-bun 0.5.0 → 1.0.0

package/src/hub-rest.ts

@@ -1,242 +0,0 @@
-// Model Hub REST wrappers — thin loopback JSON routes for the web chat's
-// Model Hub panel (docs/design/web-chat-redesign.md §9 Phase 3, beat-matrix
-// Axis 3 "Hub" row). Same posture as src/memory/rest.ts: pure (request|url)
-// => Response handlers with no `ctx` dependency, dispatched from
-// src/server.ts by path+method, so they're unit-testable without booting a
-// model context (see tests/serve/hub-rest.test.ts).
-//
-// Three sources, same as optiq Lab's Hub, plus the hardware-fit column optiq
-// lacks:
-//   - GET /api/hub/local    — registry's canonical downloaded models, each
-//     with a /fit-computed verdict (predicted decode tok/s + fits at a
-//     default context) — the beat-matrix "real hardware verdict per row".
-//   - GET /api/hub/search   — server-side HF model search, filtered to
-//     MLX-compatible results, normalized. NEVER auto-downloads.
-//   - POST /api/hub/download — kicks off a background download via the
-//     existing downloadModel() + process tracker (src/download.ts);
-//     progress is already visible via GET /downloads. Refuses a duplicate
-//     in-flight download for the same repo.
-//   - POST /api/hub/serve   — model-swap investigation (see the doc header
-//     above the handler): today this ALWAYS returns
-//     { ok:false, restart_required:true, command } — see
-//     docs/reference/server-config.md for why no in-process swap seam is
-//     reachable from the web chat's serving path today.
-
-import { loadModelConfig } from "./config";
-import { fit } from "./fit";
-import { downloadModel, hfToken, isDownloadActive, type DownloadOptions } from "./download";
-import { Registry, visionCapable, type ModelRecord } from "./registry";
-import { supportTier } from "./model/support";
-
-function jsonOk<T extends object>(body: T, init?: ResponseInit): Response {
-  return Response.json({ ok: true, ...body }, init);
-}
-
-function jsonErr(error: string, status = 400): Response {
-  return Response.json({ ok: false, error }, { status });
-}
-
-// ---- GET /api/hub/local -------------------------------------------------
-
-/** One row per canonical repo, mirroring /library's shape but scoped to
- *  what the Hub panel needs: size/quant/capabilities + a fit verdict at a
- *  fixed 8k context (the same "typical" context /fit and /library use, so
- *  the three surfaces never disagree). `reg`/`hubDir` are injectable so
- *  tests can point at a synthetic hub dir instead of the real
- *  ~/.cache/huggingface/hub (matching tests/unit/registry-fit.test.ts's pattern);
- *  the live server route omits both and gets the real registry. */
-export async function handleHubLocal(
-  opts: { reg?: Registry; hubDir?: string } = {},
-): Promise<Response> {
-  const reg = opts.reg ?? new Registry();
-  const ownReg = !opts.reg;
-  try {
-    await reg.scan(opts.hubDir);
-    const rows = [];
-    for (const m of reg.listCanonical()) {
-      rows.push(await hubLocalRow(m));
-    }
-    return jsonOk({ models: rows });
-  } finally {
-    if (ownReg) reg.close();
-  }
-}
-
-async function hubLocalRow(m: ModelRecord) {
-  const tier = supportTier(m.modelType, m.repoId);
-  let assessment: {
-    fits: boolean;
-    max_safe_context: number;
-    predicted_decode_tps: number;
-  } | null = null;
-  try {
-    const config = await loadModelConfig(m.path);
-    const r = fit(config, m.sizeBytes, 8192, undefined, undefined, m.expertsBytes);
-    assessment = {
-      fits: r.fits,
-      max_safe_context: r.maxSafeContext,
-      predicted_decode_tps: r.predictedDecodeTps,
-    };
-  } catch {
-    /* unreadable config — assessment stays null, row still lists */
-  }
-  return {
-    repo_id: m.repoId,
-    model_type: m.modelType,
-    size_bytes: m.sizeBytes,
-    quant_bits: m.quantBits,
-    quant_group_size: m.quantGroupSize,
-    vision: visionCapable(m),
-    supported: tier !== null,
-    support_tier: tier,
-    assessment,
-  };
-}
-
-// ---- GET /api/hub/search -------------------------------------------------
-
-export interface HubSearchResult {
-  id: string;
-  downloads: number;
-  likes: number;
-  size_estimate: number | null;
-}
-
-/** The HF Hub's model-search API, filtered to the `mlx` library tag (the
- *  tag mlx-community and every other MLX-converted repo carries) so results
- *  are MLX-compatible by construction — same convention the download path
- *  already speaks HTTPS against (huggingface.co/api/*). Injectable `fetchFn`
- *  for tests; defaults to the real global fetch. */
-export async function searchHub(
-  query: string,
-  opts: { fetchFn?: typeof fetch; limit?: number; endpoint?: string } = {},
-): Promise<
-  | { ok: true; offline: false; results: HubSearchResult[] }
-  | { ok: false; offline: true; error: string }
-> {
-  const fetchFn = opts.fetchFn ?? fetch;
-  const endpoint = opts.endpoint ?? "https://huggingface.co";
-  const limit = opts.limit ?? 30;
-  const token = hfToken();
-  const url =
-    `${endpoint}/api/models?search=${encodeURIComponent(query)}` +
-    `&filter=mlx&sort=downloads&direction=-1&limit=${limit}`;
-  let res: Response;
-  try {
-    res = await fetchFn(url, {
-      headers: token ? { authorization: `Bearer ${token}` } : {},
-      signal: AbortSignal.timeout(10_000),
-    });
-  } catch (e) {
-    // Network unreachable (offline, DNS failure, timeout) — never surface
-    // this as a 500; the Hub panel shows an explicit offline state instead.
-    return { ok: false, offline: true, error: (e as Error).message };
-  }
-  if (!res.ok) {
-    return { ok: false, offline: true, error: `HF search ${res.status}` };
-  }
-  let body: unknown;
-  try {
-    body = await res.json();
-  } catch (e) {
-    return { ok: false, offline: true, error: `HF search: bad response (${(e as Error).message})` };
-  }
-  const rows = Array.isArray(body) ? body : [];
-  const results: HubSearchResult[] = rows
-    // Belt-and-suspenders: the API's filter=mlx already restricts to the
-    // tag, but a defensive re-check keeps a future upstream filter change
-    // from silently widening results to non-MLX repos.
-    .filter((r) => Array.isArray((r as Record<string, unknown>).tags)
-      ? ((r as { tags: string[] }).tags).includes("mlx")
-      : true)
-    .map((r) => {
-      const row = r as Record<string, unknown>;
-      return {
-        id: String(row.id ?? row.modelId ?? ""),
-        downloads: typeof row.downloads === "number" ? row.downloads : 0,
-        likes: typeof row.likes === "number" ? row.likes : 0,
-        // The search endpoint doesn't return file sizes (that's a second
-        // per-repo call this v1 skips to keep search fast) — null, not a
-        // fabricated number; the frontend's fit badge lands after download.
-        size_estimate: null,
-      };
-    })
-    .filter((r) => r.id.length > 0);
-  return { ok: true, offline: false, results };
-}
-
-export async function handleHubSearch(url: URL): Promise<Response> {
-  const q = url.searchParams.get("q")?.trim() ?? "";
-  if (!q) return jsonErr("missing ?q=");
-  const result = await searchHub(q);
-  if (!result.ok) return jsonOk({ offline: true, error: result.error, results: [] });
-  return jsonOk({ offline: false, results: result.results });
-}
-
-// ---- POST /api/hub/download -----------------------------------------------
-
-// downloadModel()'s own DownloadStatus row (src/download.ts's downloadLog,
-// read via isDownloadActive) only exists once listRepoFiles' network round
-// trip resolves — a rapid double-submit of this route can both pass that
-// check before either row is written. Route-local admission closes that
-// window: a repo is marked in-flight synchronously, before the first
-// `await`, and cleared in a `finally` once downloadModel settles either way.
-const inFlightHubDownloads = new Set<string>();
-
-export async function handleHubDownload(request: Request): Promise<Response> {
-  const body = (await request.json().catch(() => ({}))) as { repo?: string };
-  const repo = body.repo?.trim();
-  if (!repo) return jsonErr("missing \"repo\"");
-  if (inFlightHubDownloads.has(repo) || isDownloadActive(repo))
-    return jsonErr(`a download for ${repo} is already in progress`, 409);
-  inFlightHubDownloads.add(repo);
-  // Fire-and-forget, mirroring the CLI's background-download pattern
-  // (cli.ts's `downloadModel(recRepo).then(...).catch(...)`) — progress is
-  // already visible via GET /downloads (the process-global tracker
-  // downloadModel() itself writes to); this route just starts it and
-  // returns immediately rather than blocking on a multi-GB transfer.
-  const opts: DownloadOptions = {};
-  downloadModel(repo, opts)
-    .then(async () => {
-      try {
-        const reg = new Registry();
-        try { await reg.scan(); } finally { reg.close(); }
-      } catch { /* best-effort refresh; /downloads still shows completion */ }
-    })
-    .catch(() => { /* status recorded on the tracker; /downloads shows the error */ })
-    .finally(() => inFlightHubDownloads.delete(repo));
-  return jsonOk({ repo, started: true });
-}
-
-// ---- POST /api/hub/serve --------------------------------------------------
-
-/** Model-swap investigation (docs/reference/server-config.md): the web
- *  chat's `/ws/chat` is explicitly NOT proxied even under `--isolate`
- *  (src/serve/isolate.ts serves it a 501 with a pointer back to the direct,
- *  non-isolated server) and `--isolate` itself is opt-in, not the default —
- *  so the process the web chat actually talks to always has exactly one
- *  model loaded in-process with no drop-weights-and-reload seam. The
- *  isolate.ts `ModelPool` (P2, spawn-overlap child-per-model) IS a real,
- *  working live-swap mechanism, but it lives entirely on the `--isolate`
- *  reverse-proxy's `/v1/*` HTTP surface — not reachable from the WebSocket
- *  chat path this Hub panel serves. Faking a swap here (killing/reloading
- *  the in-process model while `/ws/chat` sessions are attached) would leave
- *  the server in a half-state the ground rules forbid ("the AI may crash,
- *  the UI never may" — a self-inflicted crash is not better). Honest
- *  answer: refuse, and hand back the exact restart command. Follow-up:
- *  wire /ws/chat through the isolate proxy (or move session state above the
- *  engine boundary) so ModelPool's spawn-overlap swap is actually reachable
- *  from the web chat — tracked as the Hub's live-swap follow-up. */
-export async function handleHubServe(request: Request): Promise<Response> {
-  const body = (await request.json().catch(() => ({}))) as { model?: string };
-  const model = body.model?.trim();
-  if (!model) return jsonErr("missing \"model\"");
-  // ok:false is deliberate — this is not an error the caller mishandled, it
-  // is the honest capability answer ("no live swap today"), but it is also
-  // not success: the frontend must not treat this as "now serving `model`".
-  return Response.json({
-    ok: false,
-    restart_required: true,
-    command: `mlx-bun serve ${model}`,
-  });
-}

package/src/index.ts

@@ -1,63 +0,0 @@
-// Public library surface (the npm "." export). What is re-exported here
-// is the semver contract — everything else under src/ is internal and may
-// change without notice. Mirrors the README "Library" example plus the
-// pieces a consumer needs around it.
-//
-// NOTE: library consumers bypass the CLI's first-run step, so call
-// ensureNativeRuntime() once before constructing a model on a machine
-// that may not have the MLX runtime yet (no-op when already present).
-
-export { ensureNativeRuntime, nativeRuntimeDir } from "./native-pack";
-export { loadModelConfig } from "./config";
-export { Weights } from "./weights";
-export { Gemma4Model } from "./model/gemma4";
-export { MiniCPM5Model } from "./model/minicpm5";
-export {
-  createModel,
-  openGlm52RuntimeModel,
-  openModel,
-  type ModelOpenOptions,
-  type Glm52RuntimeOpenOptions,
-  type RuntimeModel,
-} from "./model/factory";
-export { ModelImplementationRegistry, type ModelImplementation, type ModelImplementationProvider } from "./model/implementation";
-export type { ModelServingBinding, ModelPromptBuilder, BuiltPrompt, ServedModelInfo } from "./serve/model-binding";
-export type { ServingContext, ModelHostSource, AdapterService } from "./serve/model-host";
-export type { MlxGatewayBinding, MlxBatchGroup } from "./backends/mlx/gateway-binding";
-export type { MlxSerialServices, MlxSerialBinding } from "./backends/mlx/serial-executor";
-export { Qwen3Model } from "./model/qwen3";
-export { configFingerprint } from "./model/fingerprint";
-export {
-  BUILTIN_ARTIFACT_PROFILES,
-  ENGINE_CAPABILITIES,
-  externalArtifactFingerprint,
-  resolveModelProfile,
-  type ArtifactModelProfile,
-  type EngineCapability,
-  type FidelityTarget,
-  type FidelityTier,
-  type GenerationLoop,
-  type ModelArtifactIdentity,
-  type ModelExecutionComposition,
-  type ModelGraph,
-  type ModelLoader,
-  type ModelProfile,
-  type ModelSpecialization,
-  type ResolveModelProfileOptions,
-  type ResolvedModelProfile,
-} from "./model/profile";
-export { generate } from "./generate";
-export { loadTokenizer } from "./tokenizer";
-export { embedOne, embedMany, isEmbeddingModel, withInstruction, type EmbedResult } from "./embed";
-export { ChatTemplate } from "./chat-template";
-export { chooseAutoModel, COEXIST_FRACTION, DEFAULT_REPO_ID, fit, largestRecommendedRepoId, recommendedRepoId, skuMatrix, thisMachine } from "./fit";
-export { downloadModel } from "./download";
-export { Registry } from "./registry";
-export {
-  createServer,
-  shutdownServer,
-  loadContext,
-  type LoadContextOptions,
-  type ServerContext,
-  type ServerOptions,
-} from "./server";

package/src/inference/denoising.ts

@@ -1,17 +0,0 @@
-import type { GraphDescriptor } from "./graph";
-
-/** Denoising has canvas state and feedback, independent of AR token caches.
- * Returned tensors/state are owned by the run. Inputs remain borrowed. A
- * fused method may bypass this graph and implement InferenceMethod directly. */
-export interface DenoisingGraph<Tensor, State> {
-  readonly descriptor: GraphDescriptor;
-  readonly vocabSize: number;
-  readonly canvasLength: number;
-  readonly embedScale: number;
-  prefill(promptIds: number[], vision?: Tensor): State;
-  extendPrefill(tokens: Tensor, state: State): void;
-  decoderLogits(canvas: Tensor, state: State, feedback: Tensor | null): Tensor;
-  dequantEmbedWeight(): Tensor;
-  softEmbeddings(logits: Tensor, weight: Tensor): Tensor;
-  closeState(state: State): void;
-}

package/src/inference/draft-acceptance.ts

@@ -1,41 +0,0 @@
-/** One request's exact-token speculative acceptance walk. The backend owns
- * logits and sampling; this state owns only the accepted prefix and stop facts.
- * A group advances each live walk independently, regardless of batch size. */
-export class DraftAcceptance {
-  position = 0;
-  accepted = 0;
-  correction: number | null = null;
-  readonly emitted: number[] = [];
-  sawEos = false;
-  grammarDone = false;
-  done = false;
-
-  constructor(
-    readonly drafts: readonly number[],
-    readonly remaining: number,
-    readonly eosTokenIds: readonly number[],
-  ) {}
-
-  /** Supply one target sample after its sampler has updated request history
-   * and grammar. Once done, this request needs no further target samples. */
-  accept(token: number, grammarDone = false): void {
-    const matches = this.position < this.drafts.length && token === this.drafts[this.position];
-    this.position++;
-    if (matches) {
-      this.accepted++;
-      if (this.eosTokenIds.includes(token)) {
-        this.sawEos = this.done = true;
-        return;
-      }
-      this.emitted.push(token);
-      this.grammarDone = grammarDone;
-      this.done = grammarDone || this.emitted.length >= this.remaining;
-      return;
-    }
-    this.correction = token;
-    this.sawEos = this.eosTokenIds.includes(token);
-    if (!this.sawEos) this.emitted.push(token);
-    this.grammarDone = grammarDone;
-    this.done = true;
-  }
-}

package/src/inference/draft-output.ts

@@ -1,49 +0,0 @@
-import type { Cancellation, CancelReason, GenerationOutput, TokenLogprobs } from "../contracts/generation";
-import type { DraftAcceptance } from "./draft-acceptance";
-
-export interface DraftOutputRow {
-  readonly acceptance: DraftAcceptance;
-  readonly logprobs?: readonly (TokenLogprobs | undefined)[];
-  readonly output: Pick<GenerationOutput, "commit">;
-  readonly cancellation?: Cancellation;
-}
-
-/** Counts apply to this round. Accepted counts describe processed proposed
- * inputs, excluding an unprocessed correction/bonus and any unpublished EOS.
- * Failed/cancelled requests must be discarded, never checkpointed. */
-export type DraftOutputResult = { readonly generated: number; readonly accepted: number } & (
-  | { readonly kind: "continue"; readonly pending: number }
-  | { readonly kind: "stop" | "length" }
-  | { readonly kind: "cancelled"; readonly reason: CancelReason }
-  | { readonly kind: "failed"; readonly error: unknown }
-);
-
-/** Deliver verified content through the output interface before resolving
- * retained state. A stopped or failed consumer affects only its own request.
- * Token-sized publications preserve callbacks that stop inside a draft burst. */
-export async function deliverDraftOutputs(rows: readonly DraftOutputRow[]): Promise<DraftOutputResult[]> {
-  const results: DraftOutputResult[] = [];
-  for (const row of rows) results.push(await deliver(row));
-  return results;
-}
-
-async function deliver(row: DraftOutputRow): Promise<DraftOutputResult> {
-  const { acceptance } = row;
-  let generated = 0;
-  const retained = () => ({ generated, accepted: Math.min(generated, acceptance.accepted) });
-  try {
-    for (const token of acceptance.emitted) {
-      const reason = row.cancellation?.reason;
-      if (reason) return { kind: "cancelled", reason, generated, accepted: 0 };
-      const metadata = row.logprobs?.[generated];
-      const more = await row.output.commit([token], metadata ? [metadata] : undefined);
-      generated++;
-      if (more === false) return { kind: "stop", ...retained() };
-    }
-    const reason = row.cancellation?.reason;
-    if (reason) return { kind: "cancelled", reason, generated, accepted: 0 };
-    if (acceptance.sawEos || acceptance.grammarDone) return { kind: "stop", ...retained() };
-    if (generated >= acceptance.remaining) return { kind: "length", ...retained() };
-    return { kind: "continue", pending: acceptance.correction!, ...retained() };
-  } catch (error) { return { kind: "failed", error, generated, accepted: 0 }; }
-}

package/src/inference/graph.ts

@@ -1,33 +0,0 @@
-/** Describes an implementation's ABI, not a claim of oracle parity or speed. */
-export interface GraphDescriptor {
-  readonly id: string;
-  readonly backend: string;
-  readonly graphAbi: string;
-  readonly stateAbi: string;
-  readonly artifact: string;
-}
-
-export type LogitSelection =
-  | { readonly type: "all" }
-  | { readonly type: "last" }
-  | { readonly type: "range"; readonly start: number; readonly end: number };
-
-/** Backend-bound graph. Tensor/State/Inputs stay concrete within the binding.
- * Inputs and hidden are borrowed until the returned lazy work completes;
- * returned hidden/logits are owned by the caller. The graph appends to state.
- * Hidden is [batch, positions, hidden-width]; logits are [batch, selected
- * positions, vocabulary]. Selection precedes the vocabulary projection.
- * Dtypes and evaluation/fence semantics belong to the declared backend ABI.
- * Per-run masks, positions, media, taps, and adapters belong in Inputs or in
- * a bound graph context; they are not mutable session fields. */
-export interface AutoregressiveGraph<Tensor, State, Inputs> {
-  readonly descriptor: GraphDescriptor;
-  forwardHidden(inputs: Inputs, state: State): Tensor | Promise<Tensor>;
-  projectLogits(hidden: Tensor, selection: LogitSelection): Tensor;
-}
-
-/** A fused InferenceMethod can bypass this graph interface entirely. It need
- * only satisfy the method's output, cancellation, and ownership contracts. */
-export interface GraphFactory<Artifact, Binding, Graph> {
-  open(artifact: Artifact, binding: Binding): Promise<{ graph: Graph; close(): Promise<void> }>;
-}

package/src/inference/prefill.ts

@@ -1,45 +0,0 @@
-/** Request-level chunk policy. Execution consumes the selected size; model
- * backends can account for their temporary workspace without changing admission. */
-export interface PrefillPolicy {
-  chunkSize(promptTokens: number): number;
-}
-
-export interface PrefillPosition {
-  readonly length: number;
-  readonly position: number;
-  readonly chunkSize: number;
-  readonly tailSplit: boolean;
-  readonly snapshotAt?: number | null;
-}
-
-export interface PrefillStep {
-  readonly start: number;
-  readonly end: number;
-  readonly kind: "drain" | "final";
-  readonly snapshot: boolean;
-  /** Batch admission may finish a short last drain and token zero in one tick.
-   * Serial execution still yields between every drain and the next forward. */
-  readonly batchYield: boolean;
-}
-
-/** Shared serial/solo-batch prefill program. No tensors, runtime policy reads,
- * or sampling. Advance position only after executing the returned step. */
-export function nextPrefillStep(input: PrefillPosition): PrefillStep {
-  const { length, position, chunkSize, tailSplit, snapshotAt } = input;
-  if (!Number.isSafeInteger(length) || !Number.isSafeInteger(position) ||
-      !Number.isSafeInteger(chunkSize) || chunkSize < 1 || position < 0 || position >= length)
-    throw new Error("invalid prefill position or chunk size");
-  if (snapshotAt != null && (!Number.isSafeInteger(snapshotAt) || snapshotAt < 0 || snapshotAt > length))
-    throw new Error("invalid prefill snapshot boundary");
-  if (snapshotAt != null && snapshotAt > position && snapshotAt < length) {
-    const end = Math.min(position + chunkSize, snapshotAt);
-    return { start: position, end, kind: "drain", snapshot: end === snapshotAt, batchYield: true };
-  }
-  const remaining = length - position;
-  if (remaining > (tailSplit ? 1 : chunkSize)) {
-    const end = position + (tailSplit ? Math.min(chunkSize, remaining - 1) : chunkSize);
-    return { start: position, end, kind: "drain", snapshot: false,
-      batchYield: !tailSplit || remaining - 1 > chunkSize };
-  }
-  return { start: position, end: length, kind: "final", snapshot: false, batchYield: false };
-}

package/src/inference/rollback.ts

@@ -1,7 +0,0 @@
-/** A complete transaction over every participating target state layer.
- * A failed begin/resolve invalidates the run; its state must be discarded. */
-export interface SpeculativeTransaction<Acceptance = number> {
-  canBegin(drafts: number): boolean;
-  begin(drafts: number): void;
-  resolve(accepted: Acceptance): void;
-}

package/src/jobs/index.ts

@@ -1,31 +0,0 @@
-// Public API for the background job system. The server imports from here:
-// create/track jobs (JobStore), submit work (in-process or GPU-leased
-// subprocess), gate inference on GPU jobs, and stream a job's log over SSE.
-
-export { JobStore, DEFAULT_JOBS_DB, DEFAULT_JOBS_DIR, newJobId } from "./db";
-export {
-  registerRunner,
-  getRunner,
-  submitInProcess,
-  submitSubprocess,
-  closeSubprocessJobs,
-  closeInProcessJobs,
-  makeEmit,
-  isGpuBusy,
-  currentGpuJob,
-  drainQueue,
-  JOB_ENTRY_PATH,
-} from "./runner";
-export type { SubmitResult, SubprocessOpts } from "./runner";
-export { tailJob, streamJobResponse } from "./sse";
-export type { TailOpts } from "./sse";
-
-// Re-export the shared contract so consumers have one import site.
-export type {
-  JobEvent,
-  Emit,
-  JobRunner,
-  JobKind,
-  JobStatus,
-  JobRow,
-} from "./types";

package/src/jobs/job-entry.ts

@@ -1,107 +0,0 @@
-// Child-process job entry: `bun job-entry.ts <jobId>`.
-//
-// Spawned by submitSubprocess so MLX/GPU state lives in its own address space
-// and an uncatchable crash (segfault / process.exit) dies here without taking
-// the server down. Port of optiq lab jobs.py `_job_main` — opens its OWN
-// JobStore (a SQLite connection MUST NOT cross the process boundary), resolves
-// the runner, runs it with a log-appending emit, sets terminal status, and
-// exits 0 (done) / 1 (failed).
-
-import { createJobTaskClient } from "./task-client";
-import { JobStore } from "./db";
-import { getRunner, makeEmit } from "./runner";
-import type { JobRunner } from "./types";
-import { runtimeValue } from "../runtime-config";
-
-/** kind → module to dynamically import so it registers its runner. Real job
- *  kinds are built by parallel efforts; importing the module is expected to
- *  call `registerRunner(kind, ...)` at top level. Missing module ⇒ the job
- *  fails cleanly (see resolveRunner). */
-const KIND_MODULES: Record<string, () => Promise<unknown>> = {
-  quantize: () => import("../quantize/job"),
-  finetune: () => import("../train/job"),
-};
-
-/** Resolve a runner for `kind`. Test kinds (noop/crash) are pre-registered in
- *  runner.ts. Real kinds are lazily imported; a missing module is a clean
- *  failure, not a crash. */
-async function resolveRunner(kind: string): Promise<JobRunner> {
-  const existing = getRunner(kind);
-  if (existing) return existing;
-
-  const load = KIND_MODULES[kind];
-  if (load) {
-    try {
-      await load();
-    } catch (e) {
-      throw new Error(
-        `kind "${kind}": failed to load runner module ${kind} ` +
-          `(${e instanceof Error ? e.message : String(e)})`,
-      );
-    }
-    const loaded = getRunner(kind);
-    if (loaded) return loaded;
-    throw new Error(`kind "${kind}": module ${kind} did not register a runner`);
-  }
-  throw new Error(`no runner registered for kind "${kind}"`);
-}
-
-function nowIso(): string {
-  return new Date().toISOString().replace("T", " ").slice(0, 19);
-}
-
-export async function runJobEntry(jobId = process.argv[2]): Promise<void> {
-  if (!jobId) {
-    console.error("usage: bun job-entry.ts <jobId>");
-    process.exit(2);
-  }
-
-  // Own fresh connection — overrides come from env so a spawned child finds
-  // the same DB/logs the parent used (tests set these to a tmp dir).
-  const store = new JobStore(
-    runtimeValue("MLX_BUN_JOBS_DB") || undefined,
-    runtimeValue("MLX_BUN_JOBS_DIR") || undefined,
-  );
-
-  const row = store.get(jobId);
-  if (!row) {
-    console.error(`job ${jobId} not found`);
-    store.close();
-    process.exit(2);
-  }
-
-  const emit = makeEmit(store, jobId, row.log_path);
-  store.setStatus(jobId, "running");
-  emit({ type: "started", ts: Date.now() });
-
-  let config: Record<string, unknown>;
-  try {
-    config = JSON.parse(row.config_json) as Record<string, unknown>;
-  } catch (e) {
-    const error = `bad config_json: ${e instanceof Error ? e.message : String(e)}`;
-    store.setStatus(jobId, "failed", { error, endedAt: nowIso() });
-    emit({ type: "failed", error, ts: Date.now() });
-    store.close();
-    process.exit(1);
-  }
-
-  try {
-    const runner = await resolveRunner(row.kind);
-    const result = await createJobTaskClient(runner).run(config, emit);
-    const out = result?.outputPath;
-    if (out) store.setOutputPath(jobId, out);
-    store.setProgress(jobId, 1);
-    store.setStatus(jobId, "done", { endedAt: nowIso() });
-    emit({ type: "done", ts: Date.now(), output_dir: out ?? row.output_path ?? undefined });
-    store.close();
-    process.exit(0);
-  } catch (e) {
-    const error = e instanceof Error ? `${e.name}: ${e.message}` : String(e);
-    store.setStatus(jobId, "failed", { error, endedAt: nowIso() });
-    emit({ type: "failed", error, ts: Date.now() });
-    store.close();
-    process.exit(1);
-  }
-}
-
-if (import.meta.main) void runJobEntry();

package/src/jobs/task-client.ts

@@ -1,19 +0,0 @@
-import type { TaskClient } from "../contracts/completion";
-import { throwIfCancelled } from "../engine/cancellation";
-import type { JobEvent, JobRunner } from "./types";
-
-/** Numerical runners retain their artifact policy; the client owns delivery
- * and cooperative cancellation at progress boundaries. No event buffering. */
-export function createJobTaskClient(runner: JobRunner): TaskClient<
-  Record<string, unknown>, JobEvent, { outputPath?: string } | void
-> {
-  return {
-    async run(request, report, cancellation) {
-      const check = () => { if (cancellation) throwIfCancelled(cancellation); };
-      check();
-      const result = await runner((event) => { check(); report(event); check(); }, request);
-      check();
-      return result;
-    },
-  };
-}

package/src/jobs/types.ts

@@ -1,2 +0,0 @@
-/** Compatibility exports; producer and browser share the portable wire contract. */
-export type * from "../contracts/jobs";