romdevtools 0.16.0 → 0.22.0

package/src/toolchains/cc65/presets/nes/chr-rom.cfg

@@ -0,0 +1,83 @@
+# NES CHR-ROM linker config preset for romdev (cc65-C with FIXED tile art).
+#
+# Use this when you write NES homebrew in C AND ship your pattern tables as a
+# fixed 8KB CHR-ROM blob (vs chr-ram-runtime, which has the CPU upload tiles to
+# CHR-RAM at runtime). The cartridge is NROM-256: 32KB PRG + 8KB CHR-ROM.
+#
+# DIFFERENCE FROM chr-ram-runtime.cfg:
+#   - Adds a ROM2 memory area (8KB CHR-ROM bank) + a CHARS segment. Put your
+#     tile data in `.segment "CHARS"` (e.g. `.incbin "tiles.chr"`); it lands in
+#     the CHR-ROM bank the PPU reads pattern tables from directly.
+#   - The companion crt0 (chr-rom.crt0.s) emits an iNES header with byte 5 = 1
+#     (one 8KB CHR-ROM bank) and does NOT clear CHR-RAM (there is none).
+#
+# To use this preset:
+#   1. linkerConfig: "chr-rom" on build({output:'rom'})  (pulls in chr-rom.crt0.s)
+#   2. Supply your tile art: a source with `.segment "CHARS"` + `.incbin
+#      "tiles.chr"`, plus the blob via binaryIncludePaths:{ "tiles.chr": path }.
+#      The CHARS segment must total exactly 8192 bytes (fill is on, so a short
+#      blob is padded; an over-long one errors).
+#   3. For a DIFFERENT cart config (NROM-128, >8KB CHR, a mapper, vertical
+#      mirroring), don't use this preset — use the parametric `inesHeader`
+#      build option instead (it generates the header + .cfg for any NROM shape).
+#
+# This is the cc65-C-with-segments shape. To rebuild a COMMERCIAL game from its
+# disassembly (one flat CODE blob with embedded vectors), use `inesHeader`.
+
+SYMBOLS {
+    __STACKSIZE__: type = weak, value = $0300;
+}
+MEMORY {
+    ZP:     file = "", start = $0002, size = $001A, type = rw, define = yes;
+
+    # iNES Cartridge Header — emitted by chr-rom.crt0.s (HEADER segment).
+    HEADER: file = %O, start = $0000, size = $0010, fill = yes;
+
+    # PRG-ROM: 2 × 16K = 32K (NROM-256).
+    ROM0:   file = %O, start = $8000, size = $7FFA, fill = yes, define = yes;
+
+    # Hardware vectors at end of PRG.
+    ROMV:   file = %O, start = $FFFA, size = $0006, fill = yes;
+
+    # CHR-ROM: one 8K bank. The PPU reads pattern tables straight from here —
+    # this is the whole point of the CHR-ROM preset.
+    ROM2:   file = %O, start = $0000, size = $2000, fill = yes, define = yes;
+
+    SRAM:   file = "", start = $0500, size = __STACKSIZE__, define = yes;
+
+    # BSS / DATA live in real RAM ($0300-$04FF, 512 bytes). NROM (mapper 0)
+    # with no battery has $6000-$7FFF UNMAPPED — don't put BSS there.
+    RAM:    file = "", start = $0300, size = $0200, define = yes;
+
+    # Shadow OAM at $0200 (page 2). NMI handler DMAs it to PPU sprite RAM.
+    OAM:    file = "", start = $0200, size = $0100;
+}
+SEGMENTS {
+    ZEROPAGE: load = ZP,              type = zp;
+    HEADER:   load = HEADER,          type = ro;
+    STARTUP:  load = ROM0,            type = ro,  define   = yes;
+    LOWCODE:  load = ROM0,            type = ro,  optional = yes;
+    ONCE:     load = ROM0,            type = ro,  optional = yes;
+    CODE:     load = ROM0,            type = ro,  define   = yes;
+    RODATA:   load = ROM0,            type = ro,  define   = yes;
+    DATA:     load = ROM0, run = RAM, type = rw,  define   = yes;
+    VECTORS:  load = ROMV,            type = rw;
+    CHARS:    load = ROM2,            type = ro;
+    BSS:      load = RAM,             type = bss, define   = yes;
+    OAM:      load = OAM,             type = bss, optional = yes;
+}
+FEATURES {
+    CONDES: type    = constructor,
+            label   = __CONSTRUCTOR_TABLE__,
+            count   = __CONSTRUCTOR_COUNT__,
+            segment = ONCE;
+    CONDES: type    = destructor,
+            label   = __DESTRUCTOR_TABLE__,
+            count   = __DESTRUCTOR_COUNT__,
+            segment = RODATA;
+    CONDES: type    = interruptor,
+            label   = __INTERRUPTOR_TABLE__,
+            count   = __INTERRUPTOR_COUNT__,
+            segment = RODATA,
+            import  = __CALLIRQ__;
+}

package/src/toolchains/cc65/presets/nes/chr-rom.crt0.s

@@ -0,0 +1,153 @@
+; crt0 for NES CHR-ROM mode + nes_runtime NMI handler.
+;
+; Companion to the linkerConfig:"chr-rom" preset. Identical to
+; chr-ram-runtime.crt0.s EXCEPT:
+;   - the iNES header sets byte 5 = 1 (one 8KB CHR-ROM bank), and
+;   - there is NO CHR-RAM clear loop — pattern tables come from the CHR-ROM
+;     bank (the CHARS segment / ROM2 area) the PPU reads directly.
+;
+; The NMI handler is the canonical sprite-engine sequence (OAM DMA + VRAM-queue
+; flush + scroll + PPUCTRL), same as the CHR-RAM runtime.
+;
+; Loaded silently by the linkerConfig:"chr-rom" preset.
+
+        .export         _exit
+        .export         __STARTUP__ : absolute = 1
+        .export         start
+        .export         nmi
+        .export         irq
+        .export         _shadow_oam
+
+        .import         initlib, donelib, callmain
+        .import         _main, zerobss, copydata
+        .import         __RAM_START__, __RAM_SIZE__
+        .import         __SRAM_START__, __SRAM_SIZE__
+        .import         _vram_queue_flush
+        .import         _scroll_x, _scroll_y, _ppuctrl_value, _nmi_counter
+        .importzp       c_sp
+
+; ------------------------------------------------------------------------
+; 16-byte iNES header — CHR-ROM (byte 5 = 1 → one 8KB CHR-ROM bank).
+
+.segment "HEADER"
+        .byte   $4e, $45, $53, $1a   ; "NES" + EOF
+        .byte   2                    ; PRG-ROM banks (16K each) → 32K
+        .byte   1                    ; CHR-ROM banks (8K each)  → 8K CHR-ROM
+        .byte   %00000001            ; flags6 — vertical mirroring
+        .byte   %00000000            ; flags7 — mapper hi nybble
+        .byte   0, 0, 0, 0, 0, 0, 0, 0
+
+; ------------------------------------------------------------------------
+.segment "STARTUP"
+
+start:
+        sei
+        cld
+        ldx     #$ff
+        txs
+
+        ; Disable everything that could fire during init.
+        lda     #0
+        sta     $2000           ; disable NMI
+        sta     $2001           ; disable rendering
+        sta     $4010           ; disable DMC IRQ
+        sta     $4015           ; disable APU channels
+        bit     $2002           ; clear vblank flag
+
+        ; Wait two VBlanks before touching the PPU (standard NES init).
+@vbl1:  bit     $2002
+        bpl     @vbl1
+@vbl2:  bit     $2002
+        bpl     @vbl2
+
+        ; Initialise shadow_oam to Y=$FF (off-screen) before anything else.
+        ldx     #0
+        lda     #$ff
+@oam:   sta     _shadow_oam,x
+        inx
+        bne     @oam
+
+        ; NO CHR-RAM clear — pattern tables live in the CHR-ROM bank (CHARS).
+        ; Just point PPUADDR at the palette ($3F00) ready for the caller.
+        bit     $2002           ; reset PPUADDR latch
+        lda     #$3F
+        sta     $2006
+        lda     #$00
+        sta     $2006
+
+        ; Clear BSS + copy DATA (cc65 conventions).
+        jsr     zerobss
+        jsr     copydata
+
+        ; Set up cc65's C parameter stack pointer.
+        lda     #<(__SRAM_START__ + __SRAM_SIZE__)
+        ldx     #>(__SRAM_START__ + __SRAM_SIZE__)
+        sta     c_sp
+        stx     c_sp+1
+
+        jsr     initlib
+        jsr     callmain
+
+_exit:  jsr     donelib
+        jmp     start
+
+; ------------------------------------------------------------------------
+; NMI handler — runs every vblank when ppuctrl bit 7 is set.
+
+.segment "STARTUP"
+
+nmi:
+        pha
+        txa
+        pha
+        tya
+        pha
+
+        ; OAM DMA: copy 256 bytes from $0200 to PPU OAM. Takes 513 cycles.
+        lda     #$00
+        sta     $2003           ; PPU OAMADDR = 0
+        lda     #$02            ; high byte of $0200
+        sta     $4014           ; PPU OAMDMA — kicks off the copy
+
+        ; Flush the VRAM queue (nametable/palette writes game code stashed).
+        jsr     _vram_queue_flush
+
+        ; Reset PPUADDR to $2000 so the PPU doesn't sample random VRAM as BG.
+        bit     $2002
+        lda     #$20
+        sta     $2006
+        lda     #$00
+        sta     $2006
+
+        ; Set scroll (two PPUSCROLL writes: x then y).
+        lda     _scroll_x
+        sta     $2005
+        lda     _scroll_y
+        sta     $2005
+
+        ; Re-enable NMI + base nametable + pattern-table bits via cached PPUCTRL.
+        lda     _ppuctrl_value
+        sta     $2000
+
+        ; Tick the frame counter so ppu_wait_nmi can return.
+        inc     _nmi_counter
+
+        pla
+        tay
+        pla
+        tax
+        pla
+        rti
+
+irq:    rti
+
+; ------------------------------------------------------------------------
+; Shadow OAM at $0200 — the NMI handler DMAs this to the PPU each frame.
+.segment "OAM"
+_shadow_oam: .res 256
+
+; ------------------------------------------------------------------------
+.segment "VECTORS"
+        .word   nmi             ; $FFFA
+        .word   start           ; $FFFC
+        .word   irq             ; $FFFE

package/src/toolchains/common/reassemble.js

@@ -20,7 +20,6 @@ const hex2 = (b) => "$" + (b & 0xFF).toString(16).padStart(2, "0").toUpperCase()
 // Label form across disassemblers: `L` + 4..8 hex digits (m68k targets can be
 // 24-bit, e.g. an $E0FF00xx RAM mirror → LE0FF0080).
 const LABEL_RE = /^(L[0-9A-Fa-f]{4,8}):\s*$/;
-const LABEL_REF_RE = /\bL[0-9A-Fa-f]{4,8}\b/g;
 
 /** Parse one disasm line into {label?, code?, bytes?[]}. */
 function parseLine(line) {
@@ -67,7 +66,7 @@ function firstDiff(a, b) {
 //   m68k (genesis)                            → objdump → m68k-elf-as/ld/objcopy
 //   arm (gba)                                 → objdump → arm-none-eabi-as/ld/objcopy
 
-const CPU_FAMILY = {
+export const CPU_FAMILY = {
   nes: "6502", c64: "6502", atari2600: "6502", atari7800: "6502", lynx: "6502",
   snes: "65816",
   sms: "z80", gg: "z80", msx: "z80",
@@ -254,7 +253,15 @@ async function reassembleGnuNative(disasm, startAddress, original, tools, family
     if (!pinned) { const n = codeIdx.find((i) => !forced.has(i)); if (n == null) break; forced.add(n); }
   }
   // Floor: clean all-`.byte` (proven byte-exact, no labels to perturb layout).
-  const rows = [".section .text", ".global _start", "_start:"];
+  // Mirror build()'s `.org` for the no-link (z80/gbz80) path: without it,
+  // objcopy emits the section from file offset 0, and assemble()'s
+  // `bin.slice(startAddress, …)` then returns bytes that are `startAddress`-short
+  // (empty for a $4000/$8000-based region) — so any non-zero-org region (MSX
+  // $4010, GB bank1 $4000, …) silently fails the floor. The linked path sets the
+  // origin via the link script, so it must NOT carry a redundant `.org`.
+  const rows = [".section .text", ".global _start"];
+  if (tools.noLink) rows.push(`.org 0x${startAddress.toString(16)}`);
+  rows.push("_start:");
   for (let i = 0; i < original.length; i += 16) rows.push("\t.byte " + Array.from(original.slice(i, i + 16)).map((b) => "0x" + b.toString(16).padStart(2, "0")).join(","));
   const r = await assemble(rows.join("\n") + "\n");
   const ok = r.ok && r.bytes.length === original.length && firstDiff(original, r.bytes) < 0;

package/src/toolchains/common/sdk-cache.js

@@ -17,7 +17,7 @@
 // This module is platform-agnostic: each toolchain passes in how to hash its
 // source, where its seed lives, and how to compile from source.
 
-import { readFile, writeFile, mkdir, stat } from "node:fs/promises";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import os from "node:os";

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

@@ -127,7 +127,7 @@ async function compileSgdkRuntime(baseHeaders, cc1Options) {
   for (const [k, v] of Object.entries(localHeaders)) {
     if (/\.i80$/i.test(k)) z80Includes[path.basename(k)] = v;
   }
-  async function loadI80From(dir, rel = "") {
+  async function loadI80From(dir, _rel = "") {
     let ents;
     try { ents = await readdir(dir, { withFileTypes: true }); } catch { return; }
     for (const e of ents) {
@@ -268,8 +268,10 @@ async function buildWithSgdk({ sources, headers, binaryIncludes, cc1Options, reb
   // implicit decls, …) parsed into structured issues[]. The SGDK runtime is
   // compiled WITHOUT these (sgdkCc1Options) — we can't fix SDK warnings and they'd
   // bury the agent's own. -Wno-unused-parameter avoids the common `(void)hard`
-  // scaffold-param noise.
-  const userCc1Options = [...sgdkCc1Options, "-Wall", "-Wextra", "-Wno-unused-parameter"];
+  // scaffold-param noise. -Wno-main: SGDK MANDATES `int main(bool hardReset)`
+  // (sys.c declares it and calls main(TRUE)/main(FALSE)); GCC's -Wmain objects to
+  // the non-standard signature, but it's REQUIRED here, not a bug — so silence it.
+  const userCc1Options = [...sgdkCc1Options, "-Wall", "-Wextra", "-Wno-unused-parameter", "-Wno-main"];
 
   // ── Stage A: gather SGDK headers (visible to tcc via tcc-style flat mount) ──
   // cc1's -iquote /work picks up sibling files mounted alongside main.c.

package/src/toolchains/index.js

@@ -117,6 +117,27 @@ const PLATFORM_DEFAULT_LANGUAGE = {
   msx:        "c",
 };
 
+/**
+ * Order build issues by DANGER so the agent reads the lethal ones first:
+ *   critical (crash-class, e.g. the uint8 infinite-loop)  →  error  →  warning  →  info.
+ * Stable within a rank (preserves source order / file:line). Pure; no dedup.
+ * @param {Array<{severity?:string, critical?:boolean}>} issues
+ * @returns {Array} the same issues, ranked
+ */
+export function rankIssues(issues) {
+  const rank = (i) =>
+    i?.critical ? 0
+    : i?.severity === "error" ? 1
+    : i?.severity === "warning" ? 2
+    : 3;
+  // map→sort→unmap keeps it stable (Array.prototype.sort is stable in V8, but
+  // tie-break on original index to be explicit and portable).
+  return issues
+    .map((issue, idx) => ({ issue, idx }))
+    .sort((a, b) => rank(a.issue) - rank(b.issue) || a.idx - b.idx)
+    .map((x) => x.issue);
+}
+
 /**
  * Public API for the platforms tool to discover the language matrix.
  * Returns `{defaultLanguage, languages: [{language, toolchain, available, note?}]}`.
@@ -835,10 +856,13 @@ export async function buildForPlatform(args) {
         r.log += "\n--- MSX ROM header present (\"AB\") ---";
       }
     }
-    // Combine lint warnings with parsed build log. Lint comes first so
-    // agents see them at the top of the issues array.
+    // Combine lint warnings with parsed build log, then RANK so an agent
+    // triaging issues[] sees the dangerous ones first: crash-class (critical)
+    // → errors → plain warnings. Without this, a "WILL HANG" infinite-loop
+    // warning sits among unused-variable noise and gets skipped (the exact
+    // "agent missed the warning, hit the crash 100 functions later" failure).
     const buildIssues = parseBuildLog(r.log);
-    const issues = [...lintIssues, ...buildIssues];
+    const issues = rankIssues([...lintIssues, ...buildIssues]);
     return {
       ok: r.exitCode === 0 && binary !== null,
       binary,

package/src/toolchains/parse-errors.js

@@ -32,6 +32,9 @@ export function parseBuildLog(log) {
     const baseStage = stage.split(/\s|\(/)[0].toLowerCase();
     if (/^cc65$|^ca65$|^ld65$/.test(baseStage)) {
       issues.push(...parseCc65Like(text, baseStage));
+      // ld65's linker-level errors (segment-missing / memory-overflow) carry no
+      // file:line and slip past parseCc65Like — pick them up too.
+      if (baseStage === "ld65") issues.push(...parseLd65Linker(text, baseStage));
     } else if (/^dasm$/.test(baseStage)) {
       issues.push(...parseDasm(text));
     } else if (/^asar$/.test(baseStage)) {
@@ -68,6 +71,7 @@ export function parseBuildLog(log) {
       // failure). Include vasm + sdcc + wla, which the old fallback omitted.
       const tag = baseStage || "unknown";
       issues.push(...parseCc65Like(text, tag));
+      issues.push(...parseLd65Linker(text, tag));
       issues.push(...parseSdcc(text, tag));
       issues.push(...parseDasm(text));
       issues.push(...parseAsar(text, tag));
@@ -109,6 +113,50 @@ function splitByStage(log) {
   return stages;
 }
 
+// ld65 LINKER diagnostics have NO file:line — parseCc65Like (which requires a
+// `file:line:` lead) misses them entirely, so a failed link returned issues[]
+// EMPTY even though the real error sat in the log. The common ones on a
+// mis-wired NES rebuild (wrong/absent linker config for the project's segments):
+//   ld65: Warning: Segment 'HEADER' does not exist
+//   ld65: Error: Memory area overflow in 'ROM0', segment 'CODE' (6 bytes)
+//   Error: Cannot generate most of the files due to memory area overflow
+// They appear either bare or with an `ld65:`/`ld65.exe:` tool prefix. We add a
+// short hint on the segment/overflow case (the linker config doesn't match the
+// project's segments — the exact CHR-ROM-vs-CHR-RAM mismatch agents hit).
+function parseLd65Linker(text, stage) {
+  const out = [];
+  const re = /^(?:ld65(?:\.exe)?:\s*)?(?<sev>Error|Warning):\s*(?<msg>.+)$/gm;
+  let m;
+  while ((m = re.exec(text))) {
+    const msg = m.groups.msg.trim().replace(/\x1b\[[0-9;]*m/g, "");
+    // Skip the file:line form — parseCc65Like already owns those (and a leading
+    // path would have been consumed as the message here, doubling the issue).
+    if (/^[^\s:]+:\d+:/.test(msg)) continue;
+    // Actionable hint in a SEPARATE field (matching GNU ld / sdld), not glued
+    // onto the message — two common ld65 link failures:
+    let hint;
+    if (/does not exist|overflow|Cannot generate/i.test(msg)) {
+      hint =
+        "The linker config's segments don't match the project. For an NROM " +
+        "rebuild use build({inesHeader:{...}}) or linkerConfig:'chr-rom'; otherwise " +
+        "check that your .cfg's SEGMENTS match the .segment names in your source.";
+    } else if (/unresolved external|undefined symbol/i.test(msg)) {
+      const sym = msg.match(/['"`]?(?<s>[A-Za-z_]\w*)['"`]?\s*$/)?.groups?.s;
+      hint =
+        `${sym ? `\`${sym}'` : "That symbol"} is referenced but never defined or linked. ` +
+        "Add the source/object that defines it (or the right cc65 lib for this platform) " +
+        "to your build, or check for a typo.";
+    }
+    out.push({
+      severity: m.groups.sev.toLowerCase() === "error" ? "error" : "warning",
+      message: msg,
+      stage: stage || "ld65",
+      ...(hint ? { hint } : {}),
+    });
+  }
+  return out;
+}
+
 // cc65, ca65, ld65 all use the gcc-style `file:line:col?: severity: message`.
 // Example:
 //   /work/main.s:12: Error: Cannot open include file 'longbranch.mac'
@@ -173,10 +221,25 @@ function parseSdcc(text, stage) {
     // An "Undefined Global" is effectively an error even though ASlink labels it
     // a warning — the ROM won't run. Promote it so the agent treats it as fatal.
     const isUndef = /undefined\s+global/i.test(msg);
+    // Give the same actionable hint GNU ld's undefined-reference path gets, so
+    // the SDCC platforms (GB/GBC/SMS/GG/MSX) reach parity on the single most
+    // common link failure (forgot to include the source/runtime that defines it).
+    // SDCC mangles C symbols with a leading '_' — show the C name too.
+    let hint;
+    if (isUndef) {
+      const sym = msg.match(/global\s+['"]?(?<s>\w+)['"]?/i)?.groups?.s;
+      const cName = sym && sym.startsWith("_") ? sym.slice(1) : sym;
+      hint =
+        `${sym ? `\`${sym}'` : "That symbol"} is called but never defined or linked` +
+        `${cName && cName !== sym ? ` (the C name is \`${cName}'; SDCC prefixes an underscore)` : ""}. ` +
+        "Add the source file (or runtime/library) that defines it to your build's sources/includes, " +
+        "or check for a typo in the name.";
+    }
     out.push({
       severity: lm.groups.sev === "Error" || isUndef ? "error" : "warning",
       message: "linker: " + msg,
       stage: "sdld",
+      ...(hint ? { hint } : {}),
     });
   }
   return out;
@@ -268,12 +331,26 @@ function parseWla(text, stage = "wla") {
   const reLink = /^(?<obj>\S+\.obj):\s*(?<file>[^\s:]+):(?<line>\d+):\s*(?<phase>[A-Z_]+):\s*(?<msg>.+)$/gm;
   let m;
   while ((m = reLink.exec(text))) {
+    const rawMsg = m.groups.msg.trim();
+    // An "unknown label" reference is SNES's undefined-symbol failure — give it
+    // the same actionable hint ld65/sdld/GNU ld carry, so SNES reaches parity.
+    let hint;
+    const lbl = /unknown label\s+["'`]?(?<l>[A-Za-z_]\w*)/i.exec(rawMsg)?.groups?.l;
+    if (lbl || /reference to an unknown/i.test(rawMsg)) {
+      hint =
+        `${lbl ? `\`${lbl}'` : "That label"} is referenced but never defined or linked. ` +
+        "Add the source/object that defines it (or the right PVSnesLib runtime) to your build, " +
+        "or check for a typo.";
+    }
     out.push({
       severity: "error",
       file: m.groups.file,
       line: parseInt(m.groups.line, 10),
-      message: `${m.groups.phase}: ${m.groups.msg.trim()}`,
+      // Keep the wla internal phase name (FIX_REFERENCES, etc.) out of the
+      // agent-facing message — it's noise; the message + hint say what to do.
+      message: rawMsg,
       stage: stage === "wla" ? "wlalink" : stage,
+      ...(hint ? { hint } : {}),
     });
   }
   // wla-65816 assembler: "<file>:<line>: ERROR|WARNING: <message>"

package/src/toolchains/sdcc/preflight-lint.js

@@ -136,10 +136,14 @@ export function lintSdccSource(source, file = "main.c", opts = {}) {
       if (bound !== null && bound > 255) {
         issues.push({
           severity: "warning",
+          // CRASH-CLASS: not cosmetic — this loop never exits and hangs the
+          // game. `critical` lifts it above ordinary warnings so an agent
+          // triaging issues[] can't miss it among unused-variable noise.
+          critical: true,
           file,
           line: i + 1,
           stage: "lint",
-          message: `uint8 loop counter '${counter}' with bound ${bound} (> 255) — infinite loop`,
+          message: `WILL HANG: uint8 loop counter '${counter}' with bound ${bound} (> 255) — infinite loop`,
           details: `A u8/uint8_t/char counter can never reach ${bound}, so this loop never exits and all code after it is dead. ${portLabel} gives no warning. Declare '${counter}' as uint16_t. See GB TROUBLESHOOTING § uint8 loop-bound trap.`,
           ref: "uint8-loop-bound",
         });

package/src/toolchains/sdcc/sdcc.js

@@ -56,7 +56,7 @@ export const SDCC_PORTS = {
   msx:        { marg: "z80",      libDir: "z80" },
 };
 
-import { runIsolated, textFile, binaryFile, getOutputBytes, getOutputText } from "../_worker/run.js";
+import { runIsolated, textFile, getOutputText } from "../_worker/run.js";
 
 /**
  * Tag the abort/crash log with the SDCC-flavored hint pointing at the

package/src/toolchains/sjasm/sjasm.js

@@ -5,7 +5,7 @@
 // #include that generated .h. Built by scripts/build-sjasm.sh.
 
 import { fileURLToPath } from "node:url";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import path from "node:path";
 
 const __filename = fileURLToPath(import.meta.url);

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

@@ -288,7 +288,7 @@ async function buildWithPvSnesLib({ sources, headers, tccOptions, wlaOptions, bi
  * Minimum-viable path (R16 original behavior). No PVSnesLib runtime;
  * bundled original crt0.asm + hdr.asm support a bare `int main()`.
  */
-async function buildMinimal({ sources, headers, tccOptions, wlaOptions, binaryIncludes = {} }) {
+async function buildMinimal({ sources, headers, tccOptions, wlaOptions, _binaryIncludes = {} }) {
   let log = "";
   const hdrAsm  = await readFile(path.join(MINIMAL_LIB_DIR, "hdr.asm"),  "utf-8");
   const crt0Asm = await readFile(path.join(MINIMAL_LIB_DIR, "crt0.asm"), "utf-8");
@@ -380,7 +380,7 @@ async function buildMinimal({ sources, headers, tccOptions, wlaOptions, binaryIn
 let _headerCache = null;
 async function loadPvSnesLibHeaders() {
   if (_headerCache) return _headerCache;
-  const { readdir, stat } = await import("node:fs/promises");
+  const { readdir } = await import("node:fs/promises");
   const out = {};
   /**
    * @param {string} dir

package/src/toolchains/vasm68k/vasm68k.js

@@ -49,10 +49,8 @@ function vasm68kPreflight(source) {
   const issues = [];
 
   // Check 1: source includes an org $00000000 or starts at $00 implicitly.
-  // vasm68k defaults to $00000000 if no org is given, so missing org is fine.
-  // But if an `org $00000200` (or similar) appears WITHOUT a preceding
-  // vector table, the cart is unbootable.
-  const hasOrg0 = /\borg\s+\$0+\b/i.test(source) || /\borg\s+0\b/i.test(source);
+  // vasm68k defaults to $00000000 if no org is given, so a missing org is fine;
+  // what actually breaks boot is a missing reset vector, which we check below.
   const hasReset = /\bdc\.l\s+(\$00FF[E-F][0-9A-F]{3}|_reset|reset)\b/i.test(source);
   if (!hasReset) {
     issues.push(

package/src/toolchains/wladx/wladx.js

@@ -15,7 +15,7 @@ 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 { runIsolated, textFile, binaryFile, getOutputBytes } from "../_worker/run.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);