Use cached V8 by default on Linux ARM64

.github/workflows/integration.yml

@@ -619,7 +619,7 @@ jobs:
   fog-native:
     name: Linux native fog correctness
     needs: [fog]
-    # Reuse the proven native-platforms / native-assets ARM QuickJS route without changing defaults.
+    # Use the shipped ARM V8/wgpu default for native fog correctness.
     runs-on: ubuntu-24.04-arm
     timeout-minutes: 60
     env:
@@ -810,7 +810,7 @@ jobs:
     name: Linux native fluid correctness
     if: ${{ needs.paths.outputs.fluid-native == 'true' && !github.event.pull_request.draft }}
     needs: paths
-    # Established native-platforms ARM QuickJS/wgpu route; no default backend change.
+    # Use the shipped ARM V8/wgpu default for native fluid correctness.
     runs-on: ubuntu-24.04-arm
     timeout-minutes: 60
     env:
@@ -888,8 +888,7 @@ jobs:
     name: packaged native asset fallback
     if: ${{ !github.event.pull_request.draft && needs.paths.outputs.native-assets == 'true' }}
     needs: paths
-    # Match native-platforms starter-linux: this architecture selects QuickJS/wgpu without
-    # changing any runtime default. Native dependencies use the repository's locked provisioner.
+    # This fallback proof explicitly selects QuickJS; the ARM desktop default is V8.
     runs-on: ubuntu-24.04-arm
     timeout-minutes: 60
     env:
@@ -934,8 +933,12 @@ jobs:
           libxcursor-dev libxi-dev libxfixes-dev libxss-dev libxkbcommon-dev
           libgtk-3-dev libwebkit2gtk-4.1-dev libxcomposite-dev xcompmgr
           libvulkan1 mesa-vulkan-drivers vulkan-tools xvfb zlib1g-dev
-      - name: Build the same QuickJS host the normal ARM desktop lane ships
-        run: pnpm --filter @threenative/runtime-native native:build
+      - name: Build the QuickJS host required by the packaged fallback
+        run: |
+          pnpm --filter @threenative/runtime-native native:build
+          node packages/runtime-native/scripts/download-deps.mjs --only quickjs
+          cmake -S packages/runtime-native -B packages/runtime-native/build/tn-linux -DMYSTRAL_USE_V8=OFF -DMYSTRAL_USE_QUICKJS=ON
+          cmake --build packages/runtime-native/build/tn-linux --target mystral --parallel 2
       - name: Build the real fixture and capture its packaged native executable
         env:
           THREENATIVE_RUNTIME_BINARY: ${{ github.workspace }}/packages/runtime-native/build/tn-linux/mystral

docs/verification/native-coverage-2026-08-28.md

@@ -13,20 +13,20 @@ targets could not be built and are named below.
 | `src/cli/` | 1690 | 1242 | 73.49% |
 | `src/fs/` | 235 | 189 | 80.43% |
 | `src/http/` | 410 | 377 | 91.95% |
-| `src/js/` | 2785 | 2212 | 79.43% |
-| `src/platform/` | 1460 | 1003 | 68.70% |
+| `src/js/` | 2793 | 2216 | 79.34% |
+| `src/platform/` | 1465 | 1008 | 68.81% |
 | `src/raytracing/` | 461 | 399 | 86.55% |
-| `src/runtime.cpp` | 2425 | 1890 | 77.94% |
+| `src/runtime.cpp` | 2442 | 1896 | 77.64% |
 | `src/screenshot_gate.cpp` | 27 | 24 | 88.89% |
 | `src/storage/` | 327 | 286 | 87.46% |
 | `src/utils/` | 0 | 0 | 0.00% |
 | `src/vfs/` | 239 | 195 | 81.59% |
-| `src/webgpu/` | 9842 | 7566 | 76.87% |
+| `src/webgpu/` | 9885 | 7581 | 76.69% |
 | `src/webtransport/` | 1391 | 1078 | 77.50% |
 | `src/workers/` | 615 | 527 | 85.69% |
-| **TOTAL** | **24785** | **19459** | **78.51%** |
+| **TOTAL** | **24858** | **19489** | **78.40%** |
 
-Source digest: `sha256:2828ae43f9f7f863426676c8b76acf9a02576361e410f0fafac09a8df706b1b9`
+Source digest: `sha256:1a8ed34cf063a9530e8fa11b2722ae0b4c475402ee1baef998b5dea0acd3a4d7`
 
 The default `pnpm budgets` gate reads this committed measurement without configuring or compiling
 the native host. Any native source, native C++ test, CTest registration, or coverage aggregation
@@ -41,7 +41,7 @@ change requires this opt-in command to refresh the record.
 | `src/fs/` | 75.43% |
 | `src/http/` | 86.95% |
 | `src/js/` | 74.50% |
-| `src/platform/` | 63.70% |
+| `src/platform/` | 63.81% |
 | `src/raytracing/` | 81.55% |
 | `src/runtime.cpp` | 73.28% |
 | `src/screenshot_gate.cpp` | 88.89% |

examples/prd242-compute-lifetime/src/conformance.js

@@ -1,8 +1,11 @@
+import { Mesh, MeshBasicNodeMaterial, PlaneGeometry } from "three/webgpu";
 // The root package bundles its Three.js dependency; this source-module import keeps this
 // conformance bundle on the same Three.js runtime as the scene while exercising the exported
 // registry implementation.
 import { ComputeDrivenRegistry } from "../../../packages/core/src/compute-driven.ts";
-import { warmUpScene } from "../../../packages/core/src/warmup.ts";
+import { createPipelineCensus } from "../../../packages/core/src/pipeline-census.ts";
+import { SoftBody3D } from "../../../packages/core/src/softbody.ts";
+import { warmUpComputeNodes, warmUpScene } from "../../../packages/core/src/warmup.ts";
 import {
   assertCondition,
   startVisualScene,
@@ -13,12 +16,123 @@ async function waitForSubmittedWork(renderer) {
   await renderer.backend?.device?.queue?.onSubmittedWorkDone?.();
 }
 
+// Cached-pipeline proof: the baseline prepares GPU buffers with zero workgroups first.
+async function assertCachedClothWarmupPreservesBuffers(renderer) {
+  assertCondition(renderer.backend?.isWebGPUBackend === true, "cloth warmup proof requires WebGPU");
+  const cloth = new SoftBody3D(
+    new Mesh(new PlaneGeometry(1, 1, 2, 2), new MeshBasicNodeMaterial()),
+    {
+      damping: 1.8,
+      gravity: [0, 0, 0],
+      pinned: [0],
+      stiffness: 36,
+      wind: [0, 0.4, 4.5],
+    },
+  );
+  const attributes = new Set();
+  const backend = renderer.backend;
+  const originalCreate = backend.createStorageAttribute;
+  const census = createPipelineCensus({ kind: "webgpu", adapterIdentity: "conformance-probe" });
+  census.installRenderer(renderer);
+  backend.createStorageAttribute = function (attribute) {
+    attributes.add(attribute);
+    return originalCreate.call(this, attribute);
+  };
+  try {
+    for (const node of cloth.warmupNodes) await renderer.computeAsync(node, 0);
+  } finally {
+    backend.createStorageAttribute = originalCreate;
+  }
+  const pipelines = census
+    .snapshot()
+    .events.filter((event) => event.kind === "compute" && event.status === "created");
+  census.dispose();
+  assertCondition(
+    pipelines.length === 2,
+    "cached cloth baseline must observe both real compute pipelines",
+  );
+  // This snapshots every solver storage attribute, including both position and velocity pairs.
+  assertCondition(
+    attributes.size >= 4,
+    "cloth proof must capture all four nonempty solver buffers",
+  );
+  const snapshots = async () =>
+    Promise.all(
+      [...attributes].map(async (attribute) => {
+        const bytes = new Uint8Array(await renderer.getArrayBufferAsync(attribute));
+        assertCondition(bytes.byteLength > 0, "cloth GPU readback must not be empty");
+        return bytes.slice();
+      }),
+    );
+  const before = await snapshots();
+  let calls = 0;
+  let clock = 0;
+  let completion;
+  let report;
+  const descriptor = Object.getOwnPropertyDescriptor(performance, "now");
+  const seam = {
+    backend,
+    computeAsync(node, count) {
+      calls += 1;
+      completion = renderer.computeAsync(node, count);
+      clock = 20;
+      return completion;
+    },
+  };
+  // Controlled deadline, not a wall-clock timeout; GPU dispatch and readback remain real.
+  try {
+    Object.defineProperty(performance, "now", { configurable: true, value: () => clock });
+    report = await warmUpComputeNodes(seam, cloth.warmupNodes, {
+      budgetMs: 10,
+      compileTimeoutMs: 10,
+    });
+  } finally {
+    if (descriptor === undefined) Reflect.deleteProperty(performance, "now");
+    else Object.defineProperty(performance, "now", descriptor);
+  }
+  assertCondition(completion?.then !== undefined, "cloth proof must await its real GPU delegate");
+  await completion;
+  await waitForSubmittedWork(renderer);
+  const after = await snapshots();
+  assertCondition(
+    calls === 1 && report.compiled === 0 && report.timedOut && report.abandoned === 2,
+    `cached cloth warmup must time out during the first half of its ordered pair: ${JSON.stringify({ calls, report })}`,
+  );
+  const equal = (left, right) =>
+    left.length === right.length && left.every((value, index) => value === right[index]);
+  assertCondition(
+    before.every((bytes, index) => equal(bytes, after[index])),
+    "cached cloth warmup mutated live GPU storage at its controlled half-pair deadline",
+  );
+  cloth.process({ kind: "webgpu", compute: (node) => renderer.compute(node) });
+  await waitForSubmittedWork(renderer);
+  const advanced = await snapshots();
+  const changed = after.filter((bytes, index) => !equal(bytes, advanced[index])).length;
+  assertCondition(
+    changed >= 4,
+    "the next real cloth solver step must mutate both position and velocity pairs",
+  );
+  cloth.detach();
+  const detail = {
+    pipelines: pipelines.length,
+    buffers: before.length,
+    unchanged: true,
+    changed,
+    calls,
+    report,
+    deadline: { budgetMs: 10, start: 0, end: 20 },
+  };
+  console.info(`TN_COMPUTE_WARMUP_CACHED_CONTROLLED:${JSON.stringify(detail)}`);
+  return detail;
+}
+
 export async function startScene(canvas, dimensions) {
   return startVisualScene(
     canvas,
     dimensions,
     "compute-driven-lifetime",
     async ({ camera, renderer, scene }) => {
+      const cachedClothWarmup = await assertCachedClothWarmupPreservesBuffers(renderer);
       const registry = new ComputeDrivenRegistry();
       const add = (object) => {
         scene.add(object);
@@ -74,6 +188,7 @@ export async function startScene(canvas, dimensions) {
       return {
         field: second,
         detail: {
+          cachedClothWarmup,
           attachments: 2,
           firstReleased: first.released,
           passesPerStep: 2,

packages/core/__tests__/animation.spec.ts

@@ -869,6 +869,20 @@ describe("AnimationPlayer stride sync on in-place clips", () => {
       ),
     ]);
 
+  it("preserves the root's exact Euler while measuring a foot-plant stride", () => {
+    const root = new Object3D();
+    const foot = new Object3D();
+    foot.name = "Foot";
+    root.add(foot);
+    root.rotation.set(0, Math.PI, 0);
+    const player = new AnimationPlayer({ root, clips: [plantedWalk()] });
+    player.play("walk");
+    player.update(1 / 60);
+
+    expect(player.stride.clipGroundSpeed).toBeGreaterThan(0);
+    expect(root.rotation.toArray()).toEqual([0, Math.PI, 0, "XYZ"]);
+  });
+
   it("matches an in-place walk cycle from the ground its planted foot sweeps", () => {
     const { body, player } = character({ clips: [plantedWalk()] });
     player.play("walk");

packages/core/__tests__/game-frame-budget-surface.spec.ts

@@ -145,6 +145,7 @@ describe("the frame budget names the surface the game's own loop drew", () => {
       const reported = JSON.parse(marker?.slice(FRAME_BUDGET_MARKER.length + 1) ?? "{}");
       expect(reported.surface).toEqual({
         atFloor: false,
+        compiling: false,
         drawingBufferHeight: 540,
         drawingBufferWidth: 1200,
         resolutionScale: 0.5,
@@ -399,3 +400,75 @@ describe("the frame budget names the surface the game's own loop drew", () => {
     }
   });
 });
+
+describe("game frame budget surface compilation telemetry", () => {
+  it("reports explicit compiling state across active compile overlap and clean windows", async () => {
+    const canvas = testCanvas();
+    let frame: ((time: number) => void) | undefined;
+    const surfaces: Array<boolean | undefined> = [];
+    const game = defineGame({
+      frameBudget: {
+        report: () => {},
+        reportEvery: 1,
+        onWindow: (window) => {
+          surfaces.push(window.surface?.compiling);
+        },
+      },
+      renderer: {
+        canvas,
+        preferWebGPU: false,
+        webgl2Factory: () => ({
+          compileAsync: () => Promise.resolve(),
+          domElement: canvas,
+          render: () => undefined,
+          setSize: () => undefined,
+        }),
+      },
+      scenes: { test: EmptySceneForReporting },
+      start: "test",
+    });
+    const requestFrame = globalThis.requestAnimationFrame;
+    Object.defineProperty(globalThis, "requestAnimationFrame", {
+      configurable: true,
+      value: (callback: (time: number) => void) => {
+        frame = callback;
+        return 1;
+      },
+    });
+    try {
+      await game.start();
+      if (frame === undefined) throw new Error("Game did not start its loop.");
+      let time = performance.now();
+      for (let index = 0; index < 10; index += 1) {
+        time += 8;
+        frame(time);
+        await Promise.resolve();
+      }
+      await game.ctx?.startup.whenReady();
+      surfaces.length = 0;
+      const ctx = game.ctx;
+      if (ctx === undefined) throw new Error("Game context was not created.");
+      const active = ctx.renderer.compileAsync(ctx.scene, ctx.camera);
+      expect(ctx.renderer.compiling).toBe(true);
+      time += 16.7;
+      frame(time);
+      await active;
+      await Promise.resolve();
+      await ctx.renderer.compileAsync(ctx.scene, ctx.camera);
+      expect(ctx.renderer.compiling).toBe(false);
+      time += 16.7;
+      frame(time);
+      await Promise.resolve();
+      time += 16.7;
+      frame(time);
+      await Promise.resolve();
+      expect(surfaces.slice(-3)).toEqual([true, true, false]);
+    } finally {
+      await game.stop();
+      Object.defineProperty(globalThis, "requestAnimationFrame", {
+        configurable: true,
+        value: requestFrame,
+      });
+    }
+  });
+});