@forgeax/engine-runtime 0.1.3 → 0.1.6

package/src/__tests__/transient-runtime-behavior.test.ts

@@ -0,0 +1,227 @@
+// feat-20260707-engine-world-clone-transient-for-editor-ssot M3 / m3t2:
+// Transient runtime behavior test (AC-07).
+//
+// AC-07: transient components remain fully functional at runtime despite
+// being skipped by collect. Design doc §6.6 semantic boundary:
+// "transient only affects rootsToSceneAsset write step — not runtime presence."
+//
+// Scenarios:
+//   (a) After rootsToSceneAsset runs on a world with Children (transient: true):
+//       world.get(entity, Children) returns ok with Children data.
+//   (b) query with Children in the query set still matches the entity after collect.
+//   (c) world.get(entity, SceneInstance) returns ok after collect.
+//   (d) Collect is non-mutating: world.get entity Children before/after collect
+//       returns the same value.
+//   (e) InstantiateScene on SceneAsset without Children data → mirror hook
+//       populates Children correctly for parent entity.
+//
+// Depends on m2t4 (deferred ChildOf wiring) — ChildOf hierarchy is the
+// canonical cause of Children being populated by the mirror hook.
+
+import type { Asset } from '@forgeax/engine-assets-runtime';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { type EntityHandle, World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { SceneInstance } from '@forgeax/engine-render';
+import { ChildOf, Children, Transform } from '@forgeax/engine-scene';
+import type { Handle, LocalEntityId, SceneAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { rootsToSceneAsset } from '../collect-scene-asset';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+
+function makeWorld(): World {
+  const world = new World();
+  for (const component of [Transform, ChildOf, Children, SceneInstance]) {
+    world.components.register(component).unwrap();
+  }
+  return world;
+}
+
+function localId(n: number): LocalEntityId {
+  return n as LocalEntityId;
+}
+
+function cat(reg: AssetRegistry, g: string, p: SceneAsset): void {
+  const r = AssetGuid.parse(g);
+  if (!r.ok) throw new Error(`bad GUID: ${g}`);
+  reg.catalog(r.value, p as Asset);
+}
+
+function rs(w: World, a: SceneAsset): Handle<'SceneAsset', 'shared'> {
+  return w.allocSharedRef('SceneAsset', a);
+}
+
+describe('m3t2 — transient runtime behavior (AC-07)', () => {
+  it('(a) world.get Children ok after rootsToSceneAsset', () => {
+    const world = makeWorld();
+    const reg = makeRegistry();
+
+    // Build a hierarchy: parent -> child via ChildOf. Mirror hook populates Children.
+    const parent = world.spawn({ component: Transform, data: {} }).unwrap();
+    world
+      .spawn({ component: Transform, data: {} }, { component: ChildOf, data: { parent } })
+      .unwrap();
+
+    // Children should be populated by mirror hook
+    const preChildren = world.get(parent, Children);
+    expect(preChildren.ok).toBe(true);
+
+    // Collect an unrelated scene — this exercises the collect path but never
+    // touches the manually-spawned entity
+    const asset: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: localId(0), components: {} }],
+    };
+    cat(reg, '00000000-0000-4000-8000-000000000000', asset);
+    const inst = reg.instantiate(rs(world, asset), world);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+
+    const collected = rootsToSceneAsset(reg, world, [inst.value]);
+    expect(collected.ok).toBe(true);
+
+    // After collect, Children is STILL in the archetype — transient means skip
+    // during serialization, not removal from the live world
+    const postChildren = world.get(parent, Children);
+    expect(postChildren.ok).toBe(true);
+    if (!postChildren.ok) return;
+    const entities = postChildren.value.entities;
+    expect(entities).toBeDefined();
+    expect(entities.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('(b) query with Children still matches entity after collect', () => {
+    const world = makeWorld();
+    const reg = makeRegistry();
+
+    const parent = world.spawn({ component: Transform, data: {} }).unwrap();
+    world
+      .spawn({ component: Transform, data: {} }, { component: ChildOf, data: { parent } })
+      .unwrap();
+
+    // Verify Children is present before collect
+    const preChildren = world.get(parent, Children);
+    expect(preChildren.ok).toBe(true);
+    if (!preChildren.ok) return;
+    expect(preChildren.value.entities.length).toBeGreaterThanOrEqual(1);
+
+    // Collect an unrelated scene to exercise the collect code path
+    const asset: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: localId(0), components: {} }],
+    };
+    cat(reg, '11111111-1111-4111-8111-111111111111', asset);
+    const inst = reg.instantiate(rs(world, asset), world);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    rootsToSceneAsset(reg, world, [inst.value]);
+
+    // After collect, query including Children should still match the parent entity.
+    // Include Entity in the `with` list to count matched rows.
+    const query = world.query({ with: [Children] }).unwrap();
+    let matchedCount = 0;
+    for (const _row of query) matchedCount += 1;
+    expect(matchedCount).toBeGreaterThanOrEqual(1);
+  });
+
+  it('(c) world.get SceneInstance ok after collect', () => {
+    const world = makeWorld();
+    const reg = makeRegistry();
+
+    const child: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: localId(0), components: {} }],
+    };
+    cat(reg, '22222222-2222-4222-8222-222222222222', child);
+    const inst = reg.instantiate(rs(world, child), world);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+
+    // pre-collect: SceneInstance is present
+    const preSI = world.get(inst.value, SceneInstance);
+    expect(preSI.ok).toBe(true);
+
+    // Collect the same root
+    const collected = rootsToSceneAsset(reg, world, [inst.value]);
+    expect(collected.ok).toBe(true);
+
+    // post-collect: SceneInstance is still present (it's transient, not removed)
+    const postSI = world.get(inst.value, SceneInstance);
+    expect(postSI.ok).toBe(true);
+  });
+
+  it('(d) collect is non-mutating: Children pre/post equals', () => {
+    const world = makeWorld();
+    const reg = makeRegistry();
+
+    const parent = world.spawn({ component: Transform, data: {} }).unwrap();
+    world
+      .spawn({ component: Transform, data: {} }, { component: ChildOf, data: { parent } })
+      .unwrap();
+
+    const preChildren = world.get(parent, Children);
+    expect(preChildren.ok).toBe(true);
+    if (!preChildren.ok) return;
+    const preLength = preChildren.value.entities.length;
+
+    // Collect an unrelated scene
+    const asset: SceneAsset = {
+      kind: 'scene',
+      entities: [{ localId: localId(0), components: {} }],
+    };
+    cat(reg, '33333333-3333-4333-8333-333333333333', asset);
+    const inst = reg.instantiate(rs(world, asset), world);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+    rootsToSceneAsset(reg, world, [inst.value]);
+
+    const postChildren = world.get(parent, Children);
+    expect(postChildren.ok).toBe(true);
+    if (!postChildren.ok) return;
+    // children count unchanged (collect does not mutate the world)
+    expect(postChildren.value.entities.length).toBe(preLength);
+  });
+
+  it('(e) instantiateScene of Children-absent SceneAsset → mirror hook populates Children', () => {
+    const world = makeWorld();
+    const reg = makeRegistry();
+
+    // Build a minimal SceneAsset: parent entity at localId 0 + child entity at
+    // localId 1 with ChildOf pointing to localId 0. No Children data in the asset.
+    // The mirror hook should populate Children on entity at localId 0.
+    const asset: SceneAsset = {
+      kind: 'scene',
+      entities: [
+        { localId: localId(0), components: { Transform: {} } },
+        { localId: localId(1), components: { Transform: {}, ChildOf: { parent: localId(0) } } },
+      ],
+    };
+    cat(reg, '44444444-4444-4444-8444-444444444444', asset);
+    const inst = reg.instantiate(rs(world, asset), world);
+    expect(inst.ok).toBe(true);
+    if (!inst.ok) return;
+
+    // The root entity carries SceneInstance with mapping array
+    const siR = world.get(inst.value, SceneInstance);
+    expect(siR.ok).toBe(true);
+    if (!siR.ok) return;
+    const mapping = siR.value.mapping;
+    expect(mapping).toBeDefined();
+
+    // mapping[0] is the entity at localId 0 (the parent). Entity handle 0
+    // is a valid entity in forgeax (ENTITY_NULL_RAW = 0xFFFFFFFF, not 0).
+    const parentEntity = mapping[0] as unknown as EntityHandle;
+
+    // The mirror hook should have populated Children on the parent entity
+    // because entity at localId 1 has ChildOf{parent = localId 0}
+    const cr = world.get(parentEntity, Children);
+    expect(cr.ok).toBe(true);
+    if (!cr.ok) return;
+    const ents = cr.value.entities;
+    expect(ents.length).toBeGreaterThanOrEqual(1);
+  });
+});

package/src/__tests__/transparent-sort-tilemap-sprite-interleave.test.ts

@@ -27,13 +27,13 @@
 // occlude them).
 
 import { World } from '@forgeax/engine-ecs';
-import type { TransparentEntry } from '@forgeax/engine-render/internal';
+import { describe, expect, it } from 'vitest';
+import type { TransparentEntry } from '../../../render/src/systems/transparent-sort-config';
 import {
-  effectivePivotYForTilemapFlip,
   setTransparentSortConfig,
   TRANSPARENT_SORT_MODE_LAYER_Y,
-} from '@forgeax/engine-render/internal';
-import { describe, expect, it } from 'vitest';
+} from '../../../render/src/systems/transparent-sort-config';
+import { effectivePivotYForTilemapFlip } from '../../../render/src/tilemap-chunk-extract-system';
 import { transparentSortEntries } from '../systems/transparent-sort';
 
 const FALSIFY = process.env.FORGEAX_FALSIFY_TILEMAP_SORT;

package/src/__tests__/variant-selection.unit.test.ts

@@ -1,5 +1,5 @@
-import { variantSetFromDefines } from '@forgeax/engine-render/internal';
 import { describe, expect, it } from 'vitest';
+import { variantSetFromDefines } from '../../../render/src/record/helpers';
 
 describe('material pass variant selection', () => {
   it('uses the manifest key order without mutating the pass map', () => {

package/src/__tests__/video-extract-bindgroup.dawn.test.ts

@@ -27,20 +27,12 @@
 //      the per-frame upload itself lands in w16, here the field falls back to the
 //      default view until a frame is uploaded).
 
+import { AssetRegistry, HANDLE_CUBE, HANDLE_QUAD } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPlaneGeometry } from '@forgeax/engine-geometry';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
-import {
-  Camera,
-  extractFrame,
-  MeshFilter,
-  MeshRenderer,
-  prepareExtractContext,
-  type RenderAssetPort,
-} from '@forgeax/engine-render/internal';
+import { Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { propagateTransforms, Transform } from '@forgeax/engine-scene';
 import type {
-  Asset,
   Handle,
   MaterialAsset,
   MaterialPass,
@@ -48,7 +40,13 @@ import type {
   VideoAsset,
 } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../index';
+import {
+  Camera as SourceCamera,
+  MeshFilter as SourceMeshFilter,
+  MeshRenderer as SourceMeshRenderer,
+} from '../../../render/src/components';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
+import { constructRuntimeRendererHost } from '../renderer-host';
 import { drawPublished } from './draw-published';
 import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
 
@@ -72,63 +70,21 @@ function transformData(x: number, y: number, z: number) {
 }
 
 function registerTestMesh(world: World) {
-  const mesh = createPlaneGeometry(1, 1);
-  if (!mesh.ok) throw new Error(mesh.error.code);
-  return world.allocSharedRef<'MeshAsset', MeshAsset>('MeshAsset', mesh.value);
-}
-
-interface TestAssetStore {
-  readonly port: RenderAssetPort;
-  readonly resolver: {
-    readonly epoch: number;
-    lookup<T extends Asset>(guid: string): T | undefined;
-    guidOf(asset: Asset): string | undefined;
-  };
-  publish(guid: string | AssetGuid, asset: Asset): void;
-}
-
-function createTestAssetStore(): TestAssetStore {
-  const shaderRegistry = makeMockShaderRegistry();
-  const payloads = new Map<string, Asset>();
-  const guids = new WeakMap<object, string>();
-  let epoch = 0;
-  const keyOf = (guid: string): string => guid.toLowerCase().replaceAll('-', '');
-  const resolver = {
-    get epoch() {
-      return epoch;
-    },
-    lookup<T extends Asset>(guid: string): T | undefined {
-      return payloads.get(keyOf(guid)) as T | undefined;
-    },
-    guidOf(asset: Asset): string | undefined {
-      return guids.get(asset);
-    },
-  };
-  const port: RenderAssetPort = {
-    get epoch() {
-      return resolver.epoch;
-    },
-    shaderRegistry,
-    lookup: resolver.lookup,
-    guidOf: resolver.guidOf,
-    materialShaderTextureFieldNames(shaderId: string): readonly string[] {
-      const artifact = shaderRegistry.findMaterialArtifact(shaderId);
-      if (!artifact.ok) return [];
-      return artifact.value.paramSchema
-        .filter((parameter) => parameter.type === 'texture2d')
-        .map((parameter) => parameter.name);
-    },
-  };
-  return {
-    port,
-    resolver,
-    publish(guid, asset) {
-      const formatted = typeof guid === 'string' ? guid : AssetGuid.format(guid);
-      payloads.set(keyOf(formatted), asset);
-      guids.set(asset, formatted);
-      epoch += 1;
+  const mesh: MeshAsset = {
+    kind: 'mesh',
+    vertices: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]),
+    indices: new Uint16Array([0, 1, 2]),
+    attributes: {
+      position: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]),
     },
+    aabb: new Float32Array([0, 0, 0, 1, 1, 1]),
+    submeshes: [
+      { indexOffset: 0, indexCount: 3, vertexCount: 3, topology: 'triangle-list', materialSlot: 0 },
+    ],
+
+    materialSlots: [{ slotName: 'Default' }],
   };
+  return world.allocSharedRef<'MeshAsset', MeshAsset>('MeshAsset', mesh);
 }
 
 /**
@@ -137,29 +93,19 @@ function createTestAssetStore(): TestAssetStore {
  */
 function catalogVideoMaterial(
   world: World,
-  assets: TestAssetStore,
+  assets: AssetRegistry,
 ): { matHandle: Handle<'MaterialAsset', 'shared'>; videoGuid: AssetGuid } {
   const videoGuid = AssetGuid.random();
   const videoGuidStr = AssetGuid.format(videoGuid);
   const video: VideoAsset = { kind: 'video', url: 'extract-bindgroup-clip.webm' };
-  assets.publish(videoGuid, video);
+  assets.catalog(videoGuid, video);
 
   const material: MaterialAsset = {
     kind: 'material',
     passes: [FORWARD_PBR_PASS],
     // The video GUID occupies the baseColorTexture texture2d slot — exactly the
     // shape a static texture would (D-5 reuse of the texture2d slot).
-    values: {
-      baseColor: [1, 1, 1],
-      baseColorTexture: {
-        texture: videoGuidStr as never,
-        coordinates: {
-          set: 0,
-          transform: { offset: [0, 0], scale: [1, 1], rotation: 0 },
-          physicalUvScale: [1, 1],
-        },
-      },
-    },
+    values: { baseColor: [1, 1, 1], baseColorTexture: { texture: videoGuidStr as never } },
   } as MaterialAsset;
   const matHandle = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', material);
   return { matHandle, videoGuid };
@@ -167,33 +113,34 @@ function catalogVideoMaterial(
 
 describe('AC-06 / R-7 — video GUID in values is a recognised texture field (M4 / w13)', () => {
   it('R-7: baseColorTexture is in the standard-PBR shader textureFieldNames set', () => {
-    const assets = createTestAssetStore();
-    const fields = assets.port.materialShaderTextureFieldNames(STANDARD_PBR_SHADER);
-    expect(fields).toContain('baseColorTexture');
+    const assets = new AssetRegistry(makeMockShaderRegistry());
+    const fields = assets.materialShaderTextureFieldNames(STANDARD_PBR_SHADER);
+    expect(fields, 'standard-PBR shader must declare texture fields').toBeDefined();
+    expect(fields?.has('baseColorTexture')).toBe(true);
   });
 
   it('extract flags the video-sourced field and does NOT carry it as a static TextureAsset handle', () => {
     const world = new World();
-    const assets = createTestAssetStore();
+    const assets = new AssetRegistry(makeMockShaderRegistry());
     const mesh = registerTestMesh(world);
     const { matHandle } = catalogVideoMaterial(world, assets);
 
     world
       .spawn(
-        { component: Transform, data: transformData(0, 0, 0) },
-        { component: MeshFilter, data: { assetHandle: mesh } },
-        { component: MeshRenderer, data: { materials: [matHandle] } },
+        { component: Transform, data: transformData(0, 0, 5) },
+        { component: SourceCamera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
       )
       .unwrap();
     world
       .spawn(
-        { component: Transform, data: transformData(0, 0, 5) },
-        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+        { component: Transform, data: transformData(0, 0, 0) },
+        { component: SourceMeshFilter, data: { assetHandle: mesh } },
+        { component: SourceMeshRenderer, data: { materials: [matHandle] } },
       )
       .unwrap();
 
     propagateTransforms(world);
-    const frame = extractFrame(world, prepareExtractContext(world, { assets: assets.port }));
+    const frame = extractFrame(world, prepareExtractContext(world, { assets, cull: 'none' }));
     expect(frame.renderables.length).toBe(1);
     const mat = frame.renderables[0]?.material;
     expect(mat).toBeDefined();
@@ -209,7 +156,8 @@ describe('AC-06 / R-7 — video GUID in values is a recognised texture field (M4
 });
 
 interface DawnHarness {
-  renderer: Awaited<ReturnType<typeof createRenderer>>;
+  renderer: import('@forgeax/engine-render').Renderer;
+  assets: AssetRegistry;
   device: GPUDevice;
 }
 
@@ -221,7 +169,7 @@ const ENGINE_MANIFEST_URL = `data:application/json,${encodeURIComponent(
   JSON.stringify(ENGINE_MANIFEST),
 )}`;
 
-async function bootDawn(assetStore: TestAssetStore): Promise<DawnHarness | null> {
+async function bootDawn(): Promise<DawnHarness | null> {
   const dawnAvailable = typeof globalThis.navigator?.gpu?.requestAdapter === 'function';
   if (!dawnAvailable) {
     throw new Error('dawn-node navigator.gpu not injected; vitest.setup-webgpu.ts regressed');
@@ -278,64 +226,65 @@ async function bootDawn(assetStore: TestAssetStore): Promise<DawnHarness | null>
     removeEventListener() {},
   } as unknown as HTMLCanvasElement;
 
-  let renderer: Awaited<ReturnType<typeof createRenderer>>;
+  let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
   try {
-    renderer = await createRenderer(
+    host = await constructRuntimeRendererHost(
       mockCanvas,
       {},
-      { shaderManifestUrl: ENGINE_MANIFEST_URL, assetResolver: assetStore.resolver },
+      {
+        shaderManifestUrl: ENGINE_MANIFEST_URL,
+      },
     );
   } finally {
     globalThis.navigator.gpu.requestAdapter = originalRequestAdapter;
   }
-  const ready = await renderer.ready;
-  expect(ready.ok).toBe(true);
-  if (!ready.ok) return null;
+  expect(host.ok).toBe(true);
+  if (!host.ok) throw host.error;
+  const { renderer, assets } = host.value;
+  expect(renderer.inspect().state).toBe('alive');
   if (sharedDevice === undefined) throw new Error('dawn device never captured');
   ensureRenderTarget(sharedDevice, 'rgba8unorm');
-  return { renderer, device: sharedDevice };
+  return { renderer, assets, device: sharedDevice };
 }
 
 describe('AC-06 — extract->record->bind group does not blow up on a video field (dawn) (M4 / w13)', () => {
   it('a renderer frame with a video-sourced baseColorTexture draws with 0 RhiError', async () => {
-    const assetStore = createTestAssetStore();
-    const harness = await bootDawn(assetStore);
+    const harness = await bootDawn();
     if (harness === null) return;
-    const { renderer, device } = harness;
+    const { renderer, assets, device } = harness;
 
     const videoGuid = AssetGuid.random();
     const videoGuidStr = AssetGuid.format(videoGuid);
     const video: VideoAsset = { kind: 'video', url: 'extract-bindgroup-clip.webm' };
-    assetStore.publish(videoGuid, video);
+    const videoCatalog = assets.catalog(videoGuid, video as never);
+    expect(videoCatalog.ok).toBe(true);
 
     const materialPayload = {
       kind: 'material' as const,
       passes: [FORWARD_PBR_PASS],
       values: {
         baseColor: [1, 1, 1],
-        baseColorTexture: {
-          texture: videoGuidStr,
-          coordinates: {
-            set: 0,
-            transform: { offset: [0, 0], scale: [1, 1], rotation: 0 },
-            physicalUvScale: [1, 1],
-          },
-        },
+        baseColorTexture: { texture: videoGuidStr as never },
       },
     };
 
-    const errorCodes: string[] = [];
-    const unsub = renderer.onError((e) => {
-      errorCodes.push(e.code);
+    const errorCodes: Array<{ code: string; causeCode?: string }> = [];
+    const unsub = renderer.subscribe((event) => {
+      if (event.kind !== 'error') return;
+      errorCodes.push({
+        code: event.error.code,
+        ...(event.error.code === 'device-operation-failed'
+          ? { causeCode: event.error.detail.cause.code }
+          : {}),
+      });
     });
 
     const world = new World();
-    const meshHandle = registerTestMesh(world);
     const matHandle = world.allocSharedRef('MaterialAsset', materialPayload);
     world
       .spawn(
         { component: Transform, data: transformData(0, 0, 0) },
-        { component: MeshFilter, data: { assetHandle: meshHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
         { component: MeshRenderer, data: { materials: [matHandle] } },
       )
       .unwrap();
@@ -355,7 +304,10 @@ describe('AC-06 — extract->record->bind group does not blow up on a video fiel
     // (the bind group is well-formed; the field falls back to the default view).
     // The expected, structured `video-upload-unsupported` signal (AC-10, asserted
     // below) is NOT a validation error and is excluded here.
-    const validationErrors = errorCodes.filter((c) => c !== 'video-upload-unsupported');
+    const validationErrors = errorCodes.filter(
+      (event) =>
+        event.code !== 'video-upload-unsupported' && event.causeCode !== 'video-upload-unsupported',
+    );
     expect(
       validationErrors,
       'a video-sourced texture field must not trip any WebGPU validation error',
@@ -370,20 +322,19 @@ describe('AC-06 — extract->record->bind group does not blow up on a video fiel
   // the production draw path end-to-end, replacing the prior orphan pure-function
   // test (resolveVideoUpload) that the production render path never called.
   it('AC-10: production draw fires video-upload-unsupported on capability double-miss', async () => {
-    const assetStore = createTestAssetStore();
-    const harness = await bootDawn(assetStore);
+    const harness = await bootDawn();
     if (harness === null) return;
-    const { renderer, device } = harness;
+    const { renderer, assets, device } = harness;
 
     const videoGuid = AssetGuid.random();
     const videoGuidStr = AssetGuid.format(videoGuid);
     const video: VideoAsset = { kind: 'video', url: 'double-miss-clip.webm' };
-    assetStore.publish(videoGuid, video);
+    expect(assets.catalog(videoGuid, video as never).ok).toBe(true);
 
-    // Mirror the demo recipe exactly: unlit shader + a World-owned plane. The video
+    // Mirror the demo recipe exactly: unlit shader + HANDLE_QUAD. The video
     // upload path (videoTextureView) is reached via the per-submesh user-region
     // bind-group loop, which iterates the shader's textureFieldNames; unlit
-    // declares baseColorTexture there. (The earlier standard-PBR geometry
+    // declares baseColorTexture there. (The earlier standard-PBR + HANDLE_CUBE
     // shape routes through a different builtin-cube pipeline branch that does not
     // hit the user-region video loop — not the production demo path.)
     const materialPayload = {
@@ -397,32 +348,31 @@ describe('AC-06 — extract->record->bind group does not blow up on a video fiel
       ],
       values: {
         baseColor: [1, 1, 1],
-        baseColorTexture: {
-          texture: videoGuidStr,
-          coordinates: {
-            set: 0,
-            transform: { offset: [0, 0], scale: [1, 1], rotation: 0 },
-            physicalUvScale: [1, 1],
-          },
-        },
+        baseColorTexture: { texture: videoGuidStr as never },
       },
     };
 
-    const fired: { code: string; hint: string }[] = [];
-    const unsub = renderer.onError((e) => {
-      fired.push({ code: e.code, hint: e.hint });
+    const fired: { code: string; causeCode?: string; hint: string }[] = [];
+    const unsub = renderer.subscribe((event) => {
+      if (event.kind !== 'error') return;
+      fired.push({
+        code: event.error.code,
+        ...(event.error.code === 'device-operation-failed'
+          ? { causeCode: event.error.detail.cause.code }
+          : {}),
+        hint: event.error.hint,
+      });
     });
 
     const world = new World();
     // NB: NO VIDEO_ELEMENT_PROVIDER_KEY resource inserted -> the production
     // upload path resolves element===undefined; high-perf path is absent on
     // dawn -> genuine AC-10 double-miss.
-    const meshHandle = registerTestMesh(world);
     const matHandle = world.allocSharedRef('MaterialAsset', materialPayload);
     world
       .spawn(
         { component: Transform, data: transformData(0, 0, 0) },
-        { component: MeshFilter, data: { assetHandle: meshHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
         { component: MeshRenderer, data: { materials: [matHandle] } },
       )
       .unwrap();
@@ -438,7 +388,10 @@ describe('AC-06 — extract->record->bind group does not blow up on a video fiel
     await device.queue.onSubmittedWorkDone();
     if (typeof unsub === 'function') unsub();
 
-    const unsupported = fired.filter((e) => e.code === 'video-upload-unsupported');
+    const unsupported = fired.filter(
+      (event) =>
+        event.code === 'video-upload-unsupported' || event.causeCode === 'video-upload-unsupported',
+    );
     expect(
       unsupported.length,
       'production videoTextureView must fire video-upload-unsupported on double-miss (AC-10), not silently bind default',