create-aura3d 1.3.3 → 1.4.1

package/templates/falling-blocks-starter/playwright.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  webServer: {
+    command: "npm run dev -- --port 5179",
+    url: "http://127.0.0.1:5179",
+    reuseExistingServer: !process.env.CI
+  },
+  use: {
+    baseURL: "http://127.0.0.1:5179"
+  }
+});

package/templates/falling-blocks-starter/public/aura-assets/showcaseBlockfallCabinet.thumb.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 180"><rect width="320" height="180" fill="#101720"/><path d="M80 126 160 46l80 80-80 28z" fill="#77a7ff"/><text x="160" y="160" text-anchor="middle" font-family="Arial" font-size="18" fill="#f4f7fb">showcaseBlockfallCabinet 2x2x3.27</text></svg>

package/templates/falling-blocks-starter/src/aura-assets.ts

@@ -0,0 +1,20 @@
+import { defineAuraAssets } from "@aura3d/engine";
+
+export const assets = defineAuraAssets({
+  cabinetModel: {
+    type: "model",
+    format: "glb",
+    url: "/aura-assets/showcaseBlockfallCabinet.679d52fe.glb",
+    bounds: [2, 2, 3.27],
+    hash: "sha256-679d52fe0c7bf99373fc873f3c3892548f6c5758ae9c81be91f09acae6a35a36",
+    metadata: {
+      materials: ["arcade_machine"],
+      animations: [],
+      textures: ["image-0", "image-1", "image-2", "image-3"],
+      license: "CC-BY-4.0",
+      author: "Dmitry Blagodaryov",
+      sourcePage: "https://huggingface.co/datasets/allenai/objaverse/blob/main/glbs/000-012/f73986356b6e4d72b7a889279837aec2.glb",
+      thumbnailUrl: "/aura-assets/showcaseBlockfallCabinet.thumb.svg"
+    }
+  }
+} as const);

package/templates/falling-blocks-starter/src/main.ts

@@ -0,0 +1,358 @@
+import {
+  camera,
+  createAuraApp,
+  game,
+  lights,
+  material,
+  model,
+  primitives,
+  scene,
+  type AuraNodeInput
+} from "@aura3d/engine";
+import { assets } from "./aura-assets";
+
+declare global {
+  interface Window {
+    __AURA3D_FALLING_BLOCKS_STARTER__?: FallingBlocksStarterEvidence;
+  }
+}
+
+type Piece = "I" | "J" | "L" | "O" | "S" | "T" | "Z";
+type Cell = Piece | null;
+
+interface FallingBlocksStarterEvidence {
+  readonly frame: number;
+  readonly score: number;
+  readonly lines: number;
+  readonly checksum: string;
+  readonly active: { readonly kind: Piece; readonly x: number; readonly y: number; readonly rotation: number } | null;
+  readonly hold: Piece | null;
+  readonly gameOver: boolean;
+  readonly events: readonly string[];
+  readonly lineClearProof: {
+    readonly lines: number;
+    readonly events: readonly string[];
+    readonly checksum: string;
+  };
+  readonly evidence: unknown;
+}
+
+const boardWidth = 10;
+const boardHeight = 22;
+const hiddenRows = 2;
+const cellSize = 0.24;
+const boardOrigin = { x: -1.2, y: -2.18 };
+const pieceColors: Record<Piece, string> = {
+  I: "#5ed7df",
+  J: "#7fa5df",
+  L: "#dfbd65",
+  O: "#dccf78",
+  S: "#84d09a",
+  T: "#b987d0",
+  Z: "#d88791"
+};
+const activeShapes: Record<Piece, readonly (readonly { readonly x: number; readonly y: number }[])[]> = {
+  I: [
+    [{ x: 0, y: 1 }, { x: 1, y: 1 }, { x: 2, y: 1 }, { x: 3, y: 1 }],
+    [{ x: 2, y: 0 }, { x: 2, y: 1 }, { x: 2, y: 2 }, { x: 2, y: 3 }],
+    [{ x: 0, y: 2 }, { x: 1, y: 2 }, { x: 2, y: 2 }, { x: 3, y: 2 }],
+    [{ x: 1, y: 0 }, { x: 1, y: 1 }, { x: 1, y: 2 }, { x: 1, y: 3 }]
+  ],
+  J: [
+    [{ x: 0, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }, { x: 2, y: 1 }],
+    [{ x: 1, y: 0 }, { x: 2, y: 0 }, { x: 1, y: 1 }, { x: 1, y: 2 }],
+    [{ x: 0, y: 1 }, { x: 1, y: 1 }, { x: 2, y: 1 }, { x: 2, y: 2 }],
+    [{ x: 1, y: 0 }, { x: 1, y: 1 }, { x: 0, y: 2 }, { x: 1, y: 2 }]
+  ],
+  L: [
+    [{ x: 2, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }, { x: 2, y: 1 }],
+    [{ x: 1, y: 0 }, { x: 1, y: 1 }, { x: 1, y: 2 }, { x: 2, y: 2 }],
+    [{ x: 0, y: 1 }, { x: 1, y: 1 }, { x: 2, y: 1 }, { x: 0, y: 2 }],
+    [{ x: 0, y: 0 }, { x: 1, y: 0 }, { x: 1, y: 1 }, { x: 1, y: 2 }]
+  ],
+  O: [
+    [{ x: 1, y: 0 }, { x: 2, y: 0 }, { x: 1, y: 1 }, { x: 2, y: 1 }],
+    [{ x: 1, y: 0 }, { x: 2, y: 0 }, { x: 1, y: 1 }, { x: 2, y: 1 }],
+    [{ x: 1, y: 0 }, { x: 2, y: 0 }, { x: 1, y: 1 }, { x: 2, y: 1 }],
+    [{ x: 1, y: 0 }, { x: 2, y: 0 }, { x: 1, y: 1 }, { x: 2, y: 1 }]
+  ],
+  S: [
+    [{ x: 1, y: 0 }, { x: 2, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }],
+    [{ x: 1, y: 0 }, { x: 1, y: 1 }, { x: 2, y: 1 }, { x: 2, y: 2 }],
+    [{ x: 1, y: 1 }, { x: 2, y: 1 }, { x: 0, y: 2 }, { x: 1, y: 2 }],
+    [{ x: 0, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }, { x: 1, y: 2 }]
+  ],
+  T: [
+    [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }, { x: 2, y: 1 }],
+    [{ x: 1, y: 0 }, { x: 1, y: 1 }, { x: 2, y: 1 }, { x: 1, y: 2 }],
+    [{ x: 0, y: 1 }, { x: 1, y: 1 }, { x: 2, y: 1 }, { x: 1, y: 2 }],
+    [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }, { x: 1, y: 2 }]
+  ],
+  Z: [
+    [{ x: 0, y: 0 }, { x: 1, y: 0 }, { x: 1, y: 1 }, { x: 2, y: 1 }],
+    [{ x: 2, y: 0 }, { x: 1, y: 1 }, { x: 2, y: 1 }, { x: 1, y: 2 }],
+    [{ x: 0, y: 1 }, { x: 1, y: 1 }, { x: 1, y: 2 }, { x: 2, y: 2 }],
+    [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }, { x: 0, y: 2 }]
+  ]
+};
+
+const input = game.input({
+  actions: {
+    left: ["KeyA", "ArrowLeft"],
+    right: ["KeyD", "ArrowRight"],
+    rotateRight: ["KeyW", "ArrowUp", "KeyX"],
+    rotateLeft: ["KeyQ", "KeyZ"],
+    softDrop: ["KeyS", "ArrowDown"],
+    hardDrop: ["Space"],
+    hold: ["KeyC", "ShiftLeft", "ShiftRight"],
+    reset: ["KeyR"]
+  },
+  bufferMs: 100
+});
+
+const falling = game.fallingBlocks({
+  width: boardWidth,
+  height: boardHeight,
+  hiddenRows,
+  seed: 7,
+  gravityFrames: 999,
+  lockDelayFrames: 18
+});
+const routeEvents = game.eventLog({ label: "falling blocks starter events", maxEvents: 18 });
+const hud = game.hud.bindings([
+  game.hud.score({ valuePath: "appState.score" }),
+  game.hud.objective({ valuePath: "appState.objective" }),
+  game.hud.eventLog({ valuePath: "appState.events" })
+]);
+const lineClearProof = createLineClearProof();
+
+setupPracticeBoard();
+
+const app = createAuraApp("#app", {
+  diagnostics: { overlay: true, performancePanel: true },
+  scene: buildScene()
+});
+
+const boardNodes = Array.from({ length: boardHeight - hiddenRows }, (_, rowIndex) =>
+  Array.from({ length: boardWidth }, (_, x) => app.nodes.require(`board-cell-${x}-${rowIndex + hiddenRows}`))
+);
+const activeNodes = Array.from({ length: 4 }, (_, index) => app.nodes.require(`active-cell-${index}`));
+const holdNode = app.nodes.require("hold-preview");
+const hudRoot = createHud();
+let objective = "Clear the prepared line. Move, rotate, hold, or hard drop.";
+let tickAccumulator = 0;
+
+app.onFrame(({ dt }: { readonly dt: number }) => {
+  input.update(dt);
+  if (input.pressed("reset")) {
+    setupPracticeBoard();
+    routeEvents.push({ type: "reset", label: "reset" });
+    objective = "Clear the prepared line. Move, rotate, hold, or hard drop.";
+  }
+  if (input.pressed("left")) recordKitEvents(falling.move(-1));
+  if (input.pressed("right")) recordKitEvents(falling.move(1));
+  if (input.pressed("rotateRight")) recordKitEvents(falling.rotate(1));
+  if (input.pressed("rotateLeft")) recordKitEvents(falling.rotate(-1));
+  if (input.pressed("softDrop")) recordKitEvents(falling.softDrop());
+  if (input.pressed("hold")) recordKitEvents(falling.hold());
+  if (input.pressed("hardDrop")) recordKitEvents(falling.hardDrop());
+
+  tickAccumulator += dt;
+  while (tickAccumulator >= 1 / 30) {
+    recordKitEvents(falling.tick(1));
+    tickAccumulator -= 1 / 30;
+  }
+
+  const state = falling.snapshot();
+  renderBoard(state);
+  renderHud(state);
+  publishEvidence(state);
+});
+
+renderBoard(falling.snapshot());
+renderHud(falling.snapshot());
+publishEvidence(falling.snapshot());
+
+function recordKitEvents(state: ReturnType<typeof falling.snapshot>): void {
+  for (const event of state.events) {
+    routeEvents.push({
+      type: event.type,
+      label: event.piece ? `${event.type}:${event.piece}` : event.type,
+      severity: event.type === "line-clear" ? "success" : event.type === "game-over" ? "warning" : "info",
+      frame: event.frame
+    });
+    if (event.type === "line-clear") objective = `Line clear. ${state.lines} line cleared. Press R to replay.`;
+    if (event.type === "hold") objective = "Held piece. Press R or continue.";
+    if (event.type === "rotate") objective = "Rotation accepted.";
+    if (event.type === "move") objective = "Move accepted.";
+  }
+}
+
+function setupPracticeBoard(): void {
+  falling.reset(7);
+  falling.setBoard(createPracticeBoard());
+  falling.setActive({ kind: "I", x: 3, y: boardHeight - 3, rotation: 0 });
+}
+
+function createPracticeBoard(): Cell[][] {
+  const board = Array.from({ length: boardHeight }, () => Array.from({ length: boardWidth }, () => null as Cell));
+  board[boardHeight - 1] = board[boardHeight - 1].map((_, x) => (x >= 3 && x <= 6 ? null : "O"));
+  board[boardHeight - 2][0] = "J";
+  board[boardHeight - 2][9] = "L";
+  return board;
+}
+
+function buildScene() {
+  const nodes: AuraNodeInput[] = [
+    model(assets.cabinetModel, { name: "typed arcade cabinet", castShadow: true })
+      .position(1.75, 0.28, -0.55)
+      .scale(0.2),
+    primitives.box({ name: "falling blocks board backplate", material: material.pbr({ color: "#172027", roughness: 0.82, metallic: 0.04 }) })
+      .position(0, 0, -0.08)
+      .scale([2.76, 5.25, 0.08]),
+    primitives.box({ name: "falling blocks board frame", material: material.neon({ color: "#8ee8d5", emissive: "#8ee8d5", emissiveIntensity: 0.22 }) })
+      .position(0, 0, -0.02)
+      .scale([2.92, 5.42, 0.04]),
+    ...boardCellNodes(),
+    ...activeCellNodes(),
+    primitives.box({ name: "hold preview", material: material.neon({ color: "#b987d0", emissive: "#b987d0", emissiveIntensity: 0.38 }) })
+      .position(-2.02, 1.92, 0.08)
+      .scale([0.42, 0.42, 0.16])
+      .runtime(game.runtimeNode("hold-preview", { tags: ["hold", "runtime"] }))
+  ];
+
+  return scene()
+    .background("#06090d")
+    .addMany(nodes)
+    .add(lights.ambient({ name: "blockfall ambient", intensity: 0.36, color: "#e8fbff" }))
+    .add(lights.directional({ name: "blockfall key", position: [3.8, 6.2, 5], intensity: 1.15, color: "#ffffff" }))
+    .camera(camera.perspective({ position: [0.25, 1.2, 7.2], target: [0.1, 0.1, 0], fov: 38 }));
+}
+
+function boardCellNodes(): AuraNodeInput[] {
+  const nodes: AuraNodeInput[] = [];
+  for (let y = hiddenRows; y < boardHeight; y += 1) {
+    for (let x = 0; x < boardWidth; x += 1) {
+      nodes.push(
+        primitives.box({ name: `board cell ${x} ${y}`, material: material.pbr({ color: "#dccf78", roughness: 0.62, metallic: 0.02 }) })
+          .position(...cellPosition(x, y), 0)
+          .scale([cellSize * 0.86, cellSize * 0.86, 0.12])
+          .runtime(game.runtimeNode(`board-cell-${x}-${y}`, { tags: ["board-cell", "runtime"] }))
+      );
+    }
+  }
+  return nodes;
+}
+
+function activeCellNodes(): AuraNodeInput[] {
+  return Array.from({ length: 4 }, (_, index) =>
+    primitives.box({ name: `active piece cell ${index}`, material: material.neon({ color: "#5ed7df", emissive: "#5ed7df", emissiveIntensity: 0.4 }) })
+      .position(-3, -3, 0.12)
+      .scale([cellSize * 0.92, cellSize * 0.92, 0.16])
+      .runtime(game.runtimeNode(`active-cell-${index}`, { tags: ["active-cell", "runtime"] }))
+  );
+}
+
+function renderBoard(state: ReturnType<typeof falling.snapshot>): void {
+  for (let y = hiddenRows; y < boardHeight; y += 1) {
+    for (let x = 0; x < boardWidth; x += 1) {
+      const node = boardNodes[y - hiddenRows][x];
+      const cell = state.board[y][x];
+      node.setVisible(Boolean(cell)).setPosition(...cellPosition(x, y), 0);
+    }
+  }
+
+  activeNodes.forEach((node) => node.setVisible(false));
+  if (state.active) {
+    const cells = activeShapes[state.active.kind][state.active.rotation] ?? activeShapes[state.active.kind][0];
+    cells.forEach((cell, index) => {
+      const x = state.active!.x + cell.x;
+      const y = state.active!.y + cell.y;
+      activeNodes[index]
+        .setVisible(y >= hiddenRows)
+        .setPosition(...cellPosition(x, y), 0.14)
+        .setScale([cellSize * 0.94, cellSize * 0.94, 0.16]);
+    });
+  }
+  holdNode.setVisible(Boolean(state.hold));
+}
+
+function cellPosition(x: number, y: number): [number, number] {
+  return [
+    boardOrigin.x + (x + 0.5) * cellSize,
+    boardOrigin.y + (boardHeight - hiddenRows - (y - hiddenRows) - 0.5) * cellSize
+  ];
+}
+
+function createHud(): HTMLElement {
+  const root = document.createElement("aside");
+  root.id = "falling-blocks-starter-hud";
+  root.style.cssText = [
+    "position:absolute",
+    "left:16px",
+    "top:16px",
+    "z-index:5",
+    "min-width:310px",
+    "font:600 13px/1.35 Inter, system-ui, sans-serif",
+    "color:#f5fbff",
+    "background:rgba(3,9,14,0.78)",
+    "border:1px solid rgba(125,220,235,0.34)",
+    "border-radius:8px",
+    "padding:12px",
+    "pointer-events:none"
+  ].join(";");
+  document.body.append(root);
+  return root;
+}
+
+function renderHud(state: ReturnType<typeof falling.snapshot>): void {
+  hudRoot.innerHTML = [
+    `<strong>Aura3D Falling Blocks Starter</strong>`,
+    `<div>Score ${state.score} | Lines ${state.lines} | Level ${state.level}</div>`,
+    `<div>Active ${state.active?.kind ?? "--"} | Hold ${state.hold ?? "--"} | Checksum ${state.checksum.slice(0, 8)}</div>`,
+    `<div>${objective}</div>`,
+    `<div>Move arrows/A-D. Rotate W/Q. Drop Space. Hold C. Reset R.</div>`
+  ].join("");
+}
+
+function publishEvidence(state: ReturnType<typeof falling.snapshot>): void {
+  const evidence = app.evidence({
+    input,
+    events: routeEvents,
+    hud,
+    appState: {
+      score: state.score,
+      objective,
+      events: routeEvents.events().map((event: { readonly label: string }) => event.label)
+    },
+    assets: {
+      typedAssets: Object.keys(assets).length,
+      missingAssets: []
+    },
+    source: { expectsGame: true }
+  });
+  window.__AURA3D_FALLING_BLOCKS_STARTER__ = {
+    frame: state.frame,
+    score: state.score,
+    lines: state.lines,
+    checksum: state.checksum,
+    active: state.active,
+    hold: state.hold,
+    gameOver: state.gameOver,
+    events: routeEvents.events().map((event: { readonly label: string }) => event.label),
+    lineClearProof,
+    evidence
+  };
+}
+
+function createLineClearProof(): FallingBlocksStarterEvidence["lineClearProof"] {
+  const proof = game.fallingBlocks({ width: boardWidth, height: boardHeight, hiddenRows, seed: 7, gravityFrames: 999 });
+  proof.setBoard(createPracticeBoard());
+  proof.setActive({ kind: "I", x: 3, y: boardHeight - 3, rotation: 0 });
+  const cleared = proof.hardDrop();
+  return {
+    lines: cleared.lines,
+    events: cleared.events.map((event) => event.piece ? `${event.type}:${event.piece}` : event.type),
+    checksum: cleared.checksum
+  };
+}

package/templates/falling-blocks-starter/tests/playable.spec.ts

@@ -0,0 +1,85 @@
+import { expect, test } from "@playwright/test";
+
+test("falling-blocks starter responds to keyboard input and clears a line", async ({ page }) => {
+  await page.goto("/");
+  await page.waitForFunction(() => document.body.dataset.aura3dReady === "true", undefined, { timeout: 45_000 });
+  await page.waitForFunction(() => Boolean((window as unknown as { __AURA3D_FALLING_BLOCKS_STARTER__?: unknown }).__AURA3D_FALLING_BLOCKS_STARTER__));
+
+  const initial = await fallingState(page);
+  expect(initial.active?.kind).toBe("I");
+  expect(initial.active?.x).toBe(3);
+  expect(initial.lineClearProof.lines).toBe(1);
+  expect(initial.lineClearProof.events).toContain("line-clear");
+
+  await tapKey(page, "ArrowRight");
+  await page.waitForTimeout(120);
+  const moved = await fallingState(page);
+  expect(moved.active?.x).toBe((initial.active?.x ?? 0) + 1);
+
+  await tapKey(page, "KeyR");
+  await page.waitForTimeout(120);
+  await tapKey(page, "ArrowUp");
+  await page.waitForTimeout(120);
+  const rotated = await fallingState(page);
+  expect(rotated.active?.rotation).not.toBe(initial.active?.rotation);
+
+  await tapKey(page, "KeyR");
+  await page.waitForTimeout(120);
+  await tapKey(page, "KeyC");
+  await page.waitForTimeout(120);
+  const held = await fallingState(page);
+  expect(held.hold).toBe("I");
+  expect(held.events).toEqual(expect.arrayContaining(["hold:I"]));
+
+  await tapKey(page, "KeyR");
+  await page.waitForTimeout(120);
+  await tapKey(page, "Space");
+  await page.waitForTimeout(160);
+  const cleared = await fallingState(page);
+  expect(cleared.lines).toBe(1);
+  expect(cleared.score).toBeGreaterThanOrEqual(100);
+  expect(cleared.events).toEqual(expect.arrayContaining(["hard-drop:I", "line-clear"]));
+
+  await tapKey(page, "KeyR");
+  await page.waitForTimeout(120);
+  const reset = await fallingState(page);
+  expect(reset.lines).toBe(0);
+  expect(reset.active?.kind).toBe("I");
+  expect(reset.events.some((event) => event.includes("reset"))).toBe(true);
+});
+
+async function fallingState(page: import("@playwright/test").Page): Promise<{
+  readonly score: number;
+  readonly lines: number;
+  readonly active: { readonly kind: string; readonly x: number; readonly rotation: number } | null;
+  readonly hold: string | null;
+  readonly events: readonly string[];
+  readonly lineClearProof: {
+    readonly lines: number;
+    readonly events: readonly string[];
+  };
+}> {
+  return await page.evaluate(() => {
+    const state = (window as unknown as {
+      readonly __AURA3D_FALLING_BLOCKS_STARTER__?: {
+        readonly score: number;
+        readonly lines: number;
+        readonly active: { readonly kind: string; readonly x: number; readonly rotation: number } | null;
+        readonly hold: string | null;
+        readonly events: readonly string[];
+        readonly lineClearProof: {
+          readonly lines: number;
+          readonly events: readonly string[];
+        };
+      };
+    }).__AURA3D_FALLING_BLOCKS_STARTER__;
+    if (!state) throw new Error("Missing __AURA3D_FALLING_BLOCKS_STARTER__ state.");
+    return state;
+  });
+}
+
+async function tapKey(page: import("@playwright/test").Page, key: string, holdMs = 90): Promise<void> {
+  await page.keyboard.down(key);
+  await page.waitForTimeout(holdMs);
+  await page.keyboard.up(key);
+}

package/templates/falling-blocks-starter/tests/route-health.spec.ts

@@ -0,0 +1,34 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { expect, test } from "@playwright/test";
+
+test.setTimeout(60_000);
+
+test("Aura3D falling-blocks starter reaches ready state with line-clear evidence", async ({ page }) => {
+  await page.goto("/");
+  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 45_000 }).toBe("true");
+
+  const drawCalls = Number(await page.locator("body").getAttribute("data-aura3d-draw-calls"));
+  const routeState = await page.evaluate(() => {
+    const value: unknown = Reflect.get(window, "__AURA3D_FALLING_BLOCKS_STARTER__");
+    const state = isRecord(value) ? value : {};
+    const lineClearProofValue = state.lineClearProof;
+    const lineClearProof = isRecord(lineClearProofValue) ? lineClearProofValue : {};
+    return {
+      score: typeof state.score === "number" ? state.score : -1,
+      lines: typeof state.lines === "number" ? state.lines : -1,
+      proofLines: typeof lineClearProof.lines === "number" ? lineClearProof.lines : 0
+    };
+
+    function isRecord(recordValue: unknown): recordValue is Readonly<Record<string, unknown>> {
+      return typeof recordValue === "object" && recordValue !== null && !Array.isArray(recordValue);
+    }
+  });
+
+  expect(drawCalls).toBeGreaterThan(0);
+  expect(routeState.score).toBeGreaterThanOrEqual(0);
+  expect(routeState.lines).toBeGreaterThanOrEqual(0);
+  expect(routeState.proofLines).toBeGreaterThan(0);
+  mkdirSync(resolve("tests/reports"), { recursive: true });
+  writeFileSync(resolve("tests/reports/route-health.json"), `${JSON.stringify({ ready: true, drawCalls, routeState }, null, 2)}\n`);
+});

package/templates/falling-blocks-starter/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}

package/templates/fighting-game/package.json

@@ -11,7 +11,7 @@
     "test": "playwright test tests/route-health.spec.ts tests/gameplay-smoke.spec.ts --workers=1"
   },
   "dependencies": {
-    "@aura3d/engine": "1.3.3"
+    "@aura3d/engine": "1.4.1"
   },
   "devDependencies": {
     "@playwright/test": "^1.52.0",

package/templates/mini-game/README.md

@@ -3,6 +3,19 @@
 Small interactive scene starter for agent-authored controls, movement, and route
 health checks.
 
+Status: playable starter, not a production game claim. This template uses a
+typed player asset, the public `game.platformer(...)` kit, runtime nodes, HUD
+evidence, keyboard input, reset, scoring, and screenshot tests. It proves the
+starter boots and responds to keyboard input through the root `@aura3d/engine`
+safe API; it does not prove production art direction, skinned animation,
+advanced PBR, WebGPU, postprocess, or commercial game polish.
+
+Before presenting a route from this template as production-quality, replace any
+placeholder art with typed primary assets from the Aura3D CLI, keep
+`model(assets.x)` for real assets, prove each claimed mechanic with keyboard
+tests, and capture desktop/mobile screenshots where the main subject is
+readable.
+
 ```bash
 npm install
 npm run dev

package/templates/mini-game/index.html

@@ -8,6 +8,6 @@
   </head>
   <body>
     <div id="app"></div>
-    <script type="module" src="/src/main.ts"></script>
+    <script type="module" src="./src/main.ts"></script>
   </body>
 </html>

package/templates/mini-game/package.json

@@ -8,10 +8,10 @@
     "typecheck": "tsc --noEmit",
     "build": "npm run typecheck && vite build",
     "preview": "vite preview --host 127.0.0.1",
-    "test": "playwright test tests/route-health.spec.ts tests/screenshot.spec.ts --workers=1"
+    "test": "playwright test tests/route-health.spec.ts tests/playable.spec.ts tests/screenshot.spec.ts --workers=1"
   },
   "dependencies": {
-    "@aura3d/engine": "1.3.3"
+    "@aura3d/engine": "1.4.1"
   },
   "devDependencies": {
     "@playwright/test": "^1.52.0",