@forgeax/engine-app 0.0.0-dev.8d955ade1c79

package/src/__tests__/execution-error-detail.test-d.ts

@@ -0,0 +1,13 @@
+import { expectTypeOf, it } from 'vitest';
+import type { AppError } from '../index';
+
+it('narrows execution error detail by code', () => {
+  const error = null as unknown as AppError;
+  if (error.code === 'app-execution-kernel-failed') {
+    expectTypeOf(error.detail.partialWrite).toEqualTypeOf<true>();
+    expectTypeOf(error.detail.retryable).toEqualTypeOf<false>();
+  }
+  if (error.code === 'app-execution-deadline-exceeded') {
+    expectTypeOf(error.detail.phase).toEqualTypeOf<'startup' | 'handshake' | 'frame'>();
+  }
+});

package/src/__tests__/execution-error-detail.unit.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { APP_ERROR_HINTS, APP_EXPECTED, AppError, type AppErrorCode } from '../index';
+
+const EXECUTION_CODES = [
+  'app-execution-tier-unavailable',
+  'app-execution-bootstrap-failed',
+  'app-execution-deadline-exceeded',
+  'app-execution-kernel-failed',
+  'app-execution-stale-world',
+  'app-execution-rebuild-failed',
+] as const satisfies readonly AppErrorCode[];
+
+describe('execution errors', () => {
+  it('has executable expected and hint tables for every execution code', () => {
+    for (const code of EXECUTION_CODES) {
+      expect(APP_EXPECTED[code].length).toBeGreaterThan(0);
+      expect(APP_ERROR_HINTS[code].length).toBeGreaterThan(0);
+    }
+  });
+
+  it('exposes unavailable facts without message parsing', () => {
+    const error = new AppError({
+      code: 'app-execution-tier-unavailable',
+      expected: APP_EXPECTED['app-execution-tier-unavailable'],
+      hint: APP_ERROR_HINTS['app-execution-tier-unavailable'],
+      detail: {
+        requestedTier: 'shared',
+        missingCapabilities: ['sharedArrayBuffer'],
+        sharedEvidencePassed: true,
+      },
+    });
+    expect(error.detail.requestedTier).toBe('shared');
+    expect(error.detail.missingCapabilities).toEqual(['sharedArrayBuffer']);
+  });
+});

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

@@ -0,0 +1,38 @@
+import type { InputBackendSample } from '@forgeax/engine-input';
+import { describe, expect, it } from 'vitest';
+import { FrameCreditLedger } from '../execution/protocol';
+
+describe('execution frame ordering', () => {
+  it('samples once and cannot issue the next credit before update, draw and completion', () => {
+    const trace: string[] = [];
+    let samples = 0;
+    const sample = (): InputBackendSample => {
+      samples += 1;
+      trace.push('sample');
+      return {
+        downKeys: new Set(),
+        upKeys: new Set(),
+        buttons: [false, false, false],
+        movementX: 0,
+        movementY: 0,
+        wheelDelta: 0,
+        focused: true,
+        pointerLocked: false,
+      };
+    };
+    const ledger = new FrameCreditLedger('world');
+    const frame = ledger.issue(1 / 60, sample);
+    expect(ledger.issue(1 / 60, sample)).toBeUndefined();
+    trace.push('update', 'draw');
+    ledger.complete({
+      kind: 'frame-complete',
+      worldIdentity: 'world',
+      frameId: frame?.frameId ?? 0,
+      engineUpdateMs: 1,
+      kernelWaitMs: 0,
+    });
+    trace.push('complete');
+    expect(trace).toEqual(['sample', 'update', 'draw', 'complete']);
+    expect(samples).toBe(1);
+  });
+});

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

@@ -0,0 +1,60 @@
+import type { InputBackendSample } from '@forgeax/engine-input';
+import { describe, expect, it } from 'vitest';
+import { FrameCreditLedger } from '../execution/protocol';
+
+const sample: InputBackendSample = {
+  downKeys: new Set(),
+  upKeys: new Set(),
+  buttons: [false, false, false],
+  movementX: 0,
+  movementY: 0,
+  wheelDelta: 0,
+  focused: true,
+  pointerLocked: false,
+};
+
+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);
+    expect(first?.frameId).toBe(1);
+    expect(ledger.issue(0.016, () => sample)).toBeUndefined();
+    expect(
+      ledger.complete({
+        kind: 'frame-complete',
+        worldIdentity: 'old',
+        frameId: 1,
+        engineUpdateMs: 1,
+        kernelWaitMs: 0,
+      }),
+    ).toBe('stale-world');
+    expect(
+      ledger.complete({
+        kind: 'frame-complete',
+        worldIdentity: 'world-1',
+        frameId: 2,
+        engineUpdateMs: 1,
+        kernelWaitMs: 0,
+      }),
+    ).toBe('late');
+    expect(
+      ledger.complete({
+        kind: 'frame-complete',
+        worldIdentity: 'world-1',
+        frameId: 1,
+        engineUpdateMs: 1,
+        kernelWaitMs: 0,
+      }),
+    ).toBe('accepted');
+    expect(
+      ledger.complete({
+        kind: 'frame-complete',
+        worldIdentity: 'world-1',
+        frameId: 1,
+        engineUpdateMs: 1,
+        kernelWaitMs: 0,
+      }),
+    ).toBe('duplicate');
+    expect(ledger.issue(0.016, () => sample)?.frameId).toBe(2);
+  });
+});

package/src/__tests__/execution-input-sample.contract.test.ts

@@ -0,0 +1,23 @@
+import { type InputBackendSample, snapshotFromSample } from '@forgeax/engine-input';
+import { describe, expect, it } from 'vitest';
+
+describe('Host to Engine input boundary', () => {
+  it('reconstructs the existing InputSnapshot from one structured-cloneable sample', () => {
+    const sample: InputBackendSample = {
+      downKeys: new Set(['w']),
+      upKeys: new Set(),
+      buttons: [false, false, false],
+      movementX: 4,
+      movementY: -2,
+      wheelDelta: 1,
+      focused: true,
+      pointerLocked: true,
+    };
+    const clone = structuredClone(sample);
+    const snapshot = snapshotFromSample(clone);
+    expect(snapshot.keyboard.down('w')).toBe(true);
+    expect(snapshot.mouse.movementDelta).toEqual({ x: 4, y: -2 });
+    expect(clone).not.toHaveProperty('window');
+    expect(clone).not.toHaveProperty('document');
+  });
+});

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,14 @@
+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>();
+  expectTypeOf(options.execution?.assetCatalog?.url).toEqualTypeOf<string | undefined>();
+  expectTypeOf(options.execution?.assetCatalog?.expectedScope).toEqualTypeOf<
+    { readonly scopeId: string; readonly generation: number } | 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__/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);
+  });
+});