romdevtools 0.71.1 → 0.84.0

package/src/toolchains/cc65/presets/gametank/gametank.h

@@ -0,0 +1,80 @@
+/*
+ * GameTank-specific defines
+ */
+
+#ifndef GAMETANK_H
+#define GAMETANK_H
+
+typedef char bool;
+#define true 1
+#define false 0
+
+#define audio_reset ((char *) 0x2000)
+#define audio_nmi ((char *) 0x2001)
+#define audio_rate ((char *) 0x2006)
+#define dma_flags ((char *) 0x2007)
+#define bank_reg ((char *) 0x2005)
+#define via ((char*) 0x2800)
+#define aram ((unsigned char *) 0x3000)
+#define vram ((unsigned char *) 0x4000)
+#define vram_VX ((char *) 0x4000)
+#define vram_VY ((char *) 0x4001)
+#define vram_GX ((char *) 0x4002)
+#define vram_GY ((char *) 0x4003)
+#define vram_WIDTH ((char *) 0x4004)
+#define vram_HEIGHT ((char *) 0x4005)
+#define vram_COLOR ((char *) 0x4007)
+#define vram_START ((char *) 0x4006)
+
+#define SCREEN_WIDTH 128
+#define SCREEN_HEIGHT 128
+
+#define DMA_ENABLE 1
+#define DMA_PAGE_OUT 2
+#define DMA_NMI 4
+#define DMA_COLORFILL_ENABLE 8
+#define DMA_GCARRY 16
+#define DMA_CPU_TO_VRAM 32
+#define DMA_IRQ 64
+#define DMA_OPAQUE 128
+
+#define BANK_GRAM_MASK 7
+#define BANK_SECOND_FRAMEBUFFER 8
+#define BANK_CLIP_X 16
+#define BANK_CLIP_Y 32
+#define BANK_RAM_MASK 192
+
+#define GRAM_PAGE(x) x
+
+#define VX 0
+#define VY 1
+#define GX 2
+#define GY 3
+#define WIDTH 4
+#define HEIGHT 5
+#define START 6
+#define COLOR 7
+
+#define gamepad_1 ((volatile char *) 0x2008)
+#define gamepad_2 ((volatile char *) 0x2009)
+
+#define ORB 0
+#define ORA 1
+#define DDRB 2
+#define DDRA 3
+#define T1C 5
+#define ACR 11
+#define PCR 12
+#define IFR 13
+#define IER 14
+
+extern char frameflag, frameflip, flagsMirror, banksMirror, bankflip;
+
+void wait();
+void nop5();
+void nop10();
+
+#define PROFILER_START(x) via[ORB] = 0x80; via[ORB] = x;
+#define PROFILER_END(x) via[ORB] = 0x80; via[ORB] = x | 0x40;
+
+#endif

package/src/toolchains/cc65/presets/gametank/sdk.cfg

@@ -0,0 +1,32 @@
+# GameTank SDK-runtime single-bank (EEPROM32K) ld65 config. Like single-bank.cfg
+# but adds the segments the bundled SDK runtime uses (LOADERS / COMMON / SAVE /
+# WAVES) — in the multi-bank SDK build these live in dedicated flash banks; for the
+# single 32 KB cart they all fold into the one ROM region (SAVE → RAM). Flat 32 KB
+# image = a valid .gtr (EEPROM32K). VECTORS pinned to $FFFA.
+MEMORY {
+    ZP:   start = $0000, size = $0100, type = rw, define = yes;
+    RAM:  start = $0200, size = $1D00, define = yes;
+    ROM:  start = $8000, size = $8000, file = %O, fill = yes, define = yes;
+}
+SEGMENTS {
+    ZEROPAGE: load = ZP,  type = zp,  define = yes;
+    DATA:     load = ROM, type = rw,  define = yes, run = RAM;
+    BSS:      load = RAM, type = bss, define = yes;
+    HEAP:     load = RAM, type = bss, optional = yes;
+    STARTUP:  load = ROM, type = ro;
+    ONCE:     load = ROM, type = ro,  optional = yes;
+    CODE:     load = ROM, type = ro;
+    RODATA:   load = ROM, type = ro;
+    LOADERS:  load = ROM, type = ro,  optional = yes;   # SDK sprite/blit loaders
+    COMMON:   load = ROM, type = ro,  optional = yes;   # SDK shared code/data
+    WAVES:    load = ROM, type = ro,  optional = yes;   # SDK audio wave tables
+    SAVE:     load = RAM, type = bss, optional = yes;    # persist (battery SRAM) — RAM-backed here
+    VECTORS:  load = ROM, type = ro,  start = $FFFA;
+}
+FEATURES {
+    CONDES: type = constructor, label = __CONSTRUCTOR_TABLE__, count = __CONSTRUCTOR_COUNT__, segment = ONCE;
+    CONDES: type = destructor,  label = __DESTRUCTOR_TABLE__,  count = __DESTRUCTOR_COUNT__,  segment = RODATA;
+}
+SYMBOLS {
+    __STACKSIZE__: type = weak, value = $0200;
+}

package/src/toolchains/cc65/presets/gametank/sdk.crt0.s

@@ -0,0 +1,61 @@
+; ---------------------------------------------------------------------------
+; GameTank SDK-runtime crt0 (single-bank EEPROM32K, with the bundled SDK gfx/
+; input/random/ACP runtime). Adapted from gametank_sdk src/gt/crt0.s, MIT — but
+; STRIPPED of flash banking + the audio-FW asset: a single 32 KB cart maps at
+; boot, so there's no flash bank to shift in, and the bare runtime has no
+; asset-pipeline audio firmware. Calls _sdk_init (init_graphics + ACP) then
+; _main. The SDK's interrupt.s provides _nmi_int / _irq_int, so this crt0 does
+; NOT define them (that was the duplicate-symbol clash with the bare crt0).
+; ---------------------------------------------------------------------------
+.export   _init, _exit
+.import   _main, _sdk_init
+.export   __STARTUP__ : absolute = 1
+.import   __RAM_START__, __RAM_SIZE__
+.import   copydata, zerobss, initlib, donelib
+
+.PC02
+
+BankReg = $2005
+VIA     = $2800
+DDRA    = 3
+ORAr    = 1
+
+.include "zeropage.inc"
+
+.segment "STARTUP"
+
+_init:    LDX     #$FF
+          TXS
+          CLD
+
+          LDX     #0
+viaWakeup:
+          INX
+          BNE     viaWakeup
+
+          STZ     BankReg            ; single 32K cart: fixed bank, nothing to shift
+          STZ     $1FFF
+
+          LDA     #%00000111         ; VIA DDRA: banking pins as output
+          STA     VIA+DDRA
+          LDA     #$FF
+          STA     VIA+ORAr
+
+; cc65 C argument-stack pointer = top of work RAM
+          LDA     #<(__RAM_START__ + __RAM_SIZE__)
+          STA     c_sp
+          LDA     #>(__RAM_START__ + __RAM_SIZE__)
+          STA     c_sp+1
+
+          JSR     zerobss
+          JSR     copydata
+          JSR     initlib
+
+          JSR     _sdk_init          ; init_graphics + ACP (the bundled runtime)
+          CLI                        ; enable IRQs — the draw queue + ACP are
+                                     ; INTERRUPT-DRIVEN (blit-done IRQ processes
+                                     ; queue_draw_box; without CLI nothing draws)
+          JSR     _main
+
+_exit:    JSR     donelib
+          BRK

package/src/toolchains/cc65/presets/gametank/sdk.vectors.s

@@ -0,0 +1,11 @@
+; GameTank SDK-runtime vector table at $FFFA. The interrupt handlers come from the
+; bundled SDK runtime (interrupt.s exports _nmi_int / _irq_int), so this just
+; imports + points the table at them. (The bare single-bank.vectors.s defines its
+; own rti handlers; the SDK preset uses the SDK's real ones.)
+.import _init, _nmi_int, _irq_int
+
+.segment "VECTORS"
+
+.addr   _nmi_int        ; $FFFA NMI
+.addr   _init           ; $FFFC RESET
+.addr   _irq_int        ; $FFFE IRQ / BRK

package/src/toolchains/cc65/presets/gametank/single-bank.cfg

@@ -0,0 +1,28 @@
+# GameTank single-bank (EEPROM32K) ld65 config — the Tier-A "bare" path.
+# Collapses the SDK's multi-bank 2 MB linkerConfig.js to ONE 32 KB ROM bank at
+# $8000-$FFFF (no flash SPI, no Node bank-cat, no zopfli). ZP/RAM match the SDK
+# (ZP $0, stack $0100, work RAM $0200-$1EFF). VECTORS at $FFFA. Output is a flat
+# 32 KB image that IS a valid .gtr (the core size-detects the EEPROM32K mapper).
+MEMORY {
+    ZP:   start = $0000, size = $0100, type = rw, define = yes;
+    RAM:  start = $0200, size = $1D00, define = yes;
+    ROM:  start = $8000, size = $8000, file = %O, fill = yes, define = yes;
+}
+SEGMENTS {
+    ZEROPAGE: load = ZP,  type = zp,  define = yes;
+    DATA:     load = ROM, type = rw,  define = yes, run = RAM;
+    BSS:      load = RAM, type = bss, define = yes;
+    HEAP:     load = RAM, type = bss, optional = yes;
+    STARTUP:  load = ROM, type = ro;
+    ONCE:     load = ROM, type = ro,  optional = yes;
+    CODE:     load = ROM, type = ro;
+    RODATA:   load = ROM, type = ro;
+    VECTORS:  load = ROM, type = ro,  start = $FFFA;
+}
+FEATURES {
+    CONDES: type = constructor, label = __CONSTRUCTOR_TABLE__, count = __CONSTRUCTOR_COUNT__, segment = ONCE;
+    CONDES: type = destructor,  label = __DESTRUCTOR_TABLE__,  count = __DESTRUCTOR_COUNT__,  segment = RODATA;
+}
+SYMBOLS {
+    __STACKSIZE__: type = weak, value = $0200;
+}

package/src/toolchains/cc65/presets/gametank/single-bank.crt0.s

@@ -0,0 +1,71 @@
+; ---------------------------------------------------------------------------
+; GameTank Tier-A crt0 (single-bank EEPROM32K, no SDK runtime).
+; Adapted from gametank_sdk src/gt/crt0.s, MIT (Clyde Shaffer). STRIPPED for the
+; bare 32 KB path: NO flash bank shift-out (the whole game is in one bank that
+; maps at boot), NO _sdk_init, NO _AudioFWPkg .incbin. Just: stack init, VIA
+; wakeup, zerobss/copydata/constructors, set the cc65 C arg-stack pointer, call
+; main(). A default NMI/IRQ handler (rti) lives here so a bare game links without
+; defining its own.
+; ---------------------------------------------------------------------------
+.export   _init, _exit
+.export   _nmi_int, _irq_int
+.import   _main
+.export   __STARTUP__ : absolute = 1
+.import   __RAM_START__, __RAM_SIZE__
+.import   copydata, zerobss, initlib, donelib
+
+.PC02                                 ; W65C02 opcode set (stz/bra/phx/…)
+
+BankReg = $2005
+VIA     = $2800
+DDRA    = 3
+ORAr    = 1
+
+.include "zeropage.inc"
+
+.segment "STARTUP"
+
+_init:    LDX     #$FF                ; init stack pointer to $01FF
+          TXS
+          CLD
+
+          LDX     #0                  ; brief VIA wakeup delay
+viaWakeup:
+          INX
+          BNE     viaWakeup
+
+          ; Park the banking register at a known state. With a single 32 KB cart
+          ; the active bank is fixed at boot, so we don't shift a flash bank in.
+          STZ     BankReg
+          STZ     $1FFF
+
+          LDA     #%00000111          ; VIA DDRA: low 3 bits output (banking pins)
+          STA     VIA+DDRA
+          LDA     #$FF
+          STA     VIA+ORAr
+
+; ---------------------------------------------------------------------------
+; cc65 C argument-stack pointer = top of work RAM
+          LDA     #<(__RAM_START__ + __RAM_SIZE__)
+          STA     c_sp
+          LDA     #>(__RAM_START__ + __RAM_SIZE__)
+          STA     c_sp+1
+
+; ---------------------------------------------------------------------------
+          JSR     zerobss             ; clear BSS
+          JSR     copydata            ; copy initialized DATA to RAM
+          JSR     initlib             ; run constructors
+
+          JSR     _main
+
+_exit:    JSR     donelib             ; run destructors
+          BRK
+
+; ---------------------------------------------------------------------------
+; Default interrupt handlers — a bare game that doesn't define its own still
+; links. (A game CAN provide _nmi_int/_irq_int; cc65's linker lets a strong
+; symbol from the game override these .export'd ones... so keep them weak by
+; only defining if absent — here they're plain rti fallbacks.)
+_nmi_int:
+_irq_int:
+          RTI

package/src/toolchains/cc65/presets/gametank/single-bank.vectors.s

@@ -0,0 +1,12 @@
+; ---------------------------------------------------------------------------
+; GameTank 6502 vector table at $FFFA (NMI / RESET / IRQ-BRK).
+; Adapted from gametank_sdk src/gt/vectors.s, MIT. The handlers are exported by
+; the Tier-A crt0 (rti defaults) — a game can override _nmi_int/_irq_int.
+; ---------------------------------------------------------------------------
+.import _init, _nmi_int, _irq_int
+
+.segment "VECTORS"
+
+.addr   _nmi_int        ; $FFFA NMI
+.addr   _init           ; $FFFC RESET
+.addr   _irq_int        ; $FFFE IRQ / BRK

package/src/toolchains/common/c-build.js

@@ -0,0 +1,109 @@
+// Shared C-SDK build-pipeline helper (0.81.0). The gba-c / genesis-c / mips-c / sh-c
+// builders all walk the SAME spine — compile each .c (cc1 → as), assemble raw .s,
+// assemble a crt0, link, optionally objcopy, finalize — and at EVERY stage repeat the
+// identical 5-part dance:
+//
+//     const r = await runX(...);
+//     log += `--- stage ---\n${r.log || "(ok)"}\n`;
+//     if (r.exitCode !== 0 || !r.<output>)
+//       return { ok: false, binary: null, log, exitCode: r.exitCode || 1, stage, ...(r.crash ? { crash } : {}) };
+//
+// That `if (...) return { ok:false, ... }` line appeared ~73 times across the 5 builders.
+// CBuild owns it: each builder makes one `new CBuild()`, calls `.stage(name, () => runX(...), pick)`,
+// and the helper accumulates the log + THROWS a BuildError on any failure. The builder
+// wraps its body in try/catch and turns a BuildError into the same `{ ok:false, ... }` shape
+// it returned before — so the public contract is byte-for-byte unchanged, the boilerplate
+// is gone, and each builder keeps only its genuinely-per-platform wiring (which crt0, which
+// libs, finalize). No behavior change.
+
+/**
+ * Thrown by CBuild.stage() when a stage fails. Carries everything the builder's
+ * error return needs. The builder catches it and maps to its result object.
+ */
+export class BuildError extends Error {
+  /** @param {{stage:string, exitCode:number, log:string, crash?:any}} info */
+  constructor(info) {
+    super(`build failed at stage: ${info.stage}`);
+    this.name = "BuildError";
+    this.stage = info.stage;
+    this.exitCode = info.exitCode;
+    this.log = info.log;
+    if (info.crash) this.crash = info.crash;
+  }
+  /**
+   * The canonical failure result the GCC/tcc C-SDK builders return (includes
+   * `ok: false`). Pass extra fields (e.g. a platform-specific `{ runtime }`) to merge.
+   * @param {Record<string, any>} [extra]
+   */
+  toResult(extra = {}) {
+    return { ok: false, ...this.fields(extra) };
+  }
+
+  /**
+   * The failure fields WITHOUT a forced `ok` — for builders (cc65/sdcc) whose
+   * lower layer returns `{ binary, log, exitCode, stage }` and lets the caller
+   * (index.js) add `ok`. Same { binary:null, log, exitCode, stage, crash? } core
+   * + any `extra` (e.g. sdcc's `failedTU` / `compiledOK`). Note: crash is only
+   * spread when present (cc65/sdcc historically never carried it — pass nothing).
+   * @param {Record<string, any>} [extra]
+   */
+  fields(extra = {}) {
+    return {
+      binary: null,
+      log: this.log,
+      exitCode: this.exitCode,
+      stage: this.stage,
+      ...(this.crash ? { crash: this.crash } : {}),
+      ...extra,
+    };
+  }
+}
+
+/**
+ * A build-log accumulator + stage runner. One per build.
+ *
+ * Usage:
+ *   const cb = new CBuild();
+ *   const cc = await cb.stage(`cc1 (${name})`, () => runCc1x({...}), r => r.asmSource);
+ *   // cc is the full run result; cb.log has the accumulated log.
+ *   // a failure THROWS BuildError — wrap the build body in try/catch.
+ */
+export class CBuild {
+  constructor() {
+    /** @type {string} accumulated build log */
+    this.log = "";
+  }
+
+  /**
+   * Run one toolchain stage, append its log, and throw BuildError on failure.
+   *
+   * @template T
+   * @param {string} name  stage label — the failure `stage` field AND, by default,
+   *                       the log header. Most builders use one string for both.
+   * @param {() => Promise<T>} run  the toolchain call (returns {log, exitCode, crash?, ...output})
+   * @param {(r: T) => any} pick  selects the stage's required output (e.g. r => r.object);
+   *                              a falsy result is treated as failure even if exitCode is 0
+   * @param {{logName?:string}} [opts]  `logName` overrides ONLY the log header when a
+   *                       builder historically logged a label that differs from the
+   *                       failure `stage` string (e.g. log "as (x → .o)" / stage "as (x)").
+   * @returns {Promise<T>} the full run result (on success)
+   */
+  async stage(name, run, pick, opts = {}) {
+    const r = await run();
+    this.log += `--- ${opts.logName ?? name} ---\n${r.log || "(ok)"}\n`;
+    if (r.exitCode !== 0 || !pick(r)) {
+      throw new BuildError({
+        stage: name,
+        exitCode: r.exitCode || 1,
+        log: this.log,
+        crash: r.crash,
+      });
+    }
+    return r;
+  }
+
+  /** Append a freeform note to the log (e.g. a sub-step that isn't a toolchain stage). */
+  note(text) {
+    this.log += text.endsWith("\n") ? text : text + "\n";
+  }
+}

package/src/toolchains/common/gcc-toolchain.js

@@ -0,0 +1,164 @@
+// Shared GCC-family toolchain factory (0.81.0). The arm/m68k/mips/sh "gcc" wrappers
+// were ~73% identical: each exported runCc1X / runXAs / runXLd / runXObjcopy that did
+// the same input-marshalling + runIsolated() + output-decoding, differing only in:
+//   - the npm package the glue ships in + the glue filenames
+//   - the per-stage arch flags (cc1 / as / ld), which for MIPS depend on endian
+//   - the linker-script filename + the objcopy output filename
+// makeGccToolchain(config) returns the 4 run functions, so each arch shrinks to a
+// small config object. Glue resolution is lazy+memoized (booting never loads a
+// toolchain package until something is actually built with it).
+//
+// All four stages keep the exact pre-refactor argv, /work paths, output encodings,
+// and return shapes (including `...(r.crash ? { crash, stage:"crash" } : {})`), so
+// this is a pure de-duplication — no behavior change.
+import { runIsolated, getOutputBytes, getOutputText } from "../_worker/run.js";
+import { makeGlueResolver, marshalInputs } from "./wasm-tool.js";
+
+/**
+ * @typedef {Object} GccArchConfig
+ * @property {string}   pkg          npm package the glue ships in
+ * @property {string}   localDir     the wrapper's __dirname (dev fallback base)
+ * @property {string}   label        tool label for "not found" errors
+ * @property {Object}   glue         glue filenames per stage
+ * @property {string}   glue.cc1     e.g. "cc1-m68k.mjs"
+ * @property {string}   glue.as      e.g. "m68k-elf-as.mjs"
+ * @property {string}   glue.ld      e.g. "m68k-elf-ld.mjs"
+ * @property {string}   glue.objcopy e.g. "m68k-elf-objcopy.mjs"
+ * @property {string[]|((endian:string)=>string[])} cc1Flags  arch flags for cc1 (before -iquote/-I)
+ * @property {string[]|((endian:string)=>string[])} asFlags   arch flags for as (before -I)
+ * @property {string[]|((endian:string)=>string[])} [ldFlags] arch flags for ld (before -T); default []
+ * @property {string}   ldScriptName name the link script is mounted as (e.g. "genesis.ld")
+ * @property {string}   outputName   objcopy output filename (e.g. "main.bin", "main.gba")
+ * @property {string}   [defaultEndian] "big"|"little" — only meaningful when flags are fns
+ */
+
+/** Resolve a flags entry that may be a constant array or an endian-dependent fn. */
+function flags(entry, endian) {
+  return typeof entry === "function" ? entry(endian) : (entry ?? []);
+}
+
+/**
+ * Build the 4 GCC-stage run functions for one architecture.
+ * @param {GccArchConfig} config
+ * @returns {{ runCc1:Function, runAs:Function, runLd:Function, runObjcopy:Function }}
+ */
+export function makeGccToolchain(config) {
+  const glue = makeGlueResolver({ pkg: config.pkg, localDir: config.localDir, label: config.label });
+  const endianOf = (args) => args.endian ?? config.defaultEndian ?? "big";
+
+  /** cc1: C source → assembly (.s). */
+  async function runCc1(args) {
+    const { source, options = [] } = args;
+    const inputFiles = marshalInputs({ primary: { name: "main.c", text: source }, text: args.headers ?? {} });
+    const argv = [
+      ...flags(config.cc1Flags, endianOf(args)),
+      "-iquote", "/work",
+      "-I", "/work",
+      ...options,
+      "/work/main.c",
+      "-o", "/work/main.s",
+    ];
+    const r = await runIsolated({
+      gluePath: glue(config.glue.cc1),
+      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" } : {}),
+    };
+  }
+
+  /** as: assembly (.s) → object (.o). */
+  async function runAs(args) {
+    const { source, options = [] } = args;
+    const inputFiles = marshalInputs({
+      primary: { name: "main.s", text: source },
+      text: args.includes ?? {},
+      binary: args.binaryIncludes ?? {},
+    });
+    const argv = [
+      ...flags(config.asFlags, endianOf(args)),
+      "-I", "/work",
+      ...options,
+      "/work/main.s",
+      "-o", "/work/main.o",
+    ];
+    const r = await runIsolated({
+      gluePath: glue(config.glue.as),
+      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" } : {}),
+    };
+  }
+
+  /** ld: objects + link script → ELF (+ map). */
+  async function runLd(args) {
+    const { objects, linkScript, libraries = [], libraryPaths = [], options = [] } = args;
+    const inputFiles = marshalInputs({
+      text: { [config.ldScriptName]: linkScript },
+      binary: { ...objects, ...(args.archives ?? {}) },
+    });
+    const argv = [
+      ...flags(config.ldFlags, endianOf(args)),
+      "-T", "/work/" + config.ldScriptName,
+      "-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: glue(config.glue.ld),
+      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" } : {}),
+    };
+  }
+
+  /** objcopy: ELF → raw binary. */
+  async function runObjcopy(args) {
+    const { elf, options = [] } = args;
+    const inputFiles = marshalInputs({ binary: { "main.elf": elf } });
+    const argv = [
+      "-O", "binary",
+      ...options,
+      "/work/main.elf",
+      "/work/" + config.outputName,
+    ];
+    const r = await runIsolated({
+      gluePath: glue(config.glue.objcopy),
+      argv,
+      inputFiles,
+      outputFiles: [{ vfsPath: "/work/" + config.outputName, encoding: "base64" }],
+    });
+    return {
+      log: r.log,
+      exitCode: r.exitCode,
+      binary: getOutputBytes(r, "/work/" + config.outputName),
+      ...(r.crash ? { crash: r.crash, stage: "crash" } : {}),
+    };
+  }
+
+  return { runCc1, runAs, runLd, runObjcopy };
+}

package/src/toolchains/common/wasm-tool.js

@@ -0,0 +1,101 @@
+// Shared WASM-toolchain plumbing (0.81.0). Every toolchain wrapper used to
+// re-implement the SAME two things:
+//   1. Resolve a tool's emscripten glue from its npm package, with a local
+//      src/ fallback for dev, throwing an install hint if neither exists.
+//   2. Marshal { name: text|bytes } maps into the runIsolated() inputFiles[]
+//      shape (textFile / binaryFile per entry).
+// This module owns both so the per-tool wrappers carry only what's genuinely
+// tool-specific (package name, glue filename, argv, output decoding).
+//
+// Resolution stays LAZY at the call site (the wrappers memoize) so booting the
+// server never touches a 100MB+ toolchain package unless that toolchain is
+// actually used to build something.
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { textFile, binaryFile } from "../_worker/run.js";
+
+/**
+ * Resolve a single tool glue FILE from its package, falling back to a local
+ * in-tree copy. This is the arm/m68k/mips/sh-gcc + asar + wladx + rgbds + dasm +
+ * vasm68k + sjasm + tcc816 shape (one .js/.mjs glue per tool).
+ *
+ * @param {Object} a
+ * @param {string} a.pkg        npm package the glue ships in (e.g. "romdev-platform-gba")
+ * @param {string} a.file       glue filename inside the package's wasm/ dir (e.g. "cc1-arm.mjs")
+ * @param {string} a.localDir   the wrapper's __dirname (its wasm/ holds the dev fallback)
+ * @param {string} [a.label]    tool name for the "not found" error (defaults to file)
+ * @returns {string} absolute path to the glue file
+ */
+export function resolveGlueFile({ pkg, file, localDir, label }) {
+  try {
+    const u = import.meta.resolve(pkg);
+    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(localDir, "wasm", file);
+  if (existsSync(local)) return local;
+  throw new Error(`${label ?? file} WASM not found — install ${pkg}`);
+}
+
+/**
+ * Resolve a tool's BASE directory (the caller derives wasm/ + share/ from it).
+ * This is the cc65 + sdcc shape, where one package holds several tools + shared
+ * data and the wrapper wants the root, validated by a sentinel file's presence.
+ *
+ * @param {Object} a
+ * @param {string} a.pkg          npm package (e.g. "romdev-toolchain-cc65")
+ * @param {string} a.sentinel     a path under the base that must exist (e.g. "wasm/cc65.js")
+ * @param {string} a.localDir     the wrapper's __dirname (the dev fallback base)
+ * @param {string} [a.label]      tool name for the "not found" error
+ * @returns {string} absolute path to the base dir
+ */
+export function resolveToolBaseDir({ pkg, sentinel, localDir, label }) {
+  try {
+    const u = import.meta.resolve(pkg);
+    const dir = path.dirname(fileURLToPath(u));
+    if (existsSync(path.join(dir, sentinel))) return dir;
+  } catch { /* package not resolvable — fall through to local */ }
+  if (existsSync(path.join(localDir, sentinel))) return localDir;
+  throw new Error(`${label ?? pkg} WASM not found — install ${pkg}`);
+}
+
+/**
+ * A lazy, memoized glue resolver bound to a package + local dir. Returns a
+ * function `glue(file)` that resolves+caches each glue path on first use.
+ * Replaces the `const _glue = {}; const xGlue = (f) => (_glue[f] ??= ...)`
+ * boilerplate every multi-tool wrapper repeats.
+ *
+ * @param {Object} a
+ * @param {string} a.pkg
+ * @param {string} a.localDir
+ * @param {string} [a.label]
+ * @returns {(file: string) => string}
+ */
+export function makeGlueResolver({ pkg, localDir, label }) {
+  const cache = {};
+  return (file) =>
+    (cache[file] ??= resolveGlueFile({ pkg, file, localDir, label }));
+}
+
+/**
+ * Marshal text + binary virtual-file maps into the runIsolated() inputFiles[]
+ * array, all rooted at /work. Order: the primary source first (if given), then
+ * text entries, then binary entries — matching what the wrappers built by hand.
+ *
+ * @param {Object} a
+ * @param {{name: string, text: string}} [a.primary]   the main source (e.g. main.c → /work/main.c)
+ * @param {Record<string,string>} [a.text]             virtual text files (headers, includes, link scripts)
+ * @param {Record<string,Uint8Array>} [a.binary]       virtual binary files (objects, archives, binary includes)
+ * @returns {import("../_worker/run.js").InputFile[]}
+ */
+export function marshalInputs({ primary, text = {}, binary = {} } = {}) {
+  /** @type {import("../_worker/run.js").InputFile[]} */
+  const files = [];
+  if (primary) files.push(textFile("/work/" + primary.name, primary.text));
+  for (const [name, content] of Object.entries(text))
+    files.push(textFile("/work/" + name, content));
+  for (const [name, bytes] of Object.entries(binary))
+    files.push(binaryFile("/work/" + name, bytes));
+  return files;
+}