@forgeax/engine-app 0.1.4 → 0.1.6

package/src/__tests__/draw-source-single-world-regression.test.ts

@@ -28,24 +28,21 @@
 //     seam insertion point)
 
 import { World } from '@forgeax/engine-ecs';
-import type { Renderer } from '@forgeax/engine-render';
+import { createRenderReadLease } from '@forgeax/engine-ecs/projection';
+import type { Renderer, RenderFrameInput } from '@forgeax/engine-render';
 import { describe, expect, it } from 'vitest';
 import { createFrameLoop, type FrameLoopOptions } from '../internal/frame-loop';
 
 interface DrawCall {
-  readonly worlds: unknown;
-  readonly options: unknown;
+  readonly request: RenderFrameInput;
 }
 
 function makeSpyRenderer(): { renderer: Renderer; calls: DrawCall[] } {
   const calls: DrawCall[] = [];
   const renderer = {
-    backend: 'webgpu' as const,
-    ready: Promise.resolve({ ok: true, value: undefined }),
-    attachWorld: () => ({ ok: true, value: undefined }),
-    detachWorld: () => {},
-    draw(worlds: unknown, options: unknown): { ok: true; value: undefined } {
-      calls.push({ worlds, options });
+    attach: (world: World) => ({ ok: true, value: createRenderReadLease(world) }),
+    draw(request: RenderFrameInput): { ok: true; value: undefined } {
+      calls.push({ request });
       return { ok: true, value: undefined };
     },
     onError(): () => void {
@@ -119,11 +116,10 @@ describe('drawSource seam degrades to single-world path (w8, AC-03 regression)',
 
     expect(calls.length).toBeGreaterThanOrEqual(3);
     for (const call of calls) {
-      expect(Array.isArray(call.worlds)).toBe(true);
-      const arr = call.worlds as unknown[];
-      expect(arr.length).toBe(1);
-      expect(arr[0]).toBe(world);
-      expect(call.options).toEqual({ cameraOwner: 0, resourceOwner: 0 });
+      expect(call.request.leases).toHaveLength(1);
+      expect(call.request.leases[0]?.worldIdentity).toBe(world.identity);
+      expect(call.request.camera.lease).toBe(call.request.leases[0]);
+      expect(call.request.environment.lease).toBe(call.request.leases[0]);
     }
 
     loop.stop();
@@ -150,11 +146,10 @@ describe('drawSource seam degrades to single-world path (w8, AC-03 regression)',
     expect(pulls).toBeGreaterThanOrEqual(3);
     expect(calls.length).toBeGreaterThanOrEqual(3);
     for (const call of calls) {
-      expect(Array.isArray(call.worlds)).toBe(true);
-      const arr = call.worlds as unknown[];
-      expect(arr.length).toBe(1);
-      expect(arr[0]).toBe(world);
-      expect(call.options).toEqual({ cameraOwner: 0, resourceOwner: 0 });
+      expect(call.request.leases).toHaveLength(1);
+      expect(call.request.leases[0]?.worldIdentity).toBe(world.identity);
+      expect(call.request.camera.lease).toBe(call.request.leases[0]);
+      expect(call.request.environment.lease).toBe(call.request.leases[0]);
     }
 
     loop.stop();
@@ -175,11 +170,15 @@ describe('drawSource seam degrades to single-world path (w8, AC-03 regression)',
     pump(1);
 
     expect(calls).toHaveLength(3);
-    expect(calls[0]?.options).toEqual({ cameraOwner: 0, resourceOwner: 0 });
-    expect(calls[1]?.worlds).toEqual([world, overlay]);
-    expect(calls[1]?.options).toEqual({ cameraOwner: 0, resourceOwner: 0 });
-    expect(calls[2]?.worlds).toEqual([world]);
-    expect(calls[2]?.options).toEqual({ cameraOwner: 0, resourceOwner: 0 });
+    expect(calls[0]?.request.leases).toHaveLength(1);
+    expect(calls[0]?.request.leases[0]?.worldIdentity).toBe(world.identity);
+    expect(calls[1]?.request.leases).toHaveLength(2);
+    expect(calls[1]?.request.leases[0]?.worldIdentity).toBe(world.identity);
+    expect(calls[1]?.request.leases[1]?.worldIdentity).toBe(overlay.identity);
+    expect(calls[1]?.request.camera.lease).toBe(calls[1]?.request.leases[0]);
+    expect(calls[1]?.request.environment.lease).toBe(calls[1]?.request.leases[0]);
+    expect(calls[2]?.request.leases).toHaveLength(1);
+    expect(calls[2]?.request.leases[0]?.worldIdentity).toBe(world.identity);
     loop.stop();
   });
 });

package/src/__tests__/engine-worker-bootstrap-channel.unit.test.ts

@@ -38,6 +38,10 @@ describe('Engine Worker thick bootstrap channel', () => {
       bootstrapUrl: 'https://example.test/bootstrap.js',
       bootstrapData: { gameId: 'sample' },
       bootstrapPort: channel.port2,
+      assetCatalog: {
+        url: '/__pack/scopes/sample/7/catalog.json',
+        expectedScope: { scopeId: 'sample', generation: 7 },
+      },
       timeoutMs: 100,
       tier: 'engine-worker',
       workerFactory: () => worker as unknown as Worker,
@@ -49,6 +53,10 @@ describe('Engine Worker thick bootstrap channel', () => {
       kind: 'init',
       bootstrapData: { gameId: 'sample' },
       bootstrapPort: channel.port2,
+      assetCatalog: {
+        url: '/__pack/scopes/sample/7/catalog.json',
+        expectedScope: { scopeId: 'sample', generation: 7 },
+      },
     });
     expect(worker.posts[0]?.transfer).toEqual([offscreen, channel.port2]);
     started.ok && started.value.dispose();

package/src/__tests__/engine-worker-world-swap.unit.test.ts

@@ -1,12 +1,19 @@
 import { World } from '@forgeax/engine-ecs';
-import type { Renderer } from '@forgeax/engine-render';
+import type { Renderer, RenderWorldLease } from '@forgeax/engine-render';
 import { describe, expect, it, vi } from 'vitest';
 import { commitAttachedWorld, SerializedRebuildQueue } from '../execution/attached-world-swap';
 
-function rendererOwner(): Pick<Renderer, 'attachWorld' | 'detachWorld'> {
+function rendererOwner(): Pick<Renderer, 'attach'> {
+  const lease = {
+    worldIdentity: {},
+    generation: 0,
+    readChanges: vi.fn(),
+    querySpans: vi.fn(),
+    inspectCursor: vi.fn(),
+    dispose: vi.fn(),
+  } as unknown as RenderWorldLease;
   return {
-    attachWorld: vi.fn(() => ({ ok: true as const, value: undefined })),
-    detachWorld: vi.fn(),
+    attach: vi.fn(() => ({ ok: true as const, value: lease })),
   };
 }
 
@@ -36,41 +43,27 @@ describe('worker attached World swap', () => {
 
   it('publishes the candidate before detaching the previous World', async () => {
     const renderer = rendererOwner();
-    const previous = new World();
     const next = new World();
 
-    await expect(commitAttachedWorld(renderer, previous, next, async () => true)).resolves.toBe(
-      true,
-    );
-    expect(renderer.attachWorld).toHaveBeenCalledWith(next);
-    expect(renderer.detachWorld).toHaveBeenCalledOnce();
-    expect(renderer.detachWorld).toHaveBeenCalledWith(previous);
+    await expect(commitAttachedWorld(renderer, next, async () => true)).resolves.toBe(true);
+    expect(renderer.attach).toHaveBeenCalledWith(next);
   });
 
   it('detaches a candidate whose bootstrap fails and keeps the previous World', async () => {
     const renderer = rendererOwner();
-    const previous = new World();
     const next = new World();
 
-    await expect(commitAttachedWorld(renderer, previous, next, async () => false)).resolves.toBe(
-      false,
-    );
-    expect(renderer.detachWorld).toHaveBeenCalledOnce();
-    expect(renderer.detachWorld).toHaveBeenCalledWith(next);
-    expect(renderer.detachWorld).not.toHaveBeenCalledWith(previous);
+    await expect(commitAttachedWorld(renderer, next, async () => false)).resolves.toBe(false);
   });
 
   it('detaches a candidate whose bootstrap throws', async () => {
     const renderer = rendererOwner();
-    const previous = new World();
     const next = new World();
 
     await expect(
-      commitAttachedWorld(renderer, previous, next, async () => {
+      commitAttachedWorld(renderer, next, async () => {
         throw new Error('bootstrap failed');
       }),
     ).rejects.toThrow('bootstrap failed');
-    expect(renderer.detachWorld).toHaveBeenCalledOnce();
-    expect(renderer.detachWorld).toHaveBeenCalledWith(next);
   });
 });

package/src/__tests__/errors-pointer-lock-failed.test.ts

@@ -34,7 +34,6 @@ describe('AppErrorCode closed union', () => {
       'app-not-started',
       'app-already-running',
       'app-canvas-detached',
-      'app-invalid-canvas-pixel-ratio',
       'app-frame-step-invalid',
       'app-system-update-failed',
       'app-pointer-lock-failed',
@@ -47,11 +46,11 @@ describe('AppErrorCode closed union', () => {
       'app-execution-rebuild-failed',
     ];
 
-    expect(allCodes).toHaveLength(14);
+    expect(allCodes).toHaveLength(13);
 
     // Each member must be unique.
     const unique = new Set(allCodes);
-    expect(unique.size).toBe(14);
+    expect(unique.size).toBe(13);
   });
 
   it('exhaustive switch over AppErrorCode has zero default branch', () => {
@@ -68,8 +67,6 @@ describe('AppErrorCode closed union', () => {
           return 'already running';
         case 'app-canvas-detached':
           return 'canvas detached';
-        case 'app-invalid-canvas-pixel-ratio':
-          return 'invalid canvas pixel ratio';
         case 'app-frame-step-invalid':
           return 'frame step invalid';
         case 'app-system-update-failed':
@@ -189,12 +186,12 @@ describe("'app-pointer-lock-failed' detail shape", () => {
 describe('APP_EXPECTED / APP_ERROR_HINTS bidirectional symmetry', () => {
   it('APP_EXPECTED has one key per AppErrorCode member', () => {
     const keys = Object.keys(APP_EXPECTED);
-    expect(keys).toHaveLength(14);
+    expect(keys).toHaveLength(13);
   });
 
   it('APP_ERROR_HINTS has one key per AppErrorCode member', () => {
     const keys = Object.keys(APP_ERROR_HINTS);
-    expect(keys).toHaveLength(14);
+    expect(keys).toHaveLength(13);
   });
 
   it('APP_EXPECTED and APP_ERROR_HINTS have the same key set', () => {

package/src/__tests__/execution-bootstrap-isolation.unit.test.ts

@@ -1,4 +1,4 @@
-import { createWorldContext, Update, World } from '@forgeax/engine-ecs';
+import { createWorldContext, World } from '@forgeax/engine-ecs';
 import { describe, expect, it, vi } from 'vitest';
 import {
   executionBootstrapHostPlugin,
@@ -44,9 +44,8 @@ describe('execution bootstrap isolation', () => {
     const url = moduleUrl(`export default function(){return {plugins:[{
       name:'module-system',inject:['world'],apply(ctx){
         const system={name:'module-system',queries:[],fn(){}};
-        const update=ctx.world.scheduleToken('Update');
-        ctx.world.addSystem(update,system).unwrap();
-        ctx.effect(()=>()=>ctx.world.removeSystem(update,system.name),'test/system');
+        ctx.world.addSystem(ctx.world.scheduleToken('Update'),system).unwrap();
+        ctx.effect(()=>()=>ctx.world.removeSystem(ctx.world.scheduleToken('Update'),system.name),'test/system');
       }
     }]}}`);
     const prepared = await prepareBootstrapEntry(url, undefined);
@@ -54,9 +53,9 @@ describe('execution bootstrap isolation', () => {
     if (!prepared.ok) return;
     const world = new World();
     const context = await createWorldContext(world, prepared.value.plugins ?? []);
-    expect(world.inspect().scheduleSystemCount(Update)).toBe(1);
+    expect(world.inspect().scheduleSystemCount(world.scheduleToken('Update'))).toBe(1);
     await context.fiber.dispose();
-    expect(world.inspect().scheduleSystemCount(Update)).toBe(0);
+    expect(world.inspect().scheduleSystemCount(world.scheduleToken('Update'))).toBe(0);
   });
 
   it('rejects a missing default export structurally', async () => {

package/src/__tests__/execution-frame-order.unit.test.ts

@@ -21,8 +21,8 @@ describe('execution frame ordering', () => {
       };
     };
     const ledger = new FrameCreditLedger('world');
-    const frame = ledger.issue(1 / 60, sample, { width: 320, height: 180 });
-    expect(ledger.issue(1 / 60, sample, { width: 320, height: 180 })).toBeUndefined();
+    const frame = ledger.issue(1 / 60, sample);
+    expect(ledger.issue(1 / 60, sample)).toBeUndefined();
     trace.push('update', 'draw');
     ledger.complete({
       kind: 'frame-complete',

package/src/__tests__/execution-frame-protocol.unit.test.ts

@@ -16,10 +16,9 @@ const sample: InputBackendSample = {
 describe('frame credit protocol', () => {
   it('allows one in-flight frame and handles duplicate, late and old identities without writes', () => {
     const ledger = new FrameCreditLedger('world-1');
-    const first = ledger.issue(0.016, () => sample, { width: 320, height: 180 });
+    const first = ledger.issue(0.016, () => sample);
     expect(first?.frameId).toBe(1);
-    expect(first).toMatchObject({ canvasWidth: 320, canvasHeight: 180 });
-    expect(ledger.issue(0.016, () => sample, { width: 320, height: 180 })).toBeUndefined();
+    expect(ledger.issue(0.016, () => sample)).toBeUndefined();
     expect(
       ledger.complete({
         kind: 'frame-complete',
@@ -56,6 +55,6 @@ describe('frame credit protocol', () => {
         kernelWaitMs: 0,
       }),
     ).toBe('duplicate');
-    expect(ledger.issue(0.016, () => sample, { width: 640, height: 320 })?.frameId).toBe(2);
+    expect(ledger.issue(0.016, () => sample)?.frameId).toBe(2);
   });
 });

package/src/__tests__/execution-public-api.test-d.ts

@@ -7,4 +7,8 @@ it('discovers execution from the public App surface', () => {
   expectTypeOf(app.execution).toEqualTypeOf<ExecutionControl>();
   expectTypeOf(app.execution.report()).toEqualTypeOf<ExecutionReport>();
   expectTypeOf(options.execution?.bootstrap).toEqualTypeOf<string | URL | undefined>();
+  expectTypeOf(options.execution?.assetCatalog?.url).toEqualTypeOf<string | undefined>();
+  expectTypeOf(options.execution?.assetCatalog?.expectedScope).toEqualTypeOf<
+    { readonly scopeId: string; readonly generation: number } | undefined
+  >();
 });

package/src/__tests__/frame-loop-time-elapsed.test.ts

@@ -20,7 +20,7 @@ function makeSpyRenderer(): Renderer {
   return {
     backend: 'webgpu' as const,
     ready: Promise.resolve({ ok: true, value: undefined }),
-    attachWorld: () => ({ ok: true, value: undefined }),
+    attach: () => ({ ok: true, value: undefined }),
     detachWorld: () => {},
     draw(): { ok: true; value: undefined } {
       return { ok: true, value: undefined };

package/src/__tests__/frame-loop-time.unit.test.ts

@@ -8,7 +8,7 @@ function renderer(): Renderer {
   return {
     backend: 'webgpu',
     ready: Promise.resolve({ ok: true, value: undefined }),
-    attachWorld: () => ({ ok: true, value: undefined }),
+    attach: () => ({ ok: true, value: undefined }),
     detachWorld: () => {},
     draw: () => ({ ok: true, value: undefined }),
     onError: () => () => {},

package/src/__tests__/frame-loop-world-array.test.ts

@@ -15,27 +15,38 @@
 // world identity path (worldId 0) is preserved (AC-03 regression guarantee).
 
 import { Update, World } from '@forgeax/engine-ecs';
-import type { Renderer } from '@forgeax/engine-render';
+import type { Renderer, RenderWorldLease } from '@forgeax/engine-render';
 import { describe, expect, it, vi } from 'vitest';
 import { createFrameLoop } from '../internal/frame-loop';
 
 interface DrawCall {
-  readonly worlds: unknown;
-  readonly options: unknown;
+  readonly request: unknown;
+}
+
+function lease(onDispose: () => void = () => {}): RenderWorldLease {
+  return {
+    worldIdentity: {},
+    generation: 0,
+    readChanges: vi.fn(),
+    querySpans: vi.fn(),
+    inspectCursor: vi.fn(),
+    dispose: onDispose,
+  } as unknown as RenderWorldLease;
 }
 
 function makeSpyRenderer(): { renderer: Renderer; calls: DrawCall[] } {
   const calls: DrawCall[] = [];
   const renderer = {
     backend: 'webgpu' as const,
-    ready: Promise.resolve({ ok: true, value: undefined }),
-    attachWorld(): { ok: true; value: undefined } {
-      return { ok: true, value: undefined };
+    attach(): { ok: true; value: RenderWorldLease } {
+      return { ok: true, value: lease() };
     },
-    detachWorld(): void {},
-    draw(worlds: unknown, options: unknown): { ok: true; value: undefined } {
-      calls.push({ worlds, options });
-      return { ok: true, value: undefined };
+    draw(request: unknown): {
+      ok: true;
+      value: { frameId: number; deviceGeneration: number; completed: true };
+    } {
+      calls.push({ request });
+      return { ok: true, value: { frameId: calls.length, deviceGeneration: 0, completed: true } };
     },
     onError(): () => void {
       return () => {
@@ -92,15 +103,13 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
       .unwrap();
     const renderer = {
       backend: 'webgpu' as const,
-      ready: Promise.resolve({ ok: true, value: undefined }),
-      attachWorld(): { ok: true; value: undefined } {
+      attach(): { ok: true; value: RenderWorldLease } {
         events.push('attach');
-        return { ok: true, value: undefined };
+        return { ok: true, value: lease() };
       },
-      detachWorld(): void {},
-      draw(): { ok: true; value: undefined } {
+      draw(): { ok: true; value: { frameId: number; deviceGeneration: number; completed: true } } {
         events.push('draw');
-        return { ok: true, value: undefined };
+        return { ok: true, value: { frameId: 1, deviceGeneration: 0, completed: true } };
       },
       onError: () => () => {},
       dispose: () => {},
@@ -133,7 +142,7 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     ]);
   });
 
-  it('calls renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }) once per running frame', () => {
+  it('calls renderer.draw with one lease-bound world per running frame', () => {
     const world = new World();
     const { renderer, calls } = makeSpyRenderer();
     const { raf, caf, now, pump } = makeSyncScheduler();
@@ -148,13 +157,11 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
 
     expect(calls.length).toBeGreaterThanOrEqual(3);
     for (const call of calls) {
-      // The worlds argument is an array carrying exactly the single world.
-      expect(Array.isArray(call.worlds)).toBe(true);
-      const arr = call.worlds as unknown[];
-      expect(arr.length).toBe(1);
-      expect(arr[0]).toBe(world);
-      // owner is the required, defaulted-to-0 index (single-world identity).
-      expect(call.options).toEqual({ cameraOwner: 0, resourceOwner: 0 });
+      expect(call.request).toMatchObject({
+        leases: [{ worldIdentity: expect.any(Object) }],
+        camera: { lease: expect.any(Object) },
+        environment: { lease: expect.any(Object) },
+      });
     }
 
     loop.stop();
@@ -202,11 +209,9 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     const rhiErr = { code: 'rhi-not-available' } as const;
     const renderer = {
       backend: 'webgpu' as const,
-      ready: Promise.resolve({ ok: true, value: undefined }),
-      attachWorld: () => ({ ok: true, value: undefined }),
-      detachWorld: () => {},
-      draw(worlds: unknown, options: unknown): { ok: false; error: typeof rhiErr } {
-        calls.push({ worlds, options });
+      attach: () => ({ ok: true as const, value: lease() }),
+      draw(request: unknown): { ok: false; error: typeof rhiErr } {
+        calls.push({ request });
         return { ok: false, error: rhiErr };
       },
       onError(): () => void {
@@ -226,26 +231,24 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     // start() schedules the first tick via raf; pump once to run it.
     pump(1);
 
-    expect(calls[0]?.worlds).toEqual([world]);
-    expect(calls[0]?.options).toEqual({ cameraOwner: 0, resourceOwner: 0 });
+    expect(calls[0]?.request).toMatchObject({
+      camera: { lease: expect.any(Object) },
+      environment: { lease: expect.any(Object) },
+    });
     expect(onError).toHaveBeenCalledWith(rhiErr);
 
     loop.stop();
   });
 
-  it('keeps the rAF heartbeat but freezes draw work during device loss', () => {
+  it('keeps the rAF heartbeat and submits receipt-bound frames', () => {
     const world = new World();
-    let reason: 'alive' | 'device-lost' = 'alive';
     const calls: unknown[] = [];
     const renderer = {
       backend: 'webgpu' as const,
-      ready: Promise.resolve({ ok: true, value: undefined }),
-      attachWorld: () => ({ ok: true, value: undefined }),
-      detachWorld: () => {},
-      health: () => ({ reason, recoverable: reason === 'device-lost' }),
-      draw(): { ok: true; value: undefined } {
+      attach: () => ({ ok: true as const, value: lease() }),
+      draw(): { ok: true; value: { frameId: number; deviceGeneration: number; completed: true } } {
         calls.push(undefined);
-        return { ok: true, value: undefined };
+        return { ok: true, value: { frameId: calls.length, deviceGeneration: 0, completed: true } };
       },
       onError(): () => void {
         return () => {};
@@ -257,14 +260,8 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     loop.start();
     pump(1);
     expect(calls).toHaveLength(1);
-
-    reason = 'device-lost';
     pump(3);
-    expect(calls).toHaveLength(1);
-
-    reason = 'alive';
-    pump(1);
-    expect(calls).toHaveLength(2);
+    expect(calls).toHaveLength(4);
     loop.stop();
   });
 
@@ -282,7 +279,12 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     expect(stepped.ok).toBe(true);
     expect(update).toHaveBeenCalledTimes(1);
     expect(update).toHaveBeenCalledWith(1 / 60);
-    expect(calls).toEqual([{ worlds: [world], options: { cameraOwner: 0, resourceOwner: 0 } }]);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.request).toMatchObject({
+      leases: [{ worldIdentity: expect.any(Object) }],
+      camera: { lease: expect.any(Object) },
+      environment: { lease: expect.any(Object) },
+    });
 
     expect(loop.resume().ok).toBe(true);
     expect(loop.stop().ok).toBe(true);
@@ -298,7 +300,9 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     expect(idle.ok).toBe(false);
     if (!idle.ok) {
       expect(idle.error.code).toBe('app-frame-step-invalid');
-      expect(idle.error.detail).toEqual({ state: 'idle', deltaSeconds: 1 / 60, reason: 'state' });
+      if ('detail' in idle.error) {
+        expect(idle.error.detail).toEqual({ state: 'idle', deltaSeconds: 1 / 60, reason: 'state' });
+      }
     }
 
     expect(loop.start().ok).toBe(true);
@@ -322,15 +326,14 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     const detached: World[] = [];
     const renderer = {
       backend: 'webgpu' as const,
-      ready: Promise.resolve({ ok: true, value: undefined }),
-      attachWorld(candidate: World) {
+      attach(candidate: World) {
         attached.push(candidate);
-        return { ok: true as const, value: undefined };
-      },
-      detachWorld(candidate: World): void {
-        detached.push(candidate);
+        return { ok: true as const, value: lease(() => detached.push(candidate)) };
       },
-      draw: () => ({ ok: true as const, value: undefined }),
+      draw: () => ({
+        ok: true as const,
+        value: { frameId: 1, deviceGeneration: 0, completed: true as const },
+      }),
       onError: () => () => {},
       dispose: () => {},
     } as unknown as Renderer;
@@ -361,12 +364,14 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     const detached: World[] = [];
     const renderer = {
       backend: 'webgpu' as const,
-      ready: Promise.resolve({ ok: true, value: undefined }),
-      attachWorld: () => ({ ok: true as const, value: undefined }),
-      detachWorld(candidate: World): void {
-        detached.push(candidate);
-      },
-      draw: () => ({ ok: true as const, value: undefined }),
+      attach: (candidate: World) => ({
+        ok: true as const,
+        value: lease(() => detached.push(candidate)),
+      }),
+      draw: () => ({
+        ok: true as const,
+        value: { frameId: 1, deviceGeneration: 0, completed: true as const },
+      }),
       onError: () => () => {},
       dispose: () => {},
     } as unknown as Renderer;
@@ -392,12 +397,14 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     const detached: World[] = [];
     const renderer = {
       backend: 'webgpu' as const,
-      ready: Promise.resolve({ ok: true, value: undefined }),
-      attachWorld: () => ({ ok: true as const, value: undefined }),
-      detachWorld(candidate: World): void {
-        detached.push(candidate);
-      },
-      draw: () => ({ ok: true as const, value: undefined }),
+      attach: (candidate: World) => ({
+        ok: true as const,
+        value: lease(() => detached.push(candidate)),
+      }),
+      draw: () => ({
+        ok: true as const,
+        value: { frameId: 1, deviceGeneration: 0, completed: true as const },
+      }),
       onError: () => () => {},
       dispose: () => {},
     } as unknown as Renderer;
@@ -418,12 +425,14 @@ describe('M3 / m3-t3 — frame-loop wraps the single World into [world] with own
     const detached: World[] = [];
     const renderer = {
       backend: 'webgpu' as const,
-      ready: Promise.resolve({ ok: true, value: undefined }),
-      attachWorld: () => ({ ok: true as const, value: undefined }),
-      detachWorld(candidate: World): void {
-        detached.push(candidate);
-      },
-      draw: () => ({ ok: true as const, value: undefined }),
+      attach: (candidate: World) => ({
+        ok: true as const,
+        value: lease(() => detached.push(candidate)),
+      }),
+      draw: () => ({
+        ok: true as const,
+        value: { frameId: 1, deviceGeneration: 0, completed: true as const },
+      }),
       onError: () => () => {},
       dispose: () => {},
     } as unknown as Renderer;

package/src/__tests__/plugin-profiles.unit.test.ts

@@ -2,13 +2,13 @@ import type { AudioBackend } from '@forgeax/engine-audio';
 import { createWorldContext, World } from '@forgeax/engine-ecs';
 import { type InputBackend, ownedInputBackendPlugin } from '@forgeax/engine-input';
 import { Context, type Plugin } from '@forgeax/engine-plugin';
-import { ownedRendererPlugin, type Renderer } from '@forgeax/engine-render';
+import type { Renderer } from '@forgeax/engine-render';
 import { describe, expect, it } from 'vitest';
-
 import { assembledEngineProfile } from '../internal/assembled-engine-profile';
 import { mainEngineProfile } from '../internal/main-engine-profile';
 import { remoteServerPlugin } from '../internal/remote-server-plugin';
 import { workerEngineProfile } from '../internal/worker-engine-profile';
+import { ownedRendererPlugin } from '../renderer-plugin';
 
 interface PluginMetadata {
   readonly name?: string;
@@ -74,7 +74,7 @@ function expectDag(profile: readonly Plugin[], roots: readonly string[]): void {
   expect(visited, 'built-in profile dependency cycle').toBe(profile.length);
 }
 
-const renderer = { assets: {} } as Renderer;
+const renderer = { assets: {} } as unknown as Renderer;
 const input = { sample: () => ({}) } as InputBackend;
 const audio = {} as AudioBackend;
 describe('Engine built-in plugin profiles', () => {

package/src/__tests__/profiler-default-off.test.ts

@@ -9,7 +9,7 @@ function makeRenderer(): Renderer {
   return {
     backend: 'webgpu',
     ready: Promise.resolve({ ok: true, value: undefined }),
-    attachWorld: () => ({ ok: true, value: undefined }),
+    attach: () => ({ ok: true, value: undefined }),
     detachWorld: () => {},
     draw: () => ({ ok: true, value: undefined }),
     onError: () => () => {},