create-aura3d 3.0.0 → 4.0.0

package/templates/racing-starter/tests/look-floor.ts

@@ -0,0 +1,270 @@
+/**
+ * PRD-13 T3.12/T3.13 — the shared template look floor.
+ *
+ * Every create-aura3d template's `tests/screenshot.spec.ts` calls
+ * `assertTemplateLookFloor(page, ...)` after readiness: the same five checks
+ * everywhere (PRD §6.5/T3.12):
+ *
+ *   1. non-blank — sampled WebGL pixels are lit and varied (not a uniform
+ *      clear/void frame);
+ *   2. `diagnostics().look.lint` carries no `severity === "error"` finding
+ *      (empty when A3D_QR_LOOKS is off — the check never silently skips);
+ *   3. `appliedLook.environment.specularIntensity > 0` — an environment map
+ *      actually reached the frame;
+ *   4. `appliedLook.shadows.strength >= 0.8` when the look declares a shadow
+ *      caster (a null ShadowReport means the renderer produced no shadow
+ *      evidence — recorded, not failed);
+ *   5. `appliedLook.pixelRatio >= min(devicePixelRatio, tierCap)` — the
+ *      renderer used the display density up to the tier cap (2).
+ *
+ * …plus the optional §T3.12 subject check: the lit-pixel bounding box of the
+ * canvas' central region must sit within `tolerance` of the expected subject
+ * bounds (default ±10% of frame).
+ *
+ * Templates that mount through `createAuraApp` surface `appliedLook`/`look`
+ * via the global `__AURA3D_LIVE_APPS__` registry — no per-template wiring.
+ * `skipAppDiagnostics` covers the bespoke-renderer template (animation-studio),
+ * which reports its stage environment through its own readiness evidence.
+ */
+
+import { expect, type Page } from "@playwright/test";
+
+/** Normalized canvas-space bounds the lit subject mass is expected to occupy. */
+export interface LookFloorSubjectBounds {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+
+export interface LookFloorOptions {
+  /** Expected subject bounds in normalized canvas units. Omit to skip. */
+  readonly subject?: LookFloorSubjectBounds;
+  /** Fractional tolerance on each bound axis. Default 0.1 (±10%). */
+  readonly tolerance?: number;
+  /** Template has no `__AURA3D_LIVE_APPS__` app (bespoke renderer). */
+  readonly skipAppDiagnostics?: boolean;
+}
+
+export interface LookFloorReport {
+  readonly sampledPixels: number;
+  readonly brightPixels: number;
+  readonly uniqueBuckets: number;
+  readonly subjectBounds: LookFloorSubjectBounds | null;
+  readonly appliedLook: {
+    readonly specularIntensity: number;
+    readonly shadowStrength: number | null;
+    readonly pixelRatio: number;
+    readonly renderPath: string;
+    readonly background: string | null;
+  } | null;
+  readonly lookLintErrors: readonly string[];
+  readonly devicePixelRatio: number;
+}
+
+const MIN_BRIGHT_FRACTION = 0.02;
+const MIN_UNIQUE_BUCKETS = 8;
+
+export async function assertTemplateLookFloor(page: Page, options: LookFloorOptions = {}): Promise<LookFloorReport> {
+  const canvas = page.locator("canvas").first();
+  await expect(canvas).toBeVisible();
+
+  /*
+   * Deterministic frame before profiling: pause every live app, rewind its
+   * runtime clock and step a fixed 45 frames at 1/60 — through `stepAsync`,
+   * not the synchronous registry `settle()`. The production renderer mounts
+   * asynchronously, so a sync step loop renders nothing while the mount is in
+   * flight and never yields for it to finish (the failure mode on software-GL
+   * runners: blank frames, `environment.intensity` still NaN in diagnostics).
+   * Awaiting each step also lets pending environment/IBL/asset promises resolve
+   * between frames, and one final dt=0 step re-renders the same simulated
+   * instant once that work has applied.
+   */
+  const report = await page.evaluate(async (): Promise<LookFloorReport> => {
+    interface LiveApp {
+      pause?: () => void;
+      resetRuntimeClock?: () => void;
+      step?: (dt?: number) => void;
+      stepAsync?: (dt?: number) => Promise<unknown>;
+      diagnostics?: () => Record<string, unknown>;
+    }
+    const empty = (code: string): LookFloorReport => ({
+      sampledPixels: 0,
+      brightPixels: 0,
+      uniqueBuckets: 0,
+      subjectBounds: null,
+      appliedLook: null,
+      lookLintErrors: [code],
+      devicePixelRatio: globalThis.devicePixelRatio ?? 1
+    });
+    const registry = (globalThis as { __AURA3D_LIVE_APPS__?: { all?: () => readonly LiveApp[] } }).__AURA3D_LIVE_APPS__;
+    const apps = [...(registry?.all?.() ?? [])];
+    const stepApp = async (app: LiveApp, dt: number): Promise<void> => {
+      if (app.stepAsync) {
+        try {
+          await Promise.race([
+            app.stepAsync(dt),
+            new Promise((resolvePromise) => setTimeout(resolvePromise, 30_000))
+          ]);
+          return;
+        } catch {
+          // synchronous step fallback below
+        }
+      }
+      app.step?.(dt);
+    };
+    /*
+     * Wall-clock bound on the settle loop: on software-GL CI runners a single
+     * stepped render of a heavy scene costs several seconds, so an unbounded
+     * 45-step loop outlives the test budget and fails with a bare timeout and
+     * no report. Cap the stepping and always take the dt=0 settle frame — a
+     * partially settled scene still yields a readable floor report.
+     */
+    const STEP_WALLCLOCK_BUDGET_MS = 420_000;
+    const settleStartedAt = Date.now();
+    for (const app of apps) {
+      app.pause?.();
+      app.resetRuntimeClock?.();
+      for (let index = 0; index < 45; index += 1) {
+        if (Date.now() - settleStartedAt > STEP_WALLCLOCK_BUDGET_MS) break;
+        await stepApp(app, 1 / 60);
+      }
+      await stepApp(app, 0);
+    }
+    /*
+     * Renderers outside the liveApps registry (bespoke renderers, e.g.
+     * animation-studio's A3DRenderer) cannot be stepped. Two animation
+     * frames guarantee at least one full app render finished inside this
+     * evaluate task, so the readPixels below sees a real presented frame
+     * instead of a compositor-cleared buffer.
+     */
+    if (apps.length === 0) {
+      await new Promise<void>((resolve) => {
+        requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+      });
+    }
+
+    const diagnostics = apps[0]?.diagnostics?.() as
+      | { appliedLook?: { environment?: { specularIntensity?: number; background?: string }; shadows?: { strength?: number | null } | null; pixelRatio?: number; renderPath?: string }; look?: { lint?: readonly { severity?: string; code?: string }[] } }
+      | undefined;
+    const appliedLook = diagnostics?.appliedLook
+      ? {
+          specularIntensity: diagnostics.appliedLook.environment?.specularIntensity ?? 0,
+          shadowStrength: diagnostics.appliedLook.shadows?.strength ?? null,
+          pixelRatio: diagnostics.appliedLook.pixelRatio ?? 0,
+          renderPath: diagnostics.appliedLook.renderPath ?? "unknown",
+          background: diagnostics.appliedLook.environment?.background ?? null
+        }
+      : null;
+    const lookLintErrors = (diagnostics?.look?.lint ?? [])
+      .filter((finding) => finding.severity === "error")
+      .map((finding) => finding.code ?? "unknown");
+    const devicePixelRatio = globalThis.devicePixelRatio ?? 1;
+
+    /*
+     * The app's WebGL context is not preserveDrawingBuffer, so readPixels must
+     * run in the same task as the stepped render, before compositing clears the
+     * drawing buffer. That also removes the composited element screenshot that
+     * software-GL runners could not produce inside a test timeout.
+     */
+    const target = [...document.querySelectorAll("canvas")]
+      .map((element) => ({
+        element,
+        gl: (element.getContext("webgl2") ?? element.getContext("webgl")) as WebGL2RenderingContext | WebGLRenderingContext | null
+      }))
+      .find((entry) => entry.gl !== null);
+    if (!target?.gl) return { ...empty("no-webgl-context"), appliedLook, lookLintErrors };
+    const gl = target.gl;
+    const width = gl.drawingBufferWidth;
+    const height = gl.drawingBufferHeight;
+    if (width === 0 || height === 0) return { ...empty("empty-drawing-buffer"), appliedLook, lookLintErrors };
+    // readPixels reads the currently bound framebuffer: renderers that end a
+    // frame with an offscreen target bound (shadow/post FBOs — e.g.
+    // animation-studio's bespoke renderer) would return that target's pixels
+    // instead of the canvas backbuffer. Rebind the default framebuffer first;
+    // every renderer rebinds its own targets at the start of its next frame.
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    const pixels = new Uint8Array(width * height * 4);
+    gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+
+    const BRIGHT_LUMA = 48;
+    const stride = 4; // pixels — 16×16 sample grid
+    let sampled = 0;
+    let bright = 0;
+    const buckets = new Set<number>();
+    // Central-region lit-pixel bbox: edges carry floor/backdrop, the subject
+    // mass is what every §6.4 template frames mid-frame.
+    const x0 = Math.floor(width * 0.1);
+    const x1 = Math.floor(width * 0.9);
+    const y0 = Math.floor(height * 0.1);
+    const y1 = Math.floor(height * 0.9);
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (let y = 0; y < height; y += stride) {
+      for (let x = 0; x < width; x += stride) {
+        const offset = (y * width + x) * 4;
+        const r = pixels[offset] ?? 0;
+        const g = pixels[offset + 1] ?? 0;
+        const b = pixels[offset + 2] ?? 0;
+        sampled += 1;
+        buckets.add(((r >> 4) << 8) | ((g >> 4) << 4) | (b >> 4));
+        const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+        if (luma > BRIGHT_LUMA) {
+          bright += 1;
+          if (x >= x0 && x <= x1 && y >= y0 && y <= y1) {
+            minX = Math.min(minX, x);
+            maxX = Math.max(maxX, x);
+            minY = Math.min(minY, y);
+            maxY = Math.max(maxY, y);
+          }
+        }
+      }
+    }
+    // readPixels rows run bottom-up; report `y` in the same top-down
+    // convention the composited-screenshot path produced so stored
+    // expectations stay comparable across the switch.
+    const subjectBounds = Number.isFinite(minX)
+      ? { x: minX / width, y: 1 - maxY / height, width: (maxX - minX) / width, height: (maxY - minY) / height }
+      : null;
+
+    return {
+      sampledPixels: sampled,
+      brightPixels: bright,
+      uniqueBuckets: buckets.size,
+      subjectBounds,
+      appliedLook,
+      lookLintErrors,
+      devicePixelRatio
+    };
+  });
+
+  // 1. Non-blank.
+  expect(report.brightPixels / Math.max(1, report.sampledPixels)).toBeGreaterThan(MIN_BRIGHT_FRACTION);
+  expect(report.uniqueBuckets).toBeGreaterThan(MIN_UNIQUE_BUCKETS);
+
+  if (!options.skipAppDiagnostics) {
+    // 2–5. Renderer/look evidence via __AURA3D_LIVE_APPS__.
+    expect(report.appliedLook, "appliedLook diagnostics missing — is the app mounted via createAuraApp?").not.toBeNull();
+    expect(report.lookLintErrors).toEqual([]);
+      expect(report.appliedLook!.specularIntensity).toBeGreaterThan(0);
+    if (report.appliedLook!.shadowStrength !== null) {
+      expect(report.appliedLook!.shadowStrength!).toBeGreaterThanOrEqual(0.8);
+    }
+    expect(report.appliedLook!.pixelRatio).toBeGreaterThanOrEqual(Math.min(report.devicePixelRatio, 2));
+  }
+
+  // 6. Subject bounds ±10%.
+  if (options.subject) {
+    const tolerance = options.tolerance ?? 0.1;
+    const measured = `measured ${JSON.stringify(report.subjectBounds)}`;
+    expect(report.subjectBounds, "no lit subject mass in the central frame").not.toBeNull();
+    expect(Math.abs(report.subjectBounds!.x - options.subject.x), measured).toBeLessThanOrEqual(tolerance);
+    expect(Math.abs(report.subjectBounds!.y - options.subject.y), measured).toBeLessThanOrEqual(tolerance);
+    expect(Math.abs(report.subjectBounds!.width - options.subject.width), measured).toBeLessThanOrEqual(tolerance);
+    expect(Math.abs(report.subjectBounds!.height - options.subject.height), measured).toBeLessThanOrEqual(tolerance);
+  }
+
+  return report;
+}

package/templates/racing-starter/tests/playable.spec.ts

@@ -1,50 +1,9 @@
+import { readFileSync } from "node:fs";
 import { expect, test } from "@playwright/test";
 
-test("racing starter responds to keyboard input and exposes a multi-lap route contract", 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_RACING_STARTER__?: unknown }).__AURA3D_RACING_STARTER__));
-
-  const initial = await racingState(page);
-  expect(initial.status).toBe("running");
-  expect(initial.speed).toBeCloseTo(0, 5);
-  expect(initial.checkpointCount).toBeGreaterThanOrEqual(6);
-  expect(initial.lapProof.status).toBe("contract-ready");
-  expect(initial.lapProof.events).toEqual(expect.arrayContaining([
-    "checkpoint:checkpoint-1",
-    "checkpoint:checkpoint-6",
-    "lap:multi-lap-contract",
-    "reset:available"
-  ]));
-  expect(initial.lapProof.lapsToWin).toBeGreaterThanOrEqual(3);
-  expect(initial.lapProof.minLapSeconds).toBeGreaterThanOrEqual(20);
-  expect(initial.lapProof.routeAlignedToVisibleTrack).toBe(true);
-
-  await page.keyboard.down("ArrowUp");
-  await page.waitForTimeout(260);
-  const accelerated = await racingState(page);
-  expect(accelerated.speed).toBeGreaterThan(initial.speed + 0.5);
-  expect(accelerated.progress).not.toBe(initial.progress);
-
-  await page.keyboard.down("ArrowRight");
-  await page.waitForTimeout(300);
-  await page.keyboard.up("ArrowRight");
-  const steered = await racingState(page);
-  expect(steered.heading).not.toBe(accelerated.heading);
-
-  await page.keyboard.up("ArrowUp");
-  const afterInput = await racingState(page);
-  expect(afterInput.events.length).toBeGreaterThanOrEqual(initial.events.length);
+test.setTimeout(240_000);
 
-  await tapKey(page, "KeyR");
-  await page.waitForTimeout(140);
-  const reset = await racingState(page);
-  expect(reset.status).toBe("running");
-  expect(reset.checkpoint).toBe(0);
-  expect(reset.events.some((event) => event.includes("reset"))).toBe(true);
-});
-
-async function racingState(page: import("@playwright/test").Page): Promise<{
+type RacingEvidence = {
   readonly status: string;
   readonly checkpoint: number;
   readonly checkpointCount: number;
@@ -52,42 +11,66 @@ async function racingState(page: import("@playwright/test").Page): Promise<{
   readonly progress: number;
   readonly heading: number;
   readonly events: readonly string[];
-  readonly lapProof: {
-    readonly status: string;
-    readonly events: readonly string[];
-    readonly checkpointCount: number;
-    readonly lapsToWin: number;
-    readonly minLapSeconds: number;
-    readonly routeAlignedToVisibleTrack: boolean;
+  readonly look: { readonly id: string };
+  readonly geometry: {
+    readonly tool: string;
+    readonly report: string;
+    readonly carMetres: readonly number[];
+    readonly trackMetres: readonly number[];
+    readonly carScale: number;
+    readonly routeScale: number;
   };
-}> {
-  return await page.evaluate(() => {
-    const state = (window as unknown as {
-      readonly __AURA3D_RACING_STARTER__?: {
-        readonly status: string;
-        readonly checkpoint: number;
-        readonly checkpointCount: number;
-        readonly speed: number;
-        readonly progress: number;
-        readonly heading: number;
-        readonly events: readonly string[];
-        readonly lapProof: {
-          readonly status: string;
-          readonly events: readonly string[];
-          readonly checkpointCount: number;
-          readonly lapsToWin: number;
-          readonly minLapSeconds: number;
-          readonly routeAlignedToVisibleTrack: boolean;
-        };
-      };
-    }).__AURA3D_RACING_STARTER__;
-    if (!state) throw new Error("Missing __AURA3D_RACING_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);
+function readRacingState(): RacingEvidence | undefined {
+  return (window as unknown as { readonly __AURA3D_RACING_STARTER__?: RacingEvidence }).__AURA3D_RACING_STARTER__;
 }
+
+test("racing starter responds to keyboard input, reports real geometry certification, and resets", async ({ page }) => {
+  await page.goto("/");
+  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 150_000 }).toBe("true");
+
+  const initial = await page.evaluate(readRacingState);
+  expect(initial?.status).toBe("running");
+  expect(initial?.speed).toBeCloseTo(0, 5);
+  expect(initial?.checkpointCount).toBeGreaterThanOrEqual(6);
+  // T3.2 floor evidence: the scene carries the genre look and geometry truth
+  // reports the real certify-game-geometry output, not authored constants.
+  expect(initial?.look.id).toBe("golden-hour");
+  expect(initial?.geometry.carScale).toBe(1);
+  expect(initial?.geometry.carMetres[0]).toBeGreaterThan(3);
+  expect(initial?.geometry.trackMetres[0]).toBeGreaterThan(20);
+
+  const certification = JSON.parse(readFileSync("tests/geometry-certification.json", "utf8")) as {
+    readonly result: {
+      readonly rows: readonly { readonly assetId: string; readonly category: string; readonly pass: boolean; readonly blockers: readonly string[] }[];
+    };
+  };
+  const rows = certification.result.rows;
+  expect(rows.map((row) => row.assetId).sort()).toEqual(["carModel", "trackModel"]);
+  expect(rows.every((row) => row.category === "racing")).toBe(true);
+  expect(initial?.geometry.report).toBe("tests/geometry-certification.json");
+
+  await page.keyboard.down("KeyW");
+  await page.waitForTimeout(650);
+  await page.keyboard.up("KeyW");
+  const accelerated = await page.evaluate(readRacingState);
+  expect(accelerated?.speed ?? 0).toBeGreaterThan((initial?.speed ?? 0) + 0.5);
+  expect(accelerated?.progress).not.toBe(initial?.progress);
+
+  await page.keyboard.down("KeyW");
+  await page.keyboard.down("KeyA");
+  await page.waitForTimeout(400);
+  await page.keyboard.up("KeyA");
+  await page.keyboard.up("KeyW");
+  const steered = await page.evaluate(readRacingState);
+  expect(steered?.heading).not.toBe(accelerated?.heading);
+  expect(steered?.events.length ?? 0).toBeGreaterThanOrEqual(initial?.events.length ?? 0);
+
+  await page.keyboard.press("KeyR");
+  await page.waitForTimeout(120);
+  const reset = await page.evaluate(readRacingState);
+  expect(reset?.status).toBe("running");
+  expect(reset?.checkpoint).toBe(0);
+  expect(reset?.events.some((event) => event.includes("reset"))).toBe(true);
+});

package/templates/racing-starter/tests/route-health.spec.ts

@@ -2,25 +2,26 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { expect, test } from "@playwright/test";
 
-test.setTimeout(60_000);
+test.setTimeout(240_000);
 
 test("Aura3D racing starter reaches ready state with gameplay evidence", async ({ page }) => {
   await page.goto("/");
-  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 45_000 }).toBe("true");
+  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 150_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_RACING_STARTER__");
     const state = isRecord(value) ? value : {};
-    const lapProofValue = state.lapProof;
-    const lapProof = isRecord(lapProofValue) ? lapProofValue : {};
+    const geometry = isRecord(state.geometry) ? state.geometry : {};
+    const look = isRecord(state.look) ? state.look : {};
     return {
       status: typeof state.status === "string" ? state.status : "missing",
       checkpointCount: typeof state.checkpointCount === "number" ? state.checkpointCount : 0,
-      lapProofStatus: typeof lapProof.status === "string" ? lapProof.status : "missing",
-      lapsToWin: typeof lapProof.lapsToWin === "number" ? lapProof.lapsToWin : 0,
-      minLapSeconds: typeof lapProof.minLapSeconds === "number" ? lapProof.minLapSeconds : 0,
-      routeAlignedToVisibleTrack: lapProof.routeAlignedToVisibleTrack === true
+      lookId: typeof look.id === "string" ? look.id : "missing",
+      carScale: typeof geometry.carScale === "number" ? geometry.carScale : 0,
+      carMetres: Array.isArray(geometry.carMetres) ? geometry.carMetres : [],
+      trackMetres: Array.isArray(geometry.trackMetres) ? geometry.trackMetres : [],
+      certifyReport: typeof geometry.report === "string" ? geometry.report : "missing"
     };
 
     function isRecord(recordValue: unknown): recordValue is Readonly<Record<string, unknown>> {
@@ -31,10 +32,11 @@ test("Aura3D racing starter reaches ready state with gameplay evidence", async (
   expect(drawCalls).toBeGreaterThan(0);
   expect(routeState.status).toBe("running");
   expect(routeState.checkpointCount).toBeGreaterThanOrEqual(6);
-  expect(routeState.lapProofStatus).toBe("contract-ready");
-  expect(routeState.lapsToWin).toBeGreaterThanOrEqual(3);
-  expect(routeState.minLapSeconds).toBeGreaterThanOrEqual(20);
-  expect(routeState.routeAlignedToVisibleTrack).toBe(true);
+  expect(routeState.lookId).toBe("golden-hour");
+  expect(routeState.carScale).toBe(1);
+  expect(routeState.carMetres[0]).toBeGreaterThan(3);
+  expect(routeState.trackMetres[0]).toBeGreaterThan(20);
+  expect(routeState.certifyReport).toBe("tests/geometry-certification.json");
   mkdirSync(resolve("tests/reports"), { recursive: true });
   writeFileSync(resolve("tests/reports/route-health.json"), `${JSON.stringify({ ready: true, drawCalls, routeState }, null, 2)}\n`);
 });

package/templates/racing-starter/tests/screenshot.spec.ts

@@ -0,0 +1,21 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { expect, test } from "@playwright/test";
+import { assertTemplateLookFloor } from "./look-floor";
+
+test.setTimeout(600_000);
+
+// PRD-13 T3.12 — look floor: non-blank, look.lint error-free, appliedLook
+// environment specular > 0, shadow strength >= 0.8, pixelRatio at tier cap,
+// subject bounds within ±10% — plus this template's bespoke assertions.
+test("Aura3D racing starter screenshot clears the look floor", async ({ page }) => {
+  await page.goto("/");
+  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 150_000 }).toBe("true");
+
+  const floor = await assertTemplateLookFloor(page, { subject: { x: 0.1, y: 0.3, width: 0.8, height: 0.6 } });
+  const screenshot = await page.screenshot({ fullPage: false });
+  mkdirSync(resolve("tests/reports"), { recursive: true });
+  writeFileSync(resolve("tests/reports/screenshot.png"), screenshot);
+  writeFileSync(resolve("tests/reports/screenshot.json"), `${JSON.stringify({ bytes: screenshot.byteLength, floor }, null, 2)}\n`);
+  expect(screenshot.byteLength).toBeGreaterThan(1000);
+});

package/templates/racing-starter/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vite";
+import { auraDecodersPlugin } from "@aura3d/assets/vite";
+
+// F-05-04 (05-PKG): ship + serve the decoder vendor tree at /aura-decoders/
+// so compressed (KTX2/draco/meshopt) GLBs decode same-origin with correct
+// MIME in both `vite dev` and `vite preview`/deployed builds.
+export default defineConfig({ plugins: [auraDecodersPlugin()] });

package/templates/character-controller/public/aura-assets/showcaseWalkAnimatedGirl.thumb.svg

@@ -1 +0,0 @@
-<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">showcaseWalkAnimatedGirl 86.929x161.836x37.758</text></svg>

package/templates/fighting-game/public/aura-assets/showcaseRunnerRobot.thumb.svg

@@ -1 +0,0 @@
-<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">showcaseRunnerRobot 17.509x14.644x3.963</text></svg>

package/templates/fighting-game/public/aura-assets/showcaseWalkAnimatedGirl.thumb.svg

@@ -1 +0,0 @@
-<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">showcaseWalkAnimatedGirl 86.929x161.836x37.758</text></svg>

package/templates/mini-game/public/aura-assets/showcaseKenneyOobiPlatformerHero.thumb.svg

@@ -1 +0,0 @@
-<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">showcaseKenneyOobiPlatformerHero 0.868x0.907x0.603</text></svg>

package/templates/three-compat-architecture-interior/aura.assets.json

@@ -1,7 +0,0 @@
-{
-  "schema": "aura3d.assets/1.0",
-  "assetBasePath": "/aura-assets/",
-  "outputDir": "public/aura-assets",
-  "typegen": "src/aura-assets.ts",
-  "assets": []
-}

package/templates/three-compat-architecture-interior/src/aura-assets.ts

@@ -1,3 +0,0 @@
-import { defineAuraAssets } from "@aura3d/engine";
-
-export const assets = defineAuraAssets({} as const);

package/templates/three-compat-architecture-interior/src/main.ts

@@ -1,27 +0,0 @@
-// Three-compat architecture interior: a small room built from boxes,
-// authored entirely through the public @aura3d/engine scene API.
-import { camera, createAuraApp, lights, material, primitives, scene } from "@aura3d/engine";
-
-const plaster = material.pbr({ color: "#cfd6e2", roughness: 0.85 });
-const oakFloor = material.pbr({ color: "#8a6f52", roughness: 0.6 });
-const walnut = material.pbr({ color: "#5b4231", roughness: 0.5 });
-
-createAuraApp("#app", {
-  scene: scene()
-    .background("#10141c")
-    .camera(camera.orbit({ target: [0, 1.1, 0], distance: 7 }))
-    .add(primitives.box({ name: "floor slab", size: [6, 0.12, 6], position: [0, -0.06, 0], material: oakFloor, receiveShadow: true }))
-    .add(primitives.box({ name: "back wall", size: [6, 2.8, 0.12], position: [0, 1.4, -3], material: plaster, receiveShadow: true }))
-    .add(primitives.box({ name: "side wall", size: [0.12, 2.8, 6], position: [-3, 1.4, 0], material: plaster, receiveShadow: true }))
-    .add(primitives.box({ name: "window header", size: [2.4, 0.5, 0.12], position: [1.2, 2.55, -3.01], material: plaster }))
-    .add(primitives.box({ name: "table top", size: [1.8, 0.08, 0.9], position: [0.5, 0.74, -0.8], material: walnut, castShadow: true }))
-    .add(primitives.box({ name: "table leg front", size: [0.08, 0.7, 0.08], position: [-0.3, 0.35, -0.45], material: walnut, castShadow: true }))
-    .add(primitives.box({ name: "table leg back", size: [0.08, 0.7, 0.08], position: [1.3, 0.35, -1.15], material: walnut, castShadow: true }))
-    .add(primitives.box({ name: "sofa seat", size: [2, 0.45, 0.9], position: [-1.8, 0.23, 1.3], material: material.pbr({ color: "#41506b", roughness: 0.78 }), castShadow: true }))
-    .add(primitives.box({ name: "sofa backrest", size: [2, 0.6, 0.18], position: [-1.8, 0.75, 1.66], material: material.pbr({ color: "#36435a", roughness: 0.78 }), castShadow: true }))
-    .add(primitives.cylinder({ name: "floor lamp pole", size: [0.06, 1.6, 0.06], position: [2.3, 0.8, 1.8], material: material.metal({ color: "#9aa3ad" }), castShadow: true }))
-    .add(primitives.sphere({ name: "floor lamp shade", size: 0.32, position: [2.3, 1.7, 1.8], material: material.emissive({ color: "#ffe7b8", emissive: "#ffd28a", emissiveIntensity: 0.8 }) }))
-    .add(lights.ambient({ intensity: 0.35 }))
-    .add(lights.directional({ name: "window sun", position: [4, 5, 3], intensity: 1.4 }))
-    .add(lights.point({ name: "lamp fill", position: [2.3, 1.7, 1.8], intensity: 1.1, color: "#ffd9a0" }))
-});

package/templates/three-compat-architecture-interior/tests/screenshot.spec.ts

@@ -1,15 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { expect, test } from "@playwright/test";
-
-test.setTimeout(60_000);
-
-test("Aura3D three-compat template screenshot shows content", async ({ page }) => {
-  await page.goto("/");
-  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 45_000 }).toBe("true");
-  const screenshot = await page.screenshot({ fullPage: false });
-  mkdirSync(resolve("tests/reports"), { recursive: true });
-  writeFileSync(resolve("tests/reports/screenshot.png"), screenshot);
-  writeFileSync(resolve("tests/reports/screenshot.json"), `${JSON.stringify({ bytes: screenshot.byteLength }, null, 2)}\n`);
-  expect(screenshot.byteLength).toBeGreaterThan(1000);
-});

package/templates/three-compat-asset-inspector/aura.assets.json

@@ -1,7 +0,0 @@
-{
-  "schema": "aura3d.assets/1.0",
-  "assetBasePath": "/aura-assets/",
-  "outputDir": "public/aura-assets",
-  "typegen": "src/aura-assets.ts",
-  "assets": []
-}

package/templates/three-compat-asset-inspector/src/aura-assets.ts

@@ -1,3 +0,0 @@
-import { defineAuraAssets } from "@aura3d/engine";
-
-export const assets = defineAuraAssets({} as const);

package/templates/three-compat-asset-inspector/src/main.ts

@@ -1,17 +0,0 @@
-// Three-compat asset inspector: one centered primitive on a neutral stage
-// with inspection lighting, authored through the public @aura3d/engine API.
-// Swap the torus for `model(assets.yourAsset)` once you add typed assets.
-import { camera, createAuraApp, lights, material, primitives, scene } from "@aura3d/engine";
-
-createAuraApp("#app", {
-  diagnostics: { overlay: true },
-  scene: scene()
-    .background("#0b0f16")
-    .camera(camera.orbit({ target: [0, 0.9, 0], distance: 4.2 }))
-    .add(primitives.box({ name: "inspection stage", size: [4, 0.1, 4], position: [0, -0.05, 0], material: material.pbr({ color: "#1d2533", roughness: 0.9 }), receiveShadow: true }))
-    .add(primitives.torus({ name: "inspected asset", size: 1.1, position: [0, 0.95, 0], rotation: [0.5, 0.35, 0], material: material.metal({ color: "#c9d4e4", roughness: 0.22 }), castShadow: true }))
-    .add(primitives.box({ name: "scale reference cube", size: 0.25, position: [1.4, 0.125, 0.9], material: material.pbr({ color: "#38d6ff" }), castShadow: true }))
-    .add(lights.ambient({ intensity: 0.3 }))
-    .add(lights.directional({ name: "key", position: [3, 4, 3], intensity: 1.5 }))
-    .add(lights.point({ name: "rim", position: [-2.5, 2, -2], intensity: 1.4, color: "#9fc4ff" }))
-});

package/templates/three-compat-asset-inspector/tests/screenshot.spec.ts

@@ -1,15 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { expect, test } from "@playwright/test";
-
-test.setTimeout(60_000);
-
-test("Aura3D three-compat template screenshot shows content", async ({ page }) => {
-  await page.goto("/");
-  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 45_000 }).toBe("true");
-  const screenshot = await page.screenshot({ fullPage: false });
-  mkdirSync(resolve("tests/reports"), { recursive: true });
-  writeFileSync(resolve("tests/reports/screenshot.png"), screenshot);
-  writeFileSync(resolve("tests/reports/screenshot.json"), `${JSON.stringify({ bytes: screenshot.byteLength }, null, 2)}\n`);
-  expect(screenshot.byteLength).toBeGreaterThan(1000);
-});