@forgeax/engine-render 0.1.4 → 0.1.7

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

@@ -1,167 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'vitest';
-import {
-  PipelineError,
-  type PipelineErrorCode,
-  type PipelineErrorDetail,
-  type PipelineErrorDetailFor,
-  type PipelineError as PipelineErrorType,
-} from '../pipeline-errors';
-
-const expectedCodes = [
-  'pipeline-already-registered',
-  'pipeline-not-found',
-  'vertex-color-variant-conflict',
-] as const satisfies readonly PipelineErrorCode[];
-type ExpectedCodeUnion = (typeof expectedCodes)[number];
-
-const evidence = [
-  {
-    code: 'pipeline-already-registered',
-    error: new PipelineError({
-      code: 'pipeline-already-registered',
-      detail: { id: 'forgeax::urp' },
-    }),
-    expected: 'each pipeline id is registered at most once',
-    hint: "pipeline id 'forgeax::urp' is already registered; same-id re-register is forbidden. Pick a distinct id (engine builtins use the forgeax:: prefix; user pipelines use <package>::<id>).",
-    message:
-      "pipeline: pipeline-already-registered (pipeline id 'forgeax::urp' is already registered; same-id re-register is forbidden. Pick a distinct id (engine builtins use the forgeax:: prefix; user pipelines use <package>::<id>).)",
-  },
-  {
-    code: 'pipeline-not-found',
-    error: new PipelineError({
-      code: 'pipeline-not-found',
-      detail: { handle: 42 },
-    }),
-    expected: 'installPipeline receives a handle to a registered pipeline',
-    hint: 'no pipeline is registered for handle 42. First registerPipeline(id, impl), then register a RenderPipelineAsset { kind:"render-pipeline", pipelineId: id } and install the returned handle.',
-    message:
-      'pipeline: pipeline-not-found (no pipeline is registered for handle 42. First registerPipeline(id, impl), then register a RenderPipelineAsset { kind:"render-pipeline", pipelineId: id } and install the returned handle.)',
-  },
-  {
-    code: 'vertex-color-variant-conflict',
-    error: new PipelineError({
-      code: 'vertex-color-variant-conflict',
-      detail: {
-        authored: true,
-        authoredValue: 'true',
-        projected: false,
-        variantSet: 'VERTEX_COLOR_AVAILABLE=true',
-      },
-    }),
-    expected: 'geometry projection and material variant agree on VERTEX_COLOR_AVAILABLE',
-    hint: "authored VERTEX_COLOR_AVAILABLE=true conflicts with geometry projection=false in variant set 'VERTEX_COLOR_AVAILABLE=true'. Remove the authored vertex-color axis and let geometry projection derive it.",
-    message:
-      "pipeline: vertex-color-variant-conflict (authored VERTEX_COLOR_AVAILABLE=true conflicts with geometry projection=false in variant set 'VERTEX_COLOR_AVAILABLE=true'. Remove the authored vertex-color axis and let geometry projection derive it.)",
-  },
-] as const;
-
-describe('PipelineError policy ownership', () => {
-  it('preserves the exact closed vocabulary and public type', () => {
-    expect(expectedCodes).toHaveLength(3);
-    expect(new Set(expectedCodes).size).toBe(3);
-    expectTypeOf<PipelineErrorCode>().toEqualTypeOf<ExpectedCodeUnion>();
-    expectTypeOf<ExpectedCodeUnion>().toEqualTypeOf<PipelineErrorCode>();
-
-    const acceptsCode = (code: PipelineErrorCode): PipelineErrorCode => code;
-    expect(acceptsCode(expectedCodes[0])).toBe('pipeline-already-registered');
-    // @ts-expect-error -- policy-derived closed union rejects unknown codes.
-    acceptsCode('pipeline-not-real');
-  });
-
-  it('preserves every expected value, dynamic hint, and message byte-for-byte', () => {
-    for (const { code, error, expected, hint, message } of evidence) {
-      expect(error.code).toBe(code);
-      expect(error.expected).toBe(expected);
-      expect(error.hint).toBe(hint);
-      expect(error.message).toBe(message);
-    }
-
-    const otherId = new PipelineError({
-      code: 'pipeline-already-registered',
-      detail: { id: 'game::custom' },
-    });
-    const otherHandle = new PipelineError({
-      code: 'pipeline-not-found',
-      detail: { handle: 9001 },
-    });
-    expect(otherId.hint).toBe(
-      "pipeline id 'game::custom' is already registered; same-id re-register is forbidden. Pick a distinct id (engine builtins use the forgeax:: prefix; user pipelines use <package>::<id>).",
-    );
-    expect(otherId.message).toBe(`pipeline: pipeline-already-registered (${otherId.hint})`);
-    expect(otherHandle.hint).toBe(
-      'no pipeline is registered for handle 9001. First registerPipeline(id, impl), then register a RenderPipelineAsset { kind:"render-pipeline", pipelineId: id } and install the returned handle.',
-    );
-    expect(otherHandle.message).toBe(`pipeline: pipeline-not-found (${otherHandle.hint})`);
-  });
-
-  it('preserves correlated constructor inference and detail aliases', () => {
-    expectTypeOf<PipelineErrorDetail>().toEqualTypeOf<PipelineErrorDetailFor<PipelineErrorCode>>();
-
-    const previouslyRegistered = new PipelineError({
-      code: 'pipeline-already-registered',
-      detail: { id: 'forgeax::urp' },
-    });
-    expectTypeOf(previouslyRegistered).toEqualTypeOf<
-      Extract<PipelineErrorType, { readonly code: 'pipeline-already-registered' }>
-    >();
-    expectTypeOf(previouslyRegistered.detail).toEqualTypeOf<
-      Extract<PipelineErrorType, { readonly code: 'pipeline-already-registered' }>['detail']
-    >();
-    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).toEqualTypeOf<
-      Extract<PipelineErrorType, { readonly code: 'pipeline-not-found' }>['detail']
-    >();
-    expectTypeOf(notFound.detail.handle).toEqualTypeOf<number>();
-  });
-
-  it('preserves Error identity, stack, own-key order, and descriptors', () => {
-    const error = new PipelineError({
-      code: 'pipeline-already-registered',
-      detail: { id: 'forgeax::urp' },
-    });
-
-    expect(error).toBeInstanceOf(Error);
-    expect(error).toBeInstanceOf(PipelineError);
-    expect(error.name).toBe('PipelineError');
-    expect(typeof error.stack).toBe('string');
-    expect(error.stack).toContain(`PipelineError: ${error.message}`);
-    expect(Object.keys(error)).toEqual(['code', 'expected', 'hint', 'detail', 'name']);
-    expect(Object.getOwnPropertyNames(error)).toEqual([
-      'stack',
-      'message',
-      'code',
-      'expected',
-      'hint',
-      'detail',
-      'name',
-    ]);
-
-    const descriptors = Object.getOwnPropertyDescriptors(error);
-    for (const field of ['name', 'code', 'expected', 'hint', 'detail'] as const) {
-      expect(descriptors[field]).toMatchObject({
-        configurable: true,
-        enumerable: true,
-        writable: true,
-      });
-    }
-    expect(descriptors.message).toMatchObject({
-      configurable: true,
-      enumerable: false,
-      writable: true,
-    });
-    expect(descriptors.stack).toMatchObject({
-      configurable: true,
-      enumerable: false,
-    });
-    expect(typeof descriptors.stack?.get).toBe('function');
-    expect(typeof descriptors.stack?.set).toBe('function');
-  });
-});

package/src/__tests__/pipeline-pass-trace.test.ts

@@ -1,92 +0,0 @@
-import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
-import type { RhiDevice } from '@forgeax/engine-rhi';
-import { rhi } from '@forgeax/engine-rhi-null';
-import { ok } from '@forgeax/engine-types';
-import { beforeAll, describe, expect, it } from 'vitest';
-import { hdrpPipeline } from '../hdrp-pipeline';
-import type { RenderPipelineFrame, RenderPipelineTopology } from '../render-pipeline';
-import { createRenderPipelineTemporalContract } from '../render-pipeline';
-import { urpPipeline } from '../urp-pipeline';
-
-let device: RhiDevice;
-
-beforeAll(async () => {
-  const adapter = await rhi.requestAdapter();
-  if (!adapter.ok) throw adapter.error;
-  const created = await adapter.value.requestDevice();
-  if (!created.ok) throw created.error;
-  device = created.value;
-});
-
-function topology(pipelineId: 'forgeax::urp' | 'forgeax::hdrp'): RenderPipelineTopology {
-  return {
-    pipelineId,
-    config: undefined,
-    surface: {
-      width: 64,
-      height: 64,
-      storageFormat: 'bgra8unorm',
-      viewFormat: 'bgra8unorm-srgb',
-    },
-    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'off' },
-    shadow: {
-      mapSize: 64,
-      cascadeCount: 1,
-      pointCount: 0,
-      pointFaceSize: 64,
-      spotCount: 0,
-    },
-    lane: {
-      compute: true,
-      storageBuffer: true,
-      multisample: false,
-      maxColorAttachments: 8,
-    },
-    featureTopologySignature: 'm4-contract',
-    gpuDrivenTopologySignature: '',
-    environment: { enabled: true, dirty: true },
-  };
-}
-
-describe('analytic environment compiled pass provenance', () => {
-  it.each([
-    ['forgeax::urp', urpPipeline, 'urp'],
-    ['forgeax::hdrp', hdrpPipeline, 'hdrp'],
-  ] as const)('records the %s producer and one background/disc pair', (id, pipeline, lane) => {
-    const input = topology(id);
-    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-    const temporal = createRenderPipelineTemporalContract({
-      enabled: false,
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: () => ok({ resolvedColor: undefined as never }),
-    });
-    const built = pipeline.build(
-      {
-        graph,
-        environment: { enabled: true, dirty: true },
-        projectGpuDriven: () => ok(undefined),
-        contributeFeatures: () => ok(undefined),
-        resolveTemporal: temporal.resolve,
-      },
-      input,
-    );
-    expect(built.ok).toBe(true);
-    if (!built.ok) return;
-    expect(temporal.finish().ok).toBe(true);
-    const compiled = graph.compile({ device, surfaceSize: { width: 64, height: 64 } });
-    expect(compiled.ok).toBe(true);
-    if (!compiled.ok) return;
-    const names = compiled.value.inspect().passes.map((pass) => pass.name);
-    expect(names.filter((name) => name.startsWith(`${lane}.atmosphere-producer.`))).toHaveLength(
-      42,
-    );
-    expect(names.filter((name) => name.includes('sun-disc'))).toHaveLength(1);
-    expect(names.indexOf(`${lane}.atmosphere-producer.sky.mip-0.face-0`)).toBeGreaterThan(
-      names.indexOf(lane === 'urp' ? 'shadowCascade0' : 'shadowCascade0'),
-    );
-    expect(names.indexOf(`${lane}.sun-disc`)).toBeGreaterThan(
-      names.indexOf(`${lane}.atmosphere-producer.prefilter.mip-4.face-5`),
-    );
-  });
-});

package/src/__tests__/pipeline-stage-owner.test-d.ts

@@ -1,13 +0,0 @@
-import { expectTypeOf, it } from 'vitest';
-
-import type { PipelineStage, pipelineStages } from '../pipeline';
-
-const expectedPipelineStages = ['extract', 'prepare', 'record'] as const;
-type ExpectedPipelineStage = (typeof expectedPipelineStages)[number];
-
-it('derives the pipeline stage union from the ordered tuple owner', () => {
-  expectTypeOf<typeof pipelineStages>().toEqualTypeOf<typeof expectedPipelineStages>();
-  expectTypeOf<typeof expectedPipelineStages>().toEqualTypeOf<typeof pipelineStages>();
-  expectTypeOf<PipelineStage>().toEqualTypeOf<ExpectedPipelineStage>();
-  expectTypeOf<ExpectedPipelineStage>().toEqualTypeOf<PipelineStage>();
-});

package/src/__tests__/plugin.test.ts

@@ -1,25 +0,0 @@
-import { Context } from '@forgeax/engine-plugin';
-import { describe, expect, it, vi } from 'vitest';
-
-import type { RenderFeature } from '../features/types';
-import { rendererPlugin, renderFeaturePlugin } from '../plugin';
-import type { Renderer } from '../renderer';
-
-describe('render capability plugins', () => {
-  it('uninstalls a RenderFeature when its Fiber is disposed', async () => {
-    const installRenderFeature = vi.fn(async () => ({ ok: true as const, value: undefined }));
-    const uninstallRenderFeature = vi.fn(async () => ({ ok: true as const, value: undefined }));
-    const renderer = { installRenderFeature, uninstallRenderFeature } as unknown as Renderer;
-    const feature = { identity: 'test-feature' } as RenderFeature<unknown>;
-    const context = new Context();
-    await context.plugin(rendererPlugin(renderer));
-
-    const fiber = await context.plugin(renderFeaturePlugin(feature));
-    expect(installRenderFeature).toHaveBeenCalledWith(feature);
-    expect(uninstallRenderFeature).not.toHaveBeenCalled();
-
-    await fiber.dispose();
-    expect(uninstallRenderFeature).toHaveBeenCalledOnce();
-    expect(uninstallRenderFeature).toHaveBeenCalledWith(feature);
-  });
-});

package/src/__tests__/prepared-graphics-backend-matrix.unit.test.ts

@@ -1,129 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type {
-  RenderFeatureGraphicsPassDescriptor,
-  RenderFeaturePreparedGraphicsState,
-  RenderFeaturePreparedRef,
-} from '../features/prepared-graphics';
-import { recordRenderFeatureGraphicsPass } from '../record/frame-targets';
-
-type MatrixResult = {
-  readonly acceptedCount: number;
-  readonly errorCode: string | null;
-  readonly operation: string | null;
-  readonly reason: string | null;
-  readonly generation: number;
-  readonly releaseCount: number;
-};
-
-const ref = <Kind extends RenderFeaturePreparedRef['kind']>(
-  kind: Kind,
-  generation = 1,
-): RenderFeaturePreparedRef<Kind> => ({ kind, generation });
-
-const pipeline = ref('pipeline');
-const bindings = ref('bindings');
-const vertices = ref('vertex-data');
-
-const pass: RenderFeatureGraphicsPassDescriptor = {
-  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 },
-    },
-  ],
-};
-
-const state: RenderFeaturePreparedGraphicsState = {
-  capabilityAvailable: true,
-  generation: 1,
-  attachments: [{ resource: 'color', format: 'rgba8unorm' }],
-  pipeline,
-  bindings: [bindings],
-  vertexData: [vertices],
-  indexData: [],
-};
-
-function runCase(
-  descriptor: RenderFeatureGraphicsPassDescriptor,
-  projectedState: RenderFeaturePreparedGraphicsState,
-): MatrixResult {
-  const result = recordRenderFeatureGraphicsPass(
-    'synthetic.backend-matrix',
-    descriptor,
-    projectedState,
-    { pipeline: 0, binding: 0, vertex: 0, index: 0, draw: 0 },
-  );
-  if (result.ok) {
-    return {
-      acceptedCount: result.value.acceptedDrawCount,
-      errorCode: null,
-      operation: null,
-      reason: null,
-      generation: projectedState.generation,
-      releaseCount: 0,
-    };
-  }
-  const detail = 'detail' in result.error ? result.error.detail : undefined;
-  return {
-    acceptedCount: 0,
-    errorCode: result.error.code,
-    operation: detail !== undefined && 'operation' in detail ? detail.operation : null,
-    reason: detail !== undefined && 'reason' in detail ? detail.reason : null,
-    generation: projectedState.generation,
-    releaseCount: 0,
-  };
-}
-
-const cases = [
-  { name: 'accepted', descriptor: pass, projectedState: state },
-  {
-    name: 'missing capability',
-    descriptor: pass,
-    projectedState: { ...state, capabilityAvailable: false },
-  },
-  {
-    name: 'stale generation',
-    descriptor: pass,
-    projectedState: { ...state, generation: 2 },
-  },
-] as const;
-
-describe('prepared graphics backend case matrix', () => {
-  it.each(cases)('keeps fixed comparison fields for $name', ({ descriptor, projectedState }) => {
-    const first = runCase(descriptor, projectedState);
-    const second = runCase(descriptor, projectedState);
-    expect(Object.keys(first)).toEqual([
-      'acceptedCount',
-      'errorCode',
-      'operation',
-      'reason',
-      'generation',
-      'releaseCount',
-    ]);
-    expect(second).toEqual(first);
-  });
-
-  it('distinguishes accepted work from disabled and stale work', () => {
-    const accepted = runCase(pass, state);
-    const disabled = runCase(pass, { ...state, capabilityAvailable: false });
-    const stale = runCase(pass, { ...state, generation: 2 });
-
-    expect(accepted).toMatchObject({ acceptedCount: 1, errorCode: null, generation: 1 });
-    expect(disabled).toMatchObject({
-      acceptedCount: 0,
-      errorCode: 'render-feature-preparation-failed',
-    });
-    expect(stale).toMatchObject({
-      acceptedCount: 0,
-      errorCode: 'render-feature-prepared-state-mismatch',
-    });
-    expect(disabled.releaseCount).toBe(0);
-    expect(stale.releaseCount).toBe(0);
-  });
-});

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

@@ -1,180 +0,0 @@
-import { rhi } from '@forgeax/engine-rhi-null';
-import { describe, expect, it } from 'vitest';
-import type {
-  RenderFeatureGraphicsPassDescriptor,
-  RenderFeaturePreparedGraphicsState,
-  RenderFeaturePreparedRef,
-} from '../features/prepared-graphics';
-import type { PreparedGraphicsResolvedResource } from '../prepare/prepared-graphics-resolver';
-import {
-  type RenderFeatureGraphicsRecordingLedger,
-  recordResolvedRenderFeatureGraphicsPass,
-} from '../record/frame-targets';
-
-function ref<Kind extends RenderFeaturePreparedRef['kind']>(
-  kind: Kind,
-  generation = 3,
-): RenderFeaturePreparedRef<Kind> {
-  return Object.freeze({ kind, generation });
-}
-
-const pipeline = ref('pipeline');
-const bindings = ref('bindings');
-const vertices = ref('vertex-data');
-
-const pass: RenderFeatureGraphicsPassDescriptor = {
-  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 },
-    },
-  ],
-};
-
-const state: RenderFeaturePreparedGraphicsState = {
-  capabilityAvailable: true,
-  generation: 3,
-  attachments: [{ resource: 'color', format: 'rgba8unorm' }],
-  pipeline,
-  bindings: [bindings],
-  vertexData: [vertices],
-  indexData: [],
-};
-
-function ledger(calls: unknown[]): RenderFeatureGraphicsRecordingLedger {
-  return {
-    pipeline: 0,
-    binding: 0,
-    vertex: 0,
-    index: 0,
-    draw: 0,
-    setPipeline: (handle) => calls.push(handle),
-    setBindGroup: (handle) => calls.push(handle),
-    setVertexBuffer: (_slot, handle) => calls.push(handle),
-    recordDraw: () => undefined,
-  };
-}
-
-describe('resolved prepared graphics recording', () => {
-  it('records current-device handles from the private resolved lookup', async () => {
-    const adapter = (await rhi.requestAdapter()).unwrap();
-    const device = (await adapter.requestDevice()).unwrap();
-    const buffer = device.createBuffer({ size: 4, usage: 40 }).unwrap();
-    const shader = (
-      await rhi.createShaderModule(device, { code: 'synthetic' })
-    ).unwrap() as unknown as GPUShaderModule;
-    const pipelineHandle = device
-      .createRenderPipeline({
-        layout: 'auto',
-        vertex: { module: shader, entryPoint: 'main', buffers: [] },
-        fragment: { module: shader, entryPoint: 'main', targets: [] },
-      })
-      .unwrap();
-    const layout = device.createBindGroupLayout({ entries: [] }).unwrap();
-    const bindingsHandle = device.createBindGroup({ layout, entries: [] }).unwrap();
-    const resources = new Map<object, PreparedGraphicsResolvedResource>([
-      [pipeline, { kind: 'pipeline', reference: pipeline, handle: pipelineHandle }],
-      [bindings, { kind: 'bindings', reference: bindings, handle: bindingsHandle }],
-      [
-        vertices,
-        {
-          kind: 'vertex-data',
-          reference: vertices,
-          handle: buffer,
-          size: 4,
-          physicalUsage: 40,
-        },
-      ],
-    ]);
-    const calls: unknown[] = [];
-    const resolved = {
-      generation: 3,
-      resolve: (reference: RenderFeaturePreparedRef) => resources.get(reference),
-    };
-    const result = recordResolvedRenderFeatureGraphicsPass(
-      'synthetic.resolved',
-      pass,
-      state,
-      resolved,
-      ledger(calls),
-    );
-    expect(result).toMatchObject({ ok: true, value: { acceptedDrawCount: 1 } });
-    expect(calls).toEqual([pipelineHandle, bindingsHandle, buffer]);
-    expect(calls).not.toContain(pipeline);
-    expect(calls).not.toContain(bindings);
-    expect(calls).not.toContain(vertices);
-  });
-
-  it('rejects unresolved work before the first recording mutation', () => {
-    const calls: unknown[] = [];
-    const result = recordResolvedRenderFeatureGraphicsPass(
-      'synthetic.invalid',
-      pass,
-      state,
-      { generation: 3, resolve: () => undefined },
-      ledger(calls),
-    );
-    expect(result.ok).toBe(false);
-    expect(calls).toEqual([]);
-  });
-
-  it('forwards prepared binding dynamic offsets to the render pass', async () => {
-    const adapter = (await rhi.requestAdapter()).unwrap();
-    const device = (await adapter.requestDevice()).unwrap();
-    const buffer = device.createBuffer({ size: 4, usage: 40 }).unwrap();
-    const shader = (
-      await rhi.createShaderModule(device, { code: 'synthetic' })
-    ).unwrap() as unknown as GPUShaderModule;
-    const pipelineHandle = device
-      .createRenderPipeline({
-        layout: 'auto',
-        vertex: { module: shader, entryPoint: 'main', buffers: [] },
-        fragment: { module: shader, entryPoint: 'main', targets: [] },
-      })
-      .unwrap();
-    const layout = device.createBindGroupLayout({ entries: [] }).unwrap();
-    const bindingsHandle = device.createBindGroup({ layout, entries: [] }).unwrap();
-    const resources = new Map<object, PreparedGraphicsResolvedResource>([
-      [pipeline, { kind: 'pipeline', reference: pipeline, handle: pipelineHandle }],
-      [
-        bindings,
-        {
-          kind: 'bindings',
-          reference: bindings,
-          handle: bindingsHandle,
-          dynamicOffsets: [256],
-        },
-      ],
-      [
-        vertices,
-        {
-          kind: 'vertex-data',
-          reference: vertices,
-          handle: buffer,
-          size: 4,
-          physicalUsage: 40,
-        },
-      ],
-    ]);
-    const calls: unknown[] = [];
-    const result = recordResolvedRenderFeatureGraphicsPass(
-      'synthetic.dynamic-offset',
-      pass,
-      state,
-      { generation: 3, resolve: (reference) => resources.get(reference) },
-      {
-        ...ledger(calls),
-        setBindGroupAt: (index, handle, offsets) => calls.push([index, handle, offsets]),
-      },
-    );
-
-    expect(result).toMatchObject({ ok: true });
-    expect(calls).toContainEqual([0, bindingsHandle, [256]]);
-  });
-});

package/src/__tests__/public-pipeline-id.test-d.ts

@@ -1,6 +0,0 @@
-import { expectTypeOf, it } from 'vitest';
-import { URP_PIPELINE_ID } from '../index';
-
-it('exports the built-in URP pipeline identifier from the public render entry', () => {
-  expectTypeOf(URP_PIPELINE_ID).toEqualTypeOf<'forgeax::urp'>();
-});