romdevtools 0.71.1 → 0.84.1

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

@@ -35,6 +35,7 @@ import {
 import { runSjasm, runBintos } from "../sjasm/sjasm.js";
 import { packAr } from "../common/ar.js";
 import { resolveSdkArchive } from "../common/sdk-cache.js";
+import { CBuild, BuildError } from "../common/c-build.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -254,7 +255,7 @@ export async function buildGenesisC(args) {
  *   7. objcopy -O binary → final .bin
  */
 async function buildWithSgdk({ sources, headers, binaryIncludes, cc1Options, rebuildSdk = false, writeSeed = false }) {
-  let log = "";
+  const cb = new CBuild();
   // SGDK_GCC define + freestanding-style flags must be in cc1 invocations
   const sgdkCc1Options = [
     "-DSGDK_GCC",
@@ -280,154 +281,135 @@ async function buildWithSgdk({ sources, headers, binaryIncludes, cc1Options, reb
   const sgdkHeaders = await loadSgdkHeaders();
   const tccHeaders = { ...headers, ...sgdkHeaders };
 
-  // ── Stage B: compile + assemble each user .c source ──
-  /** @type {Record<string, Uint8Array>} */
-  const userObjs = {};
-  const cFiles = Object.keys(sources).filter((n) => /\.c$/i.test(n));
-  for (const cName of cFiles) {
-    const cc = await runCc1m68k({
-      source: sources[cName],
-      headers: tccHeaders,
-      options: userCc1Options,
-    });
-    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})`, runtime: "sgdk", ...(cc.crash ? { crash: cc.crash } : {}) };
-    }
-    const as = await runM68kAs({ source: cc.asmSource });
-    log += `--- as (${cName} → .o) ---\n` + (as.log || "(ok)") + "\n";
-    if (as.exitCode !== 0 || !as.object) {
-      return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${cName})`, runtime: "sgdk", ...(as.crash ? { crash: as.crash } : {}) };
+  try {
+    // ── Stage B: compile + assemble each user .c source ──
+    /** @type {Record<string, Uint8Array>} */
+    const userObjs = {};
+    const cFiles = Object.keys(sources).filter((n) => /\.c$/i.test(n));
+    for (const cName of cFiles) {
+      const cc = await cb.stage(`cc1 (${cName})`,
+        () => runCc1m68k({ source: sources[cName], headers: tccHeaders, options: userCc1Options }),
+        (r) => r.asmSource);
+      const as = await cb.stage(`as (${cName})`,
+        () => runM68kAs({ source: cc.asmSource }),
+        (r) => r.object, { logName: `as (${cName} → .o)` });
+      userObjs[cName.replace(/\.c$/i, ".o")] = as.object;
     }
-    userObjs[cName.replace(/\.c$/i, ".o")] = as.object;
-  }
 
-  // ── Stage B': assemble user .s sibling files directly ──
-  // User .s files may .incbin sibling binary blobs (e.g. xgm2 music) — pass
-  // the same binaryIncludes map to each so the assembler can mount them.
-  const asmFiles = Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n));
-  for (const asmName of asmFiles) {
-    const as = await runM68kAs({ source: sources[asmName], binaryIncludes });
-    log += `--- as (${asmName}) ---\n` + (as.log || "(ok)") + "\n";
-    if (as.exitCode !== 0 || !as.object) {
-      return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${asmName})`, runtime: "sgdk", ...(as.crash ? { crash: as.crash } : {}) };
+    // ── Stage B': assemble user .s sibling files directly ──
+    // User .s files may .incbin sibling binary blobs (e.g. xgm2 music) — pass
+    // the same binaryIncludes map to each so the assembler can mount them.
+    const asmFiles = Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n));
+    for (const asmName of asmFiles) {
+      const as = await cb.stage(`as (${asmName})`,
+        () => runM68kAs({ source: sources[asmName], binaryIncludes }),
+        (r) => r.object);
+      userObjs[asmName.replace(/\.(s|asm)$/i, ".o")] = as.object;
     }
-    userObjs[asmName.replace(/\.(s|asm)$/i, ".o")] = as.object;
-  }
 
-  // ── Stage C: build rom_header.bin from SGDK's rom_header.c ──
-  const romHeaderC = await readFile(path.join(SGDK_LIB_DIR, "rom_header.c"), "utf-8");
-  const rhCc = await runCc1m68k({
-    source: romHeaderC,
-    headers: tccHeaders,
-    options: sgdkCc1Options,
-  });
-  log += "--- cc1 (rom_header.c) ---\n" + (rhCc.log || "(ok)") + "\n";
-  if (rhCc.exitCode !== 0 || !rhCc.asmSource) {
-    return { ok: false, binary: null, log, exitCode: rhCc.exitCode || 1, stage: "cc1 (rom_header)", runtime: "sgdk", ...(rhCc.crash ? { crash: rhCc.crash } : {}) };
-  }
-  const rhAs = await runM68kAs({ source: rhCc.asmSource });
-  log += "--- as (rom_header.s) ---\n" + (rhAs.log || "(ok)") + "\n";
-  if (rhAs.exitCode !== 0 || !rhAs.object) {
-    return { ok: false, binary: null, log, exitCode: rhAs.exitCode || 1, stage: "as (rom_header)", runtime: "sgdk", ...(rhAs.crash ? { crash: rhAs.crash } : {}) };
-  }
-  // Objcopy → raw header bin (256 bytes)
-  const rhObjcopy = await runM68kObjcopy({ elf: rhAs.object });
-  log += "--- objcopy (rom_header.o → .bin) ---\n" + (rhObjcopy.log || "(ok)") + "\n";
-  if (rhObjcopy.exitCode !== 0 || !rhObjcopy.binary) {
-    return { ok: false, binary: null, log, exitCode: rhObjcopy.exitCode || 1, stage: "objcopy (rom_header)", runtime: "sgdk", ...(rhObjcopy.crash ? { crash: rhObjcopy.crash } : {}) };
-  }
-
-  // ── Stage D: assemble sega.s with the just-built rom_header.bin as a sibling ──
-  // sega.s `.incbin "out/rom_header.bin"` — we mount it at /work/out/rom_header.bin
-  // via the worker's binaryFile facility. runM68kAs's includes map only handles text,
-  // so we need to extend the as call to accept binary siblings.
-  //
-  // Note: we use `sega.preprocessed.s` (the cpp-expanded form). The raw sega.s
-  // uses `#include <task_cst.h>` + `#define`d constants, which SGDK normally
-  // expands via gcc's `-x assembler-with-cpp` driver mode. Our `runM68kAs`
-  // wrapper calls `as` directly without cpp, so we ship the preprocessed
-  // version as a build artifact (~7 KB) instead of running cpp at every build.
-  const segaSrc = await readFile(path.join(SGDK_LIB_DIR, "sega.preprocessed.s"), "utf-8");
-  const segaAs = await runM68kAs({
-    source: segaSrc,
-    binaryIncludes: { "out/rom_header.bin": rhObjcopy.binary },
-    // SGDK assembles sega.s with the same -DSGDK_GCC etc. flags as C — pass them
-    // via -Wa,--register-prefix-optional,--bitwise-or implicitly via cc1's driver.
-    // Our as wrapper takes raw flags; the equivalent here is just --bitwise-or.
-    options: ["--register-prefix-optional", "--bitwise-or"],
-  });
-  log += "--- as (sega.s) ---\n" + (segaAs.log || "(ok)") + "\n";
-  if (segaAs.exitCode !== 0 || !segaAs.object) {
-    return { ok: false, binary: null, log, exitCode: segaAs.exitCode || 1, stage: "as (sega.s)", runtime: "sgdk", ...(segaAs.crash ? { crash: segaAs.crash } : {}) };
-  }
-
-  // ── Stage D2: compile the SGDK runtime FROM SOURCE → libmd.a ──
-  // (Z80 drivers via sjasm+bintos, all SGDK .c via m68k-gcc, libres + .s
-  // assembled, packed into an archive. No prebuilt libmd.a black box.)
-  // Seed by default (compiling SGDK from source is ~18s); rebuildSdk:true
-  // recompiles; an edit to the vendored SGDK source without the flag is flagged.
-  const sdkWarnings = [];
-  const sgdkRes = await resolveSdkArchive({
-    name: "SGDK",
-    sources: await readSgdkSources(),
-    seedPath: path.join(SGDK_LIB_DIR, "libmd.seed.a"),
-    seedHashPath: path.join(SGDK_LIB_DIR, "libmd.seed.hash"),
-    rebuild: rebuildSdk, writeSeed,
-    compileFromSource: async () => {
-      const r = await compileSgdkRuntime({ ...tccHeaders }, sgdkCc1Options);
-      return r.ok ? { ok: true, archive: r.libmd } : r;
-    },
-  });
-  if (!sgdkRes.ok) {
-    return { ok: false, binary: null, log: log + (sgdkRes.log || ""), exitCode: 1, stage: `sgdk runtime: ${sgdkRes.stage}`, runtime: "sgdk" };
-  }
-  if (sgdkRes.sdkEditIgnored) sdkWarnings.push(sgdkRes.sdkEditIgnored);
-  log += `--- SGDK runtime ${sgdkRes.fromSource ? "compiled from source" : "from prebuilt seed"} ---\n`;
-
-  // ── Stage E: link everything ──
-  const mdLd = await readFile(path.join(SGDK_LIB_DIR, "md.ld"), "utf-8");
-  const [libgcc, libc, libm] = await Promise.all([
-    readFile(path.join(MINIMAL_LIB_DIR, "libgcc.a")),
-    readFile(path.join(MINIMAL_LIB_DIR, "libc.a")),
-    readFile(path.join(MINIMAL_LIB_DIR, "libm.a")),
-  ]);
-
-  const ld = await runM68kLd({
-    objects: { "sega.o": segaAs.object, ...userObjs },
-    linkScript: mdLd,
-    archives: {
-      "libmd.a":  sgdkRes.archive,
-      "libgcc.a": new Uint8Array(libgcc),
-      "libc.a":   new Uint8Array(libc),
-      "libm.a":   new Uint8Array(libm),
-    },
-    libraries: ["md", "gcc", "c"],
-    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", runtime: "sgdk", ...(ld.crash ? { crash: ld.crash } : {}) };
-  }
-
-  // ── Stage F: extract raw ROM ──
-  const objcopy = await runM68kObjcopy({ elf: ld.elf });
-  log += "--- objcopy ---\n" + (objcopy.log || "(ok)") + "\n";
-  if (objcopy.exitCode !== 0 || !objcopy.binary) {
-    return { ok: false, binary: null, log, exitCode: objcopy.exitCode || 1, stage: "objcopy", runtime: "sgdk", ...(objcopy.crash ? { crash: objcopy.crash } : {}) };
+    // ── Stage C: build rom_header.bin from SGDK's rom_header.c ──
+    const romHeaderC = await readFile(path.join(SGDK_LIB_DIR, "rom_header.c"), "utf-8");
+    const rhCc = await cb.stage("cc1 (rom_header)",
+      () => runCc1m68k({ source: romHeaderC, headers: tccHeaders, options: sgdkCc1Options }),
+      (r) => r.asmSource, { logName: "cc1 (rom_header.c)" });
+    const rhAs = await cb.stage("as (rom_header)",
+      () => runM68kAs({ source: rhCc.asmSource }),
+      (r) => r.object, { logName: "as (rom_header.s)" });
+    // Objcopy → raw header bin (256 bytes)
+    const rhObjcopy = await cb.stage("objcopy (rom_header)",
+      () => runM68kObjcopy({ elf: rhAs.object }),
+      (r) => r.binary, { logName: "objcopy (rom_header.o → .bin)" });
+
+    // ── Stage D: assemble sega.s with the just-built rom_header.bin as a sibling ──
+    // sega.s `.incbin "out/rom_header.bin"` — we mount it at /work/out/rom_header.bin
+    // via the worker's binaryFile facility. runM68kAs's includes map only handles text,
+    // so we need to extend the as call to accept binary siblings.
+    //
+    // Note: we use `sega.preprocessed.s` (the cpp-expanded form). The raw sega.s
+    // uses `#include <task_cst.h>` + `#define`d constants, which SGDK normally
+    // expands via gcc's `-x assembler-with-cpp` driver mode. Our `runM68kAs`
+    // wrapper calls `as` directly without cpp, so we ship the preprocessed
+    // version as a build artifact (~7 KB) instead of running cpp at every build.
+    const segaSrc = await readFile(path.join(SGDK_LIB_DIR, "sega.preprocessed.s"), "utf-8");
+    const segaAs = await cb.stage("as (sega.s)",
+      () => runM68kAs({
+        source: segaSrc,
+        binaryIncludes: { "out/rom_header.bin": rhObjcopy.binary },
+        // SGDK assembles sega.s with the same -DSGDK_GCC etc. flags as C — pass them
+        // via -Wa,--register-prefix-optional,--bitwise-or implicitly via cc1's driver.
+        // Our as wrapper takes raw flags; the equivalent here is just --bitwise-or.
+        options: ["--register-prefix-optional", "--bitwise-or"],
+      }),
+      (r) => r.object);
+
+    // ── Stage D2: compile the SGDK runtime FROM SOURCE → libmd.a ──
+    // (Z80 drivers via sjasm+bintos, all SGDK .c via m68k-gcc, libres + .s
+    // assembled, packed into an archive. No prebuilt libmd.a black box.)
+    // Seed by default (compiling SGDK from source is ~18s); rebuildSdk:true
+    // recompiles; an edit to the vendored SGDK source without the flag is flagged.
+    const sdkWarnings = [];
+    const sgdkRes = await resolveSdkArchive({
+      name: "SGDK",
+      sources: await readSgdkSources(),
+      seedPath: path.join(SGDK_LIB_DIR, "libmd.seed.a"),
+      seedHashPath: path.join(SGDK_LIB_DIR, "libmd.seed.hash"),
+      rebuild: rebuildSdk, writeSeed,
+      compileFromSource: async () => {
+        const r = await compileSgdkRuntime({ ...tccHeaders }, sgdkCc1Options);
+        return r.ok ? { ok: true, archive: r.libmd } : r;
+      },
+    });
+    if (!sgdkRes.ok) {
+      // Original appended sgdkRes.log raw (no newline normalization) to the log.
+      cb.log += (sgdkRes.log || "");
+      throw new BuildError({ stage: `sgdk runtime: ${sgdkRes.stage}`, exitCode: 1, log: cb.log });
+    }
+    if (sgdkRes.sdkEditIgnored) sdkWarnings.push(sgdkRes.sdkEditIgnored);
+    cb.log += `--- SGDK runtime ${sgdkRes.fromSource ? "compiled from source" : "from prebuilt seed"} ---\n`;
+
+    // ── Stage E: link everything ──
+    const mdLd = await readFile(path.join(SGDK_LIB_DIR, "md.ld"), "utf-8");
+    const [libgcc, libc, libm] = await Promise.all([
+      readFile(path.join(MINIMAL_LIB_DIR, "libgcc.a")),
+      readFile(path.join(MINIMAL_LIB_DIR, "libc.a")),
+      readFile(path.join(MINIMAL_LIB_DIR, "libm.a")),
+    ]);
+
+    const ld = await cb.stage("ld",
+      () => runM68kLd({
+        objects: { "sega.o": segaAs.object, ...userObjs },
+        linkScript: mdLd,
+        archives: {
+          "libmd.a":  sgdkRes.archive,
+          "libgcc.a": new Uint8Array(libgcc),
+          "libc.a":   new Uint8Array(libc),
+          "libm.a":   new Uint8Array(libm),
+        },
+        libraries: ["md", "gcc", "c"],
+        libraryPaths: ["/work"],
+        options: ["--no-warn-rwx-segments"],
+      }),
+      (r) => r.elf);
+
+    // ── Stage F: extract raw ROM ──
+    const objcopy = await cb.stage("objcopy",
+      () => runM68kObjcopy({ elf: ld.elf }),
+      (r) => r.binary);
+
+    return {
+      ok: true,
+      binary: objcopy.binary,
+      log: cb.log,
+      exitCode: 0,
+      stage: "done",
+      runtime: "sgdk",
+      ...(ld.map ? { symbols: ld.map } : {}),
+      ...(sdkWarnings.length ? { sdkEditIgnored: sdkWarnings } : {}),
+    };
+  } catch (e) {
+    if (e instanceof BuildError) return e.toResult({ runtime: "sgdk" });
+    throw e;
   }
-
-  return {
-    ok: true,
-    binary: objcopy.binary,
-    log,
-    exitCode: 0,
-    stage: "done",
-    runtime: "sgdk",
-    ...(ld.map ? { symbols: ld.map } : {}),
-    ...(sdkWarnings.length ? { sdkEditIgnored: sdkWarnings } : {}),
-  };
 }
 
 /**
@@ -472,93 +454,82 @@ export function finalizeGenesisRom(bin) {
  */
 async function buildMinimal(args) {
   const { sources, headers, binaryIncludes, cc1Options } = args;
-  let log = "";
+  const cb = new CBuild();
 
-  // ── Stage 1: compile each .c file via cc1 → .s ─────────────────
-  /** @type {Record<string, Uint8Array>} */
-  const userObjs = {};
-  // User .c gets warnings on (minimal path has no SDK to flood). See buildWithSgdk.
-  const userCc1Options = [...cc1Options, "-Wall", "-Wextra", "-Wno-unused-parameter"];
-  const cFiles = Object.keys(sources).filter((n) => /\.c$/i.test(n));
-  for (const cName of cFiles) {
-    const cc = await runCc1m68k({
-      source: sources[cName],
-      headers,
-      options: userCc1Options,
-    });
-    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})`, runtime: "minimal", ...(cc.crash ? { crash: cc.crash } : {}) };
-    }
-    // ── Stage 2: assemble that .s with m68k-elf-as ────────────────
-    const as = await runM68kAs({ source: cc.asmSource });
-    log += `--- as (${cName} → .o) ---\n` + (as.log || "(ok)") + "\n";
-    if (as.exitCode !== 0 || !as.object) {
-      return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${cName})`, runtime: "minimal", ...(as.crash ? { crash: as.crash } : {}) };
+  try {
+    // ── Stage 1: compile each .c file via cc1 → .s ─────────────────
+    /** @type {Record<string, Uint8Array>} */
+    const userObjs = {};
+    // User .c gets warnings on (minimal path has no SDK to flood). See buildWithSgdk.
+    const userCc1Options = [...cc1Options, "-Wall", "-Wextra", "-Wno-unused-parameter"];
+    const cFiles = Object.keys(sources).filter((n) => /\.c$/i.test(n));
+    for (const cName of cFiles) {
+      const cc = await cb.stage(`cc1 (${cName})`,
+        () => runCc1m68k({ source: sources[cName], headers, options: userCc1Options }),
+        (r) => r.asmSource);
+      // ── Stage 2: assemble that .s with m68k-elf-as ────────────────
+      const as = await cb.stage(`as (${cName})`,
+        () => runM68kAs({ source: cc.asmSource }),
+        (r) => r.object, { logName: `as (${cName} → .o)` });
+      userObjs[cName.replace(/\.c$/i, ".o")] = as.object;
     }
-    userObjs[cName.replace(/\.c$/i, ".o")] = as.object;
-  }
 
-  // ── Stage 2b: assemble each .s file directly ───────────────────
-  const asmFiles = Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n));
-  for (const asmName of asmFiles) {
-    const as = await runM68kAs({ source: sources[asmName], binaryIncludes });
-    log += `--- as (${asmName}) ---\n` + (as.log || "(ok)") + "\n";
-    if (as.exitCode !== 0 || !as.object) {
-      return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${asmName})`, runtime: "minimal", ...(as.crash ? { crash: as.crash } : {}) };
+    // ── Stage 2b: assemble each .s file directly ───────────────────
+    const asmFiles = Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n));
+    for (const asmName of asmFiles) {
+      const as = await cb.stage(`as (${asmName})`,
+        () => runM68kAs({ source: sources[asmName], binaryIncludes }),
+        (r) => r.object);
+      userObjs[asmName.replace(/\.(s|asm)$/i, ".o")] = as.object;
     }
-    userObjs[asmName.replace(/\.(s|asm)$/i, ".o")] = as.object;
-  }
-
-  // ── Stage 3: assemble the bundled sega.s crt0 ───────────────────
-  const sega = await readFile(path.join(MINIMAL_LIB_DIR, "sega.s"), "utf-8");
-  const segaAs = await runM68kAs({ source: sega });
-  log += "--- as (sega.s crt0) ---\n" + (segaAs.log || "(ok)") + "\n";
-  if (segaAs.exitCode !== 0 || !segaAs.object) {
-    return { ok: false, binary: null, log, exitCode: segaAs.exitCode || 1, stage: "as (sega.s)", runtime: "minimal", ...(segaAs.crash ? { crash: segaAs.crash } : {}) };
-  }
 
-  // ── Stage 4: link everything ────────────────────────────────────
-  const linkScript = await readFile(path.join(MINIMAL_LIB_DIR, "genesis.ld"), "utf-8");
-  const [libgcc, libc, libm] = await Promise.all([
-    readFile(path.join(MINIMAL_LIB_DIR, "libgcc.a")),
-    readFile(path.join(MINIMAL_LIB_DIR, "libc.a")),
-    readFile(path.join(MINIMAL_LIB_DIR, "libm.a")),
-  ]);
-
-  const ld = await runM68kLd({
-    objects: { "sega.o": segaAs.object, ...userObjs },
-    linkScript,
-    archives: {
-      "libgcc.a": new Uint8Array(libgcc),
-      "libc.a":   new Uint8Array(libc),
-      "libm.a":   new Uint8Array(libm),
-    },
-    libraries: ["c", "gcc", "m"],
-    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", runtime: "minimal", ...(ld.crash ? { crash: ld.crash } : {}) };
+    // ── Stage 3: assemble the bundled sega.s crt0 ───────────────────
+    const sega = await readFile(path.join(MINIMAL_LIB_DIR, "sega.s"), "utf-8");
+    const segaAs = await cb.stage("as (sega.s)",
+      () => runM68kAs({ source: sega }),
+      (r) => r.object, { logName: "as (sega.s crt0)" });
+
+    // ── Stage 4: link everything ────────────────────────────────────
+    const linkScript = await readFile(path.join(MINIMAL_LIB_DIR, "genesis.ld"), "utf-8");
+    const [libgcc, libc, libm] = await Promise.all([
+      readFile(path.join(MINIMAL_LIB_DIR, "libgcc.a")),
+      readFile(path.join(MINIMAL_LIB_DIR, "libc.a")),
+      readFile(path.join(MINIMAL_LIB_DIR, "libm.a")),
+    ]);
+
+    const ld = await cb.stage("ld",
+      () => runM68kLd({
+        objects: { "sega.o": segaAs.object, ...userObjs },
+        linkScript,
+        archives: {
+          "libgcc.a": new Uint8Array(libgcc),
+          "libc.a":   new Uint8Array(libc),
+          "libm.a":   new Uint8Array(libm),
+        },
+        libraries: ["c", "gcc", "m"],
+        libraryPaths: ["/work"],
+        options: ["--no-warn-rwx-segments"],
+      }),
+      (r) => r.elf);
+
+    // ── Stage 5: extract raw binary ─────────────────────────────────
+    const objcopy = await cb.stage("objcopy",
+      () => runM68kObjcopy({ elf: ld.elf }),
+      (r) => r.binary);
+
+    return {
+      ok: true,
+      binary: objcopy.binary,
+      log: cb.log,
+      exitCode: 0,
+      stage: "done",
+      runtime: "minimal",
+      ...(ld.map ? { symbols: ld.map } : {}),
+    };
+  } catch (e) {
+    if (e instanceof BuildError) return e.toResult({ runtime: "minimal" });
+    throw e;
   }
-
-  // ── Stage 5: extract raw binary ─────────────────────────────────
-  const objcopy = await runM68kObjcopy({ elf: ld.elf });
-  log += "--- objcopy ---\n" + (objcopy.log || "(ok)") + "\n";
-  if (objcopy.exitCode !== 0 || !objcopy.binary) {
-    return { ok: false, binary: null, log, exitCode: objcopy.exitCode || 1, stage: "objcopy", runtime: "minimal", ...(objcopy.crash ? { crash: objcopy.crash } : {}) };
-  }
-
-  return {
-    ok: true,
-    binary: objcopy.binary,
-    log,
-    exitCode: 0,
-    stage: "done",
-    runtime: "minimal",
-    ...(ld.map ? { symbols: ld.map } : {}),
-  };
 }
 
 /** @param {{source?:string, sources?:Record<string,string>}} args */

package/src/toolchains/index.js

@@ -17,6 +17,23 @@ const CC65_TARGET = {
   atari7800: "atari7800",
   lynx: "lynx",
   pce: "pce",
+  // GameTank has no built-in cc65 target — it links bare via `-t none` + the
+  // bundled single-bank preset cfg/crt0/vectors (presets/gametank/).
+  gametank: "none",
+};
+
+/** cc65 platforms whose CPU is NOT implied by a built-in target. The built-in
+ *  targets (lynx/pce/…) set the CPU themselves; `-t none` defaults to plain 6502,
+ *  so GameTank (a real W65C02S) MUST be told `--cpu 65c02` for cc65 codegen +
+ *  `--cpu W65C02` for ca65, or it silently emits 6502 code on a 65C02. */
+const CC65_CPU = {
+  gametank: { cc: "65c02", ca: "W65C02" },
+};
+
+/** Exact ROM sizes for cc65 platforms whose mapper is size-keyed (no header).
+ *  GameTank detects EEPROM32K by a flat 32 KB image — pad to exactly 32768. */
+const CC65_ROM_SIZE = {
+  gametank: 32768,
 };
 
 /**
@@ -81,6 +98,10 @@ const LANGUAGE_TOOLCHAIN = {
     c:   { toolchain: "cc65", available: true, note: "C for PC Engine via cc65's huc6280 target — crt0 + pce.lib (VDC/VCE/PSG/joypad helpers) auto-linked. #include <pce.h>." },
     asm: { toolchain: "cc65", available: true },
   },
+  gametank: {
+    c:   { toolchain: "cc65", available: true, note: "C for GameTank (Clyde Shaffer's open W65C02S console) via cc65 `--cpu 65c02` + a bundled single-bank 32KB preset (crt0 + linker cfg + vectors), pass linkerConfig:'single-bank'. #include \"gametank.h\" for the blitter/DMA/banking/gamepad registers ($4000-$4007 blitter, $2007 dma_flags, $2005 bank_reg, $2008/9 gamepads). Bare path — color-fill the 128x128 framebuffer via the blitter; the full SDK gfx/audio/text runtime + 2MB multi-bank flash pipeline is not bundled (Tier B, deferred). Output is a flat 32KB .gtr (EEPROM32K, size-keyed mapper)." },
+    asm: { toolchain: "cc65", available: true },
+  },
   msx: {
     c:   { toolchain: "sdcc", available: true, note: "C for MSX via SDCC's z80 port. Cartridge ROM with the 'AB' header + INIT pointer at $4000; boots on C-BIOS (open MSX BIOS). MSX2 by default (runs MSX1 carts too)." },
     asm: { toolchain: "sdcc", available: true },
@@ -114,6 +135,7 @@ const PLATFORM_DEFAULT_LANGUAGE = {
   c64:        "c",
   atari7800:  "c",
   lynx:       "c",
+  gametank:   "c",
   gb:         "c",
   gbc:        "c",
   snes:       "c",
@@ -425,24 +447,56 @@ export async function buildForPlatform(args) {
     // the build pipeline does NOT auto-select presets based on source
     // contents — every byte that compiles must be visible to the caller.
     const { resolveLinkerConfig } = await import("./cc65/preset-resolver.js");
-    const { cfg, supportSources } = await resolveLinkerConfig(args.platform, args.linkerConfig);
+    const { cfg, supportSources, headers: presetHeaders } = await resolveLinkerConfig(args.platform, args.linkerConfig);
 
     // Splice in any preset support sources (crt0, etc.). User sources win
     // if there's a name collision, but the preset uses `_preset_*` so it
     // wouldn't normally collide.
     sources = { ...supportSources, ...sources };
 
+    // A preset can bundle headers (e.g. GameTank's gametank.h) so `#include
+    // "gametank.h"` just works; caller-supplied headers win on collision.
+    const mergedHeaders = { ...(presetHeaders ?? {}), ...(args.includes ?? {}) };
+
+    // CPU override for `-t none` platforms whose CPU isn't implied by the target
+    // (GameTank → cc65 `--cpu 65c02`, ca65 `--cpu W65C02`).
+    const cpu = CC65_CPU[args.platform];
+    const ccCpuOpts = cpu ? ["--cpu", cpu.cc] : [];
+    const caCpuOpts = cpu ? ["--cpu", cpu.ca] : [];
+
     const builder = anyC ? buildC : buildAsm;
     const r = await builder({
       sources,
       target: cc65Target,
-      [anyC ? "headers" : "includes"]: args.includes,
+      [anyC ? "headers" : "includes"]: anyC ? mergedHeaders : args.includes,
+      // ca65 .include files (e.g. an SDK's modules_enabled.inc) — distinct from C
+      // headers; the C path's per-TU ca65 pass needs them, and they weren't being
+      // forwarded. A platform with a multi-file asm-backed SDK (GameTank) needs this.
+      ...(args.asmIncludes ? { asmIncludes: args.asmIncludes } : {}),
       binaryIncludes: args.binaryIncludes,
       linkerConfig: cfg,
+      ccOptions: ccCpuOpts,
+      caOptions: caCpuOpts,
     });
+
+    // Size-keyed mappers (GameTank EEPROM32K): pad the flat image to the exact
+    // ROM size the core size-detects. Under-size or a few bytes over would fall
+    // into the UNKNOWN mapper path.
+    let binary = r.binary;
+    const romSize = CC65_ROM_SIZE[args.platform];
+    if (binary && r.exitCode === 0 && romSize && binary.length !== romSize) {
+      if (binary.length < romSize) {
+        const padded = new Uint8Array(romSize);
+        padded.set(binary);
+        binary = padded;
+      } else {
+        binary = binary.slice(0, romSize);
+      }
+    }
+
     return {
-      ok: r.exitCode === 0 && r.binary !== null,
-      binary: r.binary,
+      ok: r.exitCode === 0 && binary !== null,
+      binary,
       listing: "",
       symbols: "",
       log: r.log,