@forgeax/engine-render 0.1.4 → 0.1.7

package/src/__tests__/prepared-graphics-lifecycle.unit.test.ts

@@ -11,59 +11,11 @@ import type { RenderFeature } from '../features/types';
 
 const caps = { backendKind: 'null' } as unknown as Readonly<RhiCaps>;
 
-function preparedFeature(recoverCalls: number[]): RenderFeature<{ readonly ready: true }> {
-  let pipeline: { readonly kind: 'pipeline'; readonly generation: number } | undefined;
-  let bindings: { readonly kind: 'bindings'; readonly generation: number } | undefined;
-  let vertices: { readonly kind: 'vertex-data'; readonly generation: number } | undefined;
+function preparedFeature(): RenderFeature<{ readonly ready: true }> {
   return {
     identity: 'synthetic.lifecycle',
     extract: () => ok({ ready: true }),
-    prepare: (_data, context) => {
-      const result = context.graphics.preparePipeline('pipeline', {
-        shader: 'synthetic.shader',
-        vertexLayout: 'position',
-        colorFormats: ['rgba8unorm'],
-      });
-      if (!result.ok) return result;
-      pipeline = result.value;
-      const bindingsResult = context.graphics.prepareBindings('bindings', {
-        pipeline: result.value,
-        values: {},
-      });
-      if (!bindingsResult.ok) return bindingsResult;
-      bindings = bindingsResult.value;
-      const verticesResult = context.graphics.prepareVertexData('vertices', {
-        layout: 'position',
-        data: [0, 0, 0],
-      });
-      if (!verticesResult.ok) return verticesResult;
-      vertices = verticesResult.value;
-      return ok(undefined);
-    },
-    contribute: (_data, context) => {
-      if (pipeline === undefined || bindings === undefined || vertices === undefined) {
-        return err(new Error('prepared state missing') as never);
-      }
-      context.staging.addResource('color', { kind: 'texture', lifetime: 'transient' });
-      return context.staging.addGraphicsPass('prepared', {
-        attachments: {
-          colors: [{ resource: 'color', format: 'rgba8unorm', loadOp: 'load', storeOp: 'store' }],
-        },
-        draws: [
-          {
-            kind: 'draw',
-            pipeline,
-            bindings: [bindings],
-            vertexData: [{ slot: 0, resource: vertices }],
-            command: { vertexCount: 3, instanceCount: 1 },
-          },
-        ],
-      });
-    },
-    recover: () => {
-      recoverCalls.push(1);
-      return ok(undefined);
-    },
+    plan: () => ok({ resources: [], passes: [] }),
   };
 }
 
@@ -86,8 +38,7 @@ describe('prepared graphics lifecycle ownership', () => {
   });
 
   it('re-prepares after recovery and makes repeated recovery idempotent', () => {
-    const recoverCalls: number[] = [];
-    const host = createRenderFeatureHost([preparedFeature(recoverCalls)]).unwrap();
+    const host = createRenderFeatureHost([preparedFeature()]).unwrap();
     const first = runRenderFeatureFrame(host, {
       worlds: [],
       owner: 0,
@@ -107,32 +58,13 @@ describe('prepared graphics lifecycle ownership', () => {
       caps,
     });
 
-    expect(recoverCalls).toHaveLength(1);
     expect(recovered.errors).toEqual([]);
     expect(host.features[0]?.identity).toBe('synthetic.lifecycle');
     expect(host.diagnostics()[0]?.status).toBe('active');
   });
 
-  it('releases registered resources once and keeps dispose terminal', () => {
-    const host = createRenderFeatureHost([preparedFeature([])]).unwrap();
-    let releases = 0;
-    host.registerResource('synthetic.lifecycle', {
-      handle: {} as never,
-      release: () => {
-        releases += 1;
-        return ok(undefined);
-      },
-    });
-
-    expect(host.dispose()).toEqual(ok(undefined));
-    expect(host.dispose()).toEqual(ok(undefined));
-    expect(releases).toBe(1);
-    expect(host.recover({ frameNumber: 4, caps }).ok).toBe(false);
-    expect(host.diagnostics()[0]?.status).toBe('disposed');
-  });
-
   it('releases a prepared batch that never reached queue submission during recovery', () => {
-    const host = createRenderFeatureHost([preparedFeature([])]).unwrap();
+    const host = createRenderFeatureHost([preparedFeature()]).unwrap();
     let releases = 0;
     const lease = {
       release: () => {
@@ -149,7 +81,7 @@ describe('prepared graphics lifecycle ownership', () => {
   });
 
   it('keeps submitted batches alive through recovery and dispose until late completion', () => {
-    const host = createRenderFeatureHost([preparedFeature([])]).unwrap();
+    const host = createRenderFeatureHost([preparedFeature()]).unwrap();
     let releases = 0;
     const lease = {
       release: () => {
@@ -171,7 +103,7 @@ describe('prepared graphics lifecycle ownership', () => {
   });
 
   it('recovers submitted batches when queue completion rejects and reports release errors', async () => {
-    const host = createRenderFeatureHost([preparedFeature([])]).unwrap();
+    const host = createRenderFeatureHost([preparedFeature()]).unwrap();
     let releases = 0;
     const releaseError = new Error('prepared release failed');
     const firstLease = {

package/src/__tests__/prepared-graphics-resolver.unit.test.ts

@@ -141,9 +141,7 @@ describe('prepared graphics resolver', () => {
 
     const items = store.snapshot('resolver.feature').items;
     const lookup = resultMap(items);
-    const shader = (
-      await rhi.createShaderModule(currentDevice, { code: 'synthetic' })
-    ).unwrap() as unknown as GPUShaderModule;
+    const shader = (await rhi.createShaderModule(currentDevice, { code: 'synthetic' })).unwrap();
     const input: PreparedGraphicsResolverInput = {
       device: currentDevice,
       generation: 7,

package/src/__tests__/prepared-graphics-snapshot.unit.test.ts

@@ -8,8 +8,8 @@ describe('prepared graphics operation snapshots', () => {
     const pipeline: {
       shader: string;
       vertexLayout: string;
-      colorFormats: string[];
-      depthFormat: string;
+      colorFormats: GPUTextureFormat[];
+      depthFormat: GPUTextureFormat;
       topology: 'triangle-strip';
       indexFormat: 'uint32';
       renderState: {

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

@@ -1,6 +1,6 @@
 import { createProfiler } from '@forgeax/engine-profiler';
 import { describe, expect, it } from 'vitest';
-import type { RendererOptions } from '../renderer';
+import type { RendererOptions } from '../render-contract';
 
 describe('Render profiler default-off allocation boundary', () => {
   it('keeps the complete render capability path at zero event objects', () => {

package/src/__tests__/profiler-phase-catalog.test.ts

@@ -6,7 +6,7 @@ import {
   RENDER_PHASE_CATALOG,
   RENDER_RECORD_PHASE_CATALOG,
   RENDER_SCENE_STATE_PHASE_CATALOG,
-} from '../renderer';
+} from '../render-contract';
 
 describe('Render profiler phase catalog ownership', () => {
   it('matches the profiler receiver set and includes nested record owners', () => {
@@ -58,7 +58,7 @@ describe('Render profiler phase catalog ownership', () => {
   });
 
   it('keeps the phase declaration in the Render owner module', () => {
-    const source = readFileSync(new URL('../renderer.ts', import.meta.url), 'utf8');
+    const source = readFileSync(new URL('../render-contract.ts', import.meta.url), 'utf8');
     expect(source).toContain('RENDER_PHASE_CATALOG');
     expect(source).not.toContain('RenderPhaseObserver');
     expect(source).not.toContain('renderFrameSeq');

package/src/__tests__/profiler-phase-integration.test.ts

@@ -1,11 +1,7 @@
-import {
-  createProfiler,
-  type ProfileCapture,
-  type ProfileFrameToken,
-} from '@forgeax/engine-profiler';
+import { createProfiler, type ProfileFrameToken } from '@forgeax/engine-profiler';
 import { describe, expect, it } from 'vitest';
 
-import { RENDER_PHASE_CATALOG } from '../renderer';
+import { RENDER_PHASE_CATALOG } from '../render-contract';
 
 function start(profiler: ReturnType<typeof createProfiler>) {
   const result = profiler.startCapture({ frameLimit: 2, eventLimit: 16 });
@@ -13,7 +9,7 @@ function start(profiler: ReturnType<typeof createProfiler>) {
   return result.value;
 }
 
-function finish(profiler: ReturnType<typeof createProfiler>): ProfileCapture {
+function finish(profiler: ReturnType<typeof createProfiler>) {
   const session = profiler.activeSession();
   if (session === undefined) throw new Error('capture is not active');
   const result = session.finish();
@@ -43,12 +39,8 @@ describe('Render profiler phase integration', () => {
 
     const capture = finish(profiler);
     expect(capture.captureId).toBe(token.captureId);
-    expect(
-      capture.records.map((record: ProfileCapture['records'][number]) => record.frameId),
-    ).toEqual([1, 1, 1, 1]);
-    const skip = capture.records.find(
-      (record: ProfileCapture['records'][number]) => record.kind === 'skip',
-    );
+    expect(capture.records.map((record) => record.frameId)).toEqual([1, 1, 1, 1]);
+    const skip = capture.records.find((record) => record.kind === 'skip');
     expect(skip).toMatchObject({ phase: 'bind-groups', reason: 'no-render' });
     expect(skip && 'durationMicros' in skip).toBe(false);
   });

package/src/__tests__/profiler-phase-token.test.ts

@@ -1,8 +1,4 @@
-import {
-  createProfiler,
-  type ProfileCapture,
-  type ProfileFrameToken,
-} from '@forgeax/engine-profiler';
+import { createProfiler, type ProfileFrameToken } from '@forgeax/engine-profiler';
 import { describe, expect, it } from 'vitest';
 
 import {
@@ -10,7 +6,7 @@ import {
   RENDER_PHASE_CATALOG,
   RENDER_RECORD_PHASE_CATALOG,
   type RenderPhase,
-} from '../renderer';
+} from '../render-contract';
 
 const RENDER_PHASES: readonly RenderPhase[] = [
   'extract',
@@ -62,8 +58,7 @@ describe('Render profiler token and skip contract', () => {
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const skip = result.value.records.find(
-      (record: ProfileCapture['records'][number]) =>
-        record.kind === 'skip' && record.phase === 'bind-groups',
+      (record) => record.kind === 'skip' && record.phase === 'bind-groups',
     );
     expect(skip).toMatchObject({ kind: 'skip', reason: 'camera-unavailable' });
     expect(skip && 'durationMicros' in skip).toBe(false);

package/src/__tests__/public-surface.test-d.ts

@@ -1,7 +1,16 @@
-import { Camera, type Tonemap } from '@forgeax/engine-render';
+import type {
+  FrameObservationRequest,
+  FrameReceipt,
+  RendererState,
+  RenderFrameInput,
+  RenderInspection,
+  RenderWorldLease,
+} from '@forgeax/engine-render';
+import { Camera, type Tonemap, visibilityStateFromU32 } from '@forgeax/engine-render';
 import { GlyphText, Tilemap } from '@forgeax/engine-render/authoring';
 
 void Camera;
+void visibilityStateFromU32(0);
 void GlyphText;
 void Tilemap;
 
@@ -17,6 +26,61 @@ const publicToneModes: readonly Tonemap[] = [
 ];
 void publicToneModes;
 
+// M6 red snapshot: the public frame contract is receipt-bound and lease-bound.
+declare const lease: RenderWorldLease;
+declare const receipt: FrameReceipt;
+declare const request: FrameObservationRequest;
+const drawRequest: RenderFrameInput = {
+  leases: [lease],
+  camera: { lease },
+  environment: { lease },
+};
+void receipt;
+void request;
+void drawRequest;
+const alive: RendererState = 'alive';
+void alive;
+
+declare const inspection: RenderInspection;
+const backendKind: RenderInspection['capabilities']['backendKind'] =
+  inspection.capabilities.backendKind;
+void backendKind;
+
+// M6 red snapshot: the root must expose the four target concepts without
+// reopening the old renderer/device/store/readback surface.
+type _RootKeys = keyof typeof import('@forgeax/engine-render');
+type _RendererLegacyKeys = Extract<
+  keyof import('../render-contract').Renderer,
+  | 'ready'
+  | 'onError'
+  | 'device'
+  | 'store'
+  | 'readPixels'
+  | 'observeCurrentFrame'
+  | 'installRenderFeature'
+  | 'uninstallRenderFeature'
+>;
+const noLegacyRendererKeys: never = null as unknown as _RendererLegacyKeys;
+void noLegacyRendererKeys;
+type _ForbiddenRootKeys = Extract<
+  _RootKeys,
+  | 'RendererCreateOptions'
+  | 'RendererBackend'
+  | 'RendererError'
+  | 'FrameObservation'
+  | 'FrameObservationOptions'
+  | 'TONEMAP_POST_PROCESS_ID'
+>;
+const noBroadLegacyRoot: never = null as unknown as _ForbiddenRootKeys;
+void noBroadLegacyRoot;
+
+type _ForbiddenRendererIdentity = Extract<
+  keyof import('../render-contract').Renderer,
+  'projectionLedger' | 'registerPipeline' | 'installPipeline' | 'postProcess' | 'debugReadback'
+>;
+const noLegacyRendererIdentity: never = null as unknown as _ForbiddenRendererIdentity;
+void noLegacyRendererIdentity;
+
 // The host assembly factory belongs to engine-runtime, not the render barrel.
 // @ts-expect-error createRenderer is not a public render export
 type _NoPublicCreateRenderer = typeof import('@forgeax/engine-render')['createRenderer'];
@@ -26,7 +90,5 @@ type _NoPublicCreateRenderer = typeof import('@forgeax/engine-render')['createRe
 type _NoPublicGlyphText = typeof import('@forgeax/engine-render')['GlyphText'];
 // @ts-expect-error Tilemap is authoring-only
 type _NoPublicTilemap = typeof import('@forgeax/engine-render')['Tilemap'];
-// @ts-expect-error GPU stores are package-internal
-type _NoPublicGpuResourceStore = typeof import('@forgeax/engine-render')['GpuResourceStore'];
 // @ts-expect-error extract stages are package-internal
 type _NoPublicExtractFrame = typeof import('@forgeax/engine-render')['extractFrame'];

package/src/__tests__/recover-error-policy-owner.unit.test.ts

@@ -2,14 +2,6 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { describe, expect, expectTypeOf, it } from 'vitest';
 import { RecoverError, type RecoverErrorCode } from '../errors/recover';
-import {
-  RecoverError as PublicRecoverError,
-  type RecoverErrorCode as PublicRecoverErrorCode,
-} from '../index';
-import {
-  RecoverError as InternalRecoverError,
-  type RecoverErrorCode as InternalRecoverErrorCode,
-} from '../internal';
 
 const expectedCodes = [
   'recover-not-needed',
@@ -57,29 +49,19 @@ describe('RecoverError policy ownership', () => {
     expect(source).not.toMatch(/export type RecoverErrorCode = 'recover-/);
   });
 
-  it('preserves the exact four-code vocabulary, order, and public projections', () => {
+  it('preserves the exact four-code vocabulary and order', () => {
     expect(expectedCodes).toHaveLength(4);
     expect(new Set(expectedCodes).size).toBe(4);
     expectTypeOf<RecoverErrorCode>().toEqualTypeOf<(typeof expectedCodes)[number]>();
-    expectTypeOf<InternalRecoverErrorCode>().toEqualTypeOf<RecoverErrorCode>();
-    expectTypeOf<PublicRecoverErrorCode>().toEqualTypeOf<RecoverErrorCode>();
-    expect(InternalRecoverError).toBe(RecoverError);
-    expect(PublicRecoverError).toBe(RecoverError);
   });
 
   it('preserves all twelve diagnostics byte-for-byte', () => {
     for (const { code, expected, hint, message } of evidence) {
       const error = new RecoverError(code);
-      const projected = new PublicRecoverError(code);
-
       expect(error.code).toBe(code);
       expect(error.expected).toBe(expected);
       expect(error.hint).toBe(hint);
       expect(error.message).toBe(message);
-      expect(projected.code).toBe(code);
-      expect(projected.expected).toBe(expected);
-      expect(projected.hint).toBe(hint);
-      expect(projected.message).toBe(message);
     }
   });
 
@@ -88,8 +70,6 @@ describe('RecoverError policy ownership', () => {
 
     expect(error).toBeInstanceOf(Error);
     expect(error).toBeInstanceOf(RecoverError);
-    expect(error).toBeInstanceOf(InternalRecoverError);
-    expect(error).toBeInstanceOf(PublicRecoverError);
     expect(error.name).toBe('RecoverError');
     expect(Object.hasOwn(error, 'detail')).toBe(false);
     expect(typeof error.stack).toBe('string');

package/src/__tests__/render-error-code-owner.test-d.ts

@@ -6,39 +6,39 @@ import type {
   RenderErrorCode,
 } from '../errors/render';
 import { ObservationUnavailableError, RenderFeatureStageFailedError } from '../errors/render';
-import type { RenderFeatureStageFailedDetail } from '../features/types';
+import type { RenderFeatureErrorCode, RenderFeatureStageFailedDetail } from '../features/types';
+import type { RenderFeatureRecovery, RenderFeatureStage } from '../features/vocabulary';
 import type {
   RenderError as PublicRenderError,
   RenderErrorCode as PublicRenderErrorCode,
-  RenderFeatureErrorCode,
-  RenderFeatureRecovery,
-  RenderFeatureStage,
 } from '../index';
 
 const expectedCodes = [
-  'fog-owner-conflict',
-  'fog-parameters-invalid',
+  'lifecycle-construction-failed',
+  'world-lease-invalid',
+  'frame-input-invalid',
+  'scene-projection-failed',
+  'asset-binding-failed',
+  'feature-plan-failed',
+  'graph-build-failed',
+  'device-operation-failed',
+  'surface-unavailable',
+  'renderer-state-invalid',
+  'recovery-failed',
+  'cleanup-failed',
+  'frame-receipt-stale',
+  'renderer-contract-failed',
   'observation-unavailable',
-  'taa-caps-insufficient',
-  'temporal-unsupported',
-  'atmosphere-cardinality-invalid',
-  'atmosphere-sun-missing',
-  'environment-source-conflict',
-  'atmosphere-parameter-invalid',
-  'atmosphere-caps-insufficient',
-  'atmosphere-producer-failed',
   'shadow-invalid-config',
   'equirect-projection-failed',
-  'hdrp-caps-insufficient',
   'hdrp-light-budget-exceeded',
   'hdrp-index-list-overflow',
   'hdrp-deferred-caps-insufficient',
-  'gbuffer-rt-alloc-failed',
-  'gbuffer-attachment-count-mismatch',
   'point-shadow-atlas-uninitialized',
   'point-shadow-atlas-bounds-violation',
   'video-upload-unsupported',
   'vertex-storage-buffer-unavailable',
+  'vertex-color-variant-conflict',
   'skin-palette-overflow',
   'skin-material-mismatch',
   'material-skin-attr-missing',
@@ -49,6 +49,12 @@ const expectedCodes = [
   'render-feature-preparation-failed',
   'render-feature-prepared-state-mismatch',
   'render-feature-draw-recording-failed',
+  'points-lines-invalid-style',
+  'points-lines-topology-mismatch',
+  'points-lines-style-unsupported',
+  'points-lines-material-unsupported',
+  'points-lines-budget-exceeded',
+  'points-lines-prepare-failed',
 ] as const satisfies readonly RenderErrorCode[];
 type ExpectedCodeUnion = (typeof expectedCodes)[number];
 
@@ -102,12 +108,7 @@ describe('RenderError code owner', () => {
     type StageFailedError = Extract<RenderError, { readonly code: 'render-feature-stage-failed' }>;
     expectTypeOf<StageFailedError['detail']>().toEqualTypeOf<RenderFeatureStageFailedDetail>();
 
-    const stageFailed = new RenderFeatureStageFailedError(
-      'test.feature',
-      0,
-      'prepare',
-      'next-frame',
-    );
+    const stageFailed = new RenderFeatureStageFailedError('test.feature', 0, 'plan', 'next-frame');
     expectTypeOf(stageFailed).toEqualTypeOf<StageFailedError>();
     expectTypeOf(stageFailed.detail.stage).toEqualTypeOf<RenderFeatureStage>();
     expectTypeOf(stageFailed.detail.recovery).toEqualTypeOf<RenderFeatureRecovery>();

package/src/__tests__/render-error-detail-ssot.test-d.ts

@@ -1,14 +1,4 @@
 import { describe, expectTypeOf, it } from 'vitest';
-import type {
-  PipelineErrorCode,
-  PipelineErrorDetail,
-  PipelineErrorDetailFor,
-  PipelineError as PipelineErrorType,
-  PipelineNotFoundDetail,
-  PipelinePreviouslyRegisteredDetail,
-  VertexColorVariantConflictDetail,
-} from '../pipeline-errors';
-import { PipelineError } from '../pipeline-errors';
 import type {
   FullscreenInputNotFoundDetail,
   PostProcessErrorCode,
@@ -40,42 +30,7 @@ type DetailFor<C extends PostProcessErrorCode> = Extract<
   { readonly code: C }
 >['detail'];
 
-type ExpectedPipelineDetails = {
-  readonly 'pipeline-already-registered': PipelinePreviouslyRegisteredDetail;
-  readonly 'pipeline-not-found': PipelineNotFoundDetail;
-  readonly 'vertex-color-variant-conflict': VertexColorVariantConflictDetail;
-};
-
-type ExpectedPipelineCodes = keyof ExpectedPipelineDetails;
-type PipelineDetailFor<C extends PipelineErrorCode> = Extract<
-  PipelineErrorType,
-  { readonly code: C }
->['detail'];
-
 describe('render error detail aliases derive from their code resolvers', () => {
-  it('preserves the complete pipeline detail union', () => {
-    expectTypeOf<PipelineErrorDetail>().toEqualTypeOf<PipelineErrorDetailFor<PipelineErrorCode>>();
-  });
-
-  it('keeps the exact closed vocabulary and derives the public code view', () => {
-    expectTypeOf<PipelineErrorCode>().toEqualTypeOf<ExpectedPipelineCodes>();
-    expectTypeOf<ExpectedPipelineCodes>().toEqualTypeOf<PipelineErrorCode>();
-    expectTypeOf<PipelineErrorType['code']>().toEqualTypeOf<PipelineErrorCode>();
-    expectTypeOf<PipelineErrorCode>().toEqualTypeOf<PipelineErrorType['code']>();
-  });
-
-  it('preserves every pipeline code/detail correlation in the mapped error view', () => {
-    expectTypeOf<PipelineDetailFor<'pipeline-already-registered'>>().toMatchTypeOf<
-      ExpectedPipelineDetails['pipeline-already-registered']
-    >();
-    expectTypeOf<PipelineDetailFor<'pipeline-not-found'>>().toMatchTypeOf<
-      ExpectedPipelineDetails['pipeline-not-found']
-    >();
-    expectTypeOf<PipelineDetailFor<'vertex-color-variant-conflict'>>().toMatchTypeOf<
-      ExpectedPipelineDetails['vertex-color-variant-conflict']
-    >();
-  });
-
   it('preserves the complete post-process detail union', () => {
     expectTypeOf<PostProcessErrorDetail>().toEqualTypeOf<
       PostProcessErrorDetailFor<PostProcessErrorCode>
@@ -114,16 +69,6 @@ describe('render error detail aliases derive from their code resolvers', () => {
   });
 
   it('rejects unknown codes and mismatched code/detail pairs', () => {
-    // @ts-expect-error unknown literals are outside the closed code view.
-    const invalidPipelineCode: PipelineErrorCode = 'pipeline-not-real';
-    void invalidPipelineCode;
-
-    new PipelineError({
-      code: 'pipeline-not-found',
-      // @ts-expect-error the detail must match the selected code.
-      detail: { id: 'already-registered' },
-    });
-
     // @ts-expect-error unknown literals are outside the closed code view.
     const invalidCode: PostProcessErrorCode = 'post-process-not-real';
     void invalidCode;
@@ -135,46 +80,6 @@ describe('render error detail aliases derive from their code resolvers', () => {
     });
   });
 
-  it('preserves generic PipelineError constructor inference for each selected variant', () => {
-    const previouslyRegistered = new PipelineError({
-      code: 'pipeline-already-registered',
-      detail: { id: 'forward' },
-    });
-    expectTypeOf(previouslyRegistered).toEqualTypeOf<
-      Extract<PipelineErrorType, { readonly code: 'pipeline-already-registered' }>
-    >();
-    expectTypeOf(previouslyRegistered.detail.id).toEqualTypeOf<string>();
-
-    const notFound = new PipelineError({
-      code: 'pipeline-not-found',
-      detail: { handle: 42 },
-    });
-    expectTypeOf(notFound).toEqualTypeOf<
-      Extract<PipelineErrorType, { readonly code: 'pipeline-not-found' }>
-    >();
-    expectTypeOf(notFound.detail.handle).toEqualTypeOf<number>();
-  });
-
-  it('supports exhaustive PipelineError narrowing across every mapped variant', () => {
-    const describePipeline = (error: PipelineErrorType): string => {
-      switch (error.code) {
-        case 'pipeline-already-registered':
-          expectTypeOf(error.detail.id).toEqualTypeOf<string>();
-          return error.detail.id;
-        case 'pipeline-not-found':
-          expectTypeOf(error.detail.handle).toEqualTypeOf<number>();
-          return `${error.detail.handle}`;
-        case 'vertex-color-variant-conflict':
-          expectTypeOf(error.detail.authoredValue).toEqualTypeOf<string>();
-          return error.detail.authoredValue;
-      }
-      const exhaustive: never = error;
-      return exhaustive;
-    };
-
-    expectTypeOf(describePipeline).returns.toEqualTypeOf<string>();
-  });
-
   it('preserves generic constructor inference for each selected variant', () => {
     const previouslyRegistered = new PostProcessError({
       code: 'post-process-already-registered',

package/src/__tests__/render-error-exhaustive.test-d.ts

@@ -8,7 +8,8 @@ import type {
   RenderFeaturePreparedStateMismatchError,
   RenderFeatureRegistrationConflictError,
   RenderFeatureStageFailedError,
-} from '../errors';
+  VertexColorVariantConflictError,
+} from '../errors/render';
 import type { RenderFeatureErrorCode } from '../features/types';
 
 function renderFeatureCodeLabel(code: RenderFeatureErrorCode): string {
@@ -40,6 +41,20 @@ function renderCodeLabel(code: RenderErrorCode): string {
       return renderFeatureCodeLabel(code);
     case 'render-feature-pass-order-conflict':
       return renderFeatureCodeLabel(code);
+    case 'vertex-color-variant-conflict':
+      return code;
+    case 'points-lines-invalid-style':
+      return code;
+    case 'points-lines-topology-mismatch':
+      return code;
+    case 'points-lines-style-unsupported':
+      return code;
+    case 'points-lines-material-unsupported':
+      return code;
+    case 'points-lines-budget-exceeded':
+      return code;
+    case 'points-lines-prepare-failed':
+      return code;
     default:
       return code;
   }
@@ -75,6 +90,17 @@ function renderFeatureErrorLabel(error: RenderError): string {
       const typed: RenderFeaturePassOrderConflictError = error;
       return `${typed.detail.featureIdentity}:${typed.detail.passIdentity}`;
     }
+    case 'vertex-color-variant-conflict': {
+      const typed: VertexColorVariantConflictError = error;
+      return `${typed.detail.authoredValue}:${typed.detail.projected}`;
+    }
+    case 'points-lines-invalid-style':
+    case 'points-lines-topology-mismatch':
+    case 'points-lines-style-unsupported':
+    case 'points-lines-material-unsupported':
+    case 'points-lines-budget-exceeded':
+    case 'points-lines-prepare-failed':
+      return error.expected;
     default:
       return error.expected;
   }