@auraindustry/aurajs 0.0.7 → 0.1.0

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

@@ -0,0 +1,1029 @@
+import { readFileSync } from 'node:fs';
+
+function createCompileError(reason, detail) {
+  const error = new Error(`Aura Retro GBA authoring compile failed: ${reason}${detail ? ` (${detail})` : ''}`);
+  error.code = reason;
+  return error;
+}
+
+function walkBraces(source, startIndex, openChar, closeChar) {
+  let depth = 0;
+  let inString = null;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let index = startIndex; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1] || '';
+
+    if (inLineComment) {
+      if (char === '\n') inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === '*' && next === '/') {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (char === inString) {
+        inString = null;
+      }
+      continue;
+    }
+
+    if (char === '/' && next === '/') {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      inString = char;
+      continue;
+    }
+
+    if (char === openChar) {
+      depth += 1;
+      continue;
+    }
+    if (char === closeChar) {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+
+  throw createCompileError('retro_gba_authoring_parse_failed', `unmatched ${openChar}${closeChar} pair`);
+}
+
+function extractExportedStateSource(source) {
+  const match = /export\s+const\s+state\s*=\s*/m.exec(source);
+  if (!match) {
+    throw createCompileError('retro_gba_state_export_missing', 'export const state');
+  }
+  const braceIndex = source.indexOf('{', match.index);
+  if (braceIndex < 0) {
+    throw createCompileError('retro_gba_state_export_invalid', 'missing state object literal');
+  }
+  const endIndex = walkBraces(source, braceIndex, '{', '}');
+  return source.slice(braceIndex, endIndex + 1);
+}
+
+function extractFunctionBody(source, exportName) {
+  const matcher = new RegExp(`export\\s+function\\s+${exportName}\\s*\\([^)]*\\)\\s*\\{`, 'm');
+  const match = matcher.exec(source);
+  if (!match) return '';
+  const braceIndex = source.indexOf('{', match.index);
+  const endIndex = walkBraces(source, braceIndex, '{', '}');
+  return source.slice(braceIndex + 1, endIndex);
+}
+
+function loadAuthoringSource(entryFile) {
+  const source = readFileSync(entryFile, 'utf8');
+  const stateSource = extractExportedStateSource(source);
+  let stateValue = null;
+  try {
+    stateValue = Function(`"use strict"; return (${stateSource});`)();
+  } catch (error) {
+    throw createCompileError('retro_gba_state_literal_unsupported', error.message);
+  }
+  return {
+    source,
+    stateValue,
+    setupBody: extractFunctionBody(source, 'setup'),
+    updateBody: extractFunctionBody(source, 'update'),
+    drawBody: extractFunctionBody(source, 'draw'),
+  };
+}
+
+function flattenState(value, prefix = ['state'], entries = []) {
+  if (value == null || Array.isArray(value)) {
+    throw createCompileError('retro_gba_state_shape_unsupported', 'arrays and null are not supported');
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const path = [...prefix, key];
+    if (typeof child === 'number') {
+      entries.push({ path, type: 'number', initialValue: child });
+      continue;
+    }
+    if (typeof child === 'boolean') {
+      entries.push({ path, type: 'boolean', initialValue: child });
+      continue;
+    }
+    if (typeof child === 'string') {
+      entries.push({ path, type: 'string', initialValue: child });
+      continue;
+    }
+    if (typeof child === 'object' && child) {
+      flattenState(child, path, entries);
+      continue;
+    }
+    throw createCompileError('retro_gba_state_type_unsupported', `${path.join('.')} uses ${typeof child}`);
+  }
+  return entries;
+}
+
+function statePathToVariable(path) {
+  return path.join('__');
+}
+
+function createStateContext(stateEntries) {
+  const byPath = new Map();
+  for (const entry of stateEntries) {
+    byPath.set(entry.path.join('.'), {
+      ...entry,
+      variableName: statePathToVariable(entry.path),
+    });
+  }
+  return {
+    byPath,
+    stringVariables: new Set(
+      stateEntries
+        .filter((entry) => entry.type === 'string')
+        .map((entry) => statePathToVariable(entry.path)),
+    ),
+  };
+}
+
+function normalizeJsStringLiterals(expr) {
+  return expr.replace(/'([^'\\]*)'/g, (_, value) => JSON.stringify(value));
+}
+
+function mapInputButtonLiteral(rawValue) {
+  const normalized = String(rawValue).replace(/^['"`]|['"`]$/g, '').toLowerCase();
+  const lookup = {
+    a: 'AURA_KEY_A',
+    b: 'AURA_KEY_B',
+    select: 'AURA_KEY_SELECT',
+    start: 'AURA_KEY_START',
+    right: 'AURA_KEY_RIGHT',
+    left: 'AURA_KEY_LEFT',
+    up: 'AURA_KEY_UP',
+    down: 'AURA_KEY_DOWN',
+    r: 'AURA_KEY_R',
+    l: 'AURA_KEY_L',
+  };
+  if (!lookup[normalized]) {
+    throw createCompileError('retro_gba_input_button_unsupported', normalized);
+  }
+  return lookup[normalized];
+}
+
+function replaceStateReferences(expr, stateContext) {
+  return expr.replace(/\bstate(?:\.[A-Za-z_$][A-Za-z0-9_$]*)+\b/g, (match) => {
+    const key = match.replace(/\./g, '.');
+    const entry = stateContext.byPath.get(key);
+    if (!entry) {
+      throw createCompileError('retro_gba_state_reference_unknown', match);
+    }
+    return entry.variableName;
+  });
+}
+
+function replaceStringComparisons(expr, stateContext) {
+  let rendered = expr;
+  for (const variableName of stateContext.stringVariables) {
+    const escapedVar = variableName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    rendered = rendered.replace(
+      new RegExp(`\\b${escapedVar}\\b\\s*===\\s*(\"[^\"]*\")`, 'g'),
+      (_, literal) => `aura_str_eq(${variableName}, ${literal})`,
+    );
+    rendered = rendered.replace(
+      new RegExp(`(\"[^\"]*\")\\s*===\\s*\\b${escapedVar}\\b`, 'g'),
+      (_, literal) => `aura_str_eq(${literal}, ${variableName})`,
+    );
+    rendered = rendered.replace(
+      new RegExp(`\\b${escapedVar}\\b\\s*!==\\s*(\"[^\"]*\")`, 'g'),
+      (_, literal) => `(!aura_str_eq(${variableName}, ${literal}))`,
+    );
+    rendered = rendered.replace(
+      new RegExp(`(\"[^\"]*\")\\s*!==\\s*\\b${escapedVar}\\b`, 'g'),
+      (_, literal) => `(!aura_str_eq(${literal}, ${variableName}))`,
+    );
+  }
+  return rendered;
+}
+
+function emitCExpr(rawExpr, stateContext) {
+  let expr = String(rawExpr || '').trim();
+  if (!expr) {
+    throw createCompileError('retro_gba_expression_empty');
+  }
+  expr = normalizeJsStringLiterals(expr);
+  expr = expr.replace(/\baura\.input\.pressed\s*\(\s*("[^"]+")\s*\)/g, (_, value) => `aura_pressed(${mapInputButtonLiteral(value)})`);
+  expr = expr.replace(/\baura\.input\.justPressed\s*\(\s*("[^"]+")\s*\)/g, (_, value) => `aura_just_pressed(${mapInputButtonLiteral(value)})`);
+  expr = expr.replace(/\baura\.input\.repeatPressed\s*\(\s*("[^"]+")\s*\)/g, (_, value) => `aura_repeat_pressed(${mapInputButtonLiteral(value)})`);
+  expr = replaceStateReferences(expr, stateContext);
+  expr = replaceStringComparisons(expr, stateContext);
+  expr = expr.replace(/\btrue\b/g, '1');
+  expr = expr.replace(/\bfalse\b/g, '0');
+  expr = expr.replace(/!==/g, '!=');
+  expr = expr.replace(/===/g, '==');
+  return expr;
+}
+
+function parseTemplateLiteral(rawTemplate) {
+  const text = String(rawTemplate || '').trim();
+  if (!text.startsWith('`') || !text.endsWith('`')) {
+    throw createCompileError('retro_gba_template_literal_invalid', text);
+  }
+  const body = text.slice(1, -1);
+  const parts = [];
+  let literal = '';
+  for (let index = 0; index < body.length; index += 1) {
+    const char = body[index];
+    const next = body[index + 1] || '';
+    if (char === '$' && next === '{') {
+      if (literal) {
+        parts.push({ kind: 'literal', value: literal });
+        literal = '';
+      }
+      index += 2;
+      let depth = 1;
+      let expr = '';
+      for (; index < body.length; index += 1) {
+        const inner = body[index];
+        if (inner === '{') depth += 1;
+        if (inner === '}') {
+          depth -= 1;
+          if (depth === 0) break;
+        }
+        expr += inner;
+      }
+      parts.push({ kind: 'expression', value: expr.trim() });
+      continue;
+    }
+    literal += char;
+  }
+  if (literal) {
+    parts.push({ kind: 'literal', value: literal });
+  }
+  return parts;
+}
+
+function splitTopLevelArgs(source) {
+  const args = [];
+  let current = '';
+  let depthParen = 0;
+  let depthBrace = 0;
+  let depthBracket = 0;
+  let inString = null;
+  let escaped = false;
+
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    if (inString) {
+      current += char;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (char === inString) {
+        inString = null;
+      }
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      inString = char;
+      current += char;
+      continue;
+    }
+    if (char === '(') depthParen += 1;
+    if (char === ')') depthParen -= 1;
+    if (char === '{') depthBrace += 1;
+    if (char === '}') depthBrace -= 1;
+    if (char === '[') depthBracket += 1;
+    if (char === ']') depthBracket -= 1;
+    if (char === ',' && depthParen === 0 && depthBrace === 0 && depthBracket === 0) {
+      args.push(current.trim());
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) {
+    args.push(current.trim());
+  }
+  return args;
+}
+
+function parseCallStatement(source) {
+  const trimmed = String(source || '').trim().replace(/;$/, '');
+  const openIndex = trimmed.indexOf('(');
+  if (openIndex < 0 || !trimmed.endsWith(')')) {
+    throw createCompileError('retro_gba_call_statement_invalid', trimmed);
+  }
+  const callee = trimmed.slice(0, openIndex).trim();
+  const args = splitTopLevelArgs(trimmed.slice(openIndex + 1, -1));
+  return { callee, args };
+}
+
+function parseOptionsLiteral(rawOptions) {
+  if (!rawOptions) return {};
+  const text = String(rawOptions).trim();
+  if (!text.startsWith('{') || !text.endsWith('}')) return {};
+  const entries = splitTopLevelArgs(text.slice(1, -1));
+  const out = {};
+  for (const entry of entries) {
+    const colonIndex = entry.indexOf(':');
+    if (colonIndex < 0) continue;
+    const key = entry.slice(0, colonIndex).trim().replace(/^['"]|['"]$/g, '');
+    const value = entry.slice(colonIndex + 1).trim();
+    out[key] = value;
+  }
+  return out;
+}
+
+function stripLineComments(line) {
+  let inString = null;
+  let escaped = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    const next = line[index + 1] || '';
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (char === inString) {
+        inString = null;
+      }
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      inString = char;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      return line.slice(0, index);
+    }
+  }
+  return line;
+}
+
+function parseControlFlowBlock(bodySource) {
+  const lines = bodySource.split(/\r?\n/).map((line) => stripLineComments(line).trim()).filter(Boolean);
+
+  function readBlock(startIndex, insideBlock = false) {
+    const nodes = [];
+    let index = startIndex;
+
+    while (index < lines.length) {
+      const line = lines[index];
+      if (insideBlock && line === '}') {
+        return { nodes, nextIndex: index + 1 };
+      }
+      if (line.startsWith('} else')) {
+        throw createCompileError('retro_gba_else_unsupported', line);
+      }
+      if (line.startsWith('if')) {
+        const openParen = line.indexOf('(');
+        if (openParen < 0) {
+          throw createCompileError('retro_gba_if_invalid', line);
+        }
+        let depth = 0;
+        let closeParen = -1;
+        for (let scan = openParen; scan < line.length; scan += 1) {
+          if (line[scan] === '(') depth += 1;
+          if (line[scan] === ')') {
+            depth -= 1;
+            if (depth === 0) {
+              closeParen = scan;
+              break;
+            }
+          }
+        }
+        if (closeParen < 0) {
+          throw createCompileError('retro_gba_if_invalid', line);
+        }
+        const condition = line.slice(openParen + 1, closeParen).trim();
+        const remainder = line.slice(closeParen + 1).trim();
+        if (remainder === '{') {
+          const nested = readBlock(index + 1, true);
+          nodes.push({ kind: 'if', condition, consequent: nested.nodes });
+          index = nested.nextIndex;
+          continue;
+        }
+        if (remainder) {
+          nodes.push({ kind: 'if', condition, consequent: [{ kind: 'statement', source: remainder }] });
+          index += 1;
+          continue;
+        }
+        throw createCompileError('retro_gba_if_invalid', line);
+      }
+
+      nodes.push({ kind: 'statement', source: line });
+      index += 1;
+    }
+
+    if (insideBlock) {
+      throw createCompileError('retro_gba_block_invalid', 'missing closing brace');
+    }
+    return { nodes, nextIndex: index };
+  }
+
+  return readBlock(0, false).nodes;
+}
+
+function emitIndented(lines, indentLevel, source) {
+  const indent = '  '.repeat(indentLevel);
+  for (const line of source) {
+    lines.push(line ? `${indent}${line}` : '');
+  }
+}
+
+function compileSetupOrUpdateStatement(statementSource, stateContext) {
+  const trimmed = statementSource.trim().replace(/;$/, '');
+
+  if (/^state(?:\.[A-Za-z_$][A-Za-z0-9_$]*)+\s*(?:=|\+=|-=)/.test(trimmed)) {
+    const match = /^(state(?:\.[A-Za-z_$][A-Za-z0-9_$]*)+)\s*(=|\+=|-=)\s*(.+)$/.exec(trimmed);
+    if (!match) {
+      throw createCompileError('retro_gba_assignment_invalid', trimmed);
+    }
+    const entry = stateContext.byPath.get(match[1].replace(/\./g, '.'));
+    if (!entry) {
+      throw createCompileError('retro_gba_state_reference_unknown', match[1]);
+    }
+    const rhs = emitCExpr(match[3], stateContext);
+    if (entry.type === 'string' && match[2] !== '=') {
+      throw createCompileError('retro_gba_string_arithmetic_unsupported', trimmed);
+    }
+    const operator = match[2] === '=' ? '=' : match[2];
+    return [
+      `${entry.variableName} ${operator} ${rhs};`,
+      'aura_needs_redraw = 1;',
+    ];
+  }
+
+  const call = parseCallStatement(trimmed);
+  if (call.callee === 'aura.audio.playMusic') {
+    return [`aura_play_music(${emitCExpr(call.args[0], stateContext)});`];
+  }
+  if (call.callee === 'aura.audio.playSfx') {
+    return [`aura_play_sfx(${emitCExpr(call.args[0], stateContext)});`];
+  }
+  if (call.callee === 'aura.save.write') {
+    return [`aura_save_write(${emitCExpr(call.args[0], stateContext)});`];
+  }
+
+  throw createCompileError('retro_gba_setup_update_statement_unsupported', trimmed);
+}
+
+function emitTextBuilderLines(rawTextExpr, bufferName, stateContext) {
+  const expr = String(rawTextExpr).trim();
+  if (expr.startsWith('`')) {
+    const template = parseTemplateLiteral(expr);
+    const lines = [];
+    for (const part of template) {
+      if (part.kind === 'literal') {
+        lines.push(`aura_text_builder_append_literal(&${bufferName}, ${JSON.stringify(part.value)});`);
+        continue;
+      }
+      const emittedExpr = emitCExpr(part.value, stateContext);
+      const stateEntry = stateContext.byPath.get(part.value.replace(/\./g, '.'));
+      if (stateEntry?.type === 'string') {
+        lines.push(`aura_text_builder_append_literal(&${bufferName}, ${emittedExpr});`);
+      } else if (stateEntry?.type === 'boolean') {
+        lines.push(`aura_text_builder_append_literal(&${bufferName}, (${emittedExpr}) ? "TRUE" : "FALSE");`);
+      } else {
+        lines.push(`aura_text_builder_append_int(&${bufferName}, ${emittedExpr});`);
+      }
+    }
+    return lines;
+  }
+
+  const normalized = emitCExpr(expr, stateContext);
+  if (/^"/.test(normalized) || normalized.includes('?')) {
+    return [`aura_text_builder_append_literal(&${bufferName}, ${normalized});`];
+  }
+  for (const variableName of stateContext.stringVariables) {
+    if (normalized === variableName) {
+      return [`aura_text_builder_append_literal(&${bufferName}, ${normalized});`];
+    }
+  }
+  if (normalized === '1' || normalized === '0' || /\b(aura_pressed|aura_just_pressed|==|!=|>=|<=|>|<|&&|\|\|)\b/.test(normalized)) {
+    return [`aura_text_builder_append_literal(&${bufferName}, (${normalized}) ? "TRUE" : "FALSE");`];
+  }
+  return [`aura_text_builder_append_int(&${bufferName}, ${normalized});`];
+}
+
+function compileDrawStatement(statementSource, stateContext, counterRef) {
+  const trimmed = statementSource.trim().replace(/;$/, '');
+  const call = parseCallStatement(trimmed);
+
+  if (call.callee === 'aura.tilemap.setTile') {
+    const options = parseOptionsLiteral(call.args[4]);
+    const paletteValue = options.palette ? emitCExpr(options.palette, stateContext) : '0';
+    return [
+      `aura_draw_tile_by_id(${emitCExpr(call.args[3], stateContext)}, ${emitCExpr(call.args[1], stateContext)}, ${emitCExpr(call.args[2], stateContext)}, ${paletteValue});`,
+    ];
+  }
+
+  if (call.callee === 'aura.sprite.draw') {
+    const options = parseOptionsLiteral(call.args[3]);
+    const paletteValue = options.palette ? emitCExpr(options.palette, stateContext) : '0';
+    return [
+      `aura_draw_sprite_by_id(${emitCExpr(call.args[0], stateContext)}, ${emitCExpr(call.args[1], stateContext)}, ${emitCExpr(call.args[2], stateContext)}, ${paletteValue});`,
+    ];
+  }
+
+  if (call.callee === 'aura.text.write') {
+    const options = parseOptionsLiteral(call.args[3]);
+    const fontValue = options.font ? emitCExpr(options.font, stateContext) : '0';
+    const textIndex = counterRef.current;
+    counterRef.current += 1;
+    const bufferVar = `text_builder_${textIndex}`;
+    const charBuffer = `text_buffer_${textIndex}`;
+    return [
+      `char ${charBuffer}[64];`,
+      `AuraTextBuilder ${bufferVar};`,
+      `aura_text_builder_init(&${bufferVar}, ${charBuffer}, sizeof(${charBuffer}));`,
+      ...emitTextBuilderLines(call.args[0], bufferVar, stateContext),
+      `aura_draw_text_by_font(${fontValue}, ${charBuffer}, ${emitCExpr(call.args[1], stateContext)}, ${emitCExpr(call.args[2], stateContext)});`,
+    ];
+  }
+
+  throw createCompileError('retro_gba_draw_statement_unsupported', trimmed);
+}
+
+function compileNodes(nodes, stateContext, compileLeaf, indentLevel = 1, lines = [], counterRef = { current: 0 }) {
+  for (const node of nodes) {
+    if (node.kind === 'if') {
+      emitIndented(lines, indentLevel, [`if (${emitCExpr(node.condition, stateContext)}) {`]);
+      compileNodes(node.consequent, stateContext, compileLeaf, indentLevel + 1, lines, counterRef);
+      emitIndented(lines, indentLevel, ['}']);
+      continue;
+    }
+    emitIndented(lines, indentLevel, compileLeaf(node.source, stateContext, counterRef));
+  }
+  return lines;
+}
+
+function escapeCString(value) {
+  return JSON.stringify(String(value));
+}
+
+function hexColorToRgb15(hex) {
+  const text = String(hex || '').trim().replace(/^#/, '');
+  if (!/^[0-9a-fA-F]{6}$/.test(text)) {
+    throw createCompileError('retro_gba_palette_color_invalid', hex);
+  }
+  const red = Math.round(parseInt(text.slice(0, 2), 16) / 255 * 31);
+  const green = Math.round(parseInt(text.slice(2, 4), 16) / 255 * 31);
+  const blue = Math.round(parseInt(text.slice(4, 6), 16) / 255 * 31);
+  return `(u16)(${red} | (${green} << 5) | (${blue} << 10))`;
+}
+
+function emitAssetTables(assets) {
+  const lines = [];
+  let paletteBaseIndex = 0;
+
+  for (const palette of assets.palettes) {
+    lines.push(`static const u16 palette__${palette.id}[] = { ${palette.colors.map((entry) => hexColorToRgb15(entry)).join(', ')} };`);
+  }
+  lines.push('');
+  lines.push('typedef struct AuraPalette { const char* id; int colorCount; int baseIndex; const u16* colors; } AuraPalette;');
+  lines.push('static const AuraPalette AURA_PALETTES[] = {');
+  for (const palette of assets.palettes) {
+    lines.push(`  { ${escapeCString(palette.id)}, ${palette.colors.length}, ${paletteBaseIndex}, palette__${palette.id} },`);
+    paletteBaseIndex += palette.colors.length;
+  }
+  lines.push('};');
+  lines.push(`static const int AURA_PALETTE_COUNT = ${assets.palettes.length};`);
+  lines.push('');
+
+  const bitmaps = [
+    ...assets.tiles.map((entry) => ({ ...entry, category: 'tile' })),
+    ...assets.sprites.map((entry) => ({ ...entry, category: 'sprite' })),
+  ];
+  for (const bitmap of bitmaps) {
+    lines.push(`static const char* const ${bitmap.category}__${bitmap.id}__rows[] = {`);
+    for (const row of bitmap.pixels) {
+      lines.push(`  ${escapeCString(row)},`);
+    }
+    lines.push('};');
+  }
+  lines.push('');
+  lines.push('typedef struct AuraBitmap { const char* id; const char* paletteId; int width; int height; const char* const* rows; } AuraBitmap;');
+  lines.push('static const AuraBitmap AURA_TILES[] = {');
+  for (const tile of assets.tiles) {
+    lines.push(`  { ${escapeCString(tile.id)}, ${escapeCString(tile.palette || assets.palettes[0]?.id || '')}, ${tile.width}, ${tile.height}, tile__${tile.id}__rows },`);
+  }
+  lines.push('};');
+  lines.push(`static const int AURA_TILE_COUNT = ${assets.tiles.length};`);
+  lines.push('static const AuraBitmap AURA_SPRITES[] = {');
+  for (const sprite of assets.sprites) {
+    lines.push(`  { ${escapeCString(sprite.id)}, ${escapeCString(sprite.palette || assets.palettes[0]?.id || '')}, ${sprite.width}, ${sprite.height}, sprite__${sprite.id}__rows },`);
+  }
+  lines.push('};');
+  lines.push(`static const int AURA_SPRITE_COUNT = ${assets.sprites.length};`);
+  lines.push('');
+
+  lines.push('typedef struct AuraGlyph { char symbol; int width; int height; const char* const* rows; } AuraGlyph;');
+  lines.push('typedef struct AuraFont { const char* id; int width; int height; int glyphCount; const AuraGlyph* glyphs; } AuraFont;');
+  for (const font of assets.fonts) {
+    for (const [glyph, rows] of Object.entries(font.glyphs)) {
+      lines.push(`static const char* const font__${font.id}__${glyph.charCodeAt(0)}__rows[] = {`);
+      for (const row of rows) {
+        lines.push(`  ${escapeCString(row)},`);
+      }
+      lines.push('};');
+    }
+    lines.push(`static const AuraGlyph font__${font.id}__glyphs[] = {`);
+    for (const [glyph, rows] of Object.entries(font.glyphs)) {
+      lines.push(`  { '${glyph.replace(/'/g, "\\'")}', ${font.width}, ${font.height}, font__${font.id}__${glyph.charCodeAt(0)}__rows },`);
+    }
+    lines.push('};');
+  }
+  lines.push('static const AuraFont AURA_FONTS[] = {');
+  for (const font of assets.fonts) {
+    lines.push(`  { ${escapeCString(font.id)}, ${font.width}, ${font.height}, ${Object.keys(font.glyphs).length}, font__${font.id}__glyphs },`);
+  }
+  lines.push('};');
+  lines.push(`static const int AURA_FONT_COUNT = ${assets.fonts.length};`);
+
+  return lines;
+}
+
+function emitStateDeclarations(stateEntries) {
+  const lines = [];
+  for (const entry of stateEntries) {
+    const variableName = statePathToVariable(entry.path);
+    if (entry.type === 'string') {
+      lines.push(`static const char* ${variableName};`);
+      continue;
+    }
+    lines.push(`static int ${variableName};`);
+  }
+  return lines;
+}
+
+function emitStateInitialization(stateEntries) {
+  const lines = ['static void aura_init_state(void) {'];
+  for (const entry of stateEntries) {
+    const variableName = statePathToVariable(entry.path);
+    if (entry.type === 'string') {
+      lines.push(`  ${variableName} = ${escapeCString(entry.initialValue)};`);
+      continue;
+    }
+    if (entry.type === 'boolean') {
+      lines.push(`  ${variableName} = ${entry.initialValue ? 1 : 0};`);
+      continue;
+    }
+    lines.push(`  ${variableName} = ${Math.trunc(entry.initialValue)};`);
+  }
+  lines.push('}');
+  lines.push('');
+  return lines;
+}
+
+function emitRuntimeSupport(assets) {
+  const fallbackPalette = assets.palettes[0]?.id || '';
+  const fallbackFont = assets.fonts[0]?.id || '';
+  return [
+    'typedef unsigned int u32;',
+    'typedef unsigned short u16;',
+    'typedef unsigned char u8;',
+    '#define REG_DISPCNT (*(volatile u16*)0x04000000)',
+    '#define REG_VCOUNT (*(volatile u16*)0x04000006)',
+    '#define REG_KEYINPUT (*(volatile u16*)0x04000130)',
+    '#define PAL_BG ((volatile u16*)0x05000000)',
+    '#define VRAM_FRONT ((volatile u16*)0x06000000)',
+    '#define VRAM_BACK ((volatile u16*)0x0600A000)',
+    '#define MODE4 0x0004',
+    '#define BG2_ENABLE 0x0400',
+    '#define BACKBUFFER 0x0010',
+    '#define AURA_KEY_A 0x0001',
+    '#define AURA_KEY_B 0x0002',
+    '#define AURA_KEY_SELECT 0x0004',
+    '#define AURA_KEY_START 0x0008',
+    '#define AURA_KEY_RIGHT 0x0010',
+    '#define AURA_KEY_LEFT 0x0020',
+    '#define AURA_KEY_UP 0x0040',
+    '#define AURA_KEY_DOWN 0x0080',
+    '#define AURA_KEY_R 0x0100',
+    '#define AURA_KEY_L 0x0200',
+    '',
+    'static u16 aura_keys_current = 0;',
+    'static u16 aura_keys_previous = 0;',
+    'static int aura_left_frames = 0;',
+    'static int aura_right_frames = 0;',
+    'static int aura_up_frames = 0;',
+    'static int aura_down_frames = 0;',
+    'static int aura_needs_redraw;',
+    'static int aura_displaying_back_buffer;',
+    'static volatile u16* aura_draw_buffer;',
+    '',
+    'typedef struct AuraTextBuilder { char* data; int capacity; int length; } AuraTextBuilder;',
+    '',
+    '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 int aura_str_eq(const char* left, const char* right) {',
+    '  int index = 0;',
+    '  if (!left || !right) return left == right;',
+    '  while (left[index] && right[index]) {',
+    '    if (left[index] != right[index]) return 0;',
+    '    index += 1;',
+    '  }',
+    '  return left[index] == right[index];',
+    '}',
+    '',
+    'static int aura_pressed(int mask) { return (aura_keys_current & mask) != 0; }',
+    'static void aura_update_repeat_frames(void) {',
+    '  aura_left_frames = (aura_keys_current & AURA_KEY_LEFT) ? (aura_left_frames + 1) : 0;',
+    '  aura_right_frames = (aura_keys_current & AURA_KEY_RIGHT) ? (aura_right_frames + 1) : 0;',
+    '  aura_up_frames = (aura_keys_current & AURA_KEY_UP) ? (aura_up_frames + 1) : 0;',
+    '  aura_down_frames = (aura_keys_current & AURA_KEY_DOWN) ? (aura_down_frames + 1) : 0;',
+    '}',
+    'static int aura_repeat_triggered(int frames) {',
+    '  return frames == 1 || frames >= 3;',
+    '}',
+    'static int aura_just_pressed(int mask) {',
+    '  return (aura_keys_current & mask) != 0 && (aura_keys_previous & mask) == 0;',
+    '}',
+    'static int aura_repeat_pressed(int mask) {',
+    '  if (mask == AURA_KEY_LEFT) return aura_repeat_triggered(aura_left_frames);',
+    '  if (mask == AURA_KEY_RIGHT) return aura_repeat_triggered(aura_right_frames);',
+    '  if (mask == AURA_KEY_UP) return aura_repeat_triggered(aura_up_frames);',
+    '  if (mask == AURA_KEY_DOWN) return aura_repeat_triggered(aura_down_frames);',
+    '  return aura_just_pressed(mask);',
+    '}',
+    '',
+    'static void fill_screen(u8 colorIndex) {',
+    '  u16 packed = (u16)(colorIndex | ((u16)colorIndex << 8));',
+    '  for (int index = 0; index < (240 * 160) / 2; index += 1) {',
+    '    aura_draw_buffer[index] = packed;',
+    '  }',
+    '}',
+    '',
+    'static void put_pixel(int x, int y, u8 colorIndex) {',
+    '  if (x < 0 || x >= 240 || y < 0 || y >= 160) return;',
+    '  int offset = (y * 240) + x;',
+    '  int wordIndex = offset >> 1;',
+    '  u16 word = aura_draw_buffer[wordIndex];',
+    '  if ((offset & 1) == 0) {',
+    '    word = (u16)((word & 0xFF00) | colorIndex);',
+    '  } else {',
+    '    word = (u16)((word & 0x00FF) | ((u16)colorIndex << 8));',
+    '  }',
+    '  aura_draw_buffer[wordIndex] = word;',
+    '}',
+    '',
+    'static void aura_present(void) {',
+    '  if (aura_displaying_back_buffer) {',
+    '    REG_DISPCNT = MODE4 | BG2_ENABLE;',
+    '    aura_draw_buffer = VRAM_BACK;',
+    '    aura_displaying_back_buffer = 0;',
+    '    return;',
+    '  }',
+    '  REG_DISPCNT = MODE4 | BG2_ENABLE | BACKBUFFER;',
+    '  aura_draw_buffer = VRAM_FRONT;',
+    '  aura_displaying_back_buffer = 1;',
+    '}',
+    '',
+    ...emitAssetTables(assets),
+    '',
+    'static void aura_load_palette(void) {',
+    '  for (int index = 0; index < 256; index += 1) {',
+    '    PAL_BG[index] = 0;',
+    '  }',
+    '  for (int paletteIndex = 0; paletteIndex < AURA_PALETTE_COUNT; paletteIndex += 1) {',
+    '    const AuraPalette* palette = &AURA_PALETTES[paletteIndex];',
+    '    for (int colorIndex = 0; colorIndex < palette->colorCount; colorIndex += 1) {',
+    '      int slot = palette->baseIndex + colorIndex;',
+    '      if (slot >= 0 && slot < 256) {',
+    '        PAL_BG[slot] = palette->colors[colorIndex];',
+    '      }',
+    '    }',
+    '  }',
+    '}',
+    '',
+    'static const AuraPalette* aura_find_palette(const char* id) {',
+    '  for (int index = 0; index < AURA_PALETTE_COUNT; index += 1) {',
+    '    if (aura_str_eq(AURA_PALETTES[index].id, id)) return &AURA_PALETTES[index];',
+    '  }',
+    '  return AURA_PALETTE_COUNT > 0 ? &AURA_PALETTES[0] : 0;',
+    '}',
+    '',
+    'static const AuraBitmap* aura_find_tile(const char* id) {',
+    '  for (int index = 0; index < AURA_TILE_COUNT; index += 1) {',
+    '    if (aura_str_eq(AURA_TILES[index].id, id)) return &AURA_TILES[index];',
+    '  }',
+    '  return 0;',
+    '}',
+    '',
+    'static const AuraBitmap* aura_find_sprite(const char* id) {',
+    '  for (int index = 0; index < AURA_SPRITE_COUNT; index += 1) {',
+    '    if (aura_str_eq(AURA_SPRITES[index].id, id)) return &AURA_SPRITES[index];',
+    '  }',
+    '  return 0;',
+    '}',
+    '',
+    'static const AuraFont* aura_find_font(const char* id) {',
+    `  const char* fallback = ${escapeCString(fallbackFont)};`,
+    '  const char* needle = id ? id : fallback;',
+    '  for (int index = 0; index < AURA_FONT_COUNT; index += 1) {',
+    '    if (aura_str_eq(AURA_FONTS[index].id, needle)) return &AURA_FONTS[index];',
+    '  }',
+    '  return AURA_FONT_COUNT > 0 ? &AURA_FONTS[0] : 0;',
+    '}',
+    '',
+    'static const AuraGlyph* aura_find_glyph(const AuraFont* font, char symbol) {',
+    '  if (!font) return 0;',
+    '  for (int index = 0; index < font->glyphCount; index += 1) {',
+    '    if (font->glyphs[index].symbol == symbol) return &font->glyphs[index];',
+    '  }',
+    '  return 0;',
+    '}',
+    '',
+    'static void aura_draw_bitmap_rows(const char* const* rows, int width, int height, const AuraPalette* palette, int x, int y, int transparentDots) {',
+    '  for (int row = 0; row < height; row += 1) {',
+    '    const char* pixels = rows[row];',
+    '    for (int col = 0; col < width; col += 1) {',
+    '      char pixel = pixels[col];',
+    '      if (pixel == \'.\' && transparentDots) continue;',
+      '      int paletteIndex = pixel == \'.\' ? 0 : (pixel - \'0\');',
+    '      if (paletteIndex < 0 || !palette || paletteIndex >= palette->colorCount) continue;',
+    '      int colorIndex = palette->baseIndex + paletteIndex;',
+    '      if (colorIndex < 0 || colorIndex >= 256) continue;',
+    '      put_pixel(x + col, y + row, (u8)colorIndex);',
+    '    }',
+    '  }',
+    '}',
+    '',
+    'static void aura_draw_tile_by_id(const char* tileId, int tileX, int tileY, const char* paletteOverride) {',
+    '  const AuraBitmap* tile = aura_find_tile(tileId);',
+    '  const AuraPalette* palette = aura_find_palette(paletteOverride ? paletteOverride : (tile ? tile->paletteId : 0));',
+    '  if (!tile || !palette) return;',
+    '  aura_draw_bitmap_rows(tile->rows, tile->width, tile->height, palette, tileX * 8, tileY * 8, 0);',
+    '}',
+    '',
+    'static void aura_draw_sprite_by_id(const char* spriteId, int x, int y, const char* paletteOverride) {',
+    '  const AuraBitmap* sprite = aura_find_sprite(spriteId);',
+    '  const AuraPalette* palette = aura_find_palette(paletteOverride ? paletteOverride : (sprite ? sprite->paletteId : 0));',
+    '  if (!sprite || !palette) return;',
+    '  aura_draw_bitmap_rows(sprite->rows, sprite->width, sprite->height, palette, x, y, 1);',
+    '}',
+    '',
+    'static void aura_text_builder_init(AuraTextBuilder* builder, char* data, int capacity) {',
+    '  builder->data = data;',
+    '  builder->capacity = capacity;',
+    '  builder->length = 0;',
+    '  if (capacity > 0) builder->data[0] = 0;',
+    '}',
+    '',
+    'static void aura_text_builder_append_char(AuraTextBuilder* builder, char value) {',
+    '  if (builder->length + 1 >= builder->capacity) return;',
+    '  builder->data[builder->length] = value;',
+    '  builder->length += 1;',
+    '  builder->data[builder->length] = 0;',
+    '}',
+    '',
+    'static void aura_text_builder_append_literal(AuraTextBuilder* builder, const char* text) {',
+    '  if (!text) return;',
+    '  for (int index = 0; text[index]; index += 1) {',
+    '    aura_text_builder_append_char(builder, text[index]);',
+    '  }',
+    '}',
+    '',
+    'static void aura_text_builder_append_int(AuraTextBuilder* builder, int value) {',
+    '  char digits[16];',
+    '  int index = 0;',
+    '  int negative = value < 0;',
+    '  unsigned int cursor = negative ? (unsigned int)(-value) : (unsigned int)value;',
+    '  if (value == 0) { aura_text_builder_append_char(builder, \'0\'); return; }',
+    '  while (cursor > 0 && index < 15) {',
+    '    digits[index++] = (char)(\'0\' + (cursor % 10));',
+    '    cursor /= 10;',
+    '  }',
+    '  if (negative) aura_text_builder_append_char(builder, \'-\');',
+    '  while (index > 0) {',
+    '    aura_text_builder_append_char(builder, digits[--index]);',
+    '  }',
+    '}',
+    '',
+    'static void aura_draw_text_by_font(const char* fontId, const char* text, int x, int y) {',
+    '  const AuraFont* font = aura_find_font(fontId);',
+    `  const AuraPalette* palette = aura_find_palette(${escapeCString(fallbackPalette)});`,
+    '  int cursorX = x;',
+    '  if (!font || !palette || !text) return;',
+    '  for (int index = 0; text[index]; index += 1) {',
+    '    char symbol = text[index];',
+    '    const AuraGlyph* glyph = aura_find_glyph(font, symbol);',
+    '    if (!glyph) glyph = aura_find_glyph(font, (char)(symbol >= \'a\' && symbol <= \'z\' ? (symbol - 32) : symbol));',
+    '    if (glyph) {',
+    '      aura_draw_bitmap_rows(glyph->rows, glyph->width, glyph->height, palette, cursorX, y, 1);',
+    '    }',
+    '    cursorX += font->width + 1;',
+    '  }',
+    '}',
+    '',
+    'static void aura_play_music(const char* trackId) { (void)trackId; }',
+    'static void aura_play_sfx(const char* effectId) { (void)effectId; }',
+    'static void aura_save_write(const char* key) { (void)key; }',
+    '',
+  ];
+}
+
+function emitFunction(name, nodes, stateContext, compileLeaf) {
+  const lines = [`static void ${name}(void) {`];
+  compileNodes(nodes, stateContext, compileLeaf, 1, lines, { current: 0 });
+  lines.push('}');
+  lines.push('');
+  return lines;
+}
+
+export function buildAuthoringBackedGbaRuntimeSource({ entryFile, identity, ir, assets }) {
+  if (ir.moduleCount !== 1) {
+    throw createCompileError('retro_gba_multi_module_unsupported', `moduleCount=${ir.moduleCount}`);
+  }
+
+  const authoring = loadAuthoringSource(entryFile);
+  const stateEntries = flattenState(authoring.stateValue, ['state']);
+  const stateContext = createStateContext(stateEntries);
+  const setupNodes = parseControlFlowBlock(authoring.setupBody);
+  const updateNodes = parseControlFlowBlock(authoring.updateBody);
+  const drawNodes = parseControlFlowBlock(authoring.drawBody);
+
+  const lines = [
+    '/*',
+    ` * Aura Retro GBA authored runtime for ${String(identity?.name || 'Aura Retro').replace(/\*\//g, '')}.`,
+    ' * Generated from the current retro-safe entry module.',
+    ' */',
+    '',
+    ...emitRuntimeSupport(assets),
+    ...emitStateDeclarations(stateEntries),
+    '',
+    ...emitStateInitialization(stateEntries),
+    ...emitFunction('aura_setup', setupNodes, stateContext, compileSetupOrUpdateStatement),
+    ...emitFunction('aura_update', updateNodes, stateContext, compileSetupOrUpdateStatement),
+    ...emitFunction('aura_draw', drawNodes, stateContext, compileDrawStatement),
+    '__attribute__((naked, section(".start"))) void _start(void) {',
+    '  __asm__ volatile(',
+    '    "ldr sp, =0x03007f00\\n"',
+    '    "bl aura_main\\n"',
+    '    "b .\\n"',
+    '  );',
+    '}',
+    '',
+    'void aura_main(void) {',
+    '  REG_DISPCNT = MODE4 | BG2_ENABLE;',
+    '  aura_draw_buffer = VRAM_BACK;',
+    '  aura_displaying_back_buffer = 0;',
+    '  aura_needs_redraw = 1;',
+    '  aura_load_palette();',
+    '  aura_init_state();',
+    '  aura_setup();',
+    '  for (;;) {',
+    '    wait_vblank();',
+    '    aura_keys_previous = aura_keys_current;',
+    '    aura_keys_current = (u16)(~REG_KEYINPUT) & 0x03FF;',
+    '    aura_update_repeat_frames();',
+    '    if (aura_keys_current != aura_keys_previous) aura_needs_redraw = 1;',
+    '    aura_update();',
+    '    if (!aura_needs_redraw) continue;',
+    '    fill_screen(0);',
+    '    aura_draw();',
+    '    aura_present();',
+    '    aura_needs_redraw = 0;',
+    '  }',
+    '}',
+    '',
+  ];
+
+  return lines.join('\n');
+}