@flighthq/render-wgpu 0.5.1-next.1069.554a2ac → 0.5.1-next.1201.9b49dee

package/src/wgpuElement.test.ts

@@ -1,145 +0,0 @@
-import {
-  createWgpuCanvasElement,
-  createWgpuRenderSurface,
-  getWgpuRenderSurfaceProvider,
-  resetWgpuRenderSurfaceProviderForTest,
-  setWgpuRenderSurfaceProvider,
-} from './wgpuElement';
-
-function entityProvider(fields: Omit<WgpuRenderSurfaceProvider, keyof Entity>): WgpuRenderSurfaceProvider {
-  return (() => {
-    const out = allocateEntity<any>();
-    Object.assign(out, fields);
-    return finishEntity(out);
-  })();
-}
-
-describe('createWgpuCanvasElement', () => {
-  afterEach(() => resetWgpuRenderSurfaceProviderForTest());
-
-  it('preserves the canonical provider result identity', () => {
-    const surface = {} as HTMLCanvasElement;
-    setWgpuRenderSurfaceProvider(entityProvider({ createRenderSurface: () => surface }));
-    expect(createWgpuCanvasElement(100, 200, 2)).toBe(surface);
-  });
-
-  it('throws an actionable Web-only setup error when the provider is absent', () => {
-    expect(() => createWgpuCanvasElement(100, 200)).toThrowError(
-      /enableHostWebWgpuRenderSurface\(\).*inject a WgpuRenderSurfaceProvider/,
-    );
-  });
-
-  it('throws the same setup error when the provider refuses', () => {
-    setWgpuRenderSurfaceProvider(entityProvider({ createRenderSurface: () => null }));
-    expect(() => createWgpuCanvasElement(100, 200)).toThrowError(/enableHostWebWgpuRenderSurface\(\)/);
-  });
-});
-
-describe('createWgpuRenderSurface', () => {
-  afterEach(() => resetWgpuRenderSurfaceProviderForTest());
-
-  it('returns null when no provider is selected', () => {
-    expect(createWgpuRenderSurface(100, 200)).toBeNull();
-  });
-
-  it('passes exact dimensions and the default pixel ratio to the selected provider', () => {
-    const surface = {} as HTMLCanvasElement;
-    const createRenderSurface = vi.fn(() => surface);
-    setWgpuRenderSurfaceProvider(entityProvider({ createRenderSurface }));
-    expect(createWgpuRenderSurface(100, 200)).toBe(surface);
-    expect(createRenderSurface).toHaveBeenCalledOnce();
-    expect(createRenderSurface).toHaveBeenCalledWith(100, 200, 1);
-  });
-
-  it('passes an explicit pixel ratio and preserves the provider result identity', () => {
-    const surface = {} as HTMLCanvasElement;
-    const createRenderSurface = vi.fn(() => surface);
-    setWgpuRenderSurfaceProvider(entityProvider({ createRenderSurface }));
-    expect(createWgpuRenderSurface(300, 150, 2.5)).toBe(surface);
-    expect(createRenderSurface).toHaveBeenCalledWith(300, 150, 2.5);
-  });
-
-  it('selects replacements and reset restores omission', () => {
-    const first = {} as HTMLCanvasElement;
-    const second = {} as HTMLCanvasElement;
-    const firstProvider = entityProvider({ createRenderSurface: vi.fn(() => first) });
-    const secondProvider = entityProvider({ createRenderSurface: vi.fn(() => second) });
-    setWgpuRenderSurfaceProvider(firstProvider);
-    expect(getWgpuRenderSurfaceProvider()).toBe(firstProvider);
-    expect(createWgpuRenderSurface(1, 2)).toBe(first);
-    setWgpuRenderSurfaceProvider(secondProvider);
-    expect(getWgpuRenderSurfaceProvider()).toBe(secondProvider);
-    expect(createWgpuRenderSurface(3, 4)).toBe(second);
-    resetWgpuRenderSurfaceProviderForTest();
-    expect(getWgpuRenderSurfaceProvider()).toBeNull();
-    expect(createWgpuRenderSurface(5, 6)).toBeNull();
-  });
-
-  it('preserves provider refusal as null', () => {
-    setWgpuRenderSurfaceProvider(entityProvider({ createRenderSurface: () => null }));
-    expect(createWgpuRenderSurface(100, 200)).toBeNull();
-  });
-
-  it('lets a native host provide a surface without reading document', () => {
-    const surface = {} as HTMLCanvasElement;
-    setWgpuRenderSurfaceProvider(entityProvider({ createRenderSurface: () => surface }));
-    withThrowingDocument(() => expect(createWgpuRenderSurface(100, 200)).toBe(surface));
-  });
-
-  it('returns null for omission and refusal without reading document', () => {
-    withThrowingDocument(() => {
-      expect(createWgpuRenderSurface(100, 200)).toBeNull();
-      setWgpuRenderSurfaceProvider(entityProvider({ createRenderSurface: () => null }));
-      expect(createWgpuRenderSurface(100, 200)).toBeNull();
-    });
-  });
-});
-
-describe('getWgpuRenderSurfaceProvider', () => {
-  afterEach(() => resetWgpuRenderSurfaceProviderForTest());
-
-  it('returns the exact selected provider', () => {
-    const provider = entityProvider({ createRenderSurface: () => ({}) as HTMLCanvasElement });
-    setWgpuRenderSurfaceProvider(provider);
-    expect(getWgpuRenderSurfaceProvider()).toBe(provider);
-  });
-});
-
-describe('resetWgpuRenderSurfaceProviderForTest', () => {
-  it('restores provider omission', () => {
-    setWgpuRenderSurfaceProvider(entityProvider({ createRenderSurface: () => ({}) as HTMLCanvasElement }));
-    resetWgpuRenderSurfaceProviderForTest();
-    expect(getWgpuRenderSurfaceProvider()).toBeNull();
-    expect(createWgpuRenderSurface(1, 1)).toBeNull();
-  });
-});
-
-describe('setWgpuRenderSurfaceProvider', () => {
-  afterEach(() => resetWgpuRenderSurfaceProviderForTest());
-
-  it('replaces the selected provider', () => {
-    const first = entityProvider({ createRenderSurface: () => ({}) as HTMLCanvasElement });
-    const second = entityProvider({ createRenderSurface: () => ({}) as HTMLCanvasElement });
-    setWgpuRenderSurfaceProvider(first);
-    setWgpuRenderSurfaceProvider(second);
-    expect(getWgpuRenderSurfaceProvider()).toBe(second);
-  });
-});
-
-function withThrowingDocument(run: () => void): void {
-  const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'document');
-  Object.defineProperty(globalThis, 'document', {
-    configurable: true,
-    get(): never {
-      throw new Error('portable WGPU code read document');
-    },
-  });
-  try {
-    run();
-  } finally {
-    if (descriptor === undefined) delete (globalThis as { document?: Document }).document;
-    else Object.defineProperty(globalThis, 'document', descriptor);
-  }
-}
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import type { Entity, WgpuRenderSurfaceProvider } from '@flighthq/types/contract';

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);
-  });
-});