@forgeax/engine-render 0.1.4 → 0.1.6

package/src/__tests__/fog-pipeline-topology.integration.test.ts

@@ -1,93 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-const urp = readFileSync(new URL('../urp-pipeline.ts', import.meta.url), 'utf8');
-const hdrp = readFileSync(new URL('../hdrp-pipeline.ts', import.meta.url), 'utf8');
-const skybox = readFileSync(new URL('../record/skybox-post-pass.ts', import.meta.url), 'utf8');
-const temporal = readFileSync(new URL('../features/scene-temporal.ts', import.meta.url), 'utf8');
-const pipelineSpec = readFileSync(new URL('../pipeline-spec.ts', import.meta.url), 'utf8');
-const deferredLighting = readFileSync(
-  new URL('../../../shader/src/hdrp-deferred-lighting.wgsl', import.meta.url),
-  'utf8',
-);
-
-function ordered(source: string, labels: readonly string[]): boolean {
-  let cursor = -1;
-  for (const label of labels) {
-    const next = source.indexOf(label, cursor + 1);
-    if (next === -1) return false;
-    cursor = next;
-  }
-  return true;
-}
-
-describe('Fog scene-radiance pipeline topology', () => {
-  it('keeps Fog before temporal resolve, bloom, tone/output, and overlay in URP', () => {
-    expect(
-      ordered(urp, [
-        'scene-radiance-fog',
-        'resolveTemporal',
-        'addTypedBloomPasses',
-        'addTypedTonemapPass',
-        'addTypedDebugOverlayPass',
-      ]),
-    ).toBe(true);
-    expect(urp).toContain('scene-radiance-fog-opaque-fragment');
-    expect(urp).not.toMatch(/fog(?:History|Texture|Buffer|BindGroup|post-process)/i);
-  });
-
-  it('keeps HDRP deferred Fog at lighting output and forward Fog at fragment output', () => {
-    expect(hdrp).toContain('scene-radiance-fog-deferred-output');
-    expect(hdrp).toContain('scene-radiance-fog-forward-fragment');
-    expect(hdrp).not.toContain("name: 'fog-post-process'");
-    expect(hdrp.indexOf('scene-radiance-fog-deferred-output')).toBeLessThan(
-      hdrp.indexOf("name: 'forward'"),
-    );
-    expect(hdrp.indexOf('scene-radiance-fog-forward-fragment')).toBeLessThan(
-      hdrp.indexOf('const temporalRaster = addSceneTemporalRasterPass'),
-    );
-    expect(hdrp).toContain('encodeDeferredLightingPass');
-    expect(hdrp).not.toContain('encode: () => undefined');
-    expect(deferredLighting).toContain('fs_lighting');
-    expect(deferredLighting).toContain('inverseViewProj');
-    expect(deferredLighting).toContain('gbufferNormal');
-    expect(deferredLighting).toContain('gbufferEmissive');
-    expect(deferredLighting).toContain('view.lightDir');
-    expect(deferredLighting).toContain('apply_fog');
-    expect(deferredLighting).toContain('if (depth >= 0.999999)');
-    expect(deferredLighting).toContain('discard;');
-  });
-
-  it('keeps deferred Fog capability-gated and depth sampling layout-compatible', () => {
-    expect(hdrp).toContain("frame.runtime.device.caps.backendKind === 'wgpu-webgl2'");
-    expect(deferredLighting).toContain('textureSampleLevel(sceneDepth, depthSampler, in.uv, 0)');
-    expect(deferredLighting).toContain(
-      'textureSampleLevel(gbufferAlbedo, gbufferSampler, in.uv, 0)',
-    );
-    expect(deferredLighting).toContain(
-      'textureSampleLevel(gbufferNormal, gbufferSampler, in.uv, 0)',
-    );
-    expect(deferredLighting).toContain(
-      'textureSampleLevel(gbufferEmissive, gbufferSampler, in.uv, 0)',
-    );
-    expect(pipelineSpec).toContain("label: 'fullscreen-post-with-gbuffer-depth-bgl'");
-    expect(pipelineSpec).toContain('...buildFullscreenPostInputEntries(spec)');
-    expect(pipelineSpec).toContain("texture: { sampleType: 'float', viewDimension: '2d' }");
-    expect(pipelineSpec).toContain("sampler: { type: 'non-filtering' }");
-  });
-
-  it('keeps Skybox on the world-ray Fog path and bypasses overlays and temporal facts', () => {
-    expect(skybox).toContain('scene-radiance-fog-skybox');
-    expect(skybox).toContain('FogRay');
-    expect(skybox).toContain('camera far');
-    expect(skybox).not.toContain('scene-temporal');
-    expect(temporal).not.toContain('apply_fog');
-    expect(temporal).not.toContain('FogViewParams');
-  });
-
-  it('has no second Fog resource/pass/history owner', () => {
-    for (const source of [urp, hdrp, skybox, temporal]) {
-      expect(source).not.toMatch(/fog(?:History|Texture|Buffer|BindGroup|post-process)/i);
-    }
-  });
-});

package/src/__tests__/fog-public-surface.integration.test.ts

@@ -1,60 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { Fog } from '@forgeax/engine-render';
-import { describe, expect, it } from 'vitest';
-
-const WORKTREE_ROOT = resolve(fileURLToPath(new URL('.', import.meta.url)), '../../../..');
-const README = readFileSync(resolve(WORKTREE_ROOT, 'packages/render/README.md'), 'utf8');
-const RENDER_INDEX = readFileSync(resolve(WORKTREE_ROOT, 'packages/render/src/index.ts'), 'utf8');
-
-describe('Fog public surface and documentation contract', () => {
-  it('keeps the single public authoring and bounded inspection route indexable', () => {
-    expect(Fog.name).toBe('Fog');
-    for (const token of [
-      '## Fog: authoring, inspection, and recovery',
-      "import { Fog } from '@forgeax/engine-render';",
-      'world.spawn({ component: Fog',
-      'resourceOwner',
-      'renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 })',
-      'renderer.renderScene.fog',
-      'bounded inspection',
-    ]) {
-      expect(README).toContain(token);
-    }
-    expect(RENDER_INDEX).toContain('Fog,');
-  });
-
-  it('documents both closed Fog errors as exhaustive structured recovery', () => {
-    for (const token of [
-      'FogOwnerConflictError',
-      'FogParametersInvalidError',
-      'fog-owner-conflict',
-      'fog-parameters-invalid',
-      '.code',
-      '.detail',
-      '.expected',
-      '.hint',
-      'switch (error.code)',
-      'retry draw',
-    ]) {
-      expect(README).toContain(token);
-    }
-  });
-
-  it('links real backend evidence and the custom-feature compile artifact', () => {
-    for (const token of [
-      'pnpm --filter @forgeax/bevy-fog smoke',
-      'pnpm --filter @forgeax/bevy-fog smoke:browser',
-      'evidence/dawn-fog-trace.json',
-      'evidence/browser-fog-trace.json',
-      'Custom RenderFeature responsibility',
-      'custom-render-feature-compile.json',
-      'observed',
-      'verdict',
-      'confidence',
-    ]) {
-      expect(README).toContain(token);
-    }
-  });
-});

package/src/__tests__/fog-ray-contract.integration.test.ts

@@ -1,73 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-
-const fogWgsl = readFileSync(
-  fileURLToPath(new URL('../../../shader/src/fog.wgsl', import.meta.url)),
-  'utf8',
-);
-
-interface RayFacts {
-  readonly origin: readonly [number, number, number];
-  readonly direction: readonly [number, number, number];
-  readonly distance: number;
-}
-
-function perspectiveRay(
-  camera: readonly [number, number, number],
-  fragment: readonly [number, number, number],
-): RayFacts {
-  const dx = fragment[0] - camera[0];
-  const dy = fragment[1] - camera[1];
-  const dz = fragment[2] - camera[2];
-  const distance = Math.hypot(dx, dy, dz);
-  return {
-    origin: camera,
-    direction: [dx / distance, dy / distance, dz / distance],
-    distance,
-  };
-}
-
-function orthographicRay(
-  cameraPlaneOrigin: readonly [number, number, number],
-  direction: readonly [number, number, number],
-  fragment: readonly [number, number, number],
-): RayFacts {
-  const dx = fragment[0] - cameraPlaneOrigin[0];
-  const dy = fragment[1] - cameraPlaneOrigin[1];
-  const dz = fragment[2] - cameraPlaneOrigin[2];
-  const distance = Math.hypot(dx, dy, dz);
-  return { origin: cameraPlaneOrigin, direction, distance };
-}
-
-describe('Fog real world-ray contract (M2)', () => {
-  it('uses origin, normalized direction, and true distance as module inputs', () => {
-    const perspective = perspectiveRay([0, 1, 3], [3, 2, -1]);
-    expect(perspective.origin).toEqual([0, 1, 3]);
-    expect(Math.hypot(...perspective.direction)).toBeCloseTo(1, 8);
-    expect(perspective.distance).toBeCloseTo(Math.sqrt(26), 8);
-
-    const orthographic = orthographicRay([2, 10, 4], [0, -1, 0], [3, 6, 4]);
-    expect(orthographic.origin).toEqual([2, 10, 4]);
-    expect(orthographic.direction).toEqual([0, -1, 0]);
-    expect(orthographic.distance).toBeCloseTo(Math.sqrt(17), 8);
-  });
-
-  it('does not derive Fog distance from fixed camera planes or non-linear depth', () => {
-    expect(fogWgsl).toContain('ray.origin');
-    expect(fogWgsl).toContain('ray.direction');
-    expect(fogWgsl).toContain('ray.distance');
-    expect(fogWgsl).not.toMatch(/\bnear\b/);
-    expect(fogWgsl).not.toMatch(/\bfar\b/);
-    expect(fogWgsl).not.toMatch(/\bdepth\b/);
-    expect(fogWgsl).not.toContain('texture');
-  });
-
-  it('preserves height direction instead of collapsing all rays to horizontal', () => {
-    const upward = [0, 1, 0] as const;
-    const downward = [0, -1, 0] as const;
-    expect(upward[1]).toBeGreaterThan(0);
-    expect(downward[1]).toBeLessThan(0);
-    expect(fogWgsl).toContain('direction.y');
-  });
-});

package/src/__tests__/fog-source-absence.integration.test.ts

@@ -1,51 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-
-const WORKTREE_ROOT = resolve(fileURLToPath(new URL('.', import.meta.url)), '../../../..');
-const APP_ROOT = resolve(WORKTREE_ROOT, 'apps/bevy/fog');
-const PRODUCTION_FILES = [
-  'index.html',
-  'src/fog.ts',
-  'src/main.ts',
-  'src/oracle.mjs',
-  'src/runner.mjs',
-] as const;
-
-describe('Bevy Fog one-cut source absence contract', () => {
-  it('keeps the app on the public Engine Fog owner', () => {
-    const source = PRODUCTION_FILES.map((file) =>
-      readFileSync(resolve(APP_ROOT, file), 'utf8'),
-    ).join('\n');
-
-    expect(source).toContain("from '@forgeax/engine-render'");
-    expect(source).toContain('Fog');
-    for (const forbidden of [
-      'FOG_POSTPROCESS_ID',
-      'packFogParams',
-      'FogRenderer',
-      'installFogPostProcess',
-      'SceneFog',
-      'getSceneFog',
-      'setSceneFog',
-      'addTypedFogPass',
-      'fog-post-process',
-      'fullscreen fallback',
-      'FOG_MODE',
-      'FOG_LINEAR',
-      'FOG_EXP2',
-    ]) {
-      expect(source).not.toContain(forbidden);
-    }
-    expect(existsSync(resolve(APP_ROOT, 'src/fog.wgsl'))).toBe(false);
-  });
-
-  it('does not reintroduce a Fog-specific resource or temporal owner', () => {
-    const source = PRODUCTION_FILES.map((file) =>
-      readFileSync(resolve(APP_ROOT, file), 'utf8'),
-    ).join('\n');
-    expect(source).not.toMatch(/fog(?:History|Texture|Buffer|BindGroup|Pass|Registry)/i);
-    expect(source).not.toContain('@forgeax/engine-render/internal');
-  });
-});

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

@@ -1,115 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { makeZeroCameraFallbackSnapshot } from '../record/frame-snapshot';
-import { RenderSceneProjection } from '../render-scene-projection';
-import type { TaaHistoryStore } from '../taa-history-store';
-import { summarizeTemporalCoverage } from '../temporal-coverage';
-import type { TemporalFrameBeginInput } from '../temporal-frame-transaction';
-import { TemporalFrameTransaction } from '../temporal-frame-transaction';
-
-function camera() {
-  return { ...makeZeroCameraFallbackSnapshot(), entityKey: 1, antialias: 'taa' as const };
-}
-
-const exactCoverage = summarizeTemporalCoverage([
-  {
-    identity: 'scene:opaque',
-    lane: 'rigid',
-    coverage: 'exact',
-    previous: 'last-submitted',
-  },
-]);
-
-function transaction(): TemporalFrameTransaction {
-  const history = {
-    beginFrame: () => ({
-      direction: 'a-to-b' as const,
-      valid: true,
-      resetReason: undefined,
-      commit: () => undefined,
-      abort: () => undefined,
-    }),
-    inspect: () => ({
-      enabled: true,
-      ownerGeneration: 1,
-      viewId: undefined,
-      width: 1,
-      height: 1,
-      format: 'rgba16float' as const,
-      direction: 'a-to-b' as const,
-      valid: true,
-      resetReason: undefined,
-      historyBytes: 0,
-      retiringGenerations: 0,
-    }),
-    resetForRecover: () => undefined,
-    dispose: () => undefined,
-  } as unknown as TaaHistoryStore;
-  return new TemporalFrameTransaction(history);
-}
-
-function commitRevision(
-  owner: TemporalFrameTransaction,
-  projection: RenderSceneProjection,
-  revision: number | undefined,
-): void {
-  const input = {
-    camera: camera(),
-    surfaceWidth: 1280,
-    surfaceHeight: 720,
-    projection,
-    visible: [],
-    coverage: exactCoverage,
-    reactiveRevision: revision,
-  } as unknown as TemporalFrameBeginInput;
-  owner.begin(input).commit();
-}
-
-function abortRevision(
-  owner: TemporalFrameTransaction,
-  projection: RenderSceneProjection,
-  revision: number | undefined,
-): void {
-  const input = {
-    camera: camera(),
-    surfaceWidth: 1280,
-    surfaceHeight: 720,
-    projection,
-    visible: [],
-    coverage: exactCoverage,
-    reactiveRevision: revision,
-  } as unknown as TemporalFrameBeginInput;
-  owner.begin(input).abort('queue-submit');
-}
-
-describe('Fog revision temporal lane', () => {
-  it('marks every accepted revision change current-only and lets a stable frame accumulate', () => {
-    const owner = transaction();
-    const projection = new RenderSceneProjection();
-
-    commitRevision(owner, projection, 1);
-    expect(owner.inspect().coverage).toMatchObject({ exact: 1, reactive: 1, missing: 0 });
-
-    commitRevision(owner, projection, 1);
-    expect(owner.inspect().coverage).toMatchObject({ exact: 1, reactive: 0, missing: 0 });
-
-    commitRevision(owner, projection, 2);
-    expect(owner.inspect().coverage).toMatchObject({ exact: 1, reactive: 1, missing: 0 });
-    commitRevision(owner, projection, 3);
-    expect(owner.inspect().coverage).toMatchObject({ exact: 1, reactive: 1, missing: 0 });
-
-    commitRevision(owner, projection, 3);
-    expect(owner.inspect().coverage).toMatchObject({ exact: 1, reactive: 0, missing: 0 });
-  });
-
-  it('keeps a failed candidate out of the comparison baseline', () => {
-    const owner = transaction();
-    const projection = new RenderSceneProjection();
-
-    commitRevision(owner, projection, 7);
-    abortRevision(owner, projection, 8);
-    expect(owner.inspect().coverage).toMatchObject({ exact: 1, reactive: 1, missing: 0 });
-
-    commitRevision(owner, projection, 7);
-    expect(owner.inspect().coverage).toMatchObject({ exact: 1, reactive: 0, missing: 0 });
-  });
-});

package/src/__tests__/frame-chain.unit.test.ts

@@ -1,26 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { describe, expect, it } from 'vitest';
-import { buildFrameChain, prepareFrame, recordFrame } from '../frame-chain';
-
-describe('render frame chain', () => {
-  it('accepts an empty world and produces a recordable frame', () => {
-    const frame = buildFrameChain([]);
-    const prepared = prepareFrame(frame, { resources: new Map() });
-    expect(recordFrame(prepared).ok).toBe(true);
-  });
-
-  it('keeps one light snapshot identity across extract and record stages', () => {
-    const snapshot = { kind: 'spot', direction: [0, 1, 0] };
-    const extracted = buildFrameChain([snapshot]);
-    const prepared = prepareFrame(extracted, { resources: new Map() });
-
-    expect(prepared.extracted.worlds[0]).toBe(snapshot);
-    expect(recordFrame(prepared).ok).toBe(true);
-  });
-
-  it('keeps the light extract query owner singular', async () => {
-    const source = await readFile(new URL('../render-system-extract.ts', import.meta.url), 'utf8');
-    expect(source.match(/const spotLightQuery =/g)).toHaveLength(1);
-    expect(source.match(/const pointLightQuery =/g)).toHaveLength(1);
-  });
-});

package/src/__tests__/gpu-scene-field-type-owner.test-d.ts

@@ -1,27 +0,0 @@
-/// <reference types="node" />
-
-import { readFileSync } from 'node:fs';
-import { describe, expect, expectTypeOf, it } from 'vitest';
-import type { GpuSceneField, GpuSceneFieldType, GpuSceneScalar } from '../gpu-scene-schema';
-
-type ExpectedGpuSceneFieldType = 'u32' | 'i32' | 'f32' | 'vec4<f32>' | 'mat4x4<f32>';
-
-const schemaSource = readFileSync(new URL('../gpu-scene-schema.ts', import.meta.url), 'utf8');
-
-describe('GPU Scene field type owner', () => {
-  it('keeps the exact scalar and field-type declarations', () => {
-    expectTypeOf<GpuSceneScalar>().toEqualTypeOf<'u32' | 'i32' | 'f32'>();
-    expectTypeOf<GpuSceneFieldType>().toEqualTypeOf<ExpectedGpuSceneFieldType>();
-    expectTypeOf<ExpectedGpuSceneFieldType>().toEqualTypeOf<GpuSceneFieldType>();
-    expectTypeOf<GpuSceneField['type']>().toEqualTypeOf<GpuSceneFieldType>();
-    expectTypeOf<'unknown'>().not.toExtend<GpuSceneFieldType>();
-  });
-
-  it('keeps TYPE_LAYOUT as the executable field-type owner', () => {
-    expect(schemaSource).toContain('const TYPE_LAYOUT = {');
-    expect(schemaSource).toContain('export type GpuSceneFieldType = keyof typeof TYPE_LAYOUT;');
-    expect(schemaSource).not.toContain(
-      "export type GpuSceneFieldType = GpuSceneScalar | 'vec4<f32>' | 'mat4x4<f32>';",
-    );
-  });
-});

package/src/__tests__/hdrp-pipeline.unit.test.ts

@@ -1,100 +0,0 @@
-import { readFileSync } from 'node:fs';
-import type { RhiDevice } from '@forgeax/engine-rhi';
-import { describe, expect, it } from 'vitest';
-import { isGpuMembershipProducerAvailable } from '../hdrp-pipeline';
-import { createMembershipTiming } from '../record/membership-timing';
-import { resolvePostColorDomainContract } from '../render-pipeline';
-
-const hdrpSource = readFileSync(new URL('../hdrp-pipeline.ts', import.meta.url), 'utf8');
-const frameSource = readFileSync(new URL('../record/frame.ts', import.meta.url), 'utf8');
-const lightingSource = readFileSync(
-  new URL('../record/frame-lighting.ts', import.meta.url),
-  'utf8',
-);
-const graphOwnerSource = readFileSync(
-  new URL('../record/typed-frame-graph.ts', import.meta.url),
-  'utf8',
-);
-const timingSource = readFileSync(
-  new URL('../record/membership-timing.ts', import.meta.url),
-  'utf8',
-);
-
-describe('HDRP post color-domain order', () => {
-  it('selects the GPU membership producer only for a complete compute carrier', () => {
-    expect(isGpuMembershipProducerAvailable(undefined, {}, {})).toBe(false);
-    expect(isGpuMembershipProducerAvailable({ compute: false }, {}, {})).toBe(false);
-    expect(isGpuMembershipProducerAvailable({ compute: true }, null, {})).toBe(false);
-    expect(isGpuMembershipProducerAvailable({ compute: true }, {}, null)).toBe(false);
-    expect(isGpuMembershipProducerAvailable({ compute: true }, {}, {})).toBe(true);
-  });
-
-  it('keeps transparent and bloom work in linear HDR before tone output', () => {
-    const stages = resolvePostColorDomainContract('hdrp');
-    expect(stages).toContainEqual(['transparent-blend', 'linear-hdr', 'linear-hdr']);
-    expect(stages).toContainEqual(['bloom', 'linear-hdr', 'linear-hdr']);
-    expect(stages).toContainEqual(['tone', 'linear-hdr', 'linear-ldr']);
-    expect(stages).toContainEqual(['output', 'linear-ldr', 'display-encoded']);
-    expect(stages.findIndex(([name]) => name === 'tone')).toBeGreaterThan(
-      stages.findIndex(([name]) => name === 'bloom'),
-    );
-  });
-
-  it('keeps the real HDRP producer and record owner as one provenance chain', () => {
-    expect(hdrpSource).toContain("graph.addComputePass('cluster-membership-producer'");
-    expect(hdrpSource).toContain('isGpuMembershipProducerAvailable(');
-    expect(frameSource).toContain('internals.device.caps?.compute === true &&');
-    expect(hdrpSource).toContain(
-      'begin: (frame) => frame.runtime.membershipTiming?.beforeMembership() ?? {}',
-    );
-    expect(hdrpSource).toContain('frame.runtime.membershipTiming?.markTimestampPassFailed(');
-    expect(hdrpSource).toContain(
-      'after: (frame) => frame.runtime.membershipTiming?.afterMembership(frame.encoder)',
-    );
-    expect(hdrpSource).toContain('pass.dispatchWorkgroups(');
-    expect(lightingSource).toContain('recordGpuMembershipSource({');
-    expect(lightingSource).toContain('lightCount: effectiveLightCount');
-    expect(lightingSource).toContain('grid: { x: gridX, y: gridY, z: gridZ }');
-    expect(lightingSource).toContain('overflow,');
-    expect(graphOwnerSource).toContain('markEncodeFinished()');
-    expect(graphOwnerSource).toContain('markSubmitStarted()');
-    expect(graphOwnerSource).toContain('markSubmitted(command)');
-    expect(timingSource).toContain("actualProducer: 'gpu'");
-    expect(timingSource).toContain('beginningOfPassWriteIndex: 0');
-    expect(timingSource).toContain('endOfPassWriteIndex: 1');
-    expect(timingSource).not.toContain('encoder.writeTimestamp');
-    expect(timingSource).toContain('membership: {');
-    expect(timingSource).toContain('dispatchId: capture.dispatchId ?? null');
-  });
-
-  it('keeps the null/refusal route out of the accepted GPU contract', () => {
-    const timing = createMembershipTiming(
-      {
-        caps: {
-          backendKind: 'null',
-          compute: true,
-          timestampQuery: false,
-          timestampPeriodNanoseconds: null,
-        },
-      } as unknown as RhiDevice,
-      { mode: 'gpu' },
-    );
-    const result = timing.start();
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.code).toBe('timestamp-query-unsupported');
-      expect(result.error.expected).toContain('timestampQuery');
-      expect(result.error.hint).toEqual(expect.any(String));
-      expect(result.error.detail).toEqual(expect.any(String));
-    }
-  });
-
-  it('requires the report contract to carry finite positive GPU provenance', () => {
-    expect(timingSource).toContain("rawUnit: 'ticks'");
-    expect(timingSource).toContain('end <= begin');
-    expect(timingSource).toContain('Number.isFinite(durationNanoseconds)');
-    expect(timingSource).toContain('source === undefined');
-    expect(timingSource).toContain("'membership-output-mismatch'");
-    expect(timingSource).toContain("'timestamp-range-invalid'");
-  });
-});

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

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { describeIblCapability } from '../../ibl/cubemap-projection';
-
-describe('IBL capability fallback contract', () => {
-  it.each([
-    [true, 'supported', 'complete', 'passed'],
-    [false, 'degraded', 'notExecuted', 'failed'],
-  ] as const)('keeps capability=%s separate from execution and verdict', (supported, capabilityStatus, executionStatus, verdict) => {
-    const report = describeIblCapability({ rgba16floatRenderable: supported });
-
-    expect(report.capabilityStatus).toBe(capabilityStatus);
-    expect(report.executionStatus).toBe(executionStatus);
-    expect(report.verdict).toBe(verdict);
-  });
-
-  it('does not classify rgba8 as a silent HDR substitute', () => {
-    const report = describeIblCapability({ rgba16floatRenderable: false });
-
-    expect(report.outputFormat).not.toBe('rgba8unorm');
-    expect(report.fallbackArtifact).toBe('white-cube');
-    expect(report.expectedImpact).toContain('HDR');
-  });
-});

package/src/__tests__/material-derived-error-stop-draw.integration.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  type DerivedMaterialPayloadCoordinate,
-  writeDerivedMaterialPayload,
-} from '../record/material-payload.js';
-
-const textureSchema = [{ name: 'albedo', type: 'texture2d' as const }];
-const validCoordinates: Readonly<Record<string, DerivedMaterialPayloadCoordinate>> = {
-  albedo: {
-    set: 0,
-    transform: { offset: [0, 0], scale: [1, 1], rotation: 0 },
-    physicalUvScale: [1, 1],
-  },
-};
-
-describe('derived material stop-draw falsification', () => {
-  it('stops before record when the derived interface is absent', () => {
-    const result = writeDerivedMaterialPayload({
-      material: 'missing-layout',
-      schema: undefined,
-      values: {},
-      coordinates: {},
-    });
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.code).toBe('material-derived-interface-mismatch');
-  });
-
-  it('resolves omitted coordinates and stops when allocation is insufficient', () => {
-    const missing = writeDerivedMaterialPayload({
-      material: 'missing-coordinate',
-      schema: textureSchema,
-      values: {},
-      coordinates: {},
-    });
-    expect(missing.ok).toBe(true);
-
-    const shortage = writeDerivedMaterialPayload({
-      material: 'short-payload',
-      schema: textureSchema,
-      values: {},
-      coordinates: validCoordinates,
-      capacityBytes: 16,
-    });
-    expect(shortage.ok).toBe(false);
-    if (!shortage.ok) expect(shortage.error.code).toBe('material-payload-bounds');
-  });
-
-  it('stops before submit for non-finite coordinates and never returns a partial payload', () => {
-    const result = writeDerivedMaterialPayload({
-      material: 'non-finite-coordinate',
-      schema: textureSchema,
-      values: {},
-      coordinates: {
-        albedo: {
-          set: 0,
-          transform: { offset: [0, Infinity], scale: [1, 1], rotation: 0 },
-          physicalUvScale: [1, 1],
-        },
-      },
-    });
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toMatchObject({
-        code: 'material-texture-coordinate-invalid',
-        detail: { action: 'recook', reason: 'non-finite' },
-      });
-    }
-  });
-});