romdevtools 0.71.1 → 0.84.1

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 };
 }

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