romdevtools 0.71.1 → 0.84.0

package/src/toolchains/m68k-elf-gcc/gcc.js

@@ -2,229 +2,66 @@
 //
 // The full pipeline:
 //   runCc1m68k({source, headers, options}) → m68k assembly text (.s)
-//   runM68kAs({asmSource, includes})        → .o ELF object
-//   runM68kLd({objects, linkScript})        → linked .elf
-//   runM68kObjcopy({elf})                   → raw .bin Genesis ROM
+//   runM68kAs({source, includes})           → .o ELF object
+//   runM68kLd({objects, linkScript})         → linked .elf (+ map)
+//   runM68kObjcopy({elf})                    → raw .bin Genesis ROM
 //
-// Each step runs as a WASM module through our worker pool (R12
-// subprocess isolation), same pattern as wladx.js / tcc816.js. The JS
-// glue replaces gcc's normal driver — gcc-the-driver spawns cc1/as/ld
-// as subprocesses via fork/exec, which emscripten can't do. We don't
-// need it: this file orchestrates the same steps through callMain.
-
+// 0.81.0: the 4 stages are now produced by the shared makeGccToolchain() factory
+// (common/gcc-toolchain.js) — every arch's cc1/as/ld/objcopy share the same
+// input-marshalling + runIsolated + output-decoding; this file is just the m68k
+// CONFIG (glue names, arch flags, link-script name, ROM extension) + thin named
+// re-exports so existing call sites keep their runM68k* names.
+//
+// The WASM glue ships in romdev-toolchain-m68k-gcc (20MB); resolution is lazy +
+// memoized, so booting the server never loads it unless a Genesis C ROM is built.
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
 import path from "node:path";
 
-import { runIsolated, textFile, binaryFile, getOutputBytes, getOutputText } from "../_worker/run.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { makeGccToolchain } from "../common/gcc-toolchain.js";
 
-// m68k-elf-gcc's WASM ships in romdev-toolchain-m68k-gcc. Resolve each tool's
-// glue from that package; fall back to a local copy under src/ if present
-// (transition / dev). emcc's `EXPORT_ES6=1` output is ESM (uses
-// import.meta.url + dynamic require), so the glue uses .mjs extensions. The
-// package is a hard dep of romdev.
-function resolveM68kGlue(file) {
-  try {
-    const u = import.meta.resolve("romdev-toolchain-m68k-gcc");
-    const p = path.join(path.dirname(fileURLToPath(u)), "wasm", file);
-    if (existsSync(p)) return p;
-  } catch { /* package not resolvable — fall through to local */ }
-  const local = path.join(__dirname, "wasm", file);
-  if (existsSync(local)) return local;
-  throw new Error(`m68k-elf-gcc WASM (${file}) not found — install romdev-toolchain-m68k-gcc`);
-}
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-// Lazy + memoized per tool: resolve only on the first Genesis-C build that uses
-// each tool, not at module load — so booting the server never touches this
-// (20MB) package unless a Genesis C ROM is actually built.
-const _glue = {};
-const m68kGlue = (file) => (_glue[file] ??= resolveM68kGlue(file));
-
-// ── cc1 — m68k gcc C frontend, source → assembly ─────────────────────
-//
-// Canonical gcc invocation pattern (what `gcc -S` does internally):
-//   cc1 -quiet <source.c> -mcpu=68000 -O<n> -o <out.s>
-//
-// We strip the -quiet so the agent sees diagnostics, and add a fixed
-// `-mcpu=68000` since Genesis is always 68000 (no 68020+).
+const { runCc1, runAs, runLd, runObjcopy } = makeGccToolchain({
+  pkg: "romdev-toolchain-m68k-gcc",
+  localDir: __dirname,
+  label: "m68k-elf-gcc",
+  glue: {
+    cc1: "cc1-m68k.mjs",
+    as: "m68k-elf-as.mjs",
+    ld: "m68k-elf-ld.mjs",
+    objcopy: "m68k-elf-objcopy.mjs",
+  },
+  // Genesis is always a bare 68000 (no 68020+).
+  cc1Flags: ["-mcpu=68000"],
+  asFlags: ["-march=68000"],
+  ldScriptName: "genesis.ld",
+  outputName: "main.bin",
+});
 
 /**
  * Compile a C source to m68k assembly via cc1.
- *
- * @param {Object} args
- * @param {string} args.source main C source text
- * @param {Record<string, string>} [args.headers] virtual headers visible via -I/work
- * @param {string[]} [args.options] extra cc1 flags (e.g. ['-O2', '-Wall'])
+ * @param {{source:string, headers?:Record<string,string>, options?:string[]}} args
  * @returns {Promise<{log:string, exitCode:number, asmSource:string|null, crash?:any}>}
  */
-export async function runCc1m68k(args) {
-  const { source, options = [] } = args;
-  const headers = args.headers ?? {};
-  /** @type {import("../_worker/run.js").InputFile[]} */
-  const inputFiles = [textFile("/work/main.c", source)];
-  for (const [name, content] of Object.entries(headers)) {
-    inputFiles.push(textFile("/work/" + name, content));
-  }
-  const argv = [
-    "-mcpu=68000",
-    "-iquote", "/work",
-    "-I", "/work",   // also handle #include <...> form (SGDK headers etc.)
-    ...options,
-    "/work/main.c",
-    "-o", "/work/main.s",
-  ];
-  const r = await runIsolated({
-    gluePath: m68kGlue("cc1-m68k.mjs"),
-    argv,
-    inputFiles,
-    outputFiles: [{ vfsPath: "/work/main.s", encoding: "utf8" }],
-  });
-  return {
-    log: r.log,
-    exitCode: r.exitCode,
-    asmSource: getOutputText(r, "/work/main.s") || null,
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}),
-  };
-}
-
-// ── m68k-elf-as — GNU assembler, .s → .o ─────────────────────────────
+export const runCc1m68k = runCc1;
 
 /**
  * Assemble m68k assembly with m68k-elf-as.
- *
- * @param {Object} args
- * @param {string} args.source assembly source text
- * @param {Record<string, string>} [args.includes] sibling .s/.inc files (text)
- * @param {Record<string, Uint8Array>} [args.binaryIncludes] sibling binary files
- *   the .s `.incbin`s — typically a rom_header.bin or similar pre-computed blob.
- *   Mounted into MEMFS verbatim at the given path.
- * @param {string[]} [args.options]
+ * @param {{source:string, includes?:Record<string,string>, binaryIncludes?:Record<string,Uint8Array>, options?:string[]}} args
  * @returns {Promise<{log:string, exitCode:number, object:Uint8Array|null, crash?:any}>}
  */
-export async function runM68kAs(args) {
-  const { source, options = [] } = args;
-  const includes = args.includes ?? {};
-  const binaryIncludes = args.binaryIncludes ?? {};
-  /** @type {import("../_worker/run.js").InputFile[]} */
-  const inputFiles = [textFile("/work/main.s", source)];
-  for (const [name, content] of Object.entries(includes)) {
-    inputFiles.push(textFile("/work/" + name, content));
-  }
-  for (const [name, bytes] of Object.entries(binaryIncludes)) {
-    inputFiles.push(binaryFile("/work/" + name, bytes));
-  }
-  const argv = [
-    "-march=68000",
-    "-I", "/work",
-    ...options,
-    "/work/main.s",
-    "-o", "/work/main.o",
-  ];
-  const r = await runIsolated({
-    gluePath: m68kGlue("m68k-elf-as.mjs"),
-    argv,
-    inputFiles,
-    outputFiles: [{ vfsPath: "/work/main.o", encoding: "base64" }],
-  });
-  return {
-    log: r.log,
-    exitCode: r.exitCode,
-    object: getOutputBytes(r, "/work/main.o"),
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}),
-  };
-}
-
-// ── m68k-elf-ld — GNU linker, .o + linker script → .elf ──────────────
+export const runM68kAs = runAs;
 
 /**
- * Link m68k object files into an ELF executable.
- *
- * @param {Object} args
- * @param {Record<string, Uint8Array>} args.objects name → .o bytes
- * @param {string} args.linkScript ld linker script contents (genesis.ld)
- * @param {string[]} [args.libraryPaths] paths to search for archives
- * @param {string[]} [args.libraries] -l<name> archives (e.g. ['gcc', 'c', 'md'])
- * @param {Record<string, Uint8Array>} [args.archives] additional .a archives to ship
- *   into MEMFS (e.g. {'libgcc.a': bytes, 'libmd.a': bytes})
- * @param {string[]} [args.options] extra ld flags
- * @returns {Promise<{log:string, exitCode:number, elf:Uint8Array|null, crash?:any}>}
+ * Link m68k object files into an ELF executable (+ linker map).
+ * @param {{objects:Record<string,Uint8Array>, linkScript:string, libraries?:string[], libraryPaths?:string[], archives?:Record<string,Uint8Array>, options?:string[]}} args
+ * @returns {Promise<{log:string, exitCode:number, elf:Uint8Array|null, map:string|null, crash?:any}>}
  */
-export async function runM68kLd(args) {
-  const { objects, linkScript, libraries = [], libraryPaths = [], options = [] } = args;
-  const archives = args.archives ?? {};
-  /** @type {import("../_worker/run.js").InputFile[]} */
-  const inputFiles = [textFile("/work/genesis.ld", linkScript)];
-  for (const [name, bytes] of Object.entries(objects)) {
-    inputFiles.push(binaryFile("/work/" + name, bytes));
-  }
-  for (const [name, bytes] of Object.entries(archives)) {
-    inputFiles.push(binaryFile("/work/" + name, bytes));
-  }
-  const argv = [
-    "-T", "/work/genesis.ld",
-    "-o", "/work/main.elf",
-    // Emit a linker map: it lists every symbol's final address (`0xADDR symbol`
-    // style), which is how an agent finds where a RAM variable like `well[][]`
-    // landed so it can writeMemory to it. Cheap to always produce.
-    "-Map=/work/main.map",
-    ...libraryPaths.flatMap((p) => ["-L", p]),
-    ...Object.keys(objects).map((n) => "/work/" + n),
-    ...libraries.map((l) => `-l${l}`),
-    ...options,
-  ];
-  const r = await runIsolated({
-    gluePath: m68kGlue("m68k-elf-ld.mjs"),
-    argv,
-    inputFiles,
-    outputFiles: [
-      { vfsPath: "/work/main.elf", encoding: "base64" },
-      { vfsPath: "/work/main.map", encoding: "utf8" },
-    ],
-  });
-  return {
-    log: r.log,
-    exitCode: r.exitCode,
-    elf: getOutputBytes(r, "/work/main.elf"),
-    // The map is present on a successful link; absent → "" (link failed, so
-    // the caller is looking at exitCode/log anyway).
-    map: getOutputText(r, "/work/main.map") || null,
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}),
-  };
-}
-
-// ── m68k-elf-objcopy — extract raw Genesis ROM from ELF ──────────────
+export const runM68kLd = runLd;
 
 /**
  * Strip an ELF down to a raw .bin (the Genesis ROM format).
- *
- * @param {Object} args
- * @param {Uint8Array} args.elf input ELF bytes
- * @param {string[]} [args.options] extra objcopy flags
+ * @param {{elf:Uint8Array, options?:string[]}} args
  * @returns {Promise<{log:string, exitCode:number, binary:Uint8Array|null, crash?:any}>}
  */
-export async function runM68kObjcopy(args) {
-  const { elf, options = [] } = args;
-  /** @type {import("../_worker/run.js").InputFile[]} */
-  const inputFiles = [binaryFile("/work/main.elf", elf)];
-  const argv = [
-    "-O", "binary",
-    ...options,
-    "/work/main.elf",
-    "/work/main.bin",
-  ];
-  const r = await runIsolated({
-    gluePath: m68kGlue("m68k-elf-objcopy.mjs"),
-    argv,
-    inputFiles,
-    outputFiles: [{ vfsPath: "/work/main.bin", encoding: "base64" }],
-  });
-  return {
-    log: r.log,
-    exitCode: r.exitCode,
-    binary: getOutputBytes(r, "/work/main.bin"),
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}),
-  };
-}
+export const runM68kObjcopy = runObjcopy;

package/src/toolchains/mips-c/mips-c.js

@@ -13,6 +13,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 
 import { runCc1mips, runMipsAs, runMipsLd, runMipsObjcopy } from "../mips-elf-gcc/gcc.js";
+import { CBuild, BuildError } from "../common/c-build.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const LIB = path.join(__dirname, "lib");
@@ -101,89 +102,78 @@ export async function buildMipsC(args) {
     const callerHasC = (args.sources && (args.sources[`${helperName}.c`] != null));
     if (!callerHasC) autoHelperSrc = await readFile(cPath, "utf-8").catch(() => null);
   }
-  let log = "";
+  const cb = new CBuild();
+  // bound stage runners (endian + opts fixed) so the per-source loops stay terse
+  const cc1 = (source) => runCc1mips({ source, headers, options: cc1Options, endian });
+  const as = (source) => runMipsAs({ source, endian });
 
-  /** @type {Record<string, Uint8Array>} */
-  const userObjs = {};
-  for (const cName of Object.keys(sources).filter((n) => /\.c$/i.test(n))) {
-    const cc = await runCc1mips({ source: sources[cName], headers, options: cc1Options, endian });
-    log += `--- cc1 (${cName}) ---\n${cc.log || "(ok)"}\n`;
-    if (cc.exitCode !== 0 || !cc.asmSource) return { ok: false, binary: null, log, exitCode: cc.exitCode || 1, stage: `cc1 (${cName})`, ...(cc.crash ? { crash: cc.crash } : {}) };
-    const as = await runMipsAs({ source: cc.asmSource, endian });
-    log += `--- as (${cName}) ---\n${as.log || "(ok)"}\n`;
-    if (as.exitCode !== 0 || !as.object) return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${cName})`, ...(as.crash ? { crash: as.crash } : {}) };
-    userObjs[cName.replace(/\.c$/i, ".o")] = as.object;
-  }
-  // Auto-bundled helper .c (n64.c / psx.c) — compiled with the SAME headers so it can
-  // see its own header, linked alongside the user objects. Skipped when the caller
-  // supplied their own helper .c (callerHasC) above.
-  if (autoHelperSrc != null) {
-    const cc = await runCc1mips({ source: autoHelperSrc, headers, options: cc1Options, endian });
-    log += `--- cc1 (${helperName}.c, bundled) ---\n${cc.log || "(ok)"}\n`;
-    if (cc.exitCode !== 0 || !cc.asmSource) return { ok: false, binary: null, log, exitCode: cc.exitCode || 1, stage: `cc1 (${helperName}.c bundled)`, ...(cc.crash ? { crash: cc.crash } : {}) };
-    const as = await runMipsAs({ source: cc.asmSource, endian });
-    log += `--- as (${helperName}.c, bundled) ---\n${as.log || "(ok)"}\n`;
-    if (as.exitCode !== 0 || !as.object) return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${helperName}.c bundled)` };
-    userObjs[`${helperName}.o`] = as.object;
-  }
+  try {
+    /** @type {Record<string, Uint8Array>} */
+    const userObjs = {};
+    for (const cName of Object.keys(sources).filter((n) => /\.c$/i.test(n))) {
+      const cc = await cb.stage(`cc1 (${cName})`, () => cc1(sources[cName]), (r) => r.asmSource);
+      const ao = await cb.stage(`as (${cName})`, () => as(cc.asmSource), (r) => r.object);
+      userObjs[cName.replace(/\.c$/i, ".o")] = ao.object;
+    }
+    // Auto-bundled helper .c (n64.c / psx.c) — compiled with the SAME headers so it can
+    // see its own header, linked alongside the user objects. Skipped when the caller
+    // supplied their own helper .c (callerHasC) above.
+    if (autoHelperSrc != null) {
+      const cc = await cb.stage(`cc1 (${helperName}.c bundled)`, () => cc1(autoHelperSrc), (r) => r.asmSource);
+      const ao = await cb.stage(`as (${helperName}.c bundled)`, () => as(cc.asmSource), (r) => r.object);
+      userObjs[`${helperName}.o`] = ao.object;
+    }
 
-  // raw .s sources too
-  for (const sName of Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n))) {
-    const as = await runMipsAs({ source: sources[sName], endian });
-    log += `--- as (${sName}) ---\n${as.log || "(ok)"}\n`;
-    if (as.exitCode !== 0 || !as.object) return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${sName})`, ...(as.crash ? { crash: as.crash } : {}) };
-    userObjs[sName.replace(/\.(s|asm)$/i, ".o")] = as.object;
-  }
+    // raw .s sources too
+    for (const sName of Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n))) {
+      const ao = await cb.stage(`as (${sName})`, () => as(sources[sName]), (r) => r.object);
+      userObjs[sName.replace(/\.(s|asm)$/i, ".o")] = ao.object;
+    }
 
-  // crt0 (per platform)
-  const crt0Name = platform === "ps1" ? "ps1-crt0.s" : "n64-crt0.s";
-  const crt0Src = await readFile(path.join(LIB, crt0Name), "utf-8");
-  const crt0As = await runMipsAs({ source: crt0Src, endian });
-  log += `--- as (${crt0Name}) ---\n${crt0As.log || "(ok)"}\n`;
-  if (crt0As.exitCode !== 0 || !crt0As.object) return { ok: false, binary: null, log, exitCode: crt0As.exitCode || 1, stage: "as (crt0)", ...(crt0As.crash ? { crash: crt0As.crash } : {}) };
+    // crt0 (per platform)
+    const crt0Name = platform === "ps1" ? "ps1-crt0.s" : "n64-crt0.s";
+    const crt0Src = await readFile(path.join(LIB, crt0Name), "utf-8");
+    const crt0As = await cb.stage(`as (${crt0Name})`, () => as(crt0Src), (r) => r.object);
 
-  // softint.c — the few libgcc helpers (64-bit divide/mod) in plain C, so the
-  // link doesn't need an endian-specific libgcc.a (the EL libgcc isn't bundled).
-  const softSrc = await readFile(path.join(LIB, "softint.c"), "utf-8");
-  const softCc = await runCc1mips({ source: softSrc, options: cc1Options, endian });
-  const softAs = softCc.asmSource ? await runMipsAs({ source: softCc.asmSource, endian }) : { exitCode: 1 };
-  if (softCc.exitCode !== 0 || softAs.exitCode !== 0 || !softAs.object) {
-    return { ok: false, binary: null, log: log + (softCc.log || "") + (softAs.log || ""), exitCode: 1, stage: "softint" };
-  }
+    // softint.c — the few libgcc helpers (64-bit divide/mod) in plain C, so the
+    // link doesn't need an endian-specific libgcc.a (the EL libgcc isn't bundled).
+    const softSrc = await readFile(path.join(LIB, "softint.c"), "utf-8");
+    const softCc = await cb.stage("cc1 (softint.c)", () => cc1(softSrc), (r) => r.asmSource);
+    const softAs = await cb.stage("as (softint.c)", () => as(softCc.asmSource), (r) => r.object);
 
-  // link
-  const ldName = platform === "ps1" ? "ps1.ld" : "n64.ld";
-  const linkScript = await readFile(path.join(LIB, ldName), "utf-8");
-  // newlib + libgcc are endian-specific: el/ (PS1 little) vs be/ (N64 big). libgcc
-  // is only bundled for be/ — softint.c covers the EL case, so libgcc is optional.
-  const libDir = path.join(LIB, endian === "little" ? "el" : "be");
-  const [libc, libm] = await Promise.all([
-    readFile(path.join(libDir, "libc.a")), readFile(path.join(libDir, "libm.a")),
-  ]);
-  const archives = { "libc.a": new Uint8Array(libc), "libm.a": new Uint8Array(libm) };
-  const libraries = ["c", "m"];
-  try {
-    const libgcc = await readFile(path.join(libDir, "libgcc.a"));
-    archives["libgcc.a"] = new Uint8Array(libgcc);
-    libraries.unshift("gcc");
-  } catch { /* no endian libgcc — softint.c provides the needed helpers */ }
-  const ld = await runMipsLd({
-    objects: { "crt0.o": crt0As.object, "softint.o": softAs.object, ...userObjs },
-    linkScript, endian,
-    archives,
-    libraries,
-    libraryPaths: ["/work"],
-    options: ["--no-warn-rwx-segments"],
-  });
-  log += `--- ld ---\n${ld.log || "(ok)"}\n`;
-  if (ld.exitCode !== 0 || !ld.elf) return { ok: false, binary: null, log, exitCode: ld.exitCode || 1, stage: "ld", ...(ld.crash ? { crash: ld.crash } : {}) };
+    // link
+    const ldName = platform === "ps1" ? "ps1.ld" : "n64.ld";
+    const linkScript = await readFile(path.join(LIB, ldName), "utf-8");
+    // newlib + libgcc are endian-specific: el/ (PS1 little) vs be/ (N64 big). libgcc
+    // is only bundled for be/ — softint.c covers the EL case, so libgcc is optional.
+    const libDir = path.join(LIB, endian === "little" ? "el" : "be");
+    const [libc, libm] = await Promise.all([
+      readFile(path.join(libDir, "libc.a")), readFile(path.join(libDir, "libm.a")),
+    ]);
+    const archives = { "libc.a": new Uint8Array(libc), "libm.a": new Uint8Array(libm) };
+    const libraries = ["c", "m"];
+    try {
+      const libgcc = await readFile(path.join(libDir, "libgcc.a"));
+      archives["libgcc.a"] = new Uint8Array(libgcc);
+      libraries.unshift("gcc");
+    } catch { /* no endian libgcc — softint.c provides the needed helpers */ }
+    const ld = await cb.stage("ld", () => runMipsLd({
+      objects: { "crt0.o": crt0As.object, "softint.o": softAs.object, ...userObjs },
+      linkScript, endian,
+      archives,
+      libraries,
+      libraryPaths: ["/work"],
+      options: ["--no-warn-rwx-segments"],
+    }), (r) => r.elf);
 
-  const oc = await runMipsObjcopy({ elf: ld.elf });
-  log += `--- objcopy ---\n${oc.log || "(ok)"}\n`;
-  if (oc.exitCode !== 0 || !oc.binary) return { ok: false, binary: null, log, exitCode: oc.exitCode || 1, stage: "objcopy", ...(oc.crash ? { crash: oc.crash } : {}) };
+    const oc = await cb.stage("objcopy", () => runMipsObjcopy({ elf: ld.elf }), (r) => r.binary);
 
-  const binary = platform === "ps1" ? wrapPsExe(oc.binary)
-    : platform === "n64" ? wrapN64Rom(oc.binary)
-    : oc.binary;
-  return { ok: true, binary, log, exitCode: 0, stage: "done", ...(ld.map ? { symbols: ld.map } : {}) };
+    const binary = platform === "ps1" ? wrapPsExe(oc.binary)
+      : platform === "n64" ? wrapN64Rom(oc.binary)
+      : oc.binary;
+    return { ok: true, binary, log: cb.log, exitCode: 0, stage: "done", ...(ld.map ? { symbols: ld.map } : {}) };
+  } catch (e) {
+    if (e instanceof BuildError) return e.toResult();
+    throw e;
+  }
 }

package/src/toolchains/mips-elf-gcc/gcc.js

@@ -1,130 +1,67 @@
 // mips-elf-gcc — WASM toolchain wrappers for N64 / PS1 C builds.
 //
-// Pipeline (mirrors m68k-elf-gcc/gcc.js — gcc-the-driver can't fork/exec under
-// emscripten, so we orchestrate cc1 → as → ld → objcopy through callMain):
-//   runCc1mips({source, headers, options, endian}) → MIPS assembly (.s)
-//   runMipsAs({source, includes, endian})          → .o ELF object
-//   runMipsLd({objects, linkScript, ...})          → linked .elf (+ map)
-//   runMipsObjcopy({elf})                          → raw .bin
+// The full pipeline:
+//   runCc1mips({source, headers, options, endian}) → MIPS assembly text (.s)
+//   runMipsAs({source, includes, endian})           → .o ELF object
+//   runMipsLd({objects, linkScript, endian})         → linked .elf (+ map)
+//   runMipsObjcopy({elf})                            → raw .bin
 //
-// Endianness: N64 (R4300) is big-endian (default), PS1 (R3000) is little-endian
-// (-EL). The same WASM toolchain emits both — pass endian:'little' for PS1.
-
+// 0.81.0: the 4 stages come from the shared makeGccToolchain() factory
+// (common/gcc-toolchain.js); this file is just the MIPS config + thin re-exports.
+// Unlike the other arches, MIPS is bi-endian (N64 big, PS1 little) — its cc1 and
+// as/ld want DIFFERENT endian flag spellings (cc1: -mel/-meb; as/ld: -EL/-EB), so
+// the flags are functions of `endian` (default "big" for N64). MIPS32, ABI o32, -G0.
+//
+// WASM glue ships in romdev-toolchain-mips-gcc; resolution is lazy + memoized.
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
 import path from "node:path";
 
-import { runIsolated, textFile, binaryFile, getOutputBytes, getOutputText } from "../_worker/run.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { makeGccToolchain } from "../common/gcc-toolchain.js";
 
-// The WASM ships in romdev-toolchain-mips-gcc; fall back to the in-tree dev copy.
-function resolveMipsGlue(file) {
-  try {
-    const u = import.meta.resolve("romdev-toolchain-mips-gcc");
-    const p = path.join(path.dirname(fileURLToPath(u)), "wasm", file);
-    if (existsSync(p)) return p;
-  } catch { /* not resolvable — fall through */ }
-  const local = path.join(__dirname, "wasm", file);
-  if (existsSync(local)) return local;
-  throw new Error(`mips-elf-gcc WASM (${file}) not found — build it with scripts/build-mips-wasm-tools.sh`);
-}
-const _glue = {};
-const mipsGlue = (file) => (_glue[file] ??= resolveMipsGlue(file));
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-/** Endian flags differ by TOOL: cc1 (the C frontend) wants `-mel`/`-meb`; the
- *  assembler + linker want `-EL`/`-EB`. `-mabi=32` (cc1) covers both R3000 (PS1)
- *  and R4300 (N64) 32-bit code. */
-function cc1ArchFlags(endian) {
-  return [endian === "little" ? "-mel" : "-meb", "-mabi=32"];
-}
-function asArchFlags(endian) {
-  // -G0: never use GP-relative (small-data) addressing. Without it, statics land in
-  // .sdata/.sbss and the 16-bit GPREL offsets overflow ("relocation truncated") on
-  // anything but a tiny program. -G0 forces normal .data/.bss addressing.
-  return [endian === "little" ? "-EL" : "-EB", "-mabi=32", "-G0"];
-}
+const { runCc1, runAs, runLd, runObjcopy } = makeGccToolchain({
+  pkg: "romdev-toolchain-mips-gcc",
+  localDir: __dirname,
+  label: "mips-elf-gcc",
+  glue: {
+    cc1: "cc1.mjs",
+    as: "mips-elf-as.mjs",
+    ld: "mips-elf-ld.mjs",
+    objcopy: "mips-elf-objcopy.mjs",
+  },
+  defaultEndian: "big",
+  cc1Flags: (endian) => [endian === "little" ? "-mel" : "-meb", "-mabi=32"],
+  asFlags: (endian) => [endian === "little" ? "-EL" : "-EB", "-mabi=32", "-G0"],
+  ldFlags: (endian) => [endian === "little" ? "-EL" : "-EB"],
+  ldScriptName: "link.ld",
+  outputName: "main.bin",
+});
 
-// ── cc1 — MIPS gcc C frontend, source → assembly ─────────────────────
-export async function runCc1mips(args) {
-  const { source, options = [], endian = "big" } = args;
-  const headers = args.headers ?? {};
-  const inputFiles = [textFile("/work/main.c", source)];
-  for (const [name, content] of Object.entries(headers)) inputFiles.push(textFile("/work/" + name, content));
-  const argv = [
-    ...cc1ArchFlags(endian),
-    "-iquote", "/work", "-I", "/work",
-    ...options,
-    "/work/main.c", "-o", "/work/main.s",
-  ];
-  const r = await runIsolated({
-    gluePath: mipsGlue("cc1.mjs"),
-    argv, inputFiles,
-    outputFiles: [{ vfsPath: "/work/main.s", encoding: "utf8" }],
-  });
-  return { log: r.log, exitCode: r.exitCode, asmSource: getOutputText(r, "/work/main.s") || null,
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
-}
+/**
+ * Compile a C source to MIPS assembly via cc1.
+ * @param {{source:string, headers?:Record<string,string>, options?:string[], endian?:"big"|"little"}} args
+ * @returns {Promise<{log:string, exitCode:number, asmSource:string|null, crash?:any}>}
+ */
+export const runCc1mips = runCc1;
 
-// ── mips-elf-as — GNU assembler, .s → .o ─────────────────────────────
-export async function runMipsAs(args) {
-  const { source, options = [], endian = "big" } = args;
-  const includes = args.includes ?? {};
-  const binaryIncludes = args.binaryIncludes ?? {};
-  const inputFiles = [textFile("/work/main.s", source)];
-  for (const [name, content] of Object.entries(includes)) inputFiles.push(textFile("/work/" + name, content));
-  for (const [name, bytes] of Object.entries(binaryIncludes)) inputFiles.push(binaryFile("/work/" + name, bytes));
-  const argv = [...asArchFlags(endian), "-I", "/work", ...options, "/work/main.s", "-o", "/work/main.o"];
-  const r = await runIsolated({
-    gluePath: mipsGlue("mips-elf-as.mjs"),
-    argv, inputFiles,
-    outputFiles: [{ vfsPath: "/work/main.o", encoding: "base64" }],
-  });
-  return { log: r.log, exitCode: r.exitCode, object: getOutputBytes(r, "/work/main.o"),
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
-}
+/**
+ * Assemble MIPS assembly with mips-elf-as.
+ * @param {{source:string, includes?:Record<string,string>, binaryIncludes?:Record<string,Uint8Array>, options?:string[], endian?:"big"|"little"}} args
+ * @returns {Promise<{log:string, exitCode:number, object:Uint8Array|null, crash?:any}>}
+ */
+export const runMipsAs = runAs;
 
-// ── mips-elf-ld — GNU linker, .o + linker script → .elf ──────────────
-export async function runMipsLd(args) {
-  const { objects, linkScript, libraries = [], libraryPaths = [], options = [], endian = "big" } = args;
-  const archives = args.archives ?? {};
-  const inputFiles = [textFile("/work/link.ld", linkScript)];
-  for (const [name, bytes] of Object.entries(objects)) inputFiles.push(binaryFile("/work/" + name, bytes));
-  for (const [name, bytes] of Object.entries(archives)) inputFiles.push(binaryFile("/work/" + name, bytes));
-  const argv = [
-    endian === "little" ? "-EL" : "-EB",
-    "-T", "/work/link.ld",
-    "-o", "/work/main.elf",
-    "-Map=/work/main.map",
-    ...libraryPaths.flatMap((p) => ["-L", p]),
-    ...Object.keys(objects).map((n) => "/work/" + n),
-    ...libraries.map((l) => `-l${l}`),
-    ...options,
-  ];
-  const r = await runIsolated({
-    gluePath: mipsGlue("mips-elf-ld.mjs"),
-    argv, inputFiles,
-    outputFiles: [
-      { vfsPath: "/work/main.elf", encoding: "base64" },
-      { vfsPath: "/work/main.map", encoding: "utf8" },
-    ],
-  });
-  return { log: r.log, exitCode: r.exitCode, elf: getOutputBytes(r, "/work/main.elf"),
-    map: getOutputText(r, "/work/main.map") || null,
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
-}
+/**
+ * Link MIPS object files into an ELF executable (+ linker map).
+ * @param {{objects:Record<string,Uint8Array>, linkScript:string, libraries?:string[], libraryPaths?:string[], archives?:Record<string,Uint8Array>, options?:string[], endian?:"big"|"little"}} args
+ * @returns {Promise<{log:string, exitCode:number, elf:Uint8Array|null, map:string|null, crash?:any}>}
+ */
+export const runMipsLd = runLd;
 
-// ── mips-elf-objcopy — ELF → raw .bin ────────────────────────────────
-export async function runMipsObjcopy(args) {
-  const { elf, options = [] } = args;
-  const inputFiles = [binaryFile("/work/main.elf", elf)];
-  const argv = ["-O", "binary", ...options, "/work/main.elf", "/work/main.bin"];
-  const r = await runIsolated({
-    gluePath: mipsGlue("mips-elf-objcopy.mjs"),
-    argv, inputFiles,
-    outputFiles: [{ vfsPath: "/work/main.bin", encoding: "base64" }],
-  });
-  return { log: r.log, exitCode: r.exitCode, binary: getOutputBytes(r, "/work/main.bin"),
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
-}
+/**
+ * Strip an ELF down to a raw .bin.
+ * @param {{elf:Uint8Array, options?:string[]}} args
+ * @returns {Promise<{log:string, exitCode:number, binary:Uint8Array|null, crash?:any}>}
+ */
+export const runMipsObjcopy = runObjcopy;