romdevtools 0.71.1 → 0.84.0

package/src/toolchains/arm-none-eabi-gcc/gcc.js

@@ -1,216 +1,67 @@
 // arm-none-eabi-gcc — WASM toolchain wrappers for GBA C builds.
 //
-// Mirrors src/toolchains/m68k-elf-gcc/gcc.js. The GBA target uses
-// ARM7TDMI in Thumb-interwork mode by default (matches libgba's
-// expectations).
+// The full pipeline:
+//   runCc1arm({source, headers, options}) → ARM assembly text (.s)
+//   runArmAs({source, includes})           → .o ELF object
+//   runArmLd({objects, linkScript})        → linked .elf (+ map)
+//   runArmObjcopy({elf})                   → raw .gba ROM
 //
-// Pipeline:
-//   runCc1arm({source, headers, options})   → ARM assembly text (.s)
-//   runArmAs({asmSource, includes})         → .o ELF object
-//   runArmLd({objects, linkScript})         → linked .elf
-//   runArmObjcopy({elf})                    → raw .gba ROM
+// 0.81.0: the 4 stages come from the shared makeGccToolchain() factory
+// (common/gcc-toolchain.js); this file is just the ARM config + thin re-exports
+// so existing call sites keep their runArm*/runCc1arm names.
 //
-// Each step runs as a WASM module through the worker pool (R12
-// crash isolation). The WASM tools live under wasm/ (cc1-arm.{mjs,wasm}
-// etc.). emcc emits ESM (EXPORT_ES6=1) so we use .mjs extensions.
-
+// The WASM glue ships in romdev-platform-gba (155MB, incl. the 135MB cc1-arm);
+// resolution is lazy + memoized, so booting never loads it unless a GBA C ROM
+// is actually built. ARMv4T (arm7tdmi), thumb-interwork.
 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";
+import { makeGccToolchain } from "../common/gcc-toolchain.js";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-// arm-none-eabi-gcc's WASM ships in romdev-platform-gba (the GBA platform is
-// the only consumer). Resolve each tool's glue from that package; fall back to
-// a local copy under src/ if present (transition / dev). emcc emits ESM
-// (EXPORT_ES6=1) so the glue uses .mjs extensions. The package is a hard dep
-// of romdev.
-function resolveArmGlue(file) {
-  try {
-    const u = import.meta.resolve("romdev-platform-gba");
-    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(`arm-none-eabi-gcc WASM (${file}) not found — install romdev-platform-gba`);
-}
+const ARM_FLAGS = ["-mcpu=arm7tdmi", "-mthumb-interwork"];
 
-// Lazy + memoized per tool: resolve only on the first GBA-C build that uses
-// each tool, not at module load — so booting the server never touches this
-// (155MB, incl. the 135MB cc1-arm) package unless a GBA C ROM is actually built.
-const _glue = {};
-const armGlue = (file) => (_glue[file] ??= resolveArmGlue(file));
+const { runCc1, runAs, runLd, runObjcopy } = makeGccToolchain({
+  pkg: "romdev-platform-gba",
+  localDir: __dirname,
+  label: "arm-none-eabi-gcc",
+  glue: {
+    cc1: "cc1-arm.mjs",
+    as: "arm-none-eabi-as.mjs",
+    ld: "arm-none-eabi-ld.mjs",
+    objcopy: "arm-none-eabi-objcopy.mjs",
+  },
+  cc1Flags: ARM_FLAGS,
+  asFlags: ARM_FLAGS,
+  ldScriptName: "gba.ld",
+  outputName: "main.gba",
+});
 
 /**
  * Compile a C source to ARM 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
+ * @param {{source:string, headers?:Record<string,string>, options?:string[]}} args
  * @returns {Promise<{log:string, exitCode:number, asmSource:string|null, crash?:any}>}
  */
-export async function runCc1arm(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 = [
-    // GBA = ARM7TDMI. Thumb-interwork allows mixed ARM/Thumb code.
-    "-mcpu=arm7tdmi",
-    "-mthumb-interwork",
-    "-iquote", "/work",
-    "-I", "/work",
-    ...options,
-    "/work/main.c",
-    "-o", "/work/main.s",
-  ];
-  const r = await runIsolated({
-    gluePath: armGlue("cc1-arm.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" } : {}),
-  };
-}
+export const runCc1arm = runCc1;
 
 /**
  * Assemble ARM assembly with arm-none-eabi-as.
- *
- * @param {Object} args
- * @param {string} args.source assembly source text
- * @param {Record<string, string>} [args.includes]
- * @param {Record<string, Uint8Array>} [args.binaryIncludes]
- * @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 runArmAs(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 = [
-    "-mcpu=arm7tdmi",
-    "-mthumb-interwork",
-    "-I", "/work",
-    ...options,
-    "/work/main.s",
-    "-o", "/work/main.o",
-  ];
-  const r = await runIsolated({
-    gluePath: armGlue("arm-none-eabi-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" } : {}),
-  };
-}
+export const runArmAs = runAs;
 
 /**
- * Link ARM object files into an ELF executable.
- *
- * @param {Object} args
- * @param {Record<string, Uint8Array>} args.objects
- * @param {string} args.linkScript linker script contents (lnkscript / gba.ld)
- * @param {string[]} [args.libraryPaths]
- * @param {string[]} [args.libraries]
- * @param {Record<string, Uint8Array>} [args.archives]
- * @param {string[]} [args.options]
- * @returns {Promise<{log:string, exitCode:number, elf:Uint8Array|null, crash?:any}>}
+ * Link ARM 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 runArmLd(args) {
-  const { objects, linkScript, libraries = [], libraryPaths = [], options = [] } = args;
-  const archives = args.archives ?? {};
-  /** @type {import("../_worker/run.js").InputFile[]} */
-  const inputFiles = [textFile("/work/gba.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/gba.ld",
-    "-o", "/work/main.elf",
-    // Emit a GNU ld map so symbols({op:'resolve'/'lookup'/'list'/'map'}) can turn
-    // a C global's name into an address (parsed by gnu-ld-map.js) — same as the
-    // m68k/Genesis path. Without this the GBA build returns no symbol table.
-    "-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: armGlue("arm-none-eabi-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" } : {}),
-  };
-}
+export const runArmLd = runLd;
 
 /**
  * Strip an ELF down to a raw .gba ROM.
- *
- * @param {Object} args
- * @param {Uint8Array} args.elf
- * @param {string[]} [args.options]
+ * @param {{elf:Uint8Array, options?:string[]}} args
  * @returns {Promise<{log:string, exitCode:number, binary:Uint8Array|null, crash?:any}>}
  */
-export async function runArmObjcopy(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.gba",
-  ];
-  const r = await runIsolated({
-    gluePath: armGlue("arm-none-eabi-objcopy.mjs"),
-    argv,
-    inputFiles,
-    outputFiles: [{ vfsPath: "/work/main.gba", encoding: "base64" }],
-  });
-  return {
-    log: r.log,
-    exitCode: r.exitCode,
-    binary: getOutputBytes(r, "/work/main.gba"),
-    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}),
-  };
-}
+export const runArmObjcopy = runObjcopy;

package/src/toolchains/asar/asar.js

@@ -5,30 +5,25 @@
 // directives.
 
 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";
+import { resolveGlueFile } from "../common/wasm-tool.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 // asar's WASM ships in romdev-platform-snes (the SNES platform is the only
-// consumer). Resolve from that package; fall back to a local copy under src/
-// if present (transition / dev). The package is a hard dep of romdev.
-function resolveAsarGlue() {
-  try {
-    const u = import.meta.resolve("romdev-platform-snes");
-    const p = path.join(path.dirname(fileURLToPath(u)), "wasm", "asar.js");
-    if (existsSync(p)) return p;
-  } catch { /* package not resolvable — fall through to local */ }
-  const local = path.join(__dirname, "wasm", "asar.js");
-  if (existsSync(local)) return local;
-  throw new Error("asar WASM not found — install romdev-platform-snes");
-}
-// Lazy + memoized: resolve only on the first asar (SNES asm) build, not at boot.
+// consumer); a local src/ copy is the dev fallback. Lazy + memoized: resolve
+// only on the first asar (SNES asm) build, not at boot.
 let _gluePath;
-const gluePath = () => (_gluePath ??= resolveAsarGlue());
+const gluePath = () =>
+  (_gluePath ??= resolveGlueFile({
+    pkg: "romdev-platform-snes",
+    file: "asar.js",
+    localDir: __dirname,
+    label: "asar",
+  }));
 
 /**
  * Assemble an asar source.

package/src/toolchains/cc65/cc65.js

@@ -15,6 +15,9 @@ import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
 import path from "node:path";
 
+import { resolveToolBaseDir } from "../common/wasm-tool.js";
+import { CBuild, BuildError } from "../common/c-build.js";
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -23,21 +26,18 @@ const __dirname = path.dirname(__filename);
 // needs to link a target, so they must come from the same place as the WASM.
 // Resolve the package's base dir once; fall back to a local copy under src/
 // if present (transition / dev). The package is a hard dep of romdev.
-function resolveCc65BaseDir() {
-  try {
-    const u = import.meta.resolve("romdev-toolchain-cc65");
-    const dir = path.dirname(fileURLToPath(u));
-    if (existsSync(path.join(dir, "wasm", "cc65.js"))) return dir;
-  } catch { /* package not resolvable — fall through to local */ }
-  if (existsSync(path.join(__dirname, "wasm", "cc65.js"))) return __dirname;
-  throw new Error("cc65 WASM not found — install romdev-toolchain-cc65");
-}
 // Lazy + memoized: resolve (and possibly throw "not installed") only on the
 // first cc65 build (NES/C64/Atari7800/Lynx), not at module load — so booting
 // the server never touches this package unless cc65 is actually used. Resolve
 // the base dir once; derive the wasm + share dirs from it on demand.
 let _cc65Base;
-const cc65Base = () => (_cc65Base ??= resolveCc65BaseDir());
+const cc65Base = () =>
+  (_cc65Base ??= resolveToolBaseDir({
+    pkg: "romdev-toolchain-cc65",
+    sentinel: "wasm/cc65.js",
+    localDir: __dirname,
+    label: "cc65",
+  }));
 
 /** True if the cc65 build toolchain WASM (cc65 + ld65, in romdev-toolchain-cc65)
  *  is installed/resolvable, without throwing — for the catalog(status) capability
@@ -45,7 +45,7 @@ const cc65Base = () => (_cc65Base ??= resolveCc65BaseDir());
  *  reflects ld65 (the linker) availability. */
 export function cc65Available() {
   try {
-    const dir = resolveCc65BaseDir();
+    const dir = cc65Base();
     return existsSync(path.join(dir, "wasm", "cc65.js")) && existsSync(path.join(dir, "wasm", "ld65.js"));
   } catch { return false; }
 }
@@ -275,63 +275,57 @@ export async function buildC(args) {
   // and these are pure upside. (NOTE: cc65 errors on an unknown -W name, so this
   // list is verified valid against the bundled cc65.)
   const ccWarn = ["-W", "unused-var,unused-func,unused-label,const-comparison,struct-param,pointer-sign"];
-  const ccOpts = args.debug ? ["-g", ...ccWarn] : [...ccWarn];
-  const caOpts = args.debug ? ["-g"] : [];
+  // ccOptions/caOptions = caller-supplied extra flags (e.g. GameTank's `--cpu 65c02`
+  // for the `-t none` path where the CPU isn't implied by a built-in cc65 target).
+  const ccOpts = [...(args.debug ? ["-g"] : []), ...ccWarn, ...(args.ccOptions ?? [])];
+  const caOpts = [...(args.debug ? ["-g"] : []), ...(args.caOptions ?? [])];
   const sources = normalizeSources(args, "main.c");
 
-  let log = "";
-  /** @type {Record<string, Uint8Array>} */
-  const objects = {};
-  for (const [name, src] of Object.entries(sources)) {
-    const ext = path.extname(name).toLowerCase();
-    let asmSource;
-    let asmName;
-    if (ext === ".s" || ext === ".asm") {
-      asmSource = src;
-      asmName = name;
-    } else {
-      const cc = await runCc65({
-        source: src,
-        headers: args.headers,
-        target: args.target,
-        options: ccOpts,
-      });
-      log += `--- cc65 (${name}) ---\n` + cc.log + "\n";
-      if (cc.exitCode !== 0 || !cc.asmSource) {
-        return { binary: null, log, exitCode: cc.exitCode || 1, stage: "cc65" };
+  const cb = new CBuild();
+  try {
+    /** @type {Record<string, Uint8Array>} */
+    const objects = {};
+    for (const [name, src] of Object.entries(sources)) {
+      const ext = path.extname(name).toLowerCase();
+      let asmSource;
+      let asmName;
+      if (ext === ".s" || ext === ".asm") {
+        asmSource = src;
+        asmName = name;
+      } else {
+        // failure stage is bare "cc65" (no name) but the log header carries the name.
+        const cc = await cb.stage("cc65",
+          () => runCc65({ source: src, headers: args.headers, target: args.target, options: ccOpts }),
+          (r) => r.asmSource, { logName: `cc65 (${name})` });
+        asmSource = cc.asmSource;
+        asmName = name.replace(/\.(c|h)$/i, ".s");
       }
-      asmSource = cc.asmSource;
-      asmName = name.replace(/\.(c|h)$/i, ".s");
+      const ca = await cb.stage("ca65",
+        () => runCa65({ source: asmSource, includes: args.asmIncludes, binaryIncludes: args.binaryIncludes, target: args.target, options: caOpts }),
+        (r) => r.object, { logName: `ca65 (${asmName})` });
+      objects[asmName.replace(/\.s$/, ".o")] = ca.object;
     }
-    const ca = await runCa65({
-      source: asmSource,
-      includes: args.asmIncludes,
-      binaryIncludes: args.binaryIncludes,
+    // ld65 is NOT throw-on-fail here: it returns its own success/failure inline with
+    // dbg + ramUsage, so keep it as a plain call (the cc65 contract has no `ok` field).
+    const ld = await runLd65({
+      objects,
       target: args.target,
-      options: caOpts,
+      debug: args.debug,
+      linkerConfig: args.linkerConfig,
     });
-    log += `--- ca65 (${asmName}) ---\n` + ca.log + "\n";
-    if (ca.exitCode !== 0 || !ca.object) {
-      return { binary: null, log, exitCode: ca.exitCode || 1, stage: "ca65" };
-    }
-    const objName = asmName.replace(/\.s$/, ".o");
-    objects[objName] = ca.object;
+    cb.log += "--- ld65 ---\n" + ld.log;   // exact: no trailing newline (matches pre-refactor)
+    return {
+      binary: ld.binary,
+      dbg: ld.dbg,
+      log: cb.log,
+      exitCode: ld.exitCode,
+      ramUsage: parseRamUsage(ld.map),
+      stage: ld.exitCode === 0 ? "done" : "ld65",
+    };
+  } catch (e) {
+    if (e instanceof BuildError) return e.fields();   // cc65 shape: no `ok` field
+    throw e;
   }
-  const ld = await runLd65({
-    objects,
-    target: args.target,
-    debug: args.debug,
-    linkerConfig: args.linkerConfig,
-  });
-  log += "--- ld65 ---\n" + ld.log;
-  return {
-    binary: ld.binary,
-    dbg: ld.dbg,
-    log,
-    exitCode: ld.exitCode,
-    ramUsage: parseRamUsage(ld.map),
-    stage: ld.exitCode === 0 ? "done" : "ld65",
-  };
 }
 
 /**
@@ -351,42 +345,38 @@ export async function buildC(args) {
  * @param {string} [args.linkerConfig] custom ld65 .cfg
  */
 export async function buildAsm(args) {
-  const caOpts = args.debug ? ["-g"] : [];
+  const caOpts = [...(args.debug ? ["-g"] : []), ...(args.caOptions ?? [])];
   const sources = normalizeSources(args, "main.s");
 
-  let log = "";
-  /** @type {Record<string, Uint8Array>} */
-  const objects = {};
-  for (const [name, src] of Object.entries(sources)) {
-    const ca = await runCa65({
-      source: src,
-      includes: args.includes,
-      binaryIncludes: args.binaryIncludes,
+  const cb = new CBuild();
+  try {
+    /** @type {Record<string, Uint8Array>} */
+    const objects = {};
+    for (const [name, src] of Object.entries(sources)) {
+      const ca = await cb.stage("ca65",
+        () => runCa65({ source: src, includes: args.includes, binaryIncludes: args.binaryIncludes, target: args.target, options: caOpts }),
+        (r) => r.object, { logName: `ca65 (${name})` });
+      objects[name.replace(/\.(s|asm)$/i, ".o")] = ca.object;
+    }
+    const ld = await runLd65({
+      objects,
       target: args.target,
-      options: caOpts,
+      debug: args.debug,
+      linkerConfig: args.linkerConfig,
     });
-    log += `--- ca65 (${name}) ---\n` + ca.log + "\n";
-    if (ca.exitCode !== 0 || !ca.object) {
-      return { binary: null, log, exitCode: ca.exitCode || 1, stage: "ca65" };
-    }
-    const objName = name.replace(/\.(s|asm)$/i, ".o");
-    objects[objName] = ca.object;
+    cb.log += "--- ld65 ---\n" + ld.log;
+    return {
+      binary: ld.binary,
+      dbg: ld.dbg,
+      log: cb.log,
+      exitCode: ld.exitCode,
+      ramUsage: parseRamUsage(ld.map),
+      stage: ld.exitCode === 0 ? "done" : "ld65",
+    };
+  } catch (e) {
+    if (e instanceof BuildError) return e.fields();   // cc65 shape: no `ok` field
+    throw e;
   }
-  const ld = await runLd65({
-    objects,
-    target: args.target,
-    debug: args.debug,
-    linkerConfig: args.linkerConfig,
-  });
-  log += "--- ld65 ---\n" + ld.log;
-  return {
-    binary: ld.binary,
-    dbg: ld.dbg,
-    log,
-    exitCode: ld.exitCode,
-    ramUsage: parseRamUsage(ld.map),
-    stage: ld.exitCode === 0 ? "done" : "ld65",
-  };
 }
 
 /**

package/src/toolchains/cc65/da65.js

@@ -3,36 +3,31 @@
 // Run with --cpu 6502 (default). For SNES/65816 use --cpu 65816.
 
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
 import path from "node:path";
 
 import { runIsolated, textFile, binaryFile } from "../_worker/run.js";
+import { resolveGlueFile } from "../common/wasm-tool.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// da65's WASM ships in romdev-toolchain-cc65 (alongside cc65 / ca65 / ld65).
-// Resolve from that package; fall back to a local copy under src/ if present
-// (transition / dev). The package is a hard dep of romdev.
-function resolveDa65Glue() {
-  try {
-    const u = import.meta.resolve("romdev-toolchain-cc65");
-    const p = path.join(path.dirname(fileURLToPath(u)), "wasm", "da65.js");
-    if (existsSync(p)) return p;
-  } catch { /* package not resolvable — fall through to local */ }
-  const local = path.join(__dirname, "wasm", "da65.js");
-  if (existsSync(local)) return local;
-  throw new Error("da65 WASM not found — install romdev-toolchain-cc65");
-}
-// Lazy + memoized: resolve only on the first da65 disassembly, not at boot.
+// da65's WASM ships in romdev-toolchain-cc65 (alongside cc65 / ca65 / ld65); a
+// local src/ copy is the dev fallback. Lazy + memoized: resolve only on the
+// first da65 disassembly, not at boot.
 let _glue;
-const glue = () => (_glue ??= resolveDa65Glue());
+const glue = () =>
+  (_glue ??= resolveGlueFile({
+    pkg: "romdev-toolchain-cc65",
+    file: "da65.js",
+    localDir: __dirname,
+    label: "da65",
+  }));
 
 /** True if the da65 WASM (romdev-toolchain-cc65) is installed/resolvable, without
  *  throwing — for capability probes (catalog status) that must not crash when the
  *  toolchain is absent. */
 export function da65Available() {
-  try { return !!resolveDa65Glue(); } catch { return false; }
+  try { return !!glue(); } catch { return false; }
 }
 
 /**

package/src/toolchains/cc65/preset-resolver.js

@@ -40,12 +40,23 @@ export async function resolveLinkerConfig(platform, arg) {
     );
   }
   const supportSources = {};
+  // Bundled headers a preset makes available to the C compile (e.g. GameTank's
+  // `gametank.h` register defs) — keyed by their REAL name so `#include "gametank.h"`
+  // resolves, NOT renamed like the `.s` support sources. A bundled header is named
+  // `<name>.h` (no `<preset>.` prefix needed); the `.s`/`.asm` files follow the
+  // support-source convention.
+  /** @type {Record<string,string>} */
+  const headers = {};
   try {
     const entries = await readdir(presetDir);
     const prefix = `${preset}.`;
     for (const f of entries) {
-      if (!f.startsWith(prefix) || f === `${preset}.cfg`) continue;
       const ext = path.extname(f).toLowerCase();
+      if (ext === ".h") {
+        headers[f] = await readFile(path.join(presetDir, f), "utf-8");
+        continue;
+      }
+      if (!f.startsWith(prefix) || f === `${preset}.cfg`) continue;
       if (ext === ".s" || ext === ".asm") {
         const contents = await readFile(path.join(presetDir, f), "utf-8");
         const suffix = f.slice(prefix.length);
@@ -55,5 +66,5 @@ export async function resolveLinkerConfig(platform, arg) {
   } catch {
     // No support files.
   }
-  return { cfg, supportSources };
+  return { cfg, supportSources, headers };
 }