@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/collect-transient-skip.test.ts

@@ -1,3 +1,5 @@
+import * as SceneOwner from '@forgeax/engine-scene';
+
 // feat-20260707-engine-world-clone-transient-for-editor-ssot M1 / m1t2:
 // Collect transient skip test (AC-02 + AC-03).
 //
@@ -9,18 +11,17 @@
 // AC-03 control: non-transient components (Transform) produce output matching
 // pre-fix baseline — boolean judgment does not falsely swallow non-transient components.
 
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { defineComponent, World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
 import type { LocalEntityId, SceneAsset, SceneEntity } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import '@forgeax/engine-render/internal';
-import '@forgeax/engine-render/internal';
-import * as SceneOwner from '@forgeax/engine-scene';
 import { rootsToSceneAsset } from '../collect-scene-asset';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
 import { registerSceneComponents } from './helpers/register-scene-components';
-import { createTestSceneAssetStore } from './helpers/scene-asset-port';
 
-function makeRegistry() {
-  return createTestSceneAssetStore();
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
 }
 
 function localId(n: number): LocalEntityId {
@@ -29,7 +30,6 @@ function localId(n: number): LocalEntityId {
 
 // biome-ignore lint/suspicious/noExplicitAny: branded Handle types differ between allocSharedRef and instantiateScene
 function registerSceneAsset(world: World, asset: SceneAsset): any {
-  registerSceneComponents(world);
   return world.allocSharedRef('SceneAsset', asset);
 }
 
@@ -45,13 +45,16 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     };
 
     const world = new World();
+    registerSceneComponents(world);
     const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const collected = rootsToSceneAsset(reg.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -72,13 +75,16 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     };
 
     const world = new World();
+    registerSceneComponents(world);
     const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const collected = rootsToSceneAsset(reg.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -113,13 +119,16 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     };
 
     const world = new World();
+    registerSceneComponents(world);
     const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const collected = rootsToSceneAsset(reg.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -136,7 +145,7 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
   });
 
   it('(d) control: non-transient component appears unchanged in output', () => {
-    const ctrl = defineComponent('M1T2_Ctrl', { val: 'f32', label: 'string' });
+    const Control = defineComponent('M1T2_Ctrl', { val: 'f32', label: 'string' });
 
     const asset: SceneAsset = {
       kind: 'scene',
@@ -144,14 +153,16 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     };
 
     const world = new World();
-    registerSceneComponents(world, [ctrl]);
+    registerSceneComponents(world, [Control]);
     const reg = makeRegistry();
+    const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const collected = rootsToSceneAsset(reg.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 

package/src/__tests__/components.test-d.ts

@@ -15,12 +15,7 @@
 //   decision §2.6.
 
 import type { InputShapeOf, SchemaOf, ShapeOf } from '@forgeax/engine-ecs';
-import type {
-  Camera,
-  DirectionalLight,
-  MeshFilter,
-  MeshRenderer,
-} from '@forgeax/engine-render/internal';
+import type { Camera, DirectionalLight, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import type { ChildOf, Transform } from '@forgeax/engine-scene';
 import type { Handle } from '@forgeax/engine-types';
 import { describe, expectTypeOf, it } from 'vitest';

package/src/__tests__/components.unit.test.ts

@@ -28,6 +28,7 @@
 // source as ancestorTitles[0]. Top-level imports merged + deduped.
 
 import { AnimationPlayer } from '@forgeax/engine-animation';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import {
   type Component,
   defineComponent,
@@ -36,16 +37,6 @@ import {
   World,
 } from '@forgeax/engine-ecs';
 import { componentDefinition, componentId, componentSchema } from '@forgeax/engine-ecs/internal';
-import {
-  GlyphText,
-  SPRITE_PLAYBACK_MODE_CLAMP,
-  SPRITE_PLAYBACK_MODE_LOOP,
-  SpriteAnimation,
-  type SpritePlaybackMode,
-  SpriteRegionOverride,
-  spritePlaybackModeFromU32,
-  Tilemap,
-} from '@forgeax/engine-render/authoring';
 import {
   ANTIALIAS_NONE,
   BLOOM_DISABLED,
@@ -53,30 +44,40 @@ import {
   CAMERA_PROJECTION_PERSPECTIVE,
   Camera,
   DirectionalLight,
-  extractFrame,
   Layer,
   MeshFilter,
   MeshRenderer,
   orthographic,
   perspective,
-  prepareExtractContext,
   SceneInstance,
   SKYBOX_MODE_CUBEMAP,
   SkyboxBackground,
   type SkyboxMode,
   SortKey,
-  skyboxModeFromF32,
   TONEMAP_NONE,
   TONEMAP_REINHARD,
   TONEMAP_REINHARD_EXTENDED,
-  tonemapFromF32,
-} from '@forgeax/engine-render/internal';
+} from '@forgeax/engine-render';
+import {
+  GlyphText,
+  SpriteAnimation,
+  SpriteRegionOverride,
+  Tilemap,
+} from '@forgeax/engine-render/authoring';
 import * as SceneOwner from '@forgeax/engine-scene';
 import { ChildOf, Children, propagateTransforms, Transform } from '@forgeax/engine-scene';
 import type { Handle, LocalEntityId, SceneAsset, SceneEntity } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
 import { describe, expect, expectTypeOf, it } from 'vitest';
-import { createTestRenderAssetOwner } from './helpers/render-asset-port';
+import { tonemapFromF32 } from '../../../render/src/components/camera';
+import { skyboxModeFromF32 } from '../../../render/src/components/skybox-background';
+import {
+  SPRITE_PLAYBACK_MODE_CLAMP,
+  SPRITE_PLAYBACK_MODE_LOOP,
+  type SpritePlaybackMode,
+  spritePlaybackModeFromU32,
+} from '../../../render/src/components/sprite-playback-mode';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 
 {
   // --- from children.test.ts ---
@@ -2456,7 +2457,7 @@ import { createTestRenderAssetOwner } from './helpers/render-asset-port';
   describe('render-system-extract count-mismatch (w12, AC-05 a)', () => {
     it('single mesh single material: extract succeeds', () => {
       const world = new World();
-      const assets = createTestRenderAssetOwner(
+      const assets = new AssetRegistry(
         // biome-ignore lint/suspicious/noExplicitAny: mock ShaderRegistry
         { findMaterialArtifact: () => ({ ok: false }) } as any,
       );
@@ -2501,7 +2502,7 @@ import { createTestRenderAssetOwner } from './helpers/render-asset-port';
     it('materials: [] with submeshes: [1] routes through D-Q7 case B mid-grey default (preserves legacy single-mesh-no-material path)', () => {
       const world = new World();
 
-      const assets = createTestRenderAssetOwner(
+      const assets = new AssetRegistry(
         // biome-ignore lint/suspicious/noExplicitAny: mock ShaderRegistry
         { findMaterialArtifact: () => ({ ok: false }) } as any,
       );
@@ -2541,7 +2542,7 @@ import { createTestRenderAssetOwner } from './helpers/render-asset-port';
     it('materials overflow emits a diagnostic and ignores the extra override', () => {
       const world = new World();
 
-      const assets = createTestRenderAssetOwner(
+      const assets = new AssetRegistry(
         // biome-ignore lint/suspicious/noExplicitAny: mock ShaderRegistry
         { findMaterialArtifact: () => ({ ok: false }) } as any,
       );

package/src/__tests__/composite-skybox-cross-world.browser.test.ts

@@ -8,7 +8,7 @@
 // world it resolves against, so both defects are invisible there).
 //
 // The editor drives:
-//   renderer.draw([editorWorld, sceneWorld], { cameraOwner: 0, resourceOwner: 1 })
+//   renderer.draw({ leases, camera: { lease: editorLease }, environment: { lease: sceneLease } })
 // - camera + gizmo (user-tier) meshes live in editorWorld (index 0)
 // - skybox (equirect->cube) + geometry live in sceneWorld  (index 1)
 //
@@ -29,8 +29,8 @@
 // composite frames, (b) the composited frame is neither empty nor uniformly
 // black (skybox sky + lit geometry both reach the swap-chain).
 
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
 import { halfFloat } from '@forgeax/engine-math';
 import {
   Camera,
@@ -41,14 +41,14 @@ import {
   SkyboxBackground,
   Skylight,
   TONEMAP_REINHARD_EXTENDED,
-} from '@forgeax/engine-render/internal';
+} from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import type { EquirectAsset, Handle, MaterialAsset, MeshAsset } from '@forgeax/engine-types';
 import { afterEach, describe, expect, it } from 'vitest';
 import { page } from 'vitest/browser';
-import { Engine } from '../index';
+import { constructRuntimeRendererHost } from '../renderer-host';
 
-type EngineRenderer = Awaited<ReturnType<typeof Engine.create>>;
+type EngineRenderer = import('@forgeax/engine-render').Renderer;
 
 // Suppress the known chromium teardown race (device GC'd while a shader
 // getCompilationInfo is in flight) — same guard the 9-light browser test uses.
@@ -121,11 +121,10 @@ function litBox(
     ],
     values: { baseColor: [color[0], color[1], color[2]], metallic: 0, roughness: 0.5 },
   });
-  const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
   world
     .spawn(
       { component: Transform, data: { pos: [x, y, 0], scale: [1.2, 1.2, 1.2] } },
-      { component: MeshFilter, data: { assetHandle: cubeHandle } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle] } },
     )
     .unwrap();
@@ -159,7 +158,7 @@ async function decodePngBase64(b64: string): Promise<Uint8Array> {
 
 // Compositor-independent readback: drive N frames, then capture the actual
 // presented canvas via the CDP-backed page.screenshot (locator scoped to the
-// canvas). The createImageBitmap(canvas) path (renderer.readPixels) depends on
+// canvas). The createImageBitmap(canvas) path is owned by this test harness and depends on
 // the chromium compositor having consumed the WebGPU swap-chain before the
 // bounce, which is unreliable headless/local (documented in
 // light-casters-9-light.browser.test.ts). The screenshot path reads the
@@ -167,15 +166,26 @@ async function decodePngBase64(b64: string): Promise<Uint8Array> {
 async function readbackAfterComposite(
   renderer: EngineRenderer,
   worlds: World[],
+  canvas: HTMLCanvasElement,
   canvasId: string,
 ): Promise<Uint8Array> {
-  for (const world of worlds) {
-    const attached = renderer.attachWorld(world);
+  const leases = worlds.map((world) => {
+    const attached = renderer.attach(world);
     if (!attached.ok) throw attached.error;
-  }
+    return attached.value;
+  });
   for (let i = 0; i < FRAMES; i++) {
     for (const world of worlds) world.update(1 / 60).unwrap();
-    const r = renderer.draw(worlds, { cameraOwner: 0, resourceOwner: 1 });
+    const cameraLease = leases[0];
+    const environmentLease = leases[1];
+    if (cameraLease === undefined || environmentLease === undefined) {
+      throw new Error('composite frame requires camera and environment leases');
+    }
+    const r = renderer.draw({
+      leases,
+      camera: { lease: cameraLease },
+      environment: { lease: environmentLease },
+    });
     if (!r.ok) throw new Error(`renderer.draw frame ${i} failed: ${r.error.code}`);
     await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
   }
@@ -194,9 +204,17 @@ async function readbackAfterComposite(
   } catch {
     // Fallback: createImageBitmap(canvas) bounce (may read all-zero if the
     // compositor has not consumed the swap-chain — handled by the alpha gate).
-    const r = await renderer.readPixels();
-    if (!r.ok) throw new Error(`readPixels fallback failed: ${r.error.code}`);
-    return r.value;
+    const bitmap = await createImageBitmap(canvas);
+    const offscreen = new OffscreenCanvas(bitmap.width, bitmap.height);
+    const context = offscreen.getContext('2d', { willReadFrequently: true });
+    if (context === null) {
+      bitmap.close();
+      throw new Error('OffscreenCanvas 2D context unavailable for canvas readback');
+    }
+    context.drawImage(bitmap, 0, 0);
+    const image = context.getImageData(0, 0, bitmap.width, bitmap.height);
+    bitmap.close();
+    return new Uint8Array(image.data.buffer, image.data.byteOffset, image.data.byteLength);
   }
 }
 
@@ -249,19 +267,28 @@ describe.skipIf(!browserReady)('composite + skybox + cross-world mesh (ENGINE-fi
     canvas.style.display = 'block';
     document.body.appendChild(canvas);
 
-    renderer = await Engine.create(canvas, {}, { shaderManifestUrl: '/shaders/manifest.json' });
-    expect(renderer.backend).toBe('webgpu');
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
+    const host = await constructRuntimeRendererHost(
+      canvas,
+      {},
+      {
+        shaderManifestUrl: '/shaders/manifest.json',
+      },
+    );
+    expect(host.ok).toBe(true);
+    if (!host.ok) throw host.error;
+    renderer = host.value.renderer;
+    expect(renderer.inspect().state).toBe('alive');
 
     const diagnostics: Diag[] = [];
-    renderer.onError((e) =>
+    renderer.subscribe((event) => {
+      if (event.kind !== 'error') return;
+      const error = event.error;
       diagnostics.push({
-        code: e.code,
-        hint: e.hint,
-        detail: (e as unknown as { detail?: unknown }).detail,
-      }),
-    );
+        code: error.code,
+        hint: error.hint,
+        detail: (error as unknown as { detail?: unknown }).detail,
+      });
+    });
 
     // editorWorld (cameraOwner, index 0): camera + directional light + one
     // user-tier gizmo mesh. NO skybox, NO scene geometry.
@@ -329,7 +356,12 @@ describe.skipIf(!browserReady)('composite + skybox + cross-world mesh (ENGINE-fi
     litBox(sceneWorld, [0.15, 0.8, 0.2, 1], 0, 0);
     litBox(sceneWorld, [0.85, 0.15, 0.15, 1], 1.8, 0);
 
-    const pixels = await readbackAfterComposite(renderer, [editorWorld, sceneWorld], canvas.id);
+    const pixels = await readbackAfterComposite(
+      renderer,
+      [editorWorld, sceneWorld],
+      canvas,
+      canvas.id,
+    );
     // The screenshot path returns the canvas element's composited surface
     // (clipped to its layout box, so its size is source-dependent); the
     // fallback createImageBitmap path returns exactly CANVAS_W*CANVAS_H*4.
@@ -350,7 +382,7 @@ describe.skipIf(!browserReady)('composite + skybox + cross-world mesh (ENGINE-fi
     // against the world it was extracted from. A cross-world resolution
     // surfaces one of two signatures depending on whether the foreign slot
     // is vacant or occupied in the (wrong) resource-owner world:
-    //   - vacant foreign slot -> shared-ref lookup miss -> `asset-not-registered`
+    //   - vacant slot   -> resolveAssetHandle miss -> `asset-not-registered`
     //   - occupied slot -> wrong-kind payload (here the sceneWorld equirect
     //     shares the gizmo's user-tier slot) -> ensureResident has no arm
     //     for kind:'equirect' -> undefined -> `residentRes.ok` throws ->

package/src/__tests__/compressed-texture-physical-extent.integration.test.ts

@@ -0,0 +1,139 @@
+import { numMipLevels } from '@forgeax/engine-assets-runtime';
+import { ok, type RhiCaps } from '@forgeax/engine-rhi';
+import type { TextureAsset } from '@forgeax/engine-types';
+import { toShared } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { GpuResidencyCache } from '../../../render/src/device/gpu-residency';
+import { deriveMipUploadLayout } from '../../../render/src/render-data';
+
+type TextureCall = { readonly size: { readonly width: number; readonly height: number } };
+type WriteCall = {
+  readonly data: Uint8Array;
+  readonly layout: { readonly bytesPerRow: number; readonly rowsPerImage: number };
+  readonly size: { readonly width: number; readonly height: number };
+};
+
+const caps: RhiCaps = {
+  backendKind: 'webgpu',
+  compute: true,
+  timestampQuery: false,
+  timestampPeriodNanoseconds: null,
+  indirectDrawing: false,
+  textureCompressionBc: true,
+  textureCompressionEtc2: false,
+  textureCompressionAstc: false,
+  multiDrawIndirect: false,
+  pushConstants: false,
+  textureBindingArray: false,
+  samplerAliasing: false,
+  firstInstanceIndirect: false,
+  storageBuffer: true,
+  storageTexture: false,
+  rgba16floatRenderable: true,
+  rg11b10ufloatRenderable: false,
+  float32Filterable: false,
+  maxColorAttachments: 8,
+};
+
+function makeStore(calls: { create: TextureCall[]; writes: WriteCall[] }): GpuResidencyCache {
+  const store = new GpuResidencyCache();
+  const texture = { tag: 'texture' };
+  store.configureGpuDevice(
+    {
+      limits: { maxTextureDimension2D: 16384 },
+      createTexture: (descriptor: TextureCall) => {
+        calls.create.push(descriptor);
+        return ok(texture);
+      },
+      createTextureView: () => ok({ tag: 'view' }),
+      destroyTexture: () => ok(undefined),
+      queue: {
+        writeTexture: (
+          _dst: unknown,
+          data: Uint8Array,
+          layout: WriteCall['layout'],
+          size: WriteCall['size'],
+        ) => {
+          calls.writes.push({ data, layout, size });
+          return ok(undefined);
+        },
+        submit: () => ok(undefined),
+      },
+    } as never,
+    undefined,
+    (() => ok(toShared<'EquirectAsset'>(1))) as never,
+    caps,
+  );
+  return store;
+}
+
+function compressedPod(): TextureAsset {
+  const layout = deriveMipUploadLayout(
+    'bc7-rgba-unorm',
+    2085,
+    1573,
+    numMipLevels({ width: 2085, height: 1573 }),
+  );
+  const bytes = new Uint8Array(layout.reduce((total, level) => total + level.byteLength, 0));
+  for (const level of layout)
+    bytes.fill(level.level + 1, level.byteOffset, level.byteOffset + level.byteLength);
+  return {
+    kind: 'texture',
+    width: 2085,
+    height: 1573,
+    format: 'bc7-rgba-unorm',
+    data: bytes,
+    colorSpace: 'linear',
+    mipmap: true,
+    mipLevelCount: layout.length,
+  };
+}
+
+describe('compressed texture physical extent recorded-RHI witness [w36]', () => {
+  it('allocates and uploads BC7 physical extents while preserving logical asset metadata', () => {
+    const calls = { create: [] as TextureCall[], writes: [] as WriteCall[] };
+    const pod = compressedPod();
+    const expected = deriveMipUploadLayout(pod.format, pod.width, pod.height, numMipLevels(pod));
+
+    const result = makeStore(calls).ensureResident(toShared<'TextureAsset'>(36), pod);
+    if (!result.ok) throw result.error;
+
+    expect(pod.width).toBe(2085);
+    expect(pod.height).toBe(1573);
+    expect(calls.create).toHaveLength(1);
+    expect(calls.create[0]?.size).toMatchObject({ width: 2088, height: 1576 });
+    expect(calls.writes).toHaveLength(expected.length);
+    for (const [index, level] of expected.entries()) {
+      const write = calls.writes[index];
+      expect(write?.size).toMatchObject({
+        width: level.physicalWidth,
+        height: level.physicalHeight,
+      });
+      expect(write?.layout).toMatchObject({
+        bytesPerRow: level.bytesPerRow,
+        rowsPerImage: level.rowsPerImage,
+      });
+      expect(write?.data.byteLength).toBe(level.byteLength);
+      expect(write?.data[0]).toBe(level.level + 1);
+    }
+  });
+
+  it('keeps the uncompressed allocation and upload extent logical', () => {
+    const calls = { create: [] as TextureCall[], writes: [] as WriteCall[] };
+    const pod: TextureAsset = {
+      kind: 'texture',
+      width: 17,
+      height: 9,
+      format: 'rgba8unorm',
+      data: new Uint8Array(17 * 9 * 4),
+      colorSpace: 'linear',
+      mipmap: false,
+    };
+
+    expect(makeStore(calls).ensureResident(toShared<'TextureAsset'>(37), pod).ok).toBe(true);
+
+    expect(calls.create[0]?.size).toMatchObject({ width: 17, height: 9 });
+    expect(calls.writes[0]?.size).toMatchObject({ width: 17, height: 9 });
+    expect(calls.writes[0]?.layout).toMatchObject({ bytesPerRow: 68, rowsPerImage: 9 });
+  });
+});

package/src/__tests__/create-renderer-assembly.integration.test.ts

@@ -1,42 +1,55 @@
+import { World } from '@forgeax/engine-ecs';
+import type { Renderer } from '@forgeax/engine-render';
 import { rhi } from '@forgeax/engine-rhi-null';
 import { describe, expect, it } from 'vitest';
+import { constructRendererHost } from '../../../render/src/construct-renderer';
 import { createRenderer } from '../createRenderer';
 import { EngineEnvironmentError } from '../errors/environment';
 
 function canvas(): HTMLCanvasElement {
-  return {
-    width: 64,
-    height: 64,
-    getContext: () => null,
-    addEventListener: () => undefined,
-    removeEventListener: () => undefined,
-  } as unknown as HTMLCanvasElement;
+  return { width: 64, height: 64, getContext: () => null } as unknown as HTMLCanvasElement;
 }
 
-const manifest = `data:application/json,${encodeURIComponent(
-  JSON.stringify({
-    schemaVersion: '1.0.0',
-    entries: [
-      { hash: 'pbr00000', wgsl: '/* pbr stub */', glsl: '', bindings: '' },
-      { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
-      { hash: 'tonemap0', wgsl: '/* tonemap stub */', glsl: '', bindings: '' },
-    ],
-  }),
-)}`;
+const manifest = `data:application/json,${encodeURIComponent(JSON.stringify({ schemaVersion: '1.0.0', entries: [] }))}`;
 
-describe('runtime assembly contract', () => {
-  it('resolves a renderer and exposes Result lifecycle methods', async () => {
-    const renderer = await createRenderer(canvas(), { rhi }, { shaderManifestUrl: manifest });
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
-    expect(renderer.draw([], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    renderer.dispose();
-    expect(renderer.draw([], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(false);
+function frameRequest(lease: Parameters<Renderer['draw']>[0]['leases'][number]) {
+  return { leases: [lease], camera: { lease }, environment: { lease } };
+}
+
+describe('runtime renderer host assembly', () => {
+  it('returns assets beside the lease-only Renderer surface', async () => {
+    const host = await constructRendererHost(canvas(), { rhi }, { shaderManifestUrl: manifest });
+    expect(host.ok).toBe(true);
+    if (!host.ok) return;
+    expect(host.value.assets.inspect()).toBeDefined();
+    const world = new World();
+    const attached = host.value.renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    expect(world.update().ok).toBe(true);
+    const frame = host.value.renderer.draw(frameRequest(attached.value));
+    expect(frame.ok).toBe(true);
+    if (frame.ok) {
+      const observed = await host.value.renderer.observe(frame.value, { include: ['timings'] });
+      expect(observed.ok).toBe(true);
+    }
+    host.value.renderer.dispose();
   });
 
-  it('preserves structured environment rejection when no backend is available', async () => {
-    await expect(createRenderer(canvas(), { rhi: undefined })).rejects.toBeInstanceOf(
-      EngineEnvironmentError,
-    );
+  it('keeps runtime construction errors structured', async () => {
+    const result = await createRenderer(canvas(), { rhi: undefined });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toBeInstanceOf(EngineEnvironmentError);
+  });
+
+  it('does not add removed backend or readiness properties', async () => {
+    const result = await createRenderer(canvas(), { rhi }, { shaderManifestUrl: manifest });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const renderer = result.value;
+    expect(renderer).not.toHaveProperty('backend');
+    expect(renderer).not.toHaveProperty('ready');
+    expect(renderer).not.toHaveProperty('assets');
+    renderer.dispose();
   });
 });