@flighthq/effects-wgpu 0.5.1-next.650.5d3df0b → 0.5.1-next.658.9cb44d7

package/README.md

@@ -13,5 +13,5 @@ Import the supported application-facing API from `@flighthq/effects-wgpu`. The `
 This package is part of the locked-version Flight SDK graph. Applications may instead install and import `@flighthq/sdk` when package-level tree shaking is sufficient.
 
 - [Flight project](https://github.com/flighthq/flight)
-- [Source for @flighthq/effects-wgpu@0.5.1-next.650.5d3df0b](https://github.com/flighthq/flight/tree/5d3df0b3bd7071e51898ec6ca5f733b81cb94a54/packages/effects-wgpu)
-- [License](https://github.com/flighthq/flight/blob/5d3df0b3bd7071e51898ec6ca5f733b81cb94a54/LICENSE.md)
+- [Source for @flighthq/effects-wgpu@0.5.1-next.658.9cb44d7](https://github.com/flighthq/flight/tree/9cb44d76b981adad2503d5e62207be99adb35c55/packages/effects-wgpu)
+- [License](https://github.com/flighthq/flight/blob/9cb44d76b981adad2503d5e62207be99adb35c55/LICENSE.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/effects-wgpu",
-  "version": "0.5.1-next.650.5d3df0b",
+  "version": "0.5.1-next.658.9cb44d7",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -38,14 +38,14 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/adjustments": "0.5.1-next.650.5d3df0b",
-    "@flighthq/color": "0.5.1-next.650.5d3df0b",
-    "@flighthq/effects": "0.5.1-next.650.5d3df0b",
-    "@flighthq/geometry": "0.5.1-next.650.5d3df0b",
-    "@flighthq/log": "0.5.1-next.650.5d3df0b",
-    "@flighthq/render-wgpu": "0.5.1-next.650.5d3df0b",
-    "@flighthq/registry": "0.5.1-next.650.5d3df0b",
-    "@flighthq/types": "0.5.1-next.650.5d3df0b"
+    "@flighthq/adjustments": "0.5.1-next.658.9cb44d7",
+    "@flighthq/color": "0.5.1-next.658.9cb44d7",
+    "@flighthq/effects": "0.5.1-next.658.9cb44d7",
+    "@flighthq/geometry": "0.5.1-next.658.9cb44d7",
+    "@flighthq/log": "0.5.1-next.658.9cb44d7",
+    "@flighthq/render-wgpu": "0.5.1-next.658.9cb44d7",
+    "@flighthq/registry": "0.5.1-next.658.9cb44d7",
+    "@flighthq/types": "0.5.1-next.658.9cb44d7"
   },
   "peerDependencies": {
     "@webgpu/types": "^0.1.70"

package/src/wgpuBevelEffect.test.ts

@@ -1,71 +1,83 @@
+import * as renderWgpuContractModule from '@flighthq/render-wgpu/contract';
 import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
 import type { BevelEffect, WgpuRenderState, WgpuRenderTarget, WgpuRenderTargetPool } from '@flighthq/types/contract';
 
-const passMock = vi.hoisted(() => ({
-  clearWgpuEffectTarget: vi.fn(),
-  createWgpuDualSourceEffectPipeline: vi.fn(() => ({ pipeline: {} })),
-  drawWgpuDualSourceEffectPass: vi.fn(
-    (
-      _state: unknown,
-      _field: unknown,
-      _source: unknown,
-      _dest: unknown,
-      _pipeline: unknown,
-      setUniforms: (f32: Float32Array) => void,
-    ) => {
-      const f32 = new Float32Array(12);
-      setUniforms(f32);
-      recorded.composites.push([...f32]);
-    },
-  ),
-}));
-const blitMock = vi.hoisted(() => ({
-  applyWgpuEffectBlitPass: vi.fn(() => recorded.calls.push('blit')),
-  applyWgpuEffectErasePass: vi.fn(() => recorded.calls.push('erase')),
-}));
-const blurMock = vi.hoisted(() => ({
-  applyWgpuEffectBoxBlur: vi.fn((_state: unknown, _s: unknown, _d: unknown, _t: unknown, options: unknown) => {
-    recorded.blurs.push(options);
-  }),
-}));
-const tintMock = vi.hoisted(() => ({
-  applyWgpuEffectTintPass: vi.fn(
-    (_state: unknown, _source: unknown, _dest: unknown, color: number, alpha: number, strength: number) => {
-      recorded.tints.push([color, alpha, strength]);
-    },
-  ),
-}));
-const targetMock = vi.hoisted(() => ({
-  acquireWgpuRenderTarget: vi.fn((_state: unknown, _pool: unknown, descriptor: unknown) => {
-    const target = { ...(descriptor as object), id: `scratch-${recorded.acquired.length}`, view: {} };
-    recorded.acquired.push(target);
-    return target;
-  }),
-  releaseWgpuRenderTarget: vi.fn((_pool: unknown, target: unknown) => recorded.released.push(target)),
-}));
-const recorded = vi.hoisted(() => ({
+import { applyBevelEffectToWgpu, defaultWgpuBevelEffectRunner, registerWgpuBevelEffect } from './wgpuBevelEffect';
+import * as wgpuEffectBlitShaderModule from './wgpuEffectBlitShader';
+import * as wgpuEffectBoxBlurModule from './wgpuEffectBoxBlur';
+import * as wgpuEffectPassModule from './wgpuEffectPass';
+import * as wgpuEffectTintShaderModule from './wgpuEffectTintShader';
+import { getWgpuRenderEffectRunner } from './wgpuRenderEffectRegistry';
+
+const recorded = {
   acquired: [] as unknown[],
   blurs: [] as unknown[],
   calls: [] as string[],
   composites: [] as number[][],
   released: [] as unknown[],
   tints: [] as (number | undefined)[][],
-}));
+};
 
-vi.mock('./wgpuEffectBlitShader', () => blitMock);
-vi.mock('./wgpuEffectBoxBlur', () => blurMock);
-vi.mock('./wgpuEffectPass', () => passMock);
-vi.mock('./wgpuEffectTintShader', () => tintMock);
+beforeAll(() => installWgpuMock());
 
-vi.mock('@flighthq/render-wgpu/contract', async () => {
-  const actual = (await vi.importActual('@flighthq/render-wgpu/contract')) as Record<string, unknown>;
-  return { ...actual, ...targetMock };
+beforeEach(() => {
+  vi.spyOn(wgpuEffectPassModule, 'clearWgpuEffectTarget').mockImplementation((() => {}) as never);
+  vi.spyOn(wgpuEffectPassModule, 'createWgpuDualSourceEffectPipeline').mockImplementation((() => ({
+    pipeline: {},
+  })) as never);
+  vi.spyOn(wgpuEffectPassModule, 'drawWgpuDualSourceEffectPass').mockImplementation(((
+    _state: unknown,
+    _field: unknown,
+    _source: unknown,
+    _dest: unknown,
+    _pipeline: unknown,
+    setUniforms: (f32: Float32Array) => void,
+  ) => {
+    const f32 = new Float32Array(12);
+    setUniforms(f32);
+    recorded.composites.push([...f32]);
+  }) as never);
+
+  vi.spyOn(wgpuEffectBlitShaderModule, 'applyWgpuEffectBlitPass').mockImplementation((() =>
+    recorded.calls.push('blit')) as never);
+  vi.spyOn(wgpuEffectBlitShaderModule, 'applyWgpuEffectErasePass').mockImplementation((() =>
+    recorded.calls.push('erase')) as never);
+
+  vi.spyOn(wgpuEffectBoxBlurModule, 'applyWgpuEffectBoxBlur').mockImplementation(((
+    _state: unknown,
+    _s: unknown,
+    _d: unknown,
+    _t: unknown,
+    options: unknown,
+  ) => {
+    recorded.blurs.push(options);
+  }) as never);
+
+  vi.spyOn(wgpuEffectTintShaderModule, 'applyWgpuEffectTintPass').mockImplementation(((
+    _state: unknown,
+    _source: unknown,
+    _dest: unknown,
+    color: number,
+    alpha: number,
+    strength: number,
+  ) => {
+    recorded.tints.push([color, alpha, strength]);
+  }) as never);
+
+  vi.spyOn(renderWgpuContractModule, 'acquireWgpuRenderTarget').mockImplementation(((
+    _state: unknown,
+    _pool: unknown,
+    descriptor: unknown,
+  ) => {
+    const target = { ...(descriptor as object), id: `scratch-${recorded.acquired.length}`, view: {} };
+    recorded.acquired.push(target);
+    return target;
+  }) as never);
+  vi.spyOn(renderWgpuContractModule, 'releaseWgpuRenderTarget').mockImplementation(((_pool: unknown, target: unknown) =>
+    recorded.released.push(target)) as never);
 });
 
-import { applyBevelEffectToWgpu, defaultWgpuBevelEffectRunner, registerWgpuBevelEffect } from './wgpuBevelEffect';
-import { getWgpuRenderEffectRunner } from './wgpuRenderEffectRegistry';
-
-beforeAll(() => installWgpuMock());
+afterEach(() => vi.restoreAllMocks());
 
 const SOURCE_WIDTH = 100;
 const SOURCE_HEIGHT = 50;

package/src/wgpuColorLutPass.test.ts

@@ -1,11 +1,10 @@
 import { installWgpuMock } from '@flighthq/render-wgpu/contract';
 import type { ColorLut, WgpuColorLutTextureCache, WgpuRenderState, WgpuRenderTarget } from '@flighthq/types/contract';
 
-const passStateMock = vi.hoisted(() => ({
-  EFFECT_VERTEX_WGSL: 'VERTEX_WGSL\n',
-  getWgpuEffectPassState: vi.fn(() => passState),
-}));
-const passState = vi.hoisted(() => ({
+import { applyColorLutPassToWgpu } from './wgpuColorLutPass';
+import * as wgpuEffectPassModule from './wgpuEffectPass';
+
+const passState = {
   acquireSlot: vi.fn(() => 256),
   beginPass: vi.fn((_dest: unknown, loadOp: string) => {
     recorded.loadOps.push(loadOp);
@@ -25,24 +24,28 @@ const passState = vi.hoisted(() => ({
     write(f32);
     recorded.uniforms.push([...f32]);
   }),
-}));
-const recorded = vi.hoisted(() => ({
+};
+const recorded = {
   bindGroups: [] as { group: unknown; index: number }[],
   draws: [] as number[],
   loadOps: [] as string[],
   pipelines: [] as unknown[],
   shaderCode: [] as string[],
   uniforms: [] as number[][],
-}));
-
-vi.mock('./wgpuEffectPass', () => passStateMock);
-
-import { applyColorLutPassToWgpu } from './wgpuColorLutPass';
+};
 
 // The WebGPU flag enums are type-level only in @webgpu/types, so jsdom has no runtime values for the
 // usage and visibility bits this module ORs together.
 beforeAll(() => installWgpuMock());
 
+beforeEach(() => {
+  vi.spyOn(wgpuEffectPassModule, 'getWgpuEffectPassState').mockReturnValue(passState as never);
+  // eslint-disable-next-line no-import-assign -- replacing a non-function export for test; works on Vite SSR namespaces
+  Object.defineProperty(wgpuEffectPassModule, 'EFFECT_VERTEX_WGSL', { value: 'VERTEX_WGSL\n', configurable: true });
+});
+
+afterEach(() => vi.restoreAllMocks());
+
 function createHarness(): {
   createTexture: ReturnType<typeof vi.fn>;
   destroyed: string[];

package/src/wgpuColorMatrixPass.test.ts

@@ -1,33 +1,37 @@
 import type { WgpuRenderState, WgpuRenderTarget } from '@flighthq/types/contract';
 
-const passMock = vi.hoisted(() => ({
-  drawWgpuEffectPass: vi.fn(
-    (
-      _state: unknown,
-      _source: unknown,
-      _dest: unknown,
-      _pipeline: unknown,
-      setUniforms: (f32: Float32Array) => void,
-    ) => {
-      const f32 = new Float32Array(20);
-      setUniforms(f32);
-      uniformState.uploads.push([...f32]);
-    },
-  ),
-}));
-const pipelineMock = vi.hoisted(() => ({
-  getWgpuEffectPipeline: vi.fn((_state: unknown, _key: string, _wgsl: string, _blend: string) => ({ pipeline: {} })),
-}));
-const uniformState = vi.hoisted(() => ({ uploads: [] as number[][] }));
-
-vi.mock('./wgpuEffectPass', () => passMock);
-vi.mock('./wgpuEffectProgramCache', () => pipelineMock);
-
 import { applyColorMatrixPassToWgpu } from './wgpuColorMatrixPass';
+import * as wgpuEffectPassModule from './wgpuEffectPass';
+import * as wgpuEffectProgramCacheModule from './wgpuEffectProgramCache';
+
+const uniformState = { uploads: [] as number[][] };
+
+beforeEach(() => {
+  vi.spyOn(wgpuEffectPassModule, 'drawWgpuEffectPass').mockImplementation(((
+    _state: unknown,
+    _source: unknown,
+    _dest: unknown,
+    _pipeline: unknown,
+    setUniforms: (f32: Float32Array) => void,
+  ) => {
+    const f32 = new Float32Array(20);
+    setUniforms(f32);
+    uniformState.uploads.push([...f32]);
+  }) as never);
+
+  vi.spyOn(wgpuEffectProgramCacheModule, 'getWgpuEffectPipeline').mockImplementation(((
+    _state: unknown,
+    _key: string,
+    _wgsl: string,
+    _blend: string,
+  ) => ({ pipeline: {} })) as never);
+});
+
+afterEach(() => vi.restoreAllMocks());
 
 function packed(matrix: ReadonlyArray<number>): readonly number[] {
   uniformState.uploads.length = 0;
-  pipelineMock.getWgpuEffectPipeline.mockClear();
+  vi.mocked(wgpuEffectProgramCacheModule.getWgpuEffectPipeline).mockClear();
   const target = {} as unknown as WgpuRenderTarget;
   applyColorMatrixPassToWgpu({} as unknown as WgpuRenderState, target, target, matrix);
   return uniformState.uploads[0]!;
@@ -96,7 +100,7 @@ describe('applyColorMatrixPassToWgpu', () => {
   it('compiles one pipeline for every matrix, in replace blend', () => {
     packed(IDENTITY);
 
-    const call = pipelineMock.getWgpuEffectPipeline.mock.calls[0]!;
+    const call = vi.mocked(wgpuEffectProgramCacheModule.getWgpuEffectPipeline).mock.calls[0]!;
     expect(call[1]).toBe('adjustment.colorMatrix');
     expect(call[3]).toBe('replace');
   });

package/src/wgpuContactShadowsEffect.test.ts

@@ -1,5 +1,3 @@
-vi.mock('./wgpuSsaoEffect', () => ({ applySsaoEffectToWgpu: vi.fn() }));
-
 import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
 
 import {
@@ -8,12 +6,18 @@ import {
   registerWgpuContactShadowsEffect,
 } from './wgpuContactShadowsEffect';
 import { getWgpuRenderEffectRunner } from './wgpuRenderEffectRegistry';
-import { applySsaoEffectToWgpu } from './wgpuSsaoEffect';
+import * as wgpuSsaoEffectMod from './wgpuSsaoEffect';
 
 beforeAll(() => {
   installWgpuMock();
 });
 
+beforeEach(() => {
+  vi.spyOn(wgpuSsaoEffectMod, 'applySsaoEffectToWgpu').mockImplementation((() => {}) as never);
+});
+
+afterEach(() => vi.restoreAllMocks());
+
 describe('applyContactShadowsEffectToWgpu', () => {
   it('maps the contact descriptor into the shared local-occlusion realization', () => {
     applyContactShadowsEffectToWgpu({} as never, {} as never, {} as never, {
@@ -23,12 +27,17 @@ describe('applyContactShadowsEffectToWgpu', () => {
       samples: 24,
     });
 
-    expect(applySsaoEffectToWgpu).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), {
-      intensity: 0.75,
-      kind: 'SsaoEffect',
-      radius: 3,
-      samples: 24,
-    });
+    expect(wgpuSsaoEffectMod.applySsaoEffectToWgpu).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      {
+        intensity: 0.75,
+        kind: 'SsaoEffect',
+        radius: 3,
+        samples: 24,
+      },
+    );
   });
 });
 

package/src/wgpuDropShadowEffect.test.ts

@@ -1,39 +1,43 @@
-vi.mock('@flighthq/render-wgpu/contract', () => {
-  let nextTargetId = 0;
-  return {
-    acquireWgpuRenderTarget: vi.fn((_state, _pool, descriptor) => ({
-      ...descriptor,
-      id: `scratch-${nextTargetId++}`,
-      texture: {},
-    })),
-    releaseWgpuRenderTarget: vi.fn(),
-  };
-});
-
-vi.mock('./wgpuEffectBlitShader', () => ({
-  applyWgpuEffectBlitOffsetPass: vi.fn(),
-  applyWgpuEffectBlitPass: vi.fn(),
-  applyWgpuEffectErasePass: vi.fn(),
-}));
-
-vi.mock('./wgpuEffectBoxBlur', () => ({
-  applyWgpuEffectBoxBlur: vi.fn(),
-}));
-
-vi.mock('./wgpuEffectPass', () => ({
-  clearWgpuEffectTarget: vi.fn(),
-}));
-
-vi.mock('./wgpuEffectTintShader', () => ({
-  applyWgpuEffectTintPass: vi.fn(),
-}));
+import * as renderWgpuContract from '@flighthq/render-wgpu/contract';
 
 import {
   applyDropShadowEffectToWgpu,
   defaultWgpuDropShadowEffectRunner,
   registerWgpuDropShadowEffect,
 } from './wgpuDropShadowEffect';
-import { applyWgpuEffectBlitPass, applyWgpuEffectErasePass } from './wgpuEffectBlitShader';
+import * as wgpuEffectBlitShaderMod from './wgpuEffectBlitShader';
+import * as wgpuEffectBoxBlurMod from './wgpuEffectBoxBlur';
+import * as wgpuEffectPassMod from './wgpuEffectPass';
+import * as wgpuEffectTintShaderMod from './wgpuEffectTintShader';
+
+let nextTargetId = 0;
+
+beforeEach(() => {
+  nextTargetId = 0;
+
+  vi.spyOn(renderWgpuContract, 'acquireWgpuRenderTarget').mockImplementation(((
+    _state: unknown,
+    _pool: unknown,
+    descriptor: Record<string, unknown>,
+  ) => ({
+    ...descriptor,
+    id: `scratch-${nextTargetId++}`,
+    texture: {},
+  })) as never);
+  vi.spyOn(renderWgpuContract, 'releaseWgpuRenderTarget').mockImplementation((() => {}) as never);
+
+  vi.spyOn(wgpuEffectBlitShaderMod, 'applyWgpuEffectBlitOffsetPass').mockImplementation((() => {}) as never);
+  vi.spyOn(wgpuEffectBlitShaderMod, 'applyWgpuEffectBlitPass').mockImplementation((() => {}) as never);
+  vi.spyOn(wgpuEffectBlitShaderMod, 'applyWgpuEffectErasePass').mockImplementation((() => {}) as never);
+
+  vi.spyOn(wgpuEffectBoxBlurMod, 'applyWgpuEffectBoxBlur').mockImplementation((() => {}) as never);
+
+  vi.spyOn(wgpuEffectPassMod, 'clearWgpuEffectTarget').mockImplementation((() => {}) as never);
+
+  vi.spyOn(wgpuEffectTintShaderMod, 'applyWgpuEffectTintPass').mockImplementation((() => {}) as never);
+});
+
+afterEach(() => vi.restoreAllMocks());
 
 describe('applyDropShadowEffectToWgpu', () => {
   it('is a function', () => {
@@ -46,8 +50,8 @@ describe('applyDropShadowEffectToWgpu', () => {
 
     applyDropShadowEffectToWgpu(createState(), source, dest, createPool(), { kind: 'DropShadowEffect' });
 
-    expect(applyWgpuEffectBlitPass).toHaveBeenCalledWith(expect.anything(), source, dest);
-    expect(applyWgpuEffectErasePass).not.toHaveBeenCalled();
+    expect(wgpuEffectBlitShaderMod.applyWgpuEffectBlitPass).toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(wgpuEffectBlitShaderMod.applyWgpuEffectErasePass).not.toHaveBeenCalled();
   });
 
   it('hides the source when sourceMode is hide', () => {
@@ -59,8 +63,8 @@ describe('applyDropShadowEffectToWgpu', () => {
       sourceMode: 'hide',
     });
 
-    expect(applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
-    expect(applyWgpuEffectErasePass).not.toHaveBeenCalled();
+    expect(wgpuEffectBlitShaderMod.applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(wgpuEffectBlitShaderMod.applyWgpuEffectErasePass).not.toHaveBeenCalled();
   });
 
   it('erases the source silhouette when sourceMode is knockout', () => {
@@ -72,8 +76,8 @@ describe('applyDropShadowEffectToWgpu', () => {
       sourceMode: 'knockout',
     });
 
-    expect(applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
-    expect(applyWgpuEffectErasePass).toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(wgpuEffectBlitShaderMod.applyWgpuEffectBlitPass).not.toHaveBeenCalledWith(expect.anything(), source, dest);
+    expect(wgpuEffectBlitShaderMod.applyWgpuEffectErasePass).toHaveBeenCalledWith(expect.anything(), source, dest);
   });
 });
 
@@ -83,10 +87,6 @@ describe('defaultWgpuDropShadowEffectRunner', () => {
   });
 });
 
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
 function createState(): never {
   return {} as never;
 }

package/src/wgpuEffectBlitShader.test.ts

@@ -1,30 +1,42 @@
 import type { WgpuRenderState, WgpuRenderTarget } from '@flighthq/types/contract';
 
-const passMock = vi.hoisted(() => ({
-  createWgpuEffectPipeline: vi.fn((_state: unknown, wgsl: string, blend?: string) => ({ blend, wgsl })),
-  drawWgpuEffectPass: vi.fn(
-    (_state: unknown, source: unknown, dest: unknown, pipeline: unknown, setUniforms: (f32: Float32Array) => void) => {
-      const f32 = new Float32Array(4);
-      setUniforms(f32);
-      recorded.draws.push({ dest, pipeline, source, uniforms: [...f32] });
-    },
-  ),
-}));
-const recorded = vi.hoisted(() => ({
-  draws: [] as { dest: unknown; pipeline: unknown; source: unknown; uniforms: number[] }[],
-}));
-
-vi.mock('./wgpuEffectPass', () => passMock);
-
 import {
   applyWgpuEffectBlitOffsetPass,
   applyWgpuEffectBlitPass,
   applyWgpuEffectErasePass,
 } from './wgpuEffectBlitShader';
+import * as wgpuEffectPassMod from './wgpuEffectPass';
+
+const recorded = {
+  draws: [] as { dest: unknown; pipeline: unknown; source: unknown; uniforms: number[] }[],
+};
 
 const SOURCE_WIDTH = 64;
 const SOURCE_HEIGHT = 32;
 
+beforeEach(() => {
+  recorded.draws.length = 0;
+
+  vi.spyOn(wgpuEffectPassMod, 'createWgpuEffectPipeline').mockImplementation(((
+    _state: unknown,
+    wgsl: string,
+    blend?: string,
+  ) => ({ blend, wgsl })) as never);
+  vi.spyOn(wgpuEffectPassMod, 'drawWgpuEffectPass').mockImplementation(((
+    _state: unknown,
+    source: unknown,
+    dest: unknown,
+    pipeline: unknown,
+    setUniforms: (f32: Float32Array) => void,
+  ) => {
+    const f32 = new Float32Array(4);
+    setUniforms(f32);
+    recorded.draws.push({ dest, pipeline, source, uniforms: [...f32] });
+  }) as never);
+});
+
+afterEach(() => vi.restoreAllMocks());
+
 function createState(): WgpuRenderState {
   return {} as unknown as WgpuRenderState;
 }
@@ -35,7 +47,7 @@ function createTarget(id: string): WgpuRenderTarget {
 
 function reset(): void {
   recorded.draws.length = 0;
-  passMock.createWgpuEffectPipeline.mockClear();
+  vi.mocked(wgpuEffectPassMod.createWgpuEffectPipeline).mockClear();
 }
 
 function offsetFor(dx: number, dy: number): readonly number[] {
@@ -99,7 +111,7 @@ describe('applyWgpuEffectBlitOffsetPass', () => {
     applyWgpuEffectBlitOffsetPass(state, source, dest, 1, 1);
     applyWgpuEffectBlitOffsetPass(state, source, dest, 2, 2);
 
-    expect(passMock.createWgpuEffectPipeline).toHaveBeenCalledTimes(1);
+    expect(wgpuEffectPassMod.createWgpuEffectPipeline).toHaveBeenCalledTimes(1);
   });
 });
 
@@ -127,7 +139,7 @@ describe('applyWgpuEffectBlitPass', () => {
     applyWgpuEffectBlitOffsetPass(state, source, dest, 1, 1);
 
     expect(new Set(recorded.draws.map((draw) => draw.pipeline)).size).toBe(3);
-    expect(passMock.createWgpuEffectPipeline).toHaveBeenCalledTimes(3);
+    expect(wgpuEffectPassMod.createWgpuEffectPipeline).toHaveBeenCalledTimes(3);
   });
 });
 
@@ -140,7 +152,7 @@ describe('applyWgpuEffectErasePass', () => {
 
     applyWgpuEffectErasePass(createState(), createTarget('source'), createTarget('dest'));
 
-    expect(passMock.createWgpuEffectPipeline.mock.calls[0]![2]).toBe('erase');
+    expect(vi.mocked(wgpuEffectPassMod.createWgpuEffectPipeline).mock.calls[0]![2]).toBe('erase');
   });
 
   it('binds the mask as its source', () => {

package/src/wgpuEffectBoxBlur.test.ts

@@ -1,19 +1,30 @@
-const mockState = vi.hoisted(() => ({
-  uniformSnapshots: [] as number[][],
-}));
+import { applyWgpuEffectBoxBlur } from './wgpuEffectBoxBlur';
+import * as wgpuEffectPassMod from './wgpuEffectPass';
+
+const uniformSnapshots: number[][] = [];
 
-vi.mock('./wgpuEffectPass', () => ({
-  createWgpuEffectPipeline: vi.fn(() => ({ blendMode: 'replace', pipeline: {} })),
-  drawWgpuEffectPass: vi.fn((_state, _source, _dest, _pipeline, setUniforms) => {
+beforeEach(() => {
+  uniformSnapshots.length = 0;
+
+  vi.spyOn(wgpuEffectPassMod, 'createWgpuEffectPipeline').mockReturnValue({
+    blendMode: 'replace',
+    pipeline: {},
+  } as never);
+  vi.spyOn(wgpuEffectPassMod, 'drawWgpuEffectPass').mockImplementation(((
+    _state: unknown,
+    _source: unknown,
+    _dest: unknown,
+    _pipeline: unknown,
+    setUniforms: Function,
+  ) => {
     const f32 = new Float32Array(16);
     const i32 = new Int32Array(f32.buffer);
     setUniforms(f32, i32);
-    mockState.uniformSnapshots.push(Array.from(f32));
-  }),
-}));
+    uniformSnapshots.push(Array.from(f32));
+  }) as never);
+});
 
-import { applyWgpuEffectBoxBlur } from './wgpuEffectBoxBlur';
-import { createWgpuEffectPipeline, drawWgpuEffectPass } from './wgpuEffectPass';
+afterEach(() => vi.restoreAllMocks());
 
 describe('applyWgpuEffectBoxBlur', () => {
   it('is a function', () => {
@@ -28,12 +39,16 @@ describe('applyWgpuEffectBoxBlur', () => {
       passes: 1,
     });
 
-    expect(createWgpuEffectPipeline).toHaveBeenCalledWith(expect.anything(), expect.any(String), 'replace');
-    expect(mockState.uniformSnapshots[0]![4]).toBeCloseTo(0.1);
-    expect(mockState.uniformSnapshots[0]![5]).toBeCloseTo(0.2);
-    expect(mockState.uniformSnapshots[0]![6]).toBeCloseTo(0.3);
-    expect(mockState.uniformSnapshots[0]![7]).toBeCloseTo(0.4);
-    expect(mockState.uniformSnapshots[0]![9]).toBe(1);
+    expect(wgpuEffectPassMod.createWgpuEffectPipeline).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.any(String),
+      'replace',
+    );
+    expect(uniformSnapshots[0]![4]).toBeCloseTo(0.1);
+    expect(uniformSnapshots[0]![5]).toBeCloseTo(0.2);
+    expect(uniformSnapshots[0]![6]).toBeCloseTo(0.3);
+    expect(uniformSnapshots[0]![7]).toBeCloseTo(0.4);
+    expect(uniformSnapshots[0]![9]).toBe(1);
   });
 
   it('uses the replacement blur pipeline for zero-radius copies', () => {
@@ -45,18 +60,13 @@ describe('applyWgpuEffectBoxBlur', () => {
       passes: 1,
     });
 
-    expect(drawWgpuEffectPass).toHaveBeenCalledTimes(1);
-    expect(vi.mocked(drawWgpuEffectPass).mock.calls[0]![2]).toBe(dest);
-    expect(mockState.uniformSnapshots[0]![8]).toBe(0);
-    expect(mockState.uniformSnapshots[0]![9]).toBe(0);
+    expect(wgpuEffectPassMod.drawWgpuEffectPass).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(wgpuEffectPassMod.drawWgpuEffectPass).mock.calls[0]![2]).toBe(dest);
+    expect(uniformSnapshots[0]![8]).toBe(0);
+    expect(uniformSnapshots[0]![9]).toBe(0);
   });
 });
 
-beforeEach(() => {
-  vi.clearAllMocks();
-  mockState.uniformSnapshots.length = 0;
-});
-
 function createState(): never {
   return {} as never;
 }