@forgeax/engine-render 0.1.4 → 0.1.7

package/src/__tests__/fog-ai-user.fixture.ts

@@ -1,350 +0,0 @@
-import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { World } from '@forgeax/engine-ecs';
-import {
-  Camera,
-  Fog,
-  type FogOwnerConflictError,
-  type FogParametersInvalidError,
-} from '@forgeax/engine-render';
-import { createRenderer } from '@forgeax/engine-render/internal';
-import { rhi } from '@forgeax/engine-rhi-null';
-import { Transform } from '@forgeax/engine-scene';
-import { expect } from 'vitest';
-
-const WORKTREE_ROOT = resolve(fileURLToPath(new URL('.', import.meta.url)), '../../../..');
-const FEATURE_ID = 'feat-20260823-scene-fog-height-aerial-perspective-v1';
-const FEATURE_DIR =
-  process.env.FORGEAX_FOG_FEATURE_DIR ??
-  resolve(WORKTREE_ROOT, `.forgeax-harness/forgeax-loop/${FEATURE_ID}`);
-const EVIDENCE_DIR = resolve(FEATURE_DIR, 'evidence');
-const EVIDENCE_PATH = resolve(EVIDENCE_DIR, 'ai-fog-walkthrough.json');
-const BROWSER_TRACE_PATH = resolve(EVIDENCE_DIR, 'browser-fog-trace.json');
-const DAWN_TRACE_PATH = resolve(EVIDENCE_DIR, 'dawn-fog-trace.json');
-const DAWN_READBACK_PATH = resolve(EVIDENCE_DIR, 'dawn-producer-pixels.json');
-
-function engineRevision(): string {
-  return process.env.FORGEAX_ENGINE_REVISION ?? 'unknown';
-}
-
-function evidenceRelativePath(path: string): string {
-  return relative(FEATURE_DIR, path).replaceAll('\\', '/');
-}
-
-type FogFailure = FogOwnerConflictError | FogParametersInvalidError;
-
-function manifestUrl(): string {
-  const manifest = {
-    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: '' },
-    ],
-  };
-  return `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
-}
-
-function canvas(): HTMLCanvasElement {
-  return {
-    width: 64,
-    height: 64,
-    getContext: () => null,
-    addEventListener: () => undefined,
-    removeEventListener: () => undefined,
-  } as unknown as HTMLCanvasElement;
-}
-
-function recoveryAction(
-  error: FogFailure,
-): 'remove-duplicate-and-retry' | 'repair-field-and-retry' {
-  switch (error.code) {
-    case 'fog-owner-conflict':
-      return 'remove-duplicate-and-retry';
-    case 'fog-parameters-invalid':
-      return 'repair-field-and-retry';
-  }
-}
-
-function readJson(path: string): Record<string, unknown> {
-  return JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
-}
-
-function browserPngReadback(trace: Record<string, unknown>): {
-  readonly path: string;
-  readonly sha256: string;
-  readonly bytes: number;
-  readonly width: number;
-  readonly height: number;
-  readonly sameExecutionContext: boolean;
-  readonly activePhase: string;
-  readonly center: readonly number[];
-} {
-  const screenshot = trace.screenshot as {
-    readonly path?: unknown;
-    readonly bytes?: unknown;
-    readonly sha256?: unknown;
-    readonly read?: {
-      readonly width?: unknown;
-      readonly height?: unknown;
-      readonly phase?: unknown;
-      readonly center?: unknown;
-    };
-  };
-  const path = typeof screenshot.path === 'string' ? screenshot.path : '';
-  expect(path).not.toBe('');
-  expect(existsSync(path)).toBe(true);
-  const png = readFileSync(path);
-  expect(
-    Buffer.from(png.subarray(0, 8)).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])),
-  ).toBe(true);
-  const width = png.readUInt32BE(16);
-  const height = png.readUInt32BE(20);
-  const sha256 = createHash('sha256').update(png).digest('hex');
-  expect(sha256).toBe(screenshot.sha256);
-  expect(png.byteLength).toBe(screenshot.bytes);
-  expect(width).toBe(screenshot.read?.width);
-  expect(height).toBe(screenshot.read?.height);
-  expect(screenshot.read?.phase).toEqual(expect.any(String));
-  expect(screenshot.read?.phase).not.toBe('disabled');
-  expect(Array.isArray(screenshot.read?.center)).toBe(true);
-  expect((screenshot.read?.center as unknown[]).length).toBe(4);
-  expect((screenshot.read?.center as unknown[]).every((value) => typeof value === 'number')).toBe(
-    true,
-  );
-  return {
-    path: evidenceRelativePath(resolve(EVIDENCE_DIR, 'browser-fog.png')),
-    sha256,
-    bytes: png.byteLength,
-    width,
-    height,
-    sameExecutionContext:
-      screenshot.read?.width === width &&
-      screenshot.read?.height === height &&
-      screenshot.sha256 === sha256,
-    activePhase: screenshot.read?.phase as string,
-    center: screenshot.read?.center as number[],
-  };
-}
-
-function activeVisual(trace: Record<string, unknown>): Record<string, unknown> {
-  const visuals = trace.visualEvidence as Array<Record<string, unknown>>;
-  const visual = visuals.find((entry) => entry.phase !== 'disabled');
-  expect(visual).toBeDefined();
-  if (visual === undefined) throw new Error('missing active sampled visual evidence');
-  expect(visual).toMatchObject({
-    phase: expect.any(String),
-    observed: expect.any(Array),
-    verdict: 'pass',
-    confidence: expect.stringMatching(/^(medium|high)$/),
-  });
-  return visual;
-}
-
-export async function runFogAiUserWalkthrough(): Promise<void> {
-  const renderer = await createRenderer(canvas(), { rhi }, { shaderManifestUrl: manifestUrl() });
-  const routedErrors: FogFailure[] = [];
-  const detachErrorListener = renderer.onError((error) => {
-    switch (error.code) {
-      case 'fog-owner-conflict':
-      case 'fog-parameters-invalid':
-        routedErrors.push(error);
-        break;
-    }
-  });
-  const world = new World();
-  const fogEntity = world
-    .spawn(
-      { component: Transform, data: {} },
-      { component: Camera, data: { fov: 60, near: 0.1, far: 1000 } },
-      { component: Fog, data: {} },
-    )
-    .unwrap();
-
-  try {
-    expect((await renderer.ready).ok).toBe(true);
-    expect(renderer.attachWorld(world).ok).toBe(true);
-
-    expect(world.update(1 / 60).ok).toBe(true);
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    const accepted = renderer.renderScene.fog;
-    expect(accepted).toMatchObject({
-      enabled: true,
-      resourceOwner: 0,
-      entity: fogEntity,
-      reactive: true,
-      failure: undefined,
-    });
-    expect(Object.keys(accepted).sort()).toEqual([
-      'enabled',
-      'entity',
-      'failure',
-      'reactive',
-      'resourceOwner',
-      'revision',
-    ]);
-    const acceptedRevision = accepted.revision;
-    expect(acceptedRevision).toEqual(expect.any(Number));
-
-    const duplicate = world.spawn({ component: Fog, data: {} }).unwrap();
-    expect(world.update(1 / 60).ok).toBe(true);
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    const conflict = routedErrors.find(
-      (error): error is FogOwnerConflictError => error.code === 'fog-owner-conflict',
-    );
-    expect(conflict).toBeDefined();
-    expect(conflict && recoveryAction(conflict)).toBe('remove-duplicate-and-retry');
-    expect(conflict).toMatchObject({
-      code: 'fog-owner-conflict',
-      expected: 'resourceOwner contains zero or one Fog entity',
-      hint: 'remove every Fog entity except one from the resourceOwner World, then retry draw',
-      detail: {
-        resourceOwner: 0,
-        entities: expect.arrayContaining([fogEntity, duplicate]),
-        omitted: 0,
-      },
-    });
-    expect(renderer.renderScene.fog).toMatchObject({
-      enabled: true,
-      entity: fogEntity,
-      revision: acceptedRevision,
-      reactive: false,
-      failure: 'fog-owner-conflict',
-    });
-
-    expect(world.despawn(duplicate).ok).toBe(true);
-    expect(world.update(1 / 60).ok).toBe(true);
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    expect(renderer.renderScene.fog.failure).toBeUndefined();
-
-    expect(world.set(fogEntity, Fog, { density: Number.NaN }).ok).toBe(true);
-    expect(world.update(1 / 60).ok).toBe(true);
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    const invalid = routedErrors.find(
-      (error): error is FogParametersInvalidError => error.code === 'fog-parameters-invalid',
-    );
-    expect(invalid).toBeDefined();
-    expect(invalid && recoveryAction(invalid)).toBe('repair-field-and-retry');
-    expect(invalid).toMatchObject({
-      code: 'fog-parameters-invalid',
-      expected: 'a finite non-negative number',
-      detail: {
-        entity: fogEntity,
-        field: 'density',
-        actual: Number.NaN,
-      },
-    });
-    expect(renderer.renderScene.fog).toMatchObject({
-      enabled: true,
-      entity: fogEntity,
-      revision: acceptedRevision,
-      reactive: false,
-      failure: 'fog-parameters-invalid',
-    });
-
-    expect(world.set(fogEntity, Fog, { density: 0.02 }).ok).toBe(true);
-    expect(world.update(1 / 60).ok).toBe(true);
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    const repaired = renderer.renderScene.fog;
-    expect(repaired).toMatchObject({
-      enabled: true,
-      entity: fogEntity,
-      reactive: true,
-      failure: undefined,
-    });
-    expect(repaired.revision).not.toBe(acceptedRevision);
-
-    const visualEvidenceAvailable = [BROWSER_TRACE_PATH, DAWN_TRACE_PATH, DAWN_READBACK_PATH].every(
-      (path) => existsSync(path),
-    );
-    if (!visualEvidenceAvailable) {
-      if (process.env.CI) return;
-      throw new Error(
-        'Fog visual evidence is missing; set FORGEAX_FOG_FEATURE_DIR to the feature evidence directory',
-      );
-    }
-
-    const browserTrace = readJson(BROWSER_TRACE_PATH);
-    const dawnTrace = readJson(DAWN_TRACE_PATH);
-    const dawnReadback = readJson(DAWN_READBACK_PATH);
-    const browserPng = browserPngReadback(browserTrace);
-    const browserVisual = activeVisual(browserTrace);
-    const dawnVisual = activeVisual(dawnTrace);
-    expect(browserTrace.backend).toBe('browser');
-    expect(browserTrace.frames).toBe(300);
-    expect(browserTrace.errors).toEqual([]);
-    expect(browserTrace.verdict).toBe('pass');
-    expect(dawnTrace.backend).toBe('dawn');
-    expect(dawnTrace.frames).toBe(300);
-    expect(dawnTrace.errors).toEqual([]);
-    expect(dawnTrace.verdict).toBe('pass');
-    expect(dawnReadback.backend).toBe('dawn');
-    expect(browserPng.sameExecutionContext).toBe(true);
-
-    const evidence = {
-      schemaVersion: 'forgeax-fog-ai-walkthrough-v1',
-      featureId: FEATURE_ID,
-      engineRevision: engineRevision(),
-      command:
-        'pnpm exec vitest run --project=@forgeax/engine-render packages/render/src/__tests__/fog-inspection.integration.test.ts',
-      result: browserTrace.verdict === 'pass' && dawnTrace.verdict === 'pass' ? 'pass' : 'fail',
-      evidence: {
-        authoring: {
-          imports: ['@forgeax/engine-render/Fog', '@forgeax/engine-ecs/World'],
-          draw: 'renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 })',
-          resourceOwner: 0,
-          acceptedRevision,
-          repairedRevision: repaired.revision,
-          inspectionKeys: Object.keys(accepted).sort(),
-        },
-        recovery: {
-          conflict: {
-            code: conflict?.code,
-            action: recoveryAction(conflict as FogOwnerConflictError),
-            detail: conflict?.detail,
-          },
-          invalid: {
-            code: invalid?.code,
-            action: recoveryAction(invalid as FogParametersInvalidError),
-            detail: invalid?.detail
-              ? {
-                  ...invalid.detail,
-                  actual: Number.isNaN(invalid.detail.actual) ? 'NaN' : invalid.detail.actual,
-                }
-              : undefined,
-          },
-          retry: {
-            failure: repaired.failure,
-            reactive: repaired.reactive,
-            revisionChanged: repaired.revision !== acceptedRevision,
-          },
-        },
-        visualEvidence: {
-          browser: {
-            trace: evidenceRelativePath(BROWSER_TRACE_PATH),
-            png: browserPng,
-            observed: browserVisual?.observed,
-            phase: browserPng.activePhase,
-            verdict: browserTrace.verdict,
-            confidence: browserVisual?.confidence,
-          },
-          dawn: {
-            trace: evidenceRelativePath(DAWN_TRACE_PATH),
-            readback: evidenceRelativePath(DAWN_READBACK_PATH),
-            observed: dawnVisual?.observed,
-            phase: (dawnTrace.phaseTrace as unknown[]).find((phase) => phase !== 'disabled'),
-            verdict: dawnTrace.verdict,
-            confidence: dawnVisual?.confidence,
-          },
-        },
-      },
-    };
-    mkdirSync(dirname(EVIDENCE_PATH), { recursive: true });
-    writeFileSync(EVIDENCE_PATH, `${JSON.stringify(evidence, null, 2)}\n`, 'utf8');
-  } finally {
-    detachErrorListener();
-    renderer.dispose();
-  }
-}

package/src/__tests__/fog-custom-render-feature.fixture.ts

@@ -1,33 +0,0 @@
-import type { RenderFeature } from '@forgeax/engine-render';
-import { ok } from '@forgeax/engine-types';
-
-export interface FogCustomRenderFrame {
-  readonly frameNumber: number;
-}
-
-export const fogCustomRenderFeature = {
-  identity: 'fixture.custom-fog-overlay',
-  extract(context) {
-    return ok<FogCustomRenderFrame>({ frameNumber: context.frameNumber });
-  },
-  prepare(data, context) {
-    void data;
-    void context;
-    return ok(undefined);
-  },
-  contribute(data, context) {
-    void data;
-    return context.staging.addPass('overlay', {
-      reads: ['scene-color'],
-      writes: ['scene-color'],
-      execute: () => undefined,
-    });
-  },
-} satisfies RenderFeature<FogCustomRenderFrame>;
-
-export const fogCustomRenderFeatureResponsibility = Object.freeze({
-  fogOwner: 'engine-render',
-  consumes: ['scene-color'],
-  writes: ['scene-color'],
-  doesNotOwn: ['fog-texture', 'fog-history', 'fog-bind-group'],
-} as const);

package/src/__tests__/fog-custom-render-feature.integration.test.ts

@@ -1,76 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { beforeAll, describe, expect, it } from 'vitest';
-import {
-  fogCustomRenderFeature,
-  fogCustomRenderFeatureResponsibility,
-} from './fog-custom-render-feature.fixture';
-
-const WORKTREE_ROOT = resolve(fileURLToPath(new URL('.', import.meta.url)), '../../../..');
-const FEATURE_ID = 'feat-20260823-scene-fog-height-aerial-perspective-v1';
-const FEATURE_DIR =
-  process.env.FORGEAX_FOG_FEATURE_DIR ??
-  resolve(WORKTREE_ROOT, `.forgeax-harness/forgeax-loop/${FEATURE_ID}`);
-const EVIDENCE_PATH = resolve(FEATURE_DIR, 'evidence/custom-render-feature-compile.json');
-const FIXTURE_PATH = 'packages/render/src/__tests__/fog-custom-render-feature.fixture.ts';
-
-let compileExitCode = 1;
-let fixtureSource = '';
-let moduleImport = false;
-let overlay = false;
-
-describe('custom RenderFeature responsibility fixture', () => {
-  // This hook launches a package-level TypeScript compiler. Coverage workers
-  // share the CI runner and can legitimately make that cold compile exceed
-  // Vitest's 10s default even though the source contract is healthy.
-  beforeAll(() => {
-    const compileCommand = 'pnpm exec tsc -p packages/render/tsconfig.json --noEmit';
-    const compile = spawnSync(
-      'pnpm',
-      ['exec', 'tsc', '-p', 'packages/render/tsconfig.json', '--noEmit'],
-      {
-        cwd: WORKTREE_ROOT,
-        encoding: 'utf8',
-        maxBuffer: 16 * 1024 * 1024,
-      },
-    );
-    compileExitCode = compile.status ?? 1;
-    moduleImport = fogCustomRenderFeature.identity === 'fixture.custom-fog-overlay';
-    overlay =
-      fogCustomRenderFeatureResponsibility.fogOwner === 'engine-render' &&
-      fogCustomRenderFeatureResponsibility.consumes.includes('scene-color') &&
-      fogCustomRenderFeatureResponsibility.writes.includes('scene-color') &&
-      fogCustomRenderFeatureResponsibility.doesNotOwn.includes('fog-history');
-    fixtureSource = readFileSync(resolve(WORKTREE_ROOT, FIXTURE_PATH), 'utf8');
-    const evidence = {
-      schemaVersion: 'forgeax-fog-custom-render-feature-compile-v1',
-      featureId: FEATURE_ID,
-      fixturePath: FIXTURE_PATH,
-      compiler: 'typescript',
-      command: compileCommand,
-      exitCode: compileExitCode,
-      moduleImport: moduleImport ? 'pass' : 'fail',
-      overlay: overlay ? 'pass' : 'fail',
-      stderr: compile.stderr.slice(-2000),
-    };
-    mkdirSync(dirname(EVIDENCE_PATH), { recursive: true });
-    writeFileSync(EVIDENCE_PATH, `${JSON.stringify(evidence, null, 2)}\n`, 'utf8');
-  }, 30_000);
-
-  it('compiles the render fixture', () => {
-    expect(compileExitCode).toBe(0);
-  });
-
-  it('imports the public RenderFeature contract', () => {
-    expect(moduleImport).toBe(true);
-    expect(fixtureSource).toContain('satisfies RenderFeature<FogCustomRenderFrame>');
-  });
-
-  it('keeps fog ownership in the engine render boundary', () => {
-    expect(overlay).toBe(true);
-    expect(fixtureSource).toContain("'scene-color'");
-    expect(fixtureSource).not.toMatch(/fog(?:History|Texture|Buffer|BindGroup|post-process)/i);
-  });
-});

package/src/__tests__/fog-inspection.integration.test.ts

@@ -1,127 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { describe, expect, it } from 'vitest';
-import { Fog } from '../components';
-import { PersistentRenderScene } from '../persistent-render-scene';
-import { extractFrames } from '../render-system-extract';
-import { runFogAiUserWalkthrough } from './fog-ai-user.fixture';
-
-interface FogInspectionExpectation {
-  readonly enabled: boolean;
-  readonly resourceOwner: number | undefined;
-  readonly entity: number | undefined;
-  readonly revision: number | undefined;
-  readonly reactive: boolean;
-  readonly failure: string | undefined;
-}
-
-interface FogPersistentInspectionExpectation {
-  readonly fog: FogInspectionExpectation;
-}
-
-interface FogSnapshotExpectation {
-  readonly color: readonly [number, number, number];
-  readonly density: number;
-  readonly heightFalloff: number;
-  readonly maxOpacity: number;
-  readonly revision: number;
-}
-
-interface FogOwnerApi {
-  readonly stageFogCandidate: (candidate: {
-    readonly snapshot: FogSnapshotExpectation;
-    readonly resourceOwner: number;
-    readonly entity: number;
-  }) => void;
-  readonly stageFogSubmission: () => void;
-  readonly stageFogFailure: (failure: {
-    readonly code: string;
-    readonly resourceOwner: number;
-  }) => void;
-}
-
-function fogInspection(persistent: PersistentRenderScene): FogInspectionExpectation {
-  return (persistent.inspect() as unknown as FogPersistentInspectionExpectation).fog;
-}
-
-describe('Fog retained snapshot inspection', () => {
-  it('publishes only after successful submit and retains LKG across failed candidates', () => {
-    const world = new World();
-    const entity = world.spawn({ component: Fog, data: {} }).unwrap();
-    const persistent = new PersistentRenderScene();
-    const frame = extractFrames([world], 0);
-    const fogOwner = persistent as unknown as FogOwnerApi;
-
-    persistent.extract(world, 0, () => frame);
-    fogOwner.stageFogCandidate({
-      snapshot: (frame as unknown as { fog: FogSnapshotExpectation }).fog,
-      resourceOwner: 0,
-      entity,
-    });
-    expect(fogInspection(persistent)).toMatchObject({
-      enabled: false,
-      reactive: false,
-      failure: undefined,
-    });
-
-    fogOwner.stageFogSubmission();
-    const accepted = fogInspection(persistent);
-    expect(accepted).toMatchObject({
-      enabled: true,
-      resourceOwner: 0,
-      entity,
-      reactive: true,
-      failure: undefined,
-    });
-    const revision = accepted.revision;
-    expect(revision).toEqual(expect.any(Number));
-
-    fogOwner.stageFogFailure({
-      code: 'fog-parameters-invalid',
-      resourceOwner: 0,
-    });
-    expect(fogInspection(persistent)).toMatchObject({
-      enabled: true,
-      entity,
-      revision,
-      failure: 'fog-parameters-invalid',
-    });
-
-    world.despawn(entity).unwrap();
-    const replacement = world.spawn({ component: Fog, data: { density: 0.02 } }).unwrap();
-    const replacementFrame = extractFrames([world], 0);
-    fogOwner.stageFogCandidate({
-      snapshot: (replacementFrame as unknown as { fog: FogSnapshotExpectation }).fog,
-      resourceOwner: 0,
-      entity: replacement,
-    });
-    fogOwner.stageFogSubmission();
-    const next = fogInspection(persistent);
-    expect(next.entity).toBe(replacement);
-    expect(next.entity).not.toBe(entity);
-    expect(next.revision).not.toBe(revision);
-    expect(next.failure).toBeUndefined();
-  });
-
-  it('keeps inspection bounded and does not expose Fog parameters or GPU handles', () => {
-    const persistent = new PersistentRenderScene();
-    const inspection = fogInspection(persistent);
-    expect(Object.keys(inspection).sort()).toEqual([
-      'enabled',
-      'entity',
-      'failure',
-      'reactive',
-      'resourceOwner',
-      'revision',
-    ]);
-    expect(inspection).not.toHaveProperty('color');
-    expect(inspection).not.toHaveProperty('density');
-    expect(inspection).not.toHaveProperty('heightFalloff');
-    expect(inspection).not.toHaveProperty('maxOpacity');
-    expect(inspection).not.toHaveProperty('handle');
-    expect(JSON.stringify(inspection).length).toBeLessThan(256);
-  });
-
-  it('supports the public cold-start authoring and structured recovery walkthrough', async () => {
-    await runFogAiUserWalkthrough();
-  });
-});

package/src/__tests__/fog-owner-state.integration.test.ts

@@ -1,112 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { describe, expect, it, vi } from 'vitest';
-import { Fog } from '../components';
-import { extractFrames } from '../render-system-extract';
-
-interface FogSnapshotExpectation {
-  readonly color: readonly [number, number, number];
-  readonly density: number;
-  readonly heightFalloff: number;
-  readonly maxOpacity: number;
-  readonly revision: number;
-}
-
-interface FogFrameExpectation {
-  readonly fog: FogSnapshotExpectation | undefined;
-}
-
-function fogFrom(frame: unknown): FogSnapshotExpectation | undefined {
-  return (frame as FogFrameExpectation).fog;
-}
-
-describe('Fog resourceOwner selection and failure contract', () => {
-  it('selects only the resourceOwner and maps 0/1/N to disabled/active/conflict', () => {
-    const cameraWorld = new World();
-    const resourceWorld = new World();
-    const overlayWorld = new World();
-    cameraWorld.spawn({ component: Fog, data: {} }).unwrap();
-    overlayWorld.spawn({ component: Fog, data: {} }).unwrap();
-
-    const disabled = extractFrames([cameraWorld, resourceWorld, overlayWorld], {
-      cameraOwner: 0,
-      resourceOwner: 1,
-    });
-    expect(fogFrom(disabled)).toBeUndefined();
-
-    const resourceFog = resourceWorld.spawn({ component: Fog, data: {} }).unwrap();
-    const active = extractFrames([cameraWorld, resourceWorld, overlayWorld], {
-      cameraOwner: 0,
-      resourceOwner: 1,
-    });
-    expect(fogFrom(active)).toMatchObject({
-      color: [0.5, 0.5, 0.5],
-      heightFalloff: 0,
-      maxOpacity: 1,
-    });
-    expect(fogFrom(active)?.density).toBeCloseTo(0.01, 5);
-
-    resourceWorld.spawn({ component: Fog, data: { density: 0.02 } }).unwrap();
-    const errors: unknown[] = [];
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation((_message, error) => {
-      errors.push(error);
-    });
-    const conflict = extractFrames([cameraWorld, resourceWorld, overlayWorld], {
-      cameraOwner: 0,
-      resourceOwner: 1,
-    });
-    expect(fogFrom(conflict)).toBeUndefined();
-    expect(errors.at(-1)).toMatchObject({
-      code: 'fog-owner-conflict',
-      detail: {
-        resourceOwner: 1,
-        entities: expect.arrayContaining([resourceFog]),
-        omitted: 0,
-      },
-    });
-    errorSpy.mockRestore();
-  });
-
-  it.each([
-    ['color', { color: [-1, 0, 0] }],
-    ['density', { density: Number.NaN }],
-    ['heightFalloff', { heightFalloff: Number.POSITIVE_INFINITY }],
-    ['maxOpacity', { maxOpacity: 2 }],
-  ] as const)('rejects invalid %s without replacing it', (field, patch) => {
-    const world = new World();
-    const entity = world.spawn({ component: Fog, data: {} }).unwrap();
-    world.set(entity, Fog, patch).unwrap();
-    const errors: unknown[] = [];
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation((_message, error) => {
-      errors.push(error);
-    });
-
-    const frame = extractFrames([world], 0);
-
-    expect(fogFrom(frame)).toBeUndefined();
-    expect(errors.at(-1)).toMatchObject({
-      code: 'fog-parameters-invalid',
-      detail: {
-        entity,
-        field,
-        expected: expect.any(String),
-      },
-    });
-    expect((errors.at(-1) as { detail?: { actual?: unknown } }).detail?.actual).toBeDefined();
-    errorSpy.mockRestore();
-  });
-
-  it('derives a new revision for every accepted component change without debounce', () => {
-    const world = new World();
-    const entity = world.spawn({ component: Fog, data: {} }).unwrap();
-    const initial = fogFrom(extractFrames([world], 0));
-    expect(initial?.revision).toEqual(expect.any(Number));
-
-    world.set(entity, Fog, { density: 0.02 }).unwrap();
-    const changed = fogFrom(extractFrames([world], 0));
-    expect(changed?.revision).not.toBe(initial?.revision);
-
-    world.set(entity, Fog, { density: 0.03 }).unwrap();
-    const changedAgain = fogFrom(extractFrames([world], 0));
-    expect(changedAgain?.revision).not.toBe(changed?.revision);
-  });
-});