@auraindustry/aurajs 0.0.7 → 0.1.0

package/src/retro/backend-gba/rom.mjs

@@ -0,0 +1,363 @@
+import { existsSync, writeFileSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { buildAuthoringBackedGbaRuntimeSource } from './authoring.mjs';
+
+const MIN_ROM_SIZE_BYTES = 32 * 1024;
+const LINK_ROM_SIZE_BYTES = 4 * 1024 * 1024;
+const MAX_ROM_SIZE_BYTES = 32 * 1024 * 1024;
+const ROM_ENTRY_OFFSET = 0x0000;
+const HEADER_LOGO_OFFSET = 0x0004;
+const HEADER_TITLE_OFFSET = 0x00A0;
+const HEADER_TITLE_END = 0x00AB;
+const HEADER_GAME_CODE_OFFSET = 0x00AC;
+const HEADER_GAME_CODE_END = 0x00AF;
+const HEADER_MAKER_CODE_OFFSET = 0x00B0;
+const HEADER_MAKER_CODE_END = 0x00B1;
+const HEADER_FIXED_VALUE_OFFSET = 0x00B2;
+const HEADER_MAIN_UNIT_CODE_OFFSET = 0x00B3;
+const HEADER_DEVICE_TYPE_OFFSET = 0x00B4;
+const HEADER_SOFTWARE_VERSION_OFFSET = 0x00BC;
+const HEADER_COMPLEMENT_CHECK_OFFSET = 0x00BD;
+const ROM_CODE_OFFSET = 0x00C0;
+
+const NINTENDO_LOGO = Uint8Array.from([
+  0x24, 0xFF, 0xAE, 0x51, 0x69, 0x9A, 0xA2, 0x21,
+  0x3D, 0x84, 0x82, 0x0A, 0x84, 0xE4, 0x09, 0xAD,
+  0x11, 0x24, 0x8B, 0x98, 0xC0, 0x81, 0x7F, 0x21,
+  0xA3, 0x52, 0xBE, 0x19, 0x93, 0x09, 0xCE, 0x20,
+  0x10, 0x46, 0x4A, 0x4A, 0xF8, 0x27, 0x31, 0xEC,
+  0x58, 0xC7, 0xE8, 0x33, 0x82, 0xE3, 0xCE, 0xBF,
+  0x85, 0xF4, 0xDF, 0x94, 0xCE, 0x4B, 0x09, 0xC1,
+  0x94, 0x56, 0x8A, 0xC0, 0x13, 0x72, 0xA7, 0xFC,
+  0x9F, 0x84, 0x4D, 0x73, 0xA3, 0xCA, 0x9A, 0x61,
+  0x58, 0x97, 0xA3, 0x27, 0xFC, 0x03, 0x98, 0x76,
+  0x23, 0x1D, 0xC7, 0x61, 0x03, 0x04, 0xAE, 0x56,
+  0xBF, 0x38, 0x84, 0x00, 0x40, 0xA7, 0x0E, 0xFD,
+  0xFF, 0x52, 0xFE, 0x03, 0x6F, 0x95, 0x30, 0xF1,
+  0x97, 0xFB, 0xC0, 0x85, 0x60, 0xD6, 0x80, 0x25,
+  0xA9, 0x63, 0xBE, 0x03, 0x01, 0x4E, 0x38, 0xE2,
+  0xF9, 0xA2, 0x34, 0xFF, 0xBB, 0x3E, 0x03, 0x44,
+  0x78, 0x00, 0x90, 0xCB, 0x88, 0x11, 0x3A, 0x94,
+  0x65, 0xC0, 0x7C, 0x63, 0x87, 0xF0, 0x3C, 0xAF,
+  0xD6, 0x25, 0xE4, 0x8B, 0x38, 0x0A, 0xAC, 0x72,
+  0x21, 0xD4, 0xF8, 0x07,
+]);
+
+function normalizeTitle(identity) {
+  const raw = String(identity?.name || identity?.executableBaseName || 'AURA RETRO')
+    .toUpperCase()
+    .replace(/[^A-Z0-9 _.-]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return raw.slice(0, HEADER_TITLE_END - HEADER_TITLE_OFFSET + 1);
+}
+
+function normalizeGameCode(identity) {
+  const stem = String(identity?.executableBaseName || identity?.name || 'AURA')
+    .toUpperCase()
+    .replace(/[^A-Z0-9]/g, '');
+  const middle = stem.slice(0, 2).padEnd(2, 'A');
+  return `A${middle}E`.slice(0, HEADER_GAME_CODE_END - HEADER_GAME_CODE_OFFSET + 1);
+}
+
+function writeAsciiField(rom, offset, endOffset, value) {
+  const bytes = Buffer.from(String(value || ''), 'ascii');
+  bytes.copy(rom, offset, 0, Math.min(bytes.length, endOffset - offset + 1));
+}
+
+function encodeArmBranch(sourceOffset, targetOffset) {
+  const delta = targetOffset - (sourceOffset + 8);
+  const word = (0xEA000000 | ((delta >> 2) & 0x00FFFFFF)) >>> 0;
+  return word;
+}
+
+function writeArmBranch(rom, sourceOffset, targetOffset) {
+  rom.writeUInt32LE(encodeArmBranch(sourceOffset, targetOffset), sourceOffset);
+}
+
+function createPlayableGbaRuntimeSource({ identity }) {
+  return [
+    'typedef unsigned int u32;',
+    'typedef unsigned short u16;',
+    '#define REG_DISPCNT (*(volatile u32*)0x04000000)',
+    '#define REG_VCOUNT (*(volatile u16*)0x04000006)',
+    '#define REG_KEYINPUT (*(volatile u16*)0x04000130)',
+    '#define VRAM ((volatile u16*)0x06000000)',
+    '#define MODE3 0x0003',
+    '#define BG2_ENABLE 0x0400',
+    '#define KEY_RIGHT 0x0010',
+    '#define KEY_LEFT  0x0020',
+    '#define KEY_UP    0x0040',
+    '#define KEY_DOWN  0x0080',
+    '#define RGB15(r,g,b) ((u16)((r) | ((g) << 5) | ((b) << 10)))',
+    '',
+    `/* Aura Retro GBA toy runtime for ${String(identity?.name || 'Aura Retro').replace(/\*\//g, '')}. */`,
+    '',
+    'static inline void wait_vblank(void) {',
+    '  while (REG_VCOUNT >= 160) {}',
+    '  while (REG_VCOUNT < 160) {}',
+    '}',
+    '',
+    'static inline int clamp_i(int value, int lo, int hi) {',
+    '  if (value < lo) return lo;',
+    '  if (value > hi) return hi;',
+    '  return value;',
+    '}',
+    '',
+    'static void fill_screen(u16 color) {',
+    '  for (int index = 0; index < 240 * 160; index += 1) {',
+    '    VRAM[index] = color;',
+    '  }',
+    '}',
+    '',
+    'static void draw_rect(int x, int y, int w, int h, u16 color) {',
+    '  int x0 = clamp_i(x, 0, 239);',
+    '  int y0 = clamp_i(y, 0, 159);',
+    '  int x1 = clamp_i(x + w, 0, 240);',
+    '  int y1 = clamp_i(y + h, 0, 160);',
+    '  for (int row = y0; row < y1; row += 1) {',
+    '    int offset = row * 240;',
+    '    for (int col = x0; col < x1; col += 1) {',
+    '      VRAM[offset + col] = color;',
+    '    }',
+    '  }',
+    '}',
+    '',
+    'static int overlaps(int ax, int ay, int aw, int ah, int bx, int by, int bw, int bh) {',
+    '  return ax < (bx + bw) && (ax + aw) > bx && ay < (by + bh) && (ay + ah) > by;',
+    '}',
+    '',
+    'void game_main(void) {',
+    '  int px = 24;',
+    '  int py = 24;',
+    '  int gx = 176;',
+    '  int gy = 104;',
+    '  int score = 0;',
+    '  int flash = 0;',
+    '  REG_DISPCNT = MODE3 | BG2_ENABLE;',
+    '  for (;;) {',
+    '    wait_vblank();',
+    '    u16 keys = (u16)(~REG_KEYINPUT) & 0x03FF;',
+    '    if (keys & KEY_LEFT) px -= 2;',
+    '    if (keys & KEY_RIGHT) px += 2;',
+    '    if (keys & KEY_UP) py -= 2;',
+    '    if (keys & KEY_DOWN) py += 2;',
+    '    px = clamp_i(px, 8, 220);',
+    '    py = clamp_i(py, 16, 140);',
+    '    if (overlaps(px, py, 12, 12, gx, gy, 12, 12)) {',
+    '      score += 1;',
+    '      flash = 10;',
+    '      gx += 37;',
+    '      gy += 23;',
+    '      if (gx > 208) gx = 24;',
+    '      if (gy > 136) gy = 24;',
+    '    }',
+    '    u16 bg = flash > 0 ? RGB15(2, 2, 8) : RGB15(0, 0, 0);',
+    '    if (flash > 0) flash -= 1;',
+    '    fill_screen(bg);',
+    '    draw_rect(6, 6, 12 + ((score & 15) * 8), 6, RGB15(31, 24, 0));',
+    '    draw_rect(gx, gy, 12, 12, RGB15(0, 31, 0));',
+    '    draw_rect(px, py, 12, 12, RGB15(31, 0, 0));',
+    '  }',
+    '}',
+    '',
+    '__attribute__((naked, section(".start"))) void _start(void) {',
+    '  __asm__ volatile(',
+    '    "ldr sp, =0x03007f00\\n"',
+    '    "bl game_main\\n"',
+    '    "b .\\n"',
+    '  );',
+    '}',
+    '',
+  ].join('\n');
+}
+
+function createGbaLinkerScript() {
+  return [
+    'ENTRY(_start)',
+    'MEMORY {',
+    `  rom (rx) : ORIGIN = 0x080000C0, LENGTH = ${LINK_ROM_SIZE_BYTES} - 0x0C0`,
+    '  iwram (rwx) : ORIGIN = 0x03000000, LENGTH = 32K',
+    '}',
+    'SECTIONS {',
+    '  .text : { KEEP(*(.start)) *(.text*) *(.rodata*) } > rom',
+    '  .bss (NOLOAD) : { *(.bss*) *(COMMON) } > iwram',
+    '  /DISCARD/ : { *(.ARM.exidx*) *(.comment*) *(.note*) *(.eh_frame*) *(.ARM.attributes) *(.data*) }',
+    '}',
+    '',
+  ].join('\n');
+}
+
+function resolveToolBinary(candidates = []) {
+  for (const candidate of candidates) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+export function resolveGameBoyAdvanceCompileToolchain() {
+  const clangPath = resolveToolBinary([
+    process.env.AURA_RETRO_GBA_CLANG,
+    '/opt/homebrew/opt/llvm/bin/clang',
+  ]);
+  const lldPath = resolveToolBinary([
+    process.env.AURA_RETRO_GBA_LLD,
+    '/opt/homebrew/opt/lld/bin/ld.lld',
+  ]);
+  const objcopyPath = resolveToolBinary([
+    process.env.AURA_RETRO_GBA_OBJCOPY,
+    '/opt/homebrew/opt/llvm/bin/llvm-objcopy',
+  ]);
+  const available = Boolean(clangPath && lldPath && objcopyPath);
+  return {
+    available,
+    clangPath,
+    lldPath,
+    objcopyPath,
+  };
+}
+
+function runToolchainStep(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: 'utf8',
+  });
+  if (result.status !== 0) {
+    const detail = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+    throw new Error(detail || `${command} failed with exit code ${result.status}`);
+  }
+}
+
+export function buildPlayableGameBoyAdvancePayload({
+  identity,
+  generatedDir,
+  entryFile,
+  ir,
+  assets,
+  logOutput = false,
+}) {
+  const toolchain = resolveGameBoyAdvanceCompileToolchain();
+  if (!toolchain.available) {
+    return {
+      ok: false,
+      mode: 'header-stub',
+      toolchain,
+    };
+  }
+
+  const runtimeSourcePath = resolve(generatedDir, 'cartridge-runtime-gba.c');
+  const linkerScriptPath = resolve(generatedDir, 'cartridge-runtime-gba.ld');
+  const objectPath = resolve(generatedDir, 'cartridge-runtime-gba.o');
+  const elfPath = resolve(generatedDir, 'cartridge-runtime-gba.elf');
+  const binaryPath = resolve(generatedDir, 'cartridge-runtime-gba.bin');
+  const runtimeSource = buildAuthoringBackedGbaRuntimeSource({
+    entryFile,
+    identity,
+    ir,
+    assets,
+  });
+
+  writeFileSync(runtimeSourcePath, runtimeSource, 'utf8');
+  writeFileSync(linkerScriptPath, createGbaLinkerScript(), 'utf8');
+
+  if (logOutput) {
+    console.log('  aura build: compiling GBA runtime source...');
+  }
+  runToolchainStep(toolchain.clangPath, [
+    '-target', 'armv4t-none-eabi',
+    '-mcpu=arm7tdmi',
+    '-marm',
+    '-ffreestanding',
+    '-fno-builtin',
+    '-fomit-frame-pointer',
+    '-fno-unwind-tables',
+    '-fno-asynchronous-unwind-tables',
+    '-fno-stack-protector',
+    '-Os',
+    '-nostdlib',
+    '-c',
+    runtimeSourcePath,
+    '-o',
+    objectPath,
+  ]);
+  if (logOutput) {
+    console.log('  aura build: linking GBA runtime...');
+  }
+  runToolchainStep(toolchain.lldPath, [
+    '-T',
+    linkerScriptPath,
+    objectPath,
+    '-o',
+    elfPath,
+  ]);
+  if (logOutput) {
+    console.log('  aura build: extracting GBA cartridge payload...');
+  }
+  runToolchainStep(toolchain.objcopyPath, [
+    '-O',
+    'binary',
+    elfPath,
+    binaryPath,
+  ]);
+
+  return {
+    ok: true,
+    mode: 'toolchain-compiled-authored-runtime',
+    toolchain,
+    runtimeSourcePath,
+    linkerScriptPath,
+    objectPath,
+    elfPath,
+    binaryPath,
+    payload: readFileSync(binaryPath),
+  };
+}
+
+export function computeGbaHeaderComplementCheck(rom) {
+  let checksum = 0;
+  for (let address = HEADER_TITLE_OFFSET; address <= HEADER_SOFTWARE_VERSION_OFFSET; address += 1) {
+    checksum = (checksum - rom[address]) & 0xFF;
+  }
+  return (checksum - 0x19) & 0xFF;
+}
+
+function roundUpToPowerOfTwo(value) {
+  let size = MIN_ROM_SIZE_BYTES;
+  while (size < value && size < MAX_ROM_SIZE_BYTES) {
+    size <<= 1;
+  }
+  return Math.min(size, MAX_ROM_SIZE_BYTES);
+}
+
+export function buildGameBoyAdvanceRom({ identity, targetProfile, ir, payload = null }) {
+  const normalizedPayload = Buffer.isBuffer(payload) ? payload : null;
+  const romSize = normalizedPayload && normalizedPayload.length > 0
+    ? roundUpToPowerOfTwo(ROM_CODE_OFFSET + normalizedPayload.length)
+    : MIN_ROM_SIZE_BYTES;
+  const rom = Buffer.alloc(romSize, 0x00);
+
+  writeArmBranch(rom, ROM_ENTRY_OFFSET, ROM_CODE_OFFSET);
+  Buffer.from(NINTENDO_LOGO).copy(rom, HEADER_LOGO_OFFSET);
+  writeAsciiField(rom, HEADER_TITLE_OFFSET, HEADER_TITLE_END, normalizeTitle(identity));
+  writeAsciiField(rom, HEADER_GAME_CODE_OFFSET, HEADER_GAME_CODE_END, normalizeGameCode(identity));
+  writeAsciiField(rom, HEADER_MAKER_CODE_OFFSET, HEADER_MAKER_CODE_END, 'HB');
+  rom[HEADER_FIXED_VALUE_OFFSET] = 0x96;
+  rom[HEADER_MAIN_UNIT_CODE_OFFSET] = 0x00;
+  rom[HEADER_DEVICE_TYPE_OFFSET] = 0x00;
+  rom[HEADER_SOFTWARE_VERSION_OFFSET] = 0x00;
+  rom[HEADER_COMPLEMENT_CHECK_OFFSET] = computeGbaHeaderComplementCheck(rom);
+
+  if (normalizedPayload && normalizedPayload.length > 0) {
+    normalizedPayload.copy(rom, ROM_CODE_OFFSET, 0, Math.min(normalizedPayload.length, rom.length - ROM_CODE_OFFSET));
+  } else {
+    writeArmBranch(rom, ROM_CODE_OFFSET, ROM_CODE_OFFSET);
+    const trace = Buffer.from(
+      `AURA:${targetProfile.target}:${ir.moduleCount}:${ir.runtimeOwnership.handles.join(',')}`,
+      'ascii',
+    );
+    trace.copy(rom, ROM_CODE_OFFSET + 4, 0, Math.min(trace.length, 160));
+  }
+  return rom;
+}

package/src/retro/backend-gbc/rom.mjs

@@ -0,0 +1,85 @@
+const ROM_SIZE_BYTES = 32 * 1024;
+const ENTRY_POINT_OFFSET = 0x0100;
+const ROM_BODY_OFFSET = 0x0150;
+const HEADER_TITLE_START = 0x0134;
+const HEADER_TITLE_END = 0x0142;
+const HEADER_CGB_FLAG = 0x0143;
+const HEADER_CHECKSUM_OFFSET = 0x014D;
+const GLOBAL_CHECKSUM_OFFSET = 0x014E;
+
+const NINTENDO_LOGO = Uint8Array.from([
+  0xCE, 0xED, 0x66, 0x66, 0xCC, 0x0D, 0x00, 0x0B,
+  0x03, 0x73, 0x00, 0x83, 0x00, 0x0C, 0x00, 0x0D,
+  0x00, 0x08, 0x11, 0x1F, 0x88, 0x89, 0x00, 0x0E,
+  0xDC, 0xCC, 0x6E, 0xE6, 0xDD, 0xDD, 0xD9, 0x99,
+  0xBB, 0xBB, 0x67, 0x63, 0x6E, 0x0E, 0xEC, 0xCC,
+  0xDD, 0xDC, 0x99, 0x9F, 0xBB, 0xB9, 0x33, 0x3E,
+]);
+
+export function computeHeaderChecksum(rom) {
+  let checksum = 0;
+  for (let address = 0x0134; address <= 0x014C; address += 1) {
+    checksum = (checksum - rom[address] - 1) & 0xFF;
+  }
+  return checksum;
+}
+
+export function computeGlobalChecksum(rom) {
+  let checksum = 0;
+  for (let index = 0; index < rom.length; index += 1) {
+    if (index === GLOBAL_CHECKSUM_OFFSET || index === (GLOBAL_CHECKSUM_OFFSET + 1)) {
+      continue;
+    }
+    checksum = (checksum + rom[index]) & 0xFFFF;
+  }
+  return checksum;
+}
+
+function normalizeTitle(identity) {
+  const raw = String(identity?.name || identity?.executableBaseName || 'AURA RETRO')
+    .toUpperCase()
+    .replace(/[^A-Z0-9 _.-]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return raw.slice(0, HEADER_TITLE_END - HEADER_TITLE_START + 1);
+}
+
+export function buildGameBoyRom({ identity, targetProfile, ir }) {
+  const rom = Buffer.alloc(ROM_SIZE_BYTES, 0x00);
+  rom[ENTRY_POINT_OFFSET + 0] = 0x00; // nop
+  rom[ENTRY_POINT_OFFSET + 1] = 0xC3; // jp $0150
+  rom[ENTRY_POINT_OFFSET + 2] = 0x50;
+  rom[ENTRY_POINT_OFFSET + 3] = 0x01;
+
+  Buffer.from(NINTENDO_LOGO).copy(rom, 0x0104);
+
+  const title = Buffer.from(normalizeTitle(identity), 'ascii');
+  title.copy(rom, HEADER_TITLE_START, 0, Math.min(title.length, HEADER_TITLE_END - HEADER_TITLE_START + 1));
+  rom[HEADER_CGB_FLAG] = targetProfile.target === 'gbc' ? 0x80 : 0x00;
+  rom[0x0144] = 0x00;
+  rom[0x0145] = 0x00;
+  rom[0x0146] = 0x00; // no SGB features
+  rom[0x0147] = 0x00; // ROM only
+  rom[0x0148] = 0x00; // 32 KiB
+  rom[0x0149] = 0x00; // no RAM
+  rom[0x014A] = 0x01; // overseas
+  rom[0x014B] = 0x00; // no old licensee
+  rom[0x014C] = 0x00; // version
+
+  // Minimal loop body. Future lowering can replace this with generated code.
+  rom[ROM_BODY_OFFSET + 0] = 0x18; // jr -2
+  rom[ROM_BODY_OFFSET + 1] = 0xFE;
+
+  // Encode a tiny trace of the validated build in an unused ROM region after the loop.
+  const trace = Buffer.from(
+    `AURA:${targetProfile.target}:${ir.moduleCount}:${ir.runtimeOwnership.handles.join(',')}`,
+    'ascii',
+  );
+  trace.copy(rom, ROM_BODY_OFFSET + 2, 0, Math.min(trace.length, 96));
+
+  rom[HEADER_CHECKSUM_OFFSET] = computeHeaderChecksum(rom);
+  const globalChecksum = computeGlobalChecksum(rom);
+  rom[GLOBAL_CHECKSUM_OFFSET] = (globalChecksum >> 8) & 0xFF;
+  rom[GLOBAL_CHECKSUM_OFFSET + 1] = globalChecksum & 0xFF;
+  return rom;
+}