@auraindustry/aurajs 0.0.7 → 0.1.0

package/src/retro/runtime-gba/contract.mjs

@@ -0,0 +1,151 @@
+const REPEATABLE_BUTTONS = ['left', 'right', 'up', 'down'];
+
+function repeatTriggered(frames) {
+  return frames === 1 || frames >= 3;
+}
+
+function normalizeInputState(value = {}, previousRepeatFrames = Object.create(null)) {
+  const pressed = new Set(Array.isArray(value.pressed) ? value.pressed.map((entry) => String(entry)) : []);
+  const justPressed = new Set(Array.isArray(value.justPressed) ? value.justPressed.map((entry) => String(entry)) : []);
+  const explicitRepeatPressed = new Set(Array.isArray(value.repeatPressed) ? value.repeatPressed.map((entry) => String(entry)) : []);
+  const repeatFrames = Object.create(null);
+  const repeatPressed = new Set(explicitRepeatPressed);
+  for (const button of REPEATABLE_BUTTONS) {
+    const nextFrames = pressed.has(button) ? ((previousRepeatFrames[button] || 0) + 1) : 0;
+    repeatFrames[button] = nextFrames;
+    if (repeatTriggered(nextFrames)) {
+      repeatPressed.add(button);
+    }
+  }
+  return {
+    repeatFrames,
+    pressed(button) {
+      return pressed.has(String(button));
+    },
+    justPressed(button) {
+      return justPressed.has(String(button));
+    },
+    repeatPressed(button) {
+      return repeatPressed.has(String(button));
+    },
+  };
+}
+
+function emptyFrameState() {
+  return {
+    backgrounds: [],
+    sprites: [],
+    text: [],
+    audio: [],
+    saveWrites: [],
+  };
+}
+
+export function createGbaRuntimeContract() {
+  const runtime = {
+    frame: 0,
+    setupRan: false,
+    input: normalizeInputState(),
+    repeatFrames: Object.create(null),
+    saveStore: Object.create(null),
+    frameState: emptyFrameState(),
+  };
+
+  const aura = {
+    input: {
+      pressed(button) {
+        return runtime.input.pressed(button);
+      },
+      justPressed(button) {
+        return runtime.input.justPressed(button);
+      },
+      repeatPressed(button) {
+        return runtime.input.repeatPressed(button);
+      },
+    },
+    tilemap: {
+      setTile(layer, x, y, tile, options = {}) {
+        runtime.frameState.backgrounds.push({
+          kind: 'tile',
+          layer: String(layer),
+          x: Number(x),
+          y: Number(y),
+          tile: String(tile),
+          options: { ...options },
+        });
+      },
+    },
+    sprite: {
+      draw(spriteId, x, y, options = {}) {
+        runtime.frameState.sprites.push({
+          spriteId: String(spriteId),
+          x: Number(x),
+          y: Number(y),
+          options: { ...options },
+        });
+      },
+    },
+    text: {
+      write(text, x, y, options = {}) {
+        runtime.frameState.text.push({
+          text: String(text),
+          x: Number(x),
+          y: Number(y),
+          options: { ...options },
+        });
+      },
+    },
+    audio: {
+      playMusic(trackId) {
+        runtime.frameState.audio.push({ kind: 'music', trackId: String(trackId) });
+      },
+      playSfx(effectId) {
+        runtime.frameState.audio.push({ kind: 'sfx', effectId: String(effectId) });
+      },
+    },
+    save: {
+      write(key, value) {
+        runtime.saveStore[String(key)] = value;
+        runtime.frameState.saveWrites.push({ key: String(key), value });
+      },
+      read(key) {
+        return runtime.saveStore[String(key)] ?? null;
+      },
+    },
+  };
+
+  function snapshot() {
+    return {
+      frame: runtime.frame,
+      setupRan: runtime.setupRan,
+      target: 'gba',
+      backgrounds: runtime.frameState.backgrounds.slice(),
+      sprites: runtime.frameState.sprites.slice(),
+      text: runtime.frameState.text.slice(),
+      audio: runtime.frameState.audio.slice(),
+      saveWrites: runtime.frameState.saveWrites.slice(),
+      saveStore: { ...runtime.saveStore },
+    };
+  }
+
+  return {
+    aura,
+    step(program, inputState = {}) {
+      runtime.frame += 1;
+      runtime.input = normalizeInputState(inputState, runtime.repeatFrames);
+      runtime.repeatFrames = runtime.input.repeatFrames;
+      runtime.frameState = emptyFrameState();
+      if (!runtime.setupRan && typeof program.setup === 'function') {
+        program.setup(aura);
+        runtime.setupRan = true;
+      }
+      if (typeof program.update === 'function') {
+        program.update(aura);
+      }
+      if (typeof program.draw === 'function') {
+        program.draw(aura);
+      }
+      return snapshot();
+    },
+  };
+}

package/src/retro/runtime-gbc/contract.mjs

@@ -0,0 +1,117 @@
+function normalizeInputState(value = {}) {
+  const pressed = new Set(Array.isArray(value.pressed) ? value.pressed.map((entry) => String(entry)) : []);
+  return {
+    pressed(button) {
+      return pressed.has(String(button));
+    },
+  };
+}
+
+function emptyFrameState() {
+  return {
+    background: [],
+    sprites: [],
+    text: [],
+    audio: [],
+    saveWrites: [],
+  };
+}
+
+export function createGbcRuntimeContract() {
+  const runtime = {
+    frame: 0,
+    setupRan: false,
+    input: normalizeInputState(),
+    saveStore: Object.create(null),
+    frameState: emptyFrameState(),
+  };
+
+  const aura = {
+    input: {
+      pressed(button) {
+        return runtime.input.pressed(button);
+      },
+    },
+    tilemap: {
+      setTile(layer, x, y, tile) {
+        runtime.frameState.background.push({
+          kind: 'tile',
+          layer: String(layer),
+          x: Number(x),
+          y: Number(y),
+          tile: String(tile),
+        });
+      },
+    },
+    sprite: {
+      draw(spriteId, x, y, options = {}) {
+        runtime.frameState.sprites.push({
+          spriteId: String(spriteId),
+          x: Number(x),
+          y: Number(y),
+          options: { ...options },
+        });
+      },
+    },
+    text: {
+      write(text, x, y, options = {}) {
+        runtime.frameState.text.push({
+          text: String(text),
+          x: Number(x),
+          y: Number(y),
+          options: { ...options },
+        });
+      },
+    },
+    audio: {
+      playMusic(trackId) {
+        runtime.frameState.audio.push({ kind: 'music', trackId: String(trackId) });
+      },
+      playSfx(effectId) {
+        runtime.frameState.audio.push({ kind: 'sfx', effectId: String(effectId) });
+      },
+    },
+    save: {
+      write(key, value) {
+        runtime.saveStore[String(key)] = value;
+        runtime.frameState.saveWrites.push({ key: String(key), value });
+      },
+      read(key) {
+        return runtime.saveStore[String(key)] ?? null;
+      },
+    },
+  };
+
+  function snapshot() {
+    return {
+      frame: runtime.frame,
+      setupRan: runtime.setupRan,
+      background: runtime.frameState.background.slice(),
+      sprites: runtime.frameState.sprites.slice(),
+      text: runtime.frameState.text.slice(),
+      audio: runtime.frameState.audio.slice(),
+      saveWrites: runtime.frameState.saveWrites.slice(),
+      saveStore: { ...runtime.saveStore },
+    };
+  }
+
+  return {
+    aura,
+    step(program, inputState = {}) {
+      runtime.frame += 1;
+      runtime.input = normalizeInputState(inputState);
+      runtime.frameState = emptyFrameState();
+      if (!runtime.setupRan && typeof program.setup === 'function') {
+        program.setup(aura);
+        runtime.setupRan = true;
+      }
+      if (typeof program.update === 'function') {
+        program.update(aura);
+      }
+      if (typeof program.draw === 'function') {
+        program.draw(aura);
+      }
+      return snapshot();
+    },
+  };
+}

package/src/retro/shared/span.mjs

@@ -0,0 +1,26 @@
+import { relative, sep } from 'node:path';
+
+export function lineColumnFromIndex(code, index) {
+  const normalizedIndex = Math.max(0, Number(index) || 0);
+  const slice = String(code || '').slice(0, normalizedIndex);
+  const lines = slice.split(/\r?\n/);
+  const line = lines.length;
+  const column = lines[lines.length - 1].length + 1;
+  return { line, column };
+}
+
+export function spanFromIndex(code, index, width = 1) {
+  const start = lineColumnFromIndex(code, index);
+  const end = lineColumnFromIndex(code, index + Math.max(1, width));
+  return {
+    line: start.line,
+    column: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+  };
+}
+
+export function relFile(projectRoot, filePath) {
+  const rel = relative(projectRoot, filePath);
+  return rel.split(sep).join('/');
+}

package/src/retro/shared/targets.mjs

@@ -0,0 +1,64 @@
+export const RETRO_TARGET_PROFILES = Object.freeze({
+  gb: Object.freeze({
+    target: 'gb',
+    displayName: 'Game Boy',
+    family: 'gb',
+    architecture: 'sm83',
+    colorMode: 'mono',
+    suggestedToolchain: 'gbdk-2020',
+    outputExtension: '.gb',
+    budgets: Object.freeze({
+      palettes: 1,
+      tiles: 192,
+      sprites: 40,
+      fonts: 2,
+      glyphsPerFont: 96,
+    }),
+  }),
+  gbc: Object.freeze({
+    target: 'gbc',
+    displayName: 'Game Boy Color',
+    family: 'gb',
+    architecture: 'sm83',
+    colorMode: 'color',
+    suggestedToolchain: 'gbdk-2020',
+    outputExtension: '.gbc',
+    budgets: Object.freeze({
+      palettes: 8,
+      tiles: 256,
+      sprites: 40,
+      fonts: 2,
+      glyphsPerFont: 96,
+    }),
+  }),
+  gba: Object.freeze({
+    target: 'gba',
+    displayName: 'Game Boy Advance',
+    family: 'gba',
+    architecture: 'arm7tdmi',
+    colorMode: 'color',
+    suggestedToolchain: 'devkitARM',
+    outputExtension: '.gba',
+    budgets: Object.freeze({
+      palettes: 16,
+      tiles: 512,
+      sprites: 128,
+      fonts: 4,
+      glyphsPerFont: 128,
+    }),
+  }),
+});
+
+export const SUPPORTED_RETRO_BUILD_TARGETS = new Set(Object.keys(RETRO_TARGET_PROFILES));
+
+export function isRetroBuildTarget(target) {
+  return SUPPORTED_RETRO_BUILD_TARGETS.has(String(target || '').trim().toLowerCase());
+}
+
+export function getRetroTargetProfile(target) {
+  const normalized = String(target || '').trim().toLowerCase();
+  if (!isRetroBuildTarget(normalized)) {
+    throw new Error(`Unsupported Aura Retro target "${target}". Supported values: gb, gbc, gba.`);
+  }
+  return RETRO_TARGET_PROFILES[normalized];
+}

package/src/retro/validator/check-project.mjs

@@ -0,0 +1,114 @@
+import { createRetroDiagnostic } from '../diagnostics/emit.mjs';
+import { spanFromIndex } from '../shared/span.mjs';
+import { loadRetroProjectGraph, summarizeRetroGraph } from '../frontend/load-project.mjs';
+import { compileRetroAssets } from '../assets/compile.mjs';
+
+const RULES = Object.freeze([
+  {
+    reasonCode: 'retro_async_unsupported',
+    regex: /(^|[^\w$])(?:async\s+function\b|await\b)/m,
+  },
+  {
+    reasonCode: 'retro_eval_unsupported',
+    regex: /(^|[^\w$.])eval\s*\(/m,
+  },
+  {
+    reasonCode: 'retro_dynamic_property_access_unsupported',
+    regex: /\[[A-Za-z_$][A-Za-z0-9_$]*\]/m,
+  },
+  {
+    reasonCode: 'retro_runtime_asset_load_unsupported',
+    regex: /(^|[^\w$.])(?:fetch\s*\(|XMLHttpRequest\b|WebSocket\b|aura\.(?:assets|fs|net)\.)/m,
+  },
+  {
+    reasonCode: 'retro_3d_api_unsupported',
+    regex: /\baura\.(?:draw3d|camera3d|light|mesh|material|scene3d|character3d)\b/m,
+  },
+  {
+    reasonCode: 'retro_desktop_api_unsupported',
+    regex: /\baura\.(?:platform|net|multiplayer|fs|video)\b/m,
+  },
+]);
+
+const TARGET_RULES = Object.freeze({
+  gb: Object.freeze([
+    {
+      reasonCode: 'retro_gb_color_feature_unsupported',
+      regex: /\b(?:palette|color)\s*:/m,
+    },
+  ]),
+  gbc: Object.freeze([]),
+  gba: Object.freeze([]),
+});
+
+function collectModuleDiagnostics(moduleMeta, target) {
+  const diagnostics = [];
+  const seen = new Set();
+
+  const activeRules = [...RULES, ...(TARGET_RULES[target] || [])];
+  for (const rule of activeRules) {
+    const match = rule.regex.exec(moduleMeta.code);
+    if (!match || seen.has(rule.reasonCode)) {
+      continue;
+    }
+    seen.add(rule.reasonCode);
+    const index = typeof match.index === 'number' ? match.index + (match[1]?.length || 0) : 0;
+    diagnostics.push(
+      createRetroDiagnostic({
+        reasonCode: rule.reasonCode,
+        filePath: moduleMeta.filePath,
+        span: spanFromIndex(moduleMeta.code, index, String(match[0] || '').length),
+      }),
+    );
+  }
+
+  return diagnostics;
+}
+
+function finalizeReport(frontend, diagnostics) {
+  const reasonCodes = [...new Set(diagnostics.map((entry) => entry.reasonCode))].sort();
+  const assetReport = compileRetroAssets({
+    projectRoot: frontend.projectRoot,
+    target: frontend.target,
+  });
+  const combinedDiagnostics = [...diagnostics, ...(assetReport.diagnostics || [])];
+  const combinedReasonCodes = [...new Set(combinedDiagnostics.map((entry) => entry.reasonCode))].sort();
+  return {
+    ok: combinedDiagnostics.length === 0,
+    valid: combinedDiagnostics.length === 0,
+    target: frontend.target,
+    targetProfile: frontend.targetProfile,
+    projectRoot: frontend.projectRoot,
+    entryFile: frontend.entryFile,
+    moduleCount: frontend.graph ? frontend.graph.order.length : 0,
+    modules: summarizeRetroGraph(frontend),
+    assets: assetReport.summary,
+    reasonCodes: combinedReasonCodes,
+    diagnostics: combinedDiagnostics,
+  };
+}
+
+export function checkRetroProject(options = {}) {
+  const frontend = loadRetroProjectGraph(options);
+  if (!frontend.ok) {
+    return finalizeReport(frontend, frontend.diagnostics || []);
+  }
+
+  const diagnostics = [];
+  for (const filePath of frontend.graph.order) {
+    const moduleMeta = frontend.graph.modules.get(filePath);
+    diagnostics.push(...collectModuleDiagnostics(moduleMeta, frontend.target));
+  }
+
+  diagnostics.sort((left, right) => {
+    const leftKey = `${left.filePath}:${left.span?.line || 0}:${left.reasonCode}`;
+    const rightKey = `${right.filePath}:${right.span?.line || 0}:${right.reasonCode}`;
+    return leftKey.localeCompare(rightKey);
+  });
+
+  return finalizeReport(frontend, diagnostics);
+}
+
+export function explainRetroProject(options = {}) {
+  return checkRetroProject(options);
+}