romdevtools 0.71.1 → 0.84.1

package/src/toolchains/rgbds/rgbds.js

@@ -8,32 +8,20 @@
 // crash? } in addition to tool-specific fields.
 
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
 import path from "node:path";
 
 import { runIsolated, textFile, binaryFile, getOutputBytes } from "../_worker/run.js";
+import { makeGlueResolver } from "../common/wasm-tool.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// RGBDS's WASM ships in romdev-toolchain-rgbds. Resolve each tool's glue
-// from that package; fall back to a local copy under src/ if present
-// (transition / dev). The package is a hard dep of romdev.
-function resolveRgbdsGlue(file) {
-  try {
-    const u = import.meta.resolve("romdev-toolchain-rgbds");
-    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(`RGBDS WASM (${file}) not found — install romdev-toolchain-rgbds`);
-}
-// Lazy + memoized per tool: resolve (and possibly throw "not installed") only
-// on the first GB/GBC asm build that uses each tool, not at module load — so
-// booting the server never touches this package unless RGBDS is actually used.
-const _glue = {};
-const rgbdsGlue = (file) => (_glue[file] ??= resolveRgbdsGlue(file));
+// RGBDS's WASM ships in romdev-toolchain-rgbds. Resolve each tool's glue from
+// that package; fall back to a local copy under src/ if present (transition /
+// dev). Lazy + memoized per tool: resolve (and possibly throw "not installed")
+// only on the first GB/GBC asm build that uses each tool, not at module load —
+// so booting the server never touches this package unless RGBDS is actually used.
+const rgbdsGlue = makeGlueResolver({ pkg: "romdev-toolchain-rgbds", localDir: __dirname, label: "RGBDS" });
 
 /**
  * Run rgbasm on a source program.

package/src/toolchains/sdcc/sdcc.js

@@ -13,10 +13,17 @@
 // share/sdcc/{include,lib/<port>} is mounted at /share/sdcc/ at call time.
 
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
 import path from "node:path";
 import { readFile } from "node:fs/promises";
 
+import { resolveToolBaseDir } from "../common/wasm-tool.js";
+// sdcc uses CBuild ONLY as the log accumulator (cb.log) — every one of its stages
+// has custom failure handling (the `[buildZ80C] FAILED on TU` context line +
+// failedTU/compiledOK fields, and sdld's raw-exitCode return) that doesn't fit the
+// generic cb.stage(throw-on-fail) shape, so they stay inline. Same partial-fit call
+// the snes-c migration made for its SDK-runtime sites.
+import { CBuild } from "../common/c-build.js";
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -25,21 +32,19 @@ const __dirname = path.dirname(__filename);
 // back to a local copy under src/ if present (transition / dev). The package
 // is a hard dep of romdev. The share/ files are mounted into MEMFS at call
 // time. (Mirrors the cc65 resolver.)
-function resolveSdccBaseDir() {
-  try {
-    const u = import.meta.resolve("romdev-toolchain-sdcc");
-    const dir = path.dirname(fileURLToPath(u));
-    if (existsSync(path.join(dir, "wasm", "sdcc.js"))) return dir;
-  } catch { /* package not resolvable — fall through to local */ }
-  if (existsSync(path.join(__dirname, "wasm", "sdcc.js"))) return __dirname;
-  throw new Error("SDCC WASM not found — install romdev-toolchain-sdcc");
-}
+//
 // Lazy + memoized: resolve (and possibly throw "not installed") only on the
 // first SDCC build (GB/GBC/SMS/GG C), not at module load — so booting the
 // server never touches this package unless SDCC is actually used. Resolve the
 // base dir once; derive each tool glue + the share dir from it on demand.
 let _sdccBase;
-const sdccBase  = () => (_sdccBase ??= resolveSdccBaseDir());
+const sdccBase  = () =>
+  (_sdccBase ??= resolveToolBaseDir({
+    pkg: "romdev-toolchain-sdcc",
+    sentinel: "wasm/sdcc.js",
+    localDir: __dirname,
+    label: "SDCC",
+  }));
 const sdccGlue  = (file) => path.join(sdccBase(), "wasm", file);
 const shareDir  = () => path.join(sdccBase(), "share", "sdcc");
 
@@ -363,7 +368,7 @@ export function ihxToBin(ihx, size, fill = 0xFF) {
  */
 export async function buildZ80C(args) {
   const sources = args.sources ?? { "main.c": args.source };
-  let log = "";
+  const cb = new CBuild();
   /** @type {Record<string, string>} */
   const objects = {};
   // SM83 (Game Boy) uses sdasgb instead of sdasz80 — different instruction set.
@@ -379,10 +384,10 @@ export async function buildZ80C(args) {
       const asmRun = isSm83 ? runSdasgb : runSdasz80;
       const asmLabel = isSm83 ? "sdasgb" : "sdasz80";
       const r = await asmRun({ source: src });
-      log += `--- ${asmLabel} (${name}) ---\n` + r.log + "\n";
+      cb.log += `--- ${asmLabel} (${name}) ---\n` + r.log + "\n";
       if (r.exitCode !== 0 || !r.rel) {
-        log += `\n[buildZ80C] FAILED on TU '${name}' (${asmLabel}). Successfully compiled before this: ${compiledOK.length === 0 ? "(none)" : compiledOK.join(", ")}\n`;
-        return { binary: null, log, exitCode: r.exitCode || 1, stage: asmLabel, failedTU: name, compiledOK: [...compiledOK] };
+        cb.log += `\n[buildZ80C] FAILED on TU '${name}' (${asmLabel}). Successfully compiled before this: ${compiledOK.length === 0 ? "(none)" : compiledOK.join(", ")}\n`;
+        return { binary: null, log: cb.log, exitCode: r.exitCode || 1, stage: asmLabel, failedTU: name, compiledOK: [...compiledOK] };
       }
       compiledOK.push(name);
       objects[name.replace(/\.(s|asm)$/i, ".rel")] = r.rel;
@@ -393,10 +398,10 @@ export async function buildZ80C(args) {
         port: args.port,
         headers: args.headers,
       });
-      log += `--- sdcc (${name}) ---\n` + r.log + "\n";
+      cb.log += `--- sdcc (${name}) ---\n` + r.log + "\n";
       if (r.exitCode !== 0 || !r.rel) {
-        log += `\n[buildZ80C] FAILED on TU '${name}' (sdcc). Successfully compiled before this: ${compiledOK.length === 0 ? "(none)" : compiledOK.join(", ")}\n`;
-        return { binary: null, log, exitCode: r.exitCode || 1, stage: "sdcc", failedTU: name, compiledOK: [...compiledOK] };
+        cb.log += `\n[buildZ80C] FAILED on TU '${name}' (sdcc). Successfully compiled before this: ${compiledOK.length === 0 ? "(none)" : compiledOK.join(", ")}\n`;
+        return { binary: null, log: cb.log, exitCode: r.exitCode || 1, stage: "sdcc", failedTU: name, compiledOK: [...compiledOK] };
       }
       compiledOK.push(name);
       objects[name.replace(/\.(c|h)$/i, ".rel")] = r.rel;
@@ -422,16 +427,20 @@ export async function buildZ80C(args) {
   let crt0Rel = args.crt0;
   if (crt0Rel && !/^XL[2-4]\b/.test(crt0Rel.trim())) {
     // Looks like .s source — assemble it via the same path we use for
-    // user .s sources.
+    // user .s sources. (Keeps its custom FAILED-context line, so inline.)
     const crt0Asm = await (isSm83 ? runSdasgb : runSdasz80)({ source: crt0Rel });
-    log += `--- ${isSm83 ? "sdasgb" : "sdasz80"} (crt0) ---\n` + crt0Asm.log + "\n";
+    cb.log += `--- ${isSm83 ? "sdasgb" : "sdasz80"} (crt0) ---\n` + crt0Asm.log + "\n";
     if (crt0Asm.exitCode !== 0 || !crt0Asm.rel) {
-      log += `\n[buildZ80C] FAILED to assemble crt0 source. Successfully compiled before this: ${compiledOK.length === 0 ? "(none)" : compiledOK.join(", ")}\n`;
-      return { binary: null, log, exitCode: crt0Asm.exitCode || 1, stage: "sdasgb-crt0" };
+      cb.log += `\n[buildZ80C] FAILED to assemble crt0 source. Successfully compiled before this: ${compiledOK.length === 0 ? "(none)" : compiledOK.join(", ")}\n`;
+      return { binary: null, log: cb.log, exitCode: crt0Asm.exitCode || 1, stage: "sdasgb-crt0" };
     }
     crt0Rel = crt0Asm.rel;
   }
 
+  // sdld is a clean stage (no per-TU context) → cb.stage. NOTE: the failure
+  // shape here had NO `exitCode || 1` fallback (raw link.exitCode); CBuild uses
+  // `exitCode || 1`. link.exitCode is non-zero on a real link failure, so this
+  // is equivalent in practice — but to stay byte-identical, handle it inline.
   const link = await runSdld({
     objects,
     port: args.port,
@@ -440,9 +449,9 @@ export async function buildZ80C(args) {
     dataLoc: args.dataLoc,
     crt0: crt0Rel,
   });
-  log += "--- sdld ---\n" + link.log;
+  cb.log += "--- sdld ---\n" + link.log;
   if (link.exitCode !== 0 || !link.ihx) {
-    return { binary: null, log, exitCode: link.exitCode, stage: "sdld" };
+    return { binary: null, log: cb.log, exitCode: link.exitCode, stage: "sdld" };
   }
   // `romBase` (e.g. MSX $4000) means the cartridge maps at that address: the
   // ihx writes records at absolute $4000+, so size the buffer to cover them,
@@ -453,7 +462,7 @@ export async function buildZ80C(args) {
     const span = args.romBase + (args.romSize || 0);
     const full = ihxToBin(link.ihx, span);
     const end = args.romSize ? args.romBase + args.romSize : full.length;
-    return { binary: full.slice(args.romBase, end), log, exitCode: 0, stage: "done", map: link.map ?? null };
+    return { binary: full.slice(args.romBase, end), log: cb.log, exitCode: 0, stage: "done", map: link.map ?? null };
   }
   // If romSize is null/0, size the buffer to the highest address the ihx
   // actually wrote (no padding to a ROM size). Used for tape targets like
@@ -466,7 +475,7 @@ export async function buildZ80C(args) {
   if (!args.romSize && args.codeLoc) {
     trimmed = binary.slice(args.codeLoc);
   }
-  return { binary: trimmed, log, exitCode: 0, stage: "done", map: link.map ?? null };
+  return { binary: trimmed, log: cb.log, exitCode: 0, stage: "done", map: link.map ?? null };
 }
 
 /**

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

@@ -16,6 +16,7 @@ import { fileURLToPath } from "node:url";
 import path from "node:path";
 
 import { runCc1sh, runShAs, runShLd } from "../sh-elf-gcc/gcc.js";
+import { CBuild, BuildError } from "../common/c-build.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -45,60 +46,51 @@ export async function buildShC(args) {
   const hasOpt = userOpts.some((o) => /^-O/.test(o));
   const cc1Options = [...(hasOpt ? [] : ["-O1"]), ...userOpts, "-ffreestanding", "-fno-builtin", "-Wall"];
   const sources = args.sources ?? (args.source != null ? { "main.c": args.source } : {});
-  let log = "";
+  const cb = new CBuild();
+  const as = (source) => runShAs({ source });
 
-  /** @type {Record<string, Uint8Array>} */
-  const userObjs = {};
-  for (const cName of Object.keys(sources).filter((n) => /\.c$/i.test(n))) {
-    const cc = await runCc1sh({ source: sources[cName], headers, options: cc1Options });
-    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 runShAs({ source: cc.asmSource });
-    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;
-  }
-  // raw .s sources too
-  for (const sName of Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n))) {
-    const as = await runShAs({ source: sources[sName] });
-    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;
-  }
+  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})`, () => runCc1sh({ source: sources[cName], headers, options: cc1Options }), (r) => r.asmSource);
+      const ao = await cb.stage(`as (${cName})`, () => as(cc.asmSource), (r) => r.object);
+      userObjs[cName.replace(/\.c$/i, ".o")] = ao.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 (stack + .bss clear + main()).
-  const crt0Src = await readFile(path.join(LIB, "dc-crt0.s"), "utf-8");
-  const crt0As = await runShAs({ source: crt0Src });
-  log += `--- as (dc-crt0.s) ---\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 (stack + .bss clear + main()).
+    const crt0Src = await readFile(path.join(LIB, "dc-crt0.s"), "utf-8");
+    const crt0As = await cb.stage("as (dc-crt0.s)", () => as(crt0Src), (r) => r.object);
 
-  // link: crt0 + user objects + newlib (libc/libm) + libgcc.
-  const linkScript = await readFile(path.join(LIB, "dc.ld"), "utf-8");
-  const [libc, libm, libgcc] = await Promise.all([
-    readFile(path.join(LIB, "libc.a")),
-    readFile(path.join(LIB, "libm.a")),
-    readFile(path.join(LIB, "libgcc.a")),
-  ]);
-  const ld = await runShLd({
-    objects: { "crt0.o": crt0As.object, ...userObjs },
-    linkScript,
-    archives: {
-      "libc.a": new Uint8Array(libc),
-      "libm.a": new Uint8Array(libm),
-      "libgcc.a": new Uint8Array(libgcc),
-    },
-    libraries: ["c", "m", "gcc"],
-    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: crt0 + user objects + newlib (libc/libm) + libgcc.
+    const linkScript = await readFile(path.join(LIB, "dc.ld"), "utf-8");
+    const [libc, libm, libgcc] = await Promise.all([
+      readFile(path.join(LIB, "libc.a")),
+      readFile(path.join(LIB, "libm.a")),
+      readFile(path.join(LIB, "libgcc.a")),
+    ]);
+    const ld = await cb.stage("ld", () => runShLd({
+      objects: { "crt0.o": crt0As.object, ...userObjs },
+      linkScript,
+      archives: {
+        "libc.a": new Uint8Array(libc),
+        "libm.a": new Uint8Array(libm),
+        "libgcc.a": new Uint8Array(libgcc),
+      },
+      libraries: ["c", "m", "gcc"],
+      libraryPaths: ["/work"],
+      options: ["--no-warn-rwx-segments"],
+    }), (r) => r.elf);
 
-  // The ELF IS the deliverable — reios boots it directly.
-  return { ok: true, binary: ld.elf, log, exitCode: 0, stage: "done", ...(ld.map ? { symbols: ld.map } : {}) };
+    // The ELF IS the deliverable — reios boots it directly.
+    return { ok: true, binary: ld.elf, 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/sh-elf-gcc/gcc.js

@@ -1,122 +1,67 @@
 // sh-elf-gcc — WASM toolchain wrappers for Dreamcast (SH-4) C builds.
 //
-// Pipeline (mirrors mips-elf-gcc/gcc.js — gcc-the-driver can't fork/exec under
-// emscripten, so we orchestrate cc1 → as → ld → objcopy through callMain):
-//   runCc1sh({source, headers, options})  → SH assembly (.s)
-//   runShAs({source, includes})           → .o ELF object
-//   runShLd({objects, linkScript, ...})   → linked .elf (+ map)
-//   runShObjcopy({elf})                   → raw .bin
+// The full pipeline:
+//   runCc1sh({source, headers, options})  → SH assembly text (.s)
+//   runShAs({source, includes})            → .o ELF object
+//   runShLd({objects, linkScript})         → linked .elf (+ map)
+//   runShObjcopy({elf})                    → raw .bin
 //
-// The Dreamcast SH-4 is little-endian, m4-single-only FP. Single endianness — no
-// EL/EB split like MIPS. The staged tool stems keep the createMips* EXPORT_NAMEs
-// the build script reused, but the glue filenames are sh-elf-*.
-
+// 0.81.0: the 4 stages come from the shared makeGccToolchain() factory
+// (common/gcc-toolchain.js); this file is just the SH-4 config + thin re-exports.
+// SH-4 little-endian, single-precision FP only (-m4-single-only at the cc1 level;
+// --isa=sh4 at as; -EL at ld). NOTE: callers should default cc1 to -O1, not -O2 —
+// the sh-elf cc1.wasm has an -O2-only pass that aborts on common control flow; that
+// default lives in the sh-c builder, not here (this wrapper passes options through).
+//
+// WASM glue ships in romdev-toolchain-sh-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-sh-gcc; fall back to the in-tree dev copy.
-function resolveShGlue(file) {
-  try {
-    const u = import.meta.resolve("romdev-toolchain-sh-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(`sh-elf-gcc WASM (${file}) not found — build it with scripts/build-sh-wasm-tools.sh`);
-}
-const _glue = {};
-const shGlue = (file) => (_glue[file] ??= resolveShGlue(file));
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-// SH-4 little-endian, m4-single-only FP. cc1 wants -ml; as wants -little --isa=sh4.
-const CC1_ARCH = ["-ml", "-m4-single-only"];
-const AS_ARCH = ["-little", "--isa=sh4"];
+const { runCc1, runAs, runLd, runObjcopy } = makeGccToolchain({
+  pkg: "romdev-toolchain-sh-gcc",
+  localDir: __dirname,
+  label: "sh-elf-gcc",
+  glue: {
+    cc1: "cc1.mjs",
+    as: "sh-elf-as.mjs",
+    ld: "sh-elf-ld.mjs",
+    objcopy: "sh-elf-objcopy.mjs",
+  },
+  cc1Flags: ["-ml", "-m4-single-only"],
+  asFlags: ["-little", "--isa=sh4"],
+  ldFlags: ["-EL"],
+  ldScriptName: "link.ld",
+  outputName: "main.bin",
+});
 
-// ── cc1 — SH gcc C frontend, source → assembly ───────────────────────
-export async function runCc1sh(args) {
-  const { source, options = [] } = 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 = [
-    ...CC1_ARCH,
-    "-iquote", "/work", "-I", "/work",
-    ...options,
-    "/work/main.c", "-o", "/work/main.s",
-  ];
-  const r = await runIsolated({
-    gluePath: shGlue("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 SH assembly via cc1.
+ * @param {{source:string, headers?:Record<string,string>, options?:string[]}} args
+ * @returns {Promise<{log:string, exitCode:number, asmSource:string|null, crash?:any}>}
+ */
+export const runCc1sh = runCc1;
 
-// ── sh-elf-as — GNU assembler, .s → .o ───────────────────────────────
-export async function runShAs(args) {
-  const { source, options = [] } = 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 = [...AS_ARCH, "-I", "/work", ...options, "/work/main.s", "-o", "/work/main.o"];
-  const r = await runIsolated({
-    gluePath: shGlue("sh-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 SH assembly with sh-elf-as.
+ * @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 const runShAs = runAs;
 
-// ── sh-elf-ld — GNU linker, .o + linker script → .elf ────────────────
-export async function runShLd(args) {
-  const { objects, linkScript, libraries = [], libraryPaths = [], options = [] } = 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 = [
-    "-EL",
-    "-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: shGlue("sh-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 SH 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 const runShLd = runLd;
 
-// ── sh-elf-objcopy — ELF → raw .bin ──────────────────────────────────
-export async function runShObjcopy(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: shGlue("sh-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 runShObjcopy = runObjcopy;

package/src/toolchains/sjasm/sjasm.js

@@ -5,25 +5,21 @@
 // #include that generated .h. Built by scripts/build-sjasm.sh.
 
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
 import path from "node:path";
 
+import { makeGlueResolver } from "../common/wasm-tool.js";
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-function resolveGlue(name) {
-  // sjasm + bintos ship in romdev-toolchain-m68k-gcc (the Genesis toolchain
-  // package — same place as the m68k compiler they pair with). Resolve from
-  // there; fall back to a local copy under src/ for dev.
-  try {
-    const u = import.meta.resolve("romdev-toolchain-m68k-gcc");
-    const p = path.join(path.dirname(fileURLToPath(u)), "wasm", name);
-    if (existsSync(p)) return p;
-  } catch { /* package not resolvable — fall through to local */ }
-  const local = path.join(__dirname, "wasm", name);
-  if (existsSync(local)) return local;
-  throw new Error(`sjasm WASM not found: ${name} — install romdev-toolchain-m68k-gcc (or run scripts/build-sjasm.sh)`);
-}
+// sjasm + bintos ship in romdev-toolchain-m68k-gcc (the Genesis toolchain
+// package — same place as the m68k compiler they pair with); a local src/ copy
+// is the dev fallback. Lazy + memoized: resolve only on first use.
+const resolveGlue = makeGlueResolver({
+  pkg: "romdev-toolchain-m68k-gcc",
+  localDir: __dirname,
+  label: "sjasm",
+});
 
 let _sjasmFactory, _bintosFactory;
 async function loadSjasm() {