@auraindustry/aurajs 0.0.7 → 0.1.1

package/templates/create/2d/prefabs/enemies.prefab.js

@@ -0,0 +1,90 @@
+import { centeredRect, pickEnemyArchetypeForWave2D, rectsOverlap, spawnEnemy2D } from '../src/starter-utils/index.js';
+
+const enemiesPrefab = {
+  id: 'enemies',
+  kind: 'prefab',
+  role: 'enemy',
+  view: {
+    kind: 'actor2d',
+  },
+  hooks: {},
+  notes: ['Starter enemy helpers still live beside the authored prefab descriptor in this template.'],
+};
+
+export function spawnWaveEnemy(width, waveState) {
+  const wave = waveState?.wave || null;
+  const archetypeId = wave?.archetype || pickEnemyArchetypeForWave2D(waveState?.waveIndex || 0).id;
+  const enemy = spawnEnemy2D({
+    x: 24 + (Math.random() * Math.max(1, width - 48)),
+    y: -22,
+    waveIndex: waveState?.waveIndex || 0,
+    archetypeId,
+  });
+
+  const speedScale = Number.isFinite(Number(wave?.speedScale))
+    ? Number(wave.speedScale)
+    : 1.0;
+  enemy.speed *= Math.max(0.4, speedScale);
+  return enemy;
+}
+
+export function updateEnemies(enemies, dt) {
+  for (const enemy of enemies) {
+    enemy.y += enemy.speed * dt;
+  }
+}
+
+export function resolveEnemyImpacts({ enemies, bullets, size, score, lives, config }) {
+  const nextBullets = bullets.slice();
+  const survivors = [];
+  let nextScore = score;
+  let nextLives = lives;
+
+  for (const enemy of enemies) {
+    const enemyBox = centeredRect(enemy.x, enemy.y, enemy.size, enemy.size);
+    let hit = false;
+
+    for (let bulletIndex = nextBullets.length - 1; bulletIndex >= 0; bulletIndex -= 1) {
+      const bullet = nextBullets[bulletIndex];
+      const bulletBox = {
+        x: bullet.x,
+        y: bullet.y,
+        w: config.bulletWidth,
+        h: config.bulletHeight,
+      };
+      if (!rectsOverlap(enemyBox, bulletBox)) continue;
+      nextBullets.splice(bulletIndex, 1);
+      hit = true;
+      nextScore += enemy.scoreValue;
+      break;
+    }
+
+    if (hit) continue;
+    if (enemy.y - (enemy.size * 0.5) > size.height) {
+      nextLives -= 1;
+      continue;
+    }
+    survivors.push(enemy);
+  }
+
+  return {
+    enemies: survivors,
+    bullets: nextBullets,
+    score: nextScore,
+    lives: nextLives,
+  };
+}
+
+export function drawEnemies(enemies) {
+  for (const enemy of enemies) {
+    aura.draw2d.rect(
+      enemy.x - (enemy.size * 0.5),
+      enemy.y - (enemy.size * 0.5),
+      enemy.size,
+      enemy.size,
+      aura.rgb(enemy.color.r, enemy.color.g, enemy.color.b),
+    );
+  }
+}
+
+export default enemiesPrefab;

package/templates/create/2d/prefabs/enemy-basic.prefab.js

@@ -0,0 +1,18 @@
+const enemyBasicPrefab = {
+  id: 'enemy-basic',
+  kind: 'prefab',
+  role: 'enemy',
+  view: { kind: 'actor2d' },
+  components: {
+    archetype: 'scout',
+    pressureRole: 'pressure',
+  },
+  hooks: {},
+  notes: ['Start here when tuning enemy setup outside the runtime bootstrap.'],
+};
+
+export function createEnemyBasicPrefab() {
+  return enemyBasicPrefab;
+}
+
+export default enemyBasicPrefab;

package/templates/create/2d/prefabs/player.prefab.js

@@ -0,0 +1,36 @@
+const playerPrefab = {
+  id: 'player',
+  kind: 'prefab',
+  role: 'player',
+  view: {
+    kind: 'actor2d',
+    collider: { shape: 'rect', size: { x: 34, y: 26 } },
+  },
+  hooks: {},
+  notes: ['Keep authored spawn/state ownership here even while the starter stays JS-first.'],
+};
+
+export function createPlayerPrefab() {
+  return playerPrefab;
+}
+
+export function createPlayerState() {
+  return { x: 0, y: 0 };
+}
+
+export function resetPlayerPosition(player, size, config) {
+  player.x = size.width * 0.5;
+  player.y = size.height - config.playerStartOffsetY;
+}
+
+export function drawPlayer(player, config) {
+  aura.draw2d.rect(
+    player.x - (config.playerWidth * 0.5),
+    player.y - (config.playerHeight * 0.5),
+    config.playerWidth,
+    config.playerHeight,
+    aura.rgb(0.28, 0.78, 1.0),
+  );
+}
+
+export default playerPrefab;

package/templates/create/2d/prefabs/projectiles.prefab.js

@@ -0,0 +1,35 @@
+const projectilesPrefab = {
+  id: 'projectiles',
+  kind: 'prefab',
+  role: 'custom',
+  view: {
+    kind: 'actor2d',
+  },
+  hooks: {},
+  notes: ['Starter projectile helpers still live beside the authored prefab descriptor in this template.'],
+};
+
+export function spawnPlayerBullet(player, config) {
+  return {
+    x: player.x - (config.bulletWidth * 0.5),
+    y: player.y - config.playerHeight,
+  };
+}
+
+export function updateBullets(bullets, dt, config) {
+  for (const bullet of bullets) {
+    bullet.y -= config.bulletSpeed * dt;
+  }
+}
+
+export function pruneOffscreenBullets(bullets, config) {
+  return bullets.filter((bullet) => bullet.y + config.bulletHeight > 0);
+}
+
+export function drawBullets(bullets, config) {
+  for (const bullet of bullets) {
+    aura.draw2d.rect(bullet.x, bullet.y, config.bulletWidth, config.bulletHeight, aura.rgb(1.0, 0.95, 0.72));
+  }
+}
+
+export default projectilesPrefab;

package/templates/create/2d/scenes/boot.scene.js

@@ -0,0 +1,12 @@
+export function createBootScene() {
+  return {
+    id: 'boot',
+    template: "2d-shooter",
+    nextSceneId: 'gameplay',
+    notes: [
+      'Use this scene for splash, loading, title flow, and session handoff.',
+      'Keep long-lived boot orchestration here instead of bloating src/main.js.',
+      'Keep save or checkpoint resume handoff in src/runtime and appState instead of ad hoc globals.',
+    ],
+  };
+}

package/templates/create/2d/scenes/gameplay.scene.js

@@ -0,0 +1,230 @@
+import {
+  axisFromKeys,
+  clamp,
+  consumeCooldown,
+  createCooldown,
+  createWaveDirector,
+  stepWaveDirector,
+  tickCooldown,
+} from '../src/starter-utils/index.js';
+import { SHOOTER_CONFIG, SHOOTER_TEXT, SHOOTER_WAVES } from '../config/gameplay/shooter.config.js';
+import {
+  createPlayerState,
+  drawPlayer,
+  resetPlayerPosition,
+} from '../prefabs/player.prefab.js';
+import {
+  drawEnemies,
+  resolveEnemyImpacts,
+  spawnWaveEnemy,
+  updateEnemies,
+} from '../prefabs/enemies.prefab.js';
+import {
+  drawBullets,
+  pruneOffscreenBullets,
+  spawnPlayerBullet,
+  updateBullets,
+} from '../prefabs/projectiles.prefab.js';
+import { drawShooterHud } from '../ui/hud.screen.js';
+
+function createShooterSessionSeed() {
+  return {
+    runsStarted: 0,
+    highScore: 0,
+    lastOutcome: 'idle',
+    lastSceneId: 'gameplay',
+  };
+}
+
+function ensureShooterSession(context, appState) {
+  if (typeof context.ensureSessionState === 'function') {
+    return context.ensureSessionState('shooter', createShooterSessionSeed());
+  }
+  if (!appState.session || typeof appState.session !== 'object' || Array.isArray(appState.session)) {
+    appState.session = {};
+  }
+  if (!appState.session.shooter || typeof appState.session.shooter !== 'object' || Array.isArray(appState.session.shooter)) {
+    appState.session.shooter = createShooterSessionSeed();
+  }
+  return appState.session.shooter;
+}
+
+function createShooterUiStateSeed() {
+  return {
+    showControlsHint: true,
+  };
+}
+
+function ensureShooterUiState(context, appState) {
+  if (typeof context.ensureUiState === 'function') {
+    return context.ensureUiState('shooterHud', createShooterUiStateSeed());
+  }
+  if (!appState.ui || typeof appState.ui !== 'object' || Array.isArray(appState.ui)) {
+    appState.ui = {};
+  }
+  if (!appState.ui.shooterHud || typeof appState.ui.shooterHud !== 'object' || Array.isArray(appState.ui.shooterHud)) {
+    appState.ui.shooterHud = createShooterUiStateSeed();
+  }
+  return appState.ui.shooterHud;
+}
+
+export function createGameplayScene(context = {}) {
+  const appState = context.appState || {};
+  const shooterSession = ensureShooterSession(context, appState);
+  const shooterUiState = ensureShooterUiState(context, appState);
+  const sceneState = {
+    player: createPlayerState(),
+    bullets: [],
+    enemies: [],
+    lives: 3,
+    score: 0,
+    shootCooldown: createCooldown(SHOOTER_CONFIG.shootCooldownSeconds),
+    waveDirector: createWaveDirector({
+      waves: SHOOTER_WAVES,
+      loop: true,
+      betweenWaveDelay: SHOOTER_CONFIG.betweenWaveDelaySeconds,
+    }),
+    gameOver: false,
+  };
+
+  function syncSessionState() {
+    shooterSession.lastSceneId = 'gameplay';
+    shooterSession.highScore = Math.max(Number(shooterSession.highScore || 0), sceneState.score);
+    shooterSession.lastScore = sceneState.score;
+    shooterSession.lastLives = sceneState.lives;
+    shooterSession.lastOutcome = sceneState.gameOver ? 'game-over' : 'running';
+  }
+
+  function resetRun() {
+    resetPlayerPosition(sceneState.player, aura.window.getSize(), SHOOTER_CONFIG);
+    sceneState.bullets = [];
+    sceneState.enemies = [];
+    sceneState.lives = 3;
+    sceneState.score = 0;
+    sceneState.shootCooldown = createCooldown(SHOOTER_CONFIG.shootCooldownSeconds);
+    sceneState.waveDirector = createWaveDirector({
+      waves: SHOOTER_WAVES,
+      loop: true,
+      betweenWaveDelay: SHOOTER_CONFIG.betweenWaveDelaySeconds,
+    });
+    sceneState.gameOver = false;
+    shooterSession.runsStarted += 1;
+    syncSessionState();
+  }
+
+  function isPauseOpen() {
+    const shellState = context.getScreenShellState?.();
+    return Array.isArray(shellState?.modals) && shellState.modals.some((entry) => entry.screenId === 'pause');
+  }
+
+  function syncPauseModal() {
+    if (!aura.input.isKeyPressed('escape')) return false;
+
+    const shellState = context.getScreenShellState?.();
+    const topModal = shellState?.modals?.[shellState.modals.length - 1] || null;
+    if (topModal) {
+      context.popModalScreen?.({ action: 'resume' });
+      return true;
+    }
+
+    context.pushModalScreen?.('pause', {
+      score: sceneState.score,
+      lives: sceneState.lives,
+      highScore: shooterSession.highScore || 0,
+      wave: (sceneState.waveDirector?.waveIndex || 0) + 1,
+    });
+    return true;
+  }
+
+  return {
+    setup() {
+      resetRun();
+      console.log(SHOOTER_TEXT.started);
+    },
+
+    update(dt) {
+      const size = aura.window.getSize();
+
+      if (syncPauseModal()) {
+        syncSessionState();
+        return;
+      }
+      if (isPauseOpen()) {
+        syncSessionState();
+        return;
+      }
+
+      if (sceneState.gameOver) {
+        if (aura.input.isKeyPressed('enter')) resetRun();
+        return;
+      }
+
+      const moveX = axisFromKeys(aura.input, ['arrowleft', 'a'], ['arrowright', 'd']);
+      const moveY = axisFromKeys(aura.input, ['arrowup', 'w'], ['arrowdown', 's']);
+      const firedThisFrame = aura.input.isKeyDown('space') || aura.input.isKeyDown('z');
+
+      if (shooterUiState.showControlsHint && (moveX !== 0 || moveY !== 0 || firedThisFrame)) {
+        shooterUiState.showControlsHint = false;
+      }
+
+      sceneState.player.x += moveX * SHOOTER_CONFIG.playerSpeed * dt;
+      sceneState.player.y += moveY * SHOOTER_CONFIG.playerSpeed * dt;
+      sceneState.player.x = clamp(
+        sceneState.player.x,
+        SHOOTER_CONFIG.playerWidth * 0.5,
+        size.width - (SHOOTER_CONFIG.playerWidth * 0.5),
+      );
+      sceneState.player.y = clamp(
+        sceneState.player.y,
+        SHOOTER_CONFIG.playerHeight * 0.5,
+        size.height - (SHOOTER_CONFIG.playerHeight * 0.5),
+      );
+
+      tickCooldown(sceneState.shootCooldown, dt);
+      if (firedThisFrame && consumeCooldown(sceneState.shootCooldown)) {
+        sceneState.bullets.push(spawnPlayerBullet(sceneState.player, SHOOTER_CONFIG));
+      }
+
+      stepWaveDirector(sceneState.waveDirector, dt, (waveState) => {
+        sceneState.enemies.push(spawnWaveEnemy(size.width, waveState));
+      });
+
+      updateBullets(sceneState.bullets, dt, SHOOTER_CONFIG);
+      sceneState.bullets = pruneOffscreenBullets(sceneState.bullets, SHOOTER_CONFIG);
+
+      updateEnemies(sceneState.enemies, dt);
+      const resolved = resolveEnemyImpacts({
+        enemies: sceneState.enemies,
+        bullets: sceneState.bullets,
+        size,
+        score: sceneState.score,
+        lives: sceneState.lives,
+        config: SHOOTER_CONFIG,
+      });
+      sceneState.enemies = resolved.enemies;
+      sceneState.bullets = resolved.bullets;
+      sceneState.score = resolved.score;
+      sceneState.lives = resolved.lives;
+      if (sceneState.lives <= 0) {
+        sceneState.gameOver = true;
+      }
+      syncSessionState();
+    },
+
+    draw() {
+      const fps = aura.window.getFPS().toFixed(0);
+      aura.draw2d.clear(aura.rgba(0.05, 0.06, 0.1, 1.0));
+      drawBullets(sceneState.bullets, SHOOTER_CONFIG);
+      drawEnemies(sceneState.enemies);
+      drawPlayer(sceneState.player, SHOOTER_CONFIG);
+      drawShooterHud({
+        waveDirector: sceneState.waveDirector,
+        score: sceneState.score,
+        lives: sceneState.lives,
+        fps,
+        gameOver: sceneState.gameOver,
+        showControlsHint: shooterUiState.showControlsHint !== false,
+      });
+    },
+  };
+}

package/templates/create/2d/scenes/menu.scene.js

@@ -0,0 +1,9 @@
+export function createMenuScene() {
+  return {
+    id: "menu",
+    nextSceneId: "gameplay",
+    notes: [
+  "Use this for title, attract mode, and difficulty selection."
+],
+  };
+}

package/templates/create/2d/src/main.js

@@ -1,196 +1,17 @@
-// {{PROJECT_TITLE}} — AuraJS 2D shooter starter
+// {{PROJECT_TITLE}} - AuraJS 2D shooter starter
 
-import { axisFromKeys, centeredRect, clamp, consumeCooldown, createCooldown, createWaveDirector, pickEnemyArchetypeForWave2D, rectsOverlap, removeWhere, spawnEnemy2D, stepWaveDirector, tickCooldown } from './starter-utils/index.js';
+import { createApp } from './runtime/app.js';
 
-const PLAYER_W = 34;
-const PLAYER_H = 26;
-const PLAYER_SPEED = 420;
-const BULLET_W = 6;
-const BULLET_H = 14;
-const BULLET_SPEED = 640;
-const SHOOT_COOLDOWN = 0.14;
-
-const WAVE_CONFIG = [
-  { maxSpawns: 9, spawnEvery: 0.62, archetype: 'scout', speedScale: 1.0 },
-  { maxSpawns: 10, spawnEvery: 0.56, archetype: 'striker', speedScale: 1.06 },
-  { maxSpawns: 8, spawnEvery: 0.74, archetype: 'tank', speedScale: 1.02 },
-  { maxSpawns: 12, spawnEvery: 0.48, archetype: null, speedScale: 1.12 },
-];
-
-let player = { x: 0, y: 0 };
-let bullets = [];
-let enemies = [];
-let lives = 3;
-let score = 0;
-let shootCooldown = createCooldown(SHOOT_COOLDOWN);
-let waveDirector = createWaveDirector({ waves: WAVE_CONFIG, loop: true, betweenWaveDelay: 1.0 });
-let gameOver = false;
-
-function hasMethod(obj, method) {
-  return Boolean(obj) && typeof obj[method] === 'function';
-}
-
-function failWithReason(reasonCode, message) {
-  throw new Error(`[2d-shooter-template] ${message} [reason:${reasonCode}]`);
-}
-
-function assertRuntimeCapabilities() {
-  const missing = [];
-  if (!hasMethod(aura.window, 'getSize')) missing.push('aura.window.getSize');
-  if (!hasMethod(aura.window, 'getFPS')) missing.push('aura.window.getFPS');
-  if (!hasMethod(aura.input, 'isKeyDown')) missing.push('aura.input.isKeyDown');
-  if (!hasMethod(aura.input, 'isKeyPressed')) missing.push('aura.input.isKeyPressed');
-  if (!hasMethod(aura.draw2d, 'clear')) missing.push('aura.draw2d.clear');
-  if (!hasMethod(aura.draw2d, 'rect')) missing.push('aura.draw2d.rect');
-  if (!hasMethod(aura.draw2d, 'text')) missing.push('aura.draw2d.text');
-  if (!hasMethod(aura.draw2d, 'measureText')) missing.push('aura.draw2d.measureText');
-  if (typeof aura.rgb !== 'function') missing.push('aura.rgb');
-  if (typeof aura.rgba !== 'function') missing.push('aura.rgba');
-  if (!aura.Color || !aura.Color.WHITE) missing.push('aura.Color.WHITE');
-
-  if (missing.length > 0) {
-    failWithReason('missing_runtime_api', `runtime missing required APIs: ${missing.join(', ')}`);
-  }
-
-  const small = aura.draw2d.measureText('Probe', { size: 8 });
-  const large = aura.draw2d.measureText('Probe', { size: 24 });
-  if (!Number.isFinite(Number(small?.width)) || !Number.isFinite(Number(large?.width)) || Number(large.width) <= Number(small.width)) {
-    failWithReason(
-      'placeholder_runtime_behavior',
-      'draw2d.measureText appears to be placeholder behavior (size does not affect width).',
-    );
-  }
-}
-
-function resetRun() {
-  const size = aura.window.getSize();
-  player.x = size.width * 0.5;
-  player.y = size.height - 70;
-  bullets = [];
-  enemies = [];
-  lives = 3;
-  score = 0;
-  shootCooldown = createCooldown(SHOOT_COOLDOWN);
-  waveDirector = createWaveDirector({ waves: WAVE_CONFIG, loop: true, betweenWaveDelay: 1.0 });
-  gameOver = false;
-}
-
-function spawnBullet() {
-  bullets.push({
-    x: player.x - (BULLET_W * 0.5),
-    y: player.y - PLAYER_H,
-  });
-}
-
-function spawnEnemy(width, waveState) {
-  const wave = waveState?.wave || null;
-  const archetype = wave?.archetype || pickEnemyArchetypeForWave2D(waveState?.waveIndex || 0).id;
-  const enemy = spawnEnemy2D({
-    x: 24 + (Math.random() * Math.max(1, width - 48)),
-    y: -22,
-    waveIndex: waveState?.waveIndex || 0,
-    archetypeId: archetype,
-  });
-
-  const speedScale = Number.isFinite(Number(wave?.speedScale))
-    ? Number(wave.speedScale)
-    : 1.0;
-  enemy.speed *= Math.max(0.4, speedScale);
-  enemies.push(enemy);
-}
+const app = createApp();
 
 aura.setup = function () {
-  assertRuntimeCapabilities();
-  resetRun();
-  console.log('{{PROJECT_TITLE}} started (2D shooter template)');
+  app.setup();
 };
 
 aura.update = function (dt) {
-  const size = aura.window.getSize();
-
-  if (gameOver) {
-    if (aura.input.isKeyPressed('enter')) resetRun();
-    return;
-  }
-
-  const moveX = axisFromKeys(aura.input, ['arrowleft', 'a'], ['arrowright', 'd']);
-  const moveY = axisFromKeys(aura.input, ['arrowup', 'w'], ['arrowdown', 's']);
-
-  player.x += moveX * PLAYER_SPEED * dt;
-  player.y += moveY * PLAYER_SPEED * dt;
-  player.x = clamp(player.x, PLAYER_W * 0.5, size.width - (PLAYER_W * 0.5));
-  player.y = clamp(player.y, PLAYER_H * 0.5, size.height - (PLAYER_H * 0.5));
-
-  tickCooldown(shootCooldown, dt);
-  if ((aura.input.isKeyDown('space') || aura.input.isKeyDown('z')) && consumeCooldown(shootCooldown)) {
-    spawnBullet();
-  }
-
-  stepWaveDirector(waveDirector, dt, (waveState) => {
-    spawnEnemy(size.width, waveState);
-  });
-
-  for (const bullet of bullets) {
-    bullet.y -= BULLET_SPEED * dt;
-  }
-  removeWhere(bullets, (bullet) => bullet.y + BULLET_H <= 0);
-
-  for (const enemy of enemies) {
-    enemy.y += enemy.speed * dt;
-  }
-
-  const survivors = [];
-  for (const enemy of enemies) {
-    const enemyBox = centeredRect(enemy.x, enemy.y, enemy.size, enemy.size);
-    let hit = false;
-
-    for (let i = bullets.length - 1; i >= 0; i -= 1) {
-      const bullet = bullets[i];
-      const bulletBox = { x: bullet.x, y: bullet.y, w: BULLET_W, h: BULLET_H };
-      if (!rectsOverlap(enemyBox, bulletBox)) continue;
-      bullets.splice(i, 1);
-      hit = true;
-      score += enemy.scoreValue;
-      break;
-    }
-
-    if (hit) continue;
-    if (enemy.y - (enemy.size * 0.5) > size.height) {
-      lives -= 1;
-      if (lives <= 0) gameOver = true;
-      continue;
-    }
-    survivors.push(enemy);
-  }
-  enemies = survivors;
+  app.update(dt);
 };
 
 aura.draw = function () {
-  const fps = aura.window.getFPS().toFixed(0);
-  aura.draw2d.clear(aura.rgba(0.05, 0.06, 0.1, 1.0));
-
-  for (const bullet of bullets) {
-    aura.draw2d.rect(bullet.x, bullet.y, BULLET_W, BULLET_H, aura.rgb(1.0, 0.95, 0.72));
-  }
-
-  for (const enemy of enemies) {
-    aura.draw2d.rect(
-      enemy.x - (enemy.size * 0.5),
-      enemy.y - (enemy.size * 0.5),
-      enemy.size,
-      enemy.size,
-      aura.rgb(enemy.color.r, enemy.color.g, enemy.color.b),
-    );
-  }
-
-  aura.draw2d.rect(player.x - (PLAYER_W * 0.5), player.y - (PLAYER_H * 0.5), PLAYER_W, PLAYER_H, aura.rgb(0.28, 0.78, 1.0));
-
-  const waveLabel = waveDirector.completed ? 'Done' : String(waveDirector.waveIndex + 1);
-  aura.draw2d.text('Move: Arrows/WASD  Fire: Space/Z', 12, 12, { color: aura.Color.WHITE, size: 15, align: 'left' });
-  aura.draw2d.text(`Wave ${waveLabel}   Score ${score}   Lives ${lives}   FPS ${fps}`, 12, 34, { color: aura.Color.WHITE, size: 14, align: 'left' });
-
-  if (gameOver) {
-    aura.draw2d.text('GAME OVER', 12, 64, { color: aura.rgb(1.0, 0.42, 0.42), size: 24, align: 'left' });
-    aura.draw2d.text('Press Enter to restart', 12, 92, { color: aura.Color.WHITE, size: 16, align: 'left' });
-  }
+  app.draw();
 };

package/templates/create/2d/src/runtime/app.js

@@ -0,0 +1,49 @@
+import { createSceneRegistry } from './scene-registry.js';
+import { createProjectInspector } from './project-inspector.js';
+import { assertRuntimeCapabilities } from './capabilities.js';
+
+export function createApp() {
+  const sceneRegistry = createSceneRegistry({
+    projectTitle: '{{PROJECT_TITLE}}',
+  });
+  const projectInspector = createProjectInspector();
+  let activeSceneId = sceneRegistry.defaultSceneId || Object.keys(sceneRegistry.scenes)[0] || null;
+
+  const activeScene = () => (activeSceneId ? sceneRegistry.scenes[activeSceneId] || null : null);
+
+  return {
+    get activeSceneId() {
+      return activeSceneId;
+    },
+    get sceneRegistry() {
+      return sceneRegistry;
+    },
+    get projectInspectorEnabled() {
+      return projectInspector.enabled;
+    },
+    getProjectInspectorState() {
+      return projectInspector.snapshot({ activeSceneId });
+    },
+    setup() {
+      assertRuntimeCapabilities();
+      activeScene()?.setup?.();
+    },
+    update(dt) {
+      projectInspector.syncInput(globalThis.aura?.input || null);
+      activeScene()?.update?.(dt);
+    },
+    draw() {
+      activeScene()?.draw?.();
+      projectInspector.draw({ activeSceneId });
+    },
+    toggleProjectInspector(nextEnabled) {
+      return projectInspector.toggle(nextEnabled);
+    },
+    swapScene(nextSceneId) {
+      if (!sceneRegistry.scenes[nextSceneId]) {
+        throw new Error(`Unknown scene "${nextSceneId}".`);
+      }
+      activeSceneId = nextSceneId;
+    },
+  };
+}