@forgeax/engine-app 0.1.2

package/src/__tests__/execution-measurement.unit.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { createMeasurementSeries } from '../execution/measurement';
+
+describe('execution measurement series', () => {
+  it('reports bounded percentiles while retaining the total sample count', () => {
+    const series = createMeasurementSeries(3);
+    series.add(100);
+    series.add(2);
+    series.add(3);
+    const report = series.add(4);
+    expect(report).toEqual({ samples: 4, p50: 3, p95: 4, p99: 4, jitter: 1 });
+  });
+
+  it('clears samples for a rebuilt World identity', () => {
+    const series = createMeasurementSeries();
+    series.add(1);
+    series.clear();
+    expect(series.add(5).samples).toBe(1);
+  });
+});

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

@@ -0,0 +1,10 @@
+import { expectTypeOf, it } from 'vitest';
+import type { App, CreateAppOptions, ExecutionControl, ExecutionReport } from '../index';
+
+it('discovers execution from the public App surface', () => {
+  const app = null as unknown as App;
+  const options = null as unknown as CreateAppOptions;
+  expectTypeOf(app.execution).toEqualTypeOf<ExecutionControl>();
+  expectTypeOf(app.execution.report()).toEqualTypeOf<ExecutionReport>();
+  expectTypeOf(options.execution?.bootstrap).toEqualTypeOf<string | URL | undefined>();
+});

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

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+import { EXECUTION_REQUESTED_TIERS, EXECUTION_TIERS } from '../index';
+
+describe('execution public affordance', () => {
+  it('advertises only stable tier names', () => {
+    expect(EXECUTION_TIERS).toEqual(['main-serial', 'engine-worker', 'shared']);
+    expect(EXECUTION_REQUESTED_TIERS).toEqual(['auto', ...EXECUTION_TIERS]);
+  });
+});

package/src/__tests__/execution-rebuild.contract.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { createExecutionReport, unavailableExecutionCapabilities } from '../execution';
+import { createLocalExecutionControl } from '../execution/control';
+
+describe('execution rebuild contract', () => {
+  it('keeps low-level local assembly explicit when no bootstrap exists', async () => {
+    const control = createLocalExecutionControl(
+      createExecutionReport('main-serial', unavailableExecutionCapabilities('local')),
+    );
+    const before = control.report();
+    const result = await control.rebuild();
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error.code).toBe('app-execution-rebuild-failed');
+    expect(control.report()).toEqual(before);
+  });
+
+  it('projects live local lifecycle and World state without a duplicate ledger', () => {
+    let world: ReturnType<typeof createExecutionReport>['world'] = {
+      identity: 'world-1',
+      health: 'healthy',
+      partialWrite: false,
+      retryable: true,
+    };
+    const control = createLocalExecutionControl(
+      createExecutionReport('main-serial', unavailableExecutionCapabilities('local')),
+      { world: () => world },
+    );
+
+    control.setEngineHealth('running');
+    expect(control.report().engine.health).toBe('running');
+    world = { ...world, health: 'poisoned', partialWrite: true, retryable: false };
+    expect(control.report().world).toEqual(world);
+    control.setEngineHealth('stopped');
+    expect(control.report().engine.health).toBe('stopped');
+  });
+});

package/src/__tests__/execution-report.contract.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import {
+  createExecutionReport,
+  EXECUTION_CAPABILITY_NAMES,
+  type ExecutionCapabilities,
+  isExecutionReport,
+  selectExecutionTier,
+} from '../index';
+
+function capabilities(available = true): ExecutionCapabilities {
+  return Object.fromEntries(
+    EXECUTION_CAPABILITY_NAMES.map((name) => [
+      name,
+      { available, reason: available ? 'observed' : 'missing' },
+    ]),
+  ) as unknown as ExecutionCapabilities;
+}
+
+describe('ExecutionReport contract', () => {
+  it('is the closed requested/actual/capability/health/performance/fault snapshot', () => {
+    const selection = selectExecutionTier({
+      requestedTier: 'auto',
+      capabilities: capabilities(),
+      sharedEvidencePassed: true,
+    }).unwrap();
+    const report = createExecutionReport('auto', capabilities(), selection);
+    expect(report.requestedTier).toBe('auto');
+    expect(report.actualTier).toBe('shared');
+    expect(report.capabilities.worker.available).toBe(true);
+    expect(report.engine.health).toBe('idle');
+    expect(report.world.health).toBe('healthy');
+    expect(report.kernelDispatch.reason).toBe('no-eligible-kernel');
+    expect(report.performance.kernelWaitMs).toBeNull();
+    expect(report.audio).toEqual({
+      owner: 'host',
+      contextState: 'suspended',
+      activeSourceCount: 0,
+      lastError: null,
+    });
+    expect(report.fault).toBeNull();
+    expect(isExecutionReport(report)).toBe(true);
+  });
+
+  it('rejects missing and extra schema fields', () => {
+    const report = createExecutionReport('main-serial', capabilities(false));
+    const { world: _world, ...missing } = report;
+    expect(isExecutionReport(missing)).toBe(false);
+    expect(isExecutionReport({ ...report, workerId: 1 })).toBe(false);
+  });
+});

package/src/__tests__/execution-report.types.test-d.ts

@@ -0,0 +1,16 @@
+import { expectTypeOf, it } from 'vitest';
+import type { ExecutionReport, ExecutionTier } from '../index';
+
+it('exposes stable report fields without transport internals', () => {
+  const report = null as unknown as ExecutionReport;
+  expectTypeOf(report.actualTier).toEqualTypeOf<ExecutionTier | null>();
+  expectTypeOf(report.world.partialWrite).toBeBoolean();
+  expectTypeOf(report.world.retryable).toBeBoolean();
+  expectTypeOf(report.kernelDispatch.dispatched).toBeNumber();
+  expectTypeOf(report.performance.hostFrameMs).toMatchTypeOf<object | null>();
+  expectTypeOf(report.audio.owner).toEqualTypeOf<'host'>();
+  // @ts-expect-error transport identities are private
+  void report.workerId;
+  // @ts-expect-error SAB shards are private
+  void report.shards;
+});

package/src/__tests__/execution-schema-freshness.unit.test.ts

@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import {
+  EXECUTION_CAPABILITY_NAMES,
+  EXECUTION_REPORT_SCHEMA_VERSION,
+  EXECUTION_REQUESTED_TIERS,
+  EXECUTION_TIERS,
+} from '../index';
+
+describe('execution schema freshness', () => {
+  it('keeps runtime catalogs aligned with the JSON schema authority', () => {
+    const schema = JSON.parse(
+      readFileSync(new URL('../../schema/execution-report.schema.json', import.meta.url), 'utf8'),
+    ) as { properties: Record<string, { const?: number; enum?: unknown[]; required?: string[] }> };
+    expect(schema.properties.schemaVersion?.const).toBe(EXECUTION_REPORT_SCHEMA_VERSION);
+    expect(schema.properties.requestedTier?.enum).toEqual(EXECUTION_REQUESTED_TIERS);
+    expect(schema.properties.actualTier?.enum).toEqual([null, ...EXECUTION_TIERS]);
+    expect(schema.properties.capabilities?.required).toEqual(EXECUTION_CAPABILITY_NAMES);
+  });
+});

package/src/__tests__/execution-selector.unit.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import {
+  EXECUTION_CAPABILITY_NAMES,
+  type ExecutionCapabilities,
+  type ExecutionCapabilityName,
+  selectExecutionTier,
+} from '../index';
+
+function facts(missing: readonly ExecutionCapabilityName[] = []): ExecutionCapabilities {
+  return Object.fromEntries(
+    EXECUTION_CAPABILITY_NAMES.map((name) => [
+      name,
+      {
+        available: !missing.includes(name),
+        reason: missing.includes(name) ? 'fixture missing' : 'fixture observed',
+      },
+    ]),
+  ) as unknown as ExecutionCapabilities;
+}
+
+describe('execution tier selector', () => {
+  it('orders auto shared to engine-worker to main-serial', () => {
+    expect(
+      selectExecutionTier({
+        requestedTier: 'auto',
+        capabilities: facts(),
+        sharedEvidencePassed: true,
+      }).unwrap().actualTier,
+    ).toBe('shared');
+    expect(
+      selectExecutionTier({
+        requestedTier: 'auto',
+        capabilities: facts(['sharedArrayBuffer']),
+        sharedEvidencePassed: true,
+      }).unwrap().actualTier,
+    ).toBe('engine-worker');
+    expect(
+      selectExecutionTier({
+        requestedTier: 'auto',
+        capabilities: facts(['workerWebGpu']),
+        sharedEvidencePassed: true,
+      }).unwrap().actualTier,
+    ).toBe('main-serial');
+  });
+
+  it('does not conflate failed shipped evidence with a missing browser capability', () => {
+    const result = selectExecutionTier({
+      requestedTier: 'shared',
+      capabilities: facts(),
+      sharedEvidencePassed: false,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      if (result.error.code !== 'app-execution-tier-unavailable') throw result.error;
+      expect(result.error.detail.missingCapabilities).toEqual([]);
+      expect(result.error.detail.sharedEvidencePassed).toBe(false);
+    }
+  });
+
+  it('never silently downgrades an explicit tier', () => {
+    const result = selectExecutionTier({
+      requestedTier: 'engine-worker',
+      capabilities: facts(['offscreenCanvas']),
+      sharedEvidencePassed: true,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      if (result.error.code !== 'app-execution-tier-unavailable') throw result.error;
+      expect(result.error.detail.missingCapabilities).toEqual(['offscreenCanvas']);
+    }
+  });
+});

package/src/__tests__/execution-shared-kernel.unit.test.ts

@@ -0,0 +1,180 @@
+import { defineComponent, World } from '@forgeax/engine-ecs';
+import { defineSharedKernel, type KernelDispatchSpan } from '@forgeax/engine-ecs/shared';
+import { describe, expect, it } from 'vitest';
+import { createKernelPool } from '../execution/kernel-pool';
+
+const Position = defineComponent('ExecutionKernelPosition', { x: 'f32' });
+
+function runPositionKernel(spans: readonly import('@forgeax/engine-ecs').QuerySpan[]): void {
+  for (const span of spans) {
+    const position = span.mut(Position);
+    for (let index = 0; index < span.length; index += 1) {
+      position.x[index] = (position.x[index] ?? 0) + 2;
+    }
+  }
+}
+
+const kernel = defineSharedKernel('https://example.test/position-kernel.mjs', {
+  name: 'execution-position-kernel',
+  queries: [{ write: [Position] }],
+  minimumRows: 1,
+  run: runPositionKernel,
+});
+
+interface TestMessage {
+  readonly kind: 'kernel-init' | 'kernel-preload' | 'kernel-job';
+  readonly ready?: Int32Array;
+  readonly control?: Int32Array;
+  readonly status?: Int32Array;
+  readonly jobIndex?: number;
+}
+
+interface TestJob {
+  readonly kind: 'kernel-job';
+  readonly binding: {
+    readonly length: number;
+    readonly write: Readonly<Record<string, Readonly<Record<string, Float32Array>>>>;
+  };
+  readonly control: Int32Array;
+  readonly status: Int32Array;
+  readonly jobIndex: number;
+}
+
+function sharedDispatchSpans(): {
+  readonly world: World;
+  readonly spans: readonly KernelDispatchSpan[];
+} {
+  const world = new World({ storage: 'shared' });
+  for (let index = 0; index < 8; index += 1) {
+    world.spawn({ component: Position, data: { x: index } }).unwrap();
+  }
+  const query = world.query({ write: [Position] }).unwrap();
+  return {
+    world,
+    spans: [...query.spans().unwrap()].map((span) => ({ queryIndex: 0, span })),
+  };
+}
+
+function workerFactory(run: (job: TestJob) => void, preloadStatus = 1): () => Worker {
+  return () =>
+    ({
+      postMessage(message: TestMessage): void {
+        if (message.kind === 'kernel-init' && message.ready !== undefined) {
+          Atomics.add(message.ready, 0, 1);
+          Atomics.notify(message.ready, 0);
+          return;
+        }
+        if (
+          message.kind === 'kernel-preload' &&
+          message.control !== undefined &&
+          message.status !== undefined &&
+          message.jobIndex !== undefined
+        ) {
+          Atomics.store(message.status, message.jobIndex, preloadStatus);
+          Atomics.add(message.control, 0, 1);
+          Atomics.notify(message.control, 0);
+          return;
+        }
+        run(message as TestJob);
+        Atomics.add(message.control as Int32Array, 0, 1);
+        Atomics.notify(message.control as Int32Array, 0);
+      },
+      terminate(): void {},
+    }) as unknown as Worker;
+}
+
+describe('shared kernel pool', () => {
+  it('shards SAB spans without copying and joins all lanes', () => {
+    const { world, spans } = sharedDispatchSpans();
+    const pool = createKernelPool({
+      lanes: 2,
+      workerFactory: workerFactory((job) => {
+        const x = job.binding.write.ExecutionKernelPosition?.x;
+        if (x === undefined) throw new Error('position binding missing');
+        for (let index = 0; index < job.binding.length; index += 1) {
+          x[index] = (x[index] ?? 0) + 2;
+        }
+        Atomics.store(job.status, job.jobIndex, 1);
+      }),
+    });
+    pool.warmup?.(kernel);
+
+    const result = pool.execute(kernel, spans);
+    expect(result).toMatchObject({ mode: 'shared', dispatched: 2, completed: 2 });
+    expect(pool.takeLastDispatch()).toEqual(result);
+    expect(pool.takeLastDispatch()).toBeNull();
+    expect(
+      Array.from(world.query({ read: [Position] }).unwrap(), (row) => row.get(Position).x),
+    ).toEqual([2, 3, 4, 5, 6, 7, 8, 9]);
+    pool.dispose();
+  });
+
+  it('reports a partial write when one lane fails after another completes', () => {
+    const { spans } = sharedDispatchSpans();
+    const pool = createKernelPool({
+      lanes: 2,
+      workerFactory: workerFactory((job) => {
+        Atomics.store(job.status, job.jobIndex, job.jobIndex === 0 ? 1 : -1);
+      }),
+    });
+    pool.warmup?.(kernel);
+
+    expect(pool.execute(kernel, spans)).toMatchObject({
+      dispatched: 2,
+      completed: 1,
+      partialWrite: true,
+    });
+    pool.dispose();
+  });
+
+  it('fails a non-responsive lane at the bounded Atomics deadline', () => {
+    const { spans } = sharedDispatchSpans();
+    const pool = createKernelPool({
+      lanes: 1,
+      timeoutMs: 1,
+      workerFactory: () =>
+        ({
+          postMessage(message: TestMessage): void {
+            if (message.kind === 'kernel-init' && message.ready !== undefined) {
+              Atomics.add(message.ready, 0, 1);
+              Atomics.notify(message.ready, 0);
+            }
+            if (
+              message.kind === 'kernel-preload' &&
+              message.control !== undefined &&
+              message.status !== undefined &&
+              message.jobIndex !== undefined
+            ) {
+              Atomics.store(message.status, message.jobIndex, 1);
+              Atomics.add(message.control, 0, 1);
+              Atomics.notify(message.control, 0);
+            }
+          },
+          terminate(): void {},
+        }) as unknown as Worker,
+    });
+    pool.warmup?.(kernel);
+
+    expect(pool.execute(kernel, spans)).toMatchObject({
+      dispatched: 1,
+      completed: 0,
+      partialWrite: true,
+    });
+    pool.dispose();
+  });
+
+  it('rejects an invalid module during readiness before any kernel dispatch', async () => {
+    let dispatched = false;
+    const pool = createKernelPool({
+      lanes: 1,
+      workerFactory: workerFactory(() => {
+        dispatched = true;
+      }, -1),
+    });
+    pool.warmup?.(kernel);
+
+    await expect(pool.ready()).rejects.toThrow('module preflight failed');
+    expect(dispatched).toBe(false);
+    pool.dispose();
+  });
+});

package/src/__tests__/execution-world-health-owner.test-d.ts

@@ -0,0 +1,9 @@
+import type { WorldExecutionHealth } from '@forgeax/engine-ecs/shared';
+import { expectTypeOf, it } from 'vitest';
+import type { ExecutionReport, ExecutionWorldHealth } from '../index';
+
+it('projects the public App health type from the ECS World owner', () => {
+  expectTypeOf<ExecutionWorldHealth>().toEqualTypeOf<WorldExecutionHealth>();
+  expectTypeOf<WorldExecutionHealth>().toEqualTypeOf<ExecutionWorldHealth>();
+  expectTypeOf<ExecutionReport['world']['health']>().toEqualTypeOf<WorldExecutionHealth>();
+});

package/src/__tests__/fallback-camera.unit.test.ts

@@ -0,0 +1,32 @@
+import { World } from '@forgeax/engine-ecs';
+import { Camera } from '@forgeax/engine-render';
+import { Transform } from '@forgeax/engine-scene';
+import { describe, expect, it } from 'vitest';
+import { ensureFallbackCamera } from '../fallback-camera';
+
+describe('ensureFallbackCamera', () => {
+  it('installs one neutral host fallback with the requested aspect', () => {
+    const world = new World();
+    const spawned = ensureFallbackCamera(world, 16 / 9);
+    expect(spawned).toBeDefined();
+    if (spawned === undefined) return;
+    expect(spawned.ok).toBe(true);
+    if (!spawned.ok) return;
+
+    expect(world.get(spawned.value, Transform).unwrap().pos).toEqual(new Float32Array([0, 0.6, 5]));
+    expect(world.get(spawned.value, Camera).unwrap().aspect).toBeCloseTo(16 / 9);
+    expect([...world.query({ with: [Camera] }).unwrap()]).toHaveLength(1);
+  });
+
+  it('preserves an authored scene camera', () => {
+    const world = new World();
+    const authored = world.spawn(
+      { component: Transform, data: { pos: [1, 2, 3] } },
+      { component: Camera, data: {} },
+    );
+    expect(authored.ok).toBe(true);
+
+    expect(ensureFallbackCamera(world, 16 / 9)).toBeUndefined();
+    expect([...world.query({ with: [Camera] }).unwrap()]).toHaveLength(1);
+  });
+});

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

@@ -0,0 +1,115 @@
+// frame-loop-time-elapsed.test.ts — Time resource `elapsed` accumulator
+// (solo bevy-examples round 20260713-212920).
+//
+// Regression guard for the friction that motivated the field: the Time resource
+// was `{ delta }` only, so absolute-time-keyed behavior (pulsing, sin(elapsed))
+// forced each system to hand-accumulate delta (drift + re-derivation). The frame-loop
+// now writes `{ delta, elapsed }` where elapsed = Σ(clamped delta). These tests pin:
+//   1. elapsed accumulates: after N frames of delta, elapsed ≈ N·delta,
+//   2. elapsed is monotonic non-decreasing,
+//   3. elapsed uses the CLAMPED delta (a huge raw gap advances elapsed by the ceiling,
+//      not the raw gap — no time jump),
+//   4. delta is still present + correct (existing consumers unaffected).
+
+import { Time, type TimeResource, World } from '@forgeax/engine-ecs';
+import type { Renderer } from '@forgeax/engine-render';
+import { describe, expect, it } from 'vitest';
+import { createFrameLoop } from '../internal/frame-loop';
+
+function makeSpyRenderer(): Renderer {
+  return {
+    backend: 'webgpu' as const,
+    ready: Promise.resolve({ ok: true, value: undefined }),
+    attachWorld: () => ({ ok: true, value: undefined }),
+    detachWorld: () => {},
+    draw(): { ok: true; value: undefined } {
+      return { ok: true, value: undefined };
+    },
+    onError(): () => void {
+      return () => {};
+    },
+    dispose(): void {},
+  } as unknown as Renderer;
+}
+
+// Scheduler whose `now` advances by a fixed step per tick (deterministic delta).
+function makeSyncScheduler(stepMs: number) {
+  let pending: ((t: number) => void) | null = null;
+  let clock = 0;
+  const raf = (cb: (t: number) => void): number => {
+    pending = cb;
+    return 1;
+  };
+  const caf = (): void => {
+    pending = null;
+  };
+  const now = (): number => {
+    clock += stepMs;
+    return clock;
+  };
+  const pump = (frames: number): void => {
+    for (let i = 0; i < frames; i++) {
+      const cb = pending;
+      pending = null;
+      if (cb === null) break;
+      cb(clock);
+    }
+  };
+  return { raf, caf, now, pump };
+}
+
+function readTime(world: World): TimeResource {
+  return world.getResource(Time);
+}
+
+describe('Time.elapsed — accumulation', () => {
+  it('after N frames of fixed delta, elapsed ≈ N·delta', () => {
+    const world = new World();
+    // 16 ms/tick → delta = 0.016 s (well under the default clamp ceiling).
+    const { raf, caf, now, pump } = makeSyncScheduler(16);
+    const loop = createFrameLoop({ world, renderer: makeSpyRenderer(), now, raf, caf });
+    loop.start();
+    pump(10);
+    const time = readTime(world);
+    expect(time.delta).toBeCloseTo(0.016, 6);
+    // 10 ticks, but start() sets the baseline at t=16 (first now()), so the first
+    // tick's delta is measured from there; elapsed is the running sum of clamped delta.
+    // Assert it equals delta * (number of ticks that ran) within a tick's slack.
+    expect(time.elapsed).toBeGreaterThan(0.1); // ~10 * 0.016 = 0.16
+    expect(time.elapsed).toBeLessThanOrEqual(0.016 * 10 + 1e-9);
+    loop.stop();
+  });
+
+  it('elapsed is monotonic non-decreasing across frames', () => {
+    const world = new World();
+    const { raf, caf, now, pump } = makeSyncScheduler(16);
+    const loop = createFrameLoop({ world, renderer: makeSpyRenderer(), now, raf, caf });
+    loop.start();
+    let prev = -1;
+    for (let i = 0; i < 20; i++) {
+      pump(1);
+      const e = readTime(world).elapsed;
+      expect(e).toBeGreaterThanOrEqual(prev);
+      prev = e;
+    }
+    loop.stop();
+  });
+
+  it('elapsed uses the CLAMPED delta — a huge raw frame gap does not jump elapsed', () => {
+    const world = new World();
+    // 5000 ms/tick → raw delta = 5 s, far above the default clamp ceiling. elapsed
+    // must advance by the CEILING per tick, not 5 s (no time jump — same clamp the
+    // delta field already applies).
+    const { raf, caf, now, pump } = makeSyncScheduler(5000);
+    const loop = createFrameLoop({ world, renderer: makeSpyRenderer(), now, raf, caf });
+    loop.start();
+    pump(3);
+    const time = readTime(world);
+    // delta is clamped, so a single frame's delta is well under the raw 5 s.
+    expect(time.delta).toBeLessThan(1);
+    // 3 clamped ticks → elapsed is a few * ceiling, nowhere near the raw 15 s.
+    expect(time.elapsed).toBeLessThan(3);
+    expect(time.elapsed).toBeCloseTo(time.delta * 3, 6);
+    loop.stop();
+  });
+});

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

@@ -0,0 +1,61 @@
+import { Time, World } from '@forgeax/engine-ecs';
+import type { Renderer } from '@forgeax/engine-render';
+import { describe, expect, it } from 'vitest';
+
+import { createFrameLoop } from '../internal/frame-loop';
+
+function renderer(): Renderer {
+  return {
+    backend: 'webgpu',
+    ready: Promise.resolve({ ok: true, value: undefined }),
+    attachWorld: () => ({ ok: true, value: undefined }),
+    detachWorld: () => {},
+    draw: () => ({ ok: true, value: undefined }),
+    onError: () => () => {},
+    onLost: () => () => {},
+    dispose: () => {},
+  } as unknown as Renderer;
+}
+
+function scheduler() {
+  let callback: ((timestamp: number) => void) | undefined;
+  return {
+    raf: (next: (timestamp: number) => void): number => {
+      callback = next;
+      return 1;
+    },
+    caf: (): void => {
+      callback = undefined;
+    },
+    tick(timestamp: number): void {
+      const next = callback;
+      callback = undefined;
+      next?.(timestamp);
+    },
+  };
+}
+
+describe('frame-loop Time forwarding', () => {
+  it('forwards one measured delta to own and injected Worlds', () => {
+    const own = new World();
+    const injected = new World();
+    const clock = scheduler();
+    const loop = createFrameLoop({
+      world: own,
+      renderer: renderer(),
+      now: (() => {
+        const values = [1000, 1016];
+        return () => values.shift() ?? 1016;
+      })(),
+      raf: clock.raf,
+      caf: clock.caf,
+      drawSource: () => ({ worlds: [own, injected], cameraOwner: 0, resourceOwner: 0 }),
+    });
+
+    loop.start().unwrap();
+    clock.tick(1016);
+
+    expect(own.getResource(Time).delta).toBeCloseTo(0.016);
+    expect(injected.getResource(Time).delta).toBeCloseTo(0.016);
+  });
+});