@flighthq/render-wgpu 0.5.1-next.973.788d3d7 → 0.6.0

package/src/wgpuMaterialRegistry.test.ts

@@ -1,100 +0,0 @@
-import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log/contract';
-import { enableRenderRegistryGuards, explainRenderRegistryMisses } from '@flighthq/render/contract';
-import type { Material, WgpuMaterialRenderer, WgpuRenderState } from '@flighthq/types/contract';
-import { StandardMaterialKind, EntityRuntimeKey, RenderRegistry } from '@flighthq/types/contract';
-
-import {
-  getWgpuMaterialRenderer,
-  registerWgpuMaterialRenderer,
-  resolveWgpuMaterialRenderer,
-} from './wgpuMaterialRegistry';
-import { createEmptyWgpuRegistries, createWgpuPipeline } from './wgpuPipeline';
-import { createWgpuDeviceState, createWgpuRenderStateRuntime, getWgpuRenderStateRuntime } from './wgpuRenderState';
-
-const TestKind = 'TestMaterial';
-const testRenderer: WgpuMaterialRenderer = { instanceFloatCount: 0, getShaderModule: () => ({}) as GPUShaderModule };
-const _pipeline = createWgpuPipeline(createEmptyWgpuRegistries());
-
-function makeState(): WgpuRenderState {
-  // `device` is what the guard's message table dispatches on to name the wgpu registrar.
-  const device = {} as GPUDevice;
-  const state = { device } as WgpuRenderState;
-  state[EntityRuntimeKey] = createWgpuRenderStateRuntime(createWgpuDeviceState(device), _pipeline);
-  return state;
-}
-
-function makeMaterial(kind: string): Material {
-  return { kind } as Material;
-}
-
-describe('getWgpuMaterialRenderer', () => {
-  it('returns null when nothing is registered for the kind', () => {
-    expect(getWgpuMaterialRenderer(makeState(), TestKind)).toBeNull();
-  });
-});
-
-describe('registerWgpuMaterialRenderer', () => {
-  it('registers a renderer retrievable by kind', () => {
-    const state = makeState();
-    const before = getWgpuRenderStateRuntime(state).registries.materialRenderers;
-    registerWgpuMaterialRenderer(state, TestKind, testRenderer);
-    expect(getWgpuMaterialRenderer(state, TestKind)).toBe(testRenderer);
-    expect(getWgpuRenderStateRuntime(state).registries.materialRenderers).not.toBe(before);
-    expect(before.entries.size).toBe(0);
-  });
-
-  it('is last-write-wins without mutating the earlier snapshot', () => {
-    const state = makeState();
-    const replacement: WgpuMaterialRenderer = { instanceFloatCount: 0, getShaderModule: () => ({}) as GPUShaderModule };
-    registerWgpuMaterialRenderer(state, TestKind, testRenderer);
-    const before = getWgpuRenderStateRuntime(state).registries.materialRenderers;
-
-    registerWgpuMaterialRenderer(state, TestKind, replacement);
-
-    expect(getWgpuMaterialRenderer(state, TestKind)).toBe(replacement);
-    expect(before.entries.get(TestKind)).toEqual({ state: 'bound', value: testRenderer });
-  });
-});
-
-describe('resolveWgpuMaterialRenderer', () => {
-  it('returns null when nothing is registered — no built-in fallback', () => {
-    expect(resolveWgpuMaterialRenderer(makeState(), null)).toBeNull();
-    expect(resolveWgpuMaterialRenderer(makeState(), makeMaterial(TestKind))).toBeNull();
-  });
-
-  it('returns the registered renderer for a material kind', () => {
-    const state = makeState();
-    registerWgpuMaterialRenderer(state, TestKind, testRenderer);
-    expect(resolveWgpuMaterialRenderer(state, makeMaterial(TestKind))).toBe(testRenderer);
-  });
-
-  it('falls back to the renderer registered for StandardMaterialKind', () => {
-    const state = makeState();
-    registerWgpuMaterialRenderer(state, StandardMaterialKind, testRenderer);
-    expect(resolveWgpuMaterialRenderer(state, makeMaterial('Other'))).toBe(testRenderer);
-    expect(resolveWgpuMaterialRenderer(state, null)).toBe(testRenderer);
-  });
-
-  it('reports the missing kind against the wgpu registrar, not the gl one', () => {
-    const state = makeState();
-    enableRenderRegistryGuards(state);
-    const sink = createMemoryLogSink(4);
-    addLogSink(sink.sink);
-
-    try {
-      resolveWgpuMaterialRenderer(state, makeMaterial(TestKind));
-
-      expect(explainRenderRegistryMisses(state).misses).toEqual([
-        { kind: TestKind, registry: RenderRegistry.MaterialRenderer },
-      ]);
-      expect(getMemoryLogSinkEntries(sink)[0]?.data).toMatchObject({
-        kind: TestKind,
-        message:
-          'resolveWgpuMaterialRenderer: material kind has no registered renderer, so nodes using it do not draw — call registerWgpuMaterialRenderer(state, kind, renderer)',
-        registry: RenderRegistry.MaterialRenderer,
-      });
-    } finally {
-      removeLogSink(sink.sink);
-    }
-  });
-});

package/src/wgpuPipeline.test.ts

@@ -1,62 +0,0 @@
-import type { WgpuPipeline } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
-
-import {
-  createEmptyWgpuRegistries,
-  createWgpuPipeline,
-  getWgpuPipelineRegistries,
-  initializeEmptyWgpuRegistries,
-} from './wgpuPipeline';
-
-describe('createEmptyWgpuRegistries', () => {
-  it('creates empty tables for every required WGPU policy seam', () => {
-    const registries = createEmptyWgpuRegistries();
-    expect(registries.renderers.shape).toBe('keyed');
-    expect(registries.compressedTextureDecoder.shape).toBe('slot');
-    expect(registries.compressedTextureUpload.shape).toBe('slot');
-    expect(registries.customMaterialShaders.shape).toBe('keyed');
-    expect(registries.materialRenderers.shape).toBe('keyed');
-    expect(registries.meshMaterialRenderers.shape).toBe('keyed');
-    expect(registries.modifierSnippets.shape).toBe('keyed');
-    expect(registries.renderEffects.shape).toBe('keyed');
-    expect(registries.shapeRasterizer.shape).toBe('slot');
-    expect(registries.strokeTessellator.shape).toBe('slot');
-    expect(registries.textureResolvers.shape).toBe('keyed');
-    expect(registries.velocityWriters.shape).toBe('keyed');
-  });
-});
-
-describe('createWgpuPipeline', () => {
-  it('returns an Entity-backed pipeline with its own runtime identity', () => {
-    const registries = createEmptyWgpuRegistries();
-    const first = createWgpuPipeline(registries);
-    const second = createWgpuPipeline(registries);
-
-    expect(EntityRuntimeKey in first).toBe(true);
-    expect(first).not.toBe(second);
-    expect(first[EntityRuntimeKey]).not.toBe(second[EntityRuntimeKey]);
-  });
-
-  it('rejects a plain literal at the Entity boundary', () => {
-    const literal = { registries: createEmptyWgpuRegistries() } as unknown as WgpuPipeline;
-    expect(EntityRuntimeKey in literal).toBe(false);
-  });
-
-  it('carries the supplied immutable registration snapshot', () => {
-    const registries = createEmptyWgpuRegistries();
-    const pipeline = createWgpuPipeline(registries);
-    expect(getWgpuPipelineRegistries(pipeline)).toBe(registries);
-  });
-});
-
-describe('getWgpuPipelineRegistries', () => {
-  it('returns the registries captured by the explicit pipeline', () => {
-    const registries = createEmptyWgpuRegistries();
-    expect(getWgpuPipelineRegistries(createWgpuPipeline(registries))).toBe(registries);
-  });
-});
-describe('initializeEmptyWgpuRegistries', () => {
-  it('is the construction initializer of createEmptyWgpuRegistries', () => {
-    expect(typeof initializeEmptyWgpuRegistries).toBe('function');
-  });
-});

package/src/wgpuSurface.test.ts

@@ -1,141 +0,0 @@
-import type { WgpuRenderState } from '@flighthq/types/contract';
-import { beforeAll, describe, expect, it } from 'vitest';
-
-import { getWgpuRenderStateRuntime } from './wgpuRenderState';
-import {
-  acquireWgpuFrameCaptureTexture,
-  createBitmapFromWgpuRenderState,
-  enableWgpuFrameCapture,
-  encodeWgpuFrameCapture,
-} from './wgpuSurface';
-import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
-
-beforeAll(() => {
-  installWgpuMock();
-});
-
-describe('acquireWgpuFrameCaptureTexture', () => {
-  it('returns null until capture is enabled, then an offscreen texture', async () => {
-    const state = await createWgpuRenderStateForTest();
-    expect(acquireWgpuFrameCaptureTexture(state)).toBeNull();
-    enableWgpuFrameCapture(state);
-    expect(acquireWgpuFrameCaptureTexture(state)).not.toBeNull();
-  });
-});
-
-describe('createBitmapFromWgpuRenderState', () => {
-  it('throws when frame capture was never enabled (no buffer to read)', async () => {
-    const state = await createWgpuRenderStateForTest();
-    await expect(createBitmapFromWgpuRenderState(state)).rejects.toThrow(/enableWgpuFrameCapture/);
-  });
-
-  it('reads the mapped buffer within the bound', async () => {
-    const state = await createWgpuRenderStateForTest();
-    installCaptureBuffer(state, () => Promise.resolve());
-
-    const bitmap = await createBitmapFromWgpuRenderState(state, 1_000);
-
-    expect(bitmap.width).toBe(1);
-    expect(bitmap.height).toBe(1);
-  });
-
-  it('fails by name when the buffer never maps, instead of awaiting forever', async () => {
-    // The driver failure this bounds: mapAsync neither resolves nor rejects. Before the bound, the
-    // caller sat here until something outside it gave up and reported a stall with no location.
-    const state = await createWgpuRenderStateForTest();
-    installCaptureBuffer(state, () => new Promise<void>(() => {}));
-
-    await expect(createBitmapFromWgpuRenderState(state, 25)).rejects.toThrow(/did not map within 25ms/);
-  });
-
-  it('leaves the wait unbounded when the caller passes 0', async () => {
-    const state = await createWgpuRenderStateForTest();
-    let settle = (): void => {};
-    installCaptureBuffer(state, () => new Promise<void>((resolve) => (settle = resolve)));
-
-    let done = false;
-    const pending = createBitmapFromWgpuRenderState(state, 0).then(() => (done = true));
-    await new Promise((resolve) => setTimeout(resolve, 40));
-    expect(done).toBe(false);
-
-    settle();
-    await pending;
-    expect(done).toBe(true);
-  });
-});
-
-// Installs a 1×1 retained capture buffer whose map step the caller controls, so the map bound can be
-// exercised without a GPU. The mock device's buffers carry no map surface of their own.
-function installCaptureBuffer(state: WgpuRenderState, mapAsync: () => Promise<void>): void {
-  const runtime = getWgpuRenderStateRuntime(state);
-  runtime.frameCaptureBuffer = {
-    mapAsync,
-    getMappedRange: () => new ArrayBuffer(256),
-    unmap: () => {},
-    destroy: () => {},
-  } as unknown as GPUBuffer;
-  runtime.frameCaptureWidth = 1;
-  runtime.frameCaptureHeight = 1;
-  runtime.frameCaptureBytesPerRow = 256;
-}
-
-describe('enableWgpuFrameCapture', () => {
-  it('sets the capture flag on the render state runtime', async () => {
-    const state = await createWgpuRenderStateForTest();
-    expect(getWgpuRenderStateRuntime(state).frameCaptureEnabled).toBeFalsy();
-    enableWgpuFrameCapture(state);
-    expect(getWgpuRenderStateRuntime(state).frameCaptureEnabled).toBe(true);
-  });
-});
-
-describe('encodeWgpuFrameCapture', () => {
-  it('is a no-op when capture is disabled', async () => {
-    const state = await createWgpuRenderStateForTest();
-    let copied = false;
-    const encoder = { copyTextureToBuffer: () => (copied = true) } as unknown as GPUCommandEncoder;
-    encodeWgpuFrameCapture(state, encoder);
-    expect(copied).toBe(false);
-  });
-
-  it('skips the copy while a readback holds the buffer, and resumes once it lets go', async () => {
-    // The writer/reader handshake over the single retained buffer: an animating scene must not keep
-    // enqueueing copies into a buffer a readback has mapped or is waiting to map.
-    const state = await createWgpuRenderStateForTest();
-    enableWgpuFrameCapture(state);
-    acquireWgpuFrameCaptureTexture(state);
-    const runtime = getWgpuRenderStateRuntime(state);
-    let mapState: GPUBufferMapState = 'unmapped';
-    installCaptureBuffer(state, () => Promise.resolve());
-    Object.defineProperty(runtime.frameCaptureBuffer, 'mapState', { get: () => mapState });
-
-    let copies = 0;
-    const encoder = { copyTextureToBuffer: () => copies++ } as unknown as GPUCommandEncoder;
-
-    mapState = 'pending';
-    encodeWgpuFrameCapture(state, encoder);
-    mapState = 'mapped';
-    encodeWgpuFrameCapture(state, encoder);
-    expect(copies).toBe(0);
-
-    mapState = 'unmapped';
-    encodeWgpuFrameCapture(state, encoder);
-    expect(copies).toBe(1);
-  });
-
-  it('still copies when the implementation reports no map state at all', async () => {
-    // Fails safe in the direction that keeps capturing: an undefined mapState must not read as "busy"
-    // and silence every copy for the rest of the run.
-    const state = await createWgpuRenderStateForTest();
-    enableWgpuFrameCapture(state);
-    acquireWgpuFrameCaptureTexture(state);
-    installCaptureBuffer(state, () => Promise.resolve());
-    Object.defineProperty(getWgpuRenderStateRuntime(state).frameCaptureBuffer, 'mapState', {
-      get: () => undefined,
-    });
-
-    let copies = 0;
-    encodeWgpuFrameCapture(state, { copyTextureToBuffer: () => copies++ } as unknown as GPUCommandEncoder);
-
-    expect(copies).toBe(1);
-  });
-});