@flighthq/effects-gl 0.3.0-next.906.07cea63 → 0.3.0

package/src/enableGlRenderEffectGuards.test.ts

@@ -0,0 +1,156 @@
+import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log/contract';
+import {
+  acquireGlRenderTexture,
+  createGlRenderState,
+  createGlRenderTexturePool,
+  writeGlRenderTextureTarget,
+} from '@flighthq/render-gl/contract';
+import type { GlRenderEffectRunner, GlRenderState, LogEntry, RenderEffect } from '@flighthq/types/contract';
+
+import {
+  areGlRenderEffectGuardsEnabled,
+  disableGlRenderEffectGuards,
+  enableGlRenderEffectGuards,
+} from './enableGlRenderEffectGuards';
+import { registerGlRenderEffect } from './glRenderEffectRegistry';
+import { applyGlRenderEffectsToRenderTexture } from './glRenderTextureEffect';
+
+describe('areGlRenderEffectGuardsEnabled', () => {
+  it('reports whether diagnostics were installed for the state', () => {
+    const state = createState();
+    expect(areGlRenderEffectGuardsEnabled(state)).toBe(false);
+
+    enableGlRenderEffectGuards(state);
+    expect(areGlRenderEffectGuardsEnabled(state)).toBe(true);
+
+    disableGlRenderEffectGuards(state);
+    expect(areGlRenderEffectGuardsEnabled(state)).toBe(false);
+  });
+});
+
+describe('disableGlRenderEffectGuards', () => {
+  it('stops reporting, leaving the silent sentinel silent again', () => {
+    const state = createState();
+    enableGlRenderEffectGuards(state);
+    disableGlRenderEffectGuards(state);
+
+    const entries = captureLog(() => {
+      expect(applyChain(state, ['test.disabled-kind'])).toBe(false);
+    });
+
+    expect(entries.length).toBe(0);
+  });
+});
+
+describe('enableGlRenderEffectGuards', () => {
+  // logOnce suppresses a key for the whole PROCESS, so a fired key can never fire again in a later
+  // test. Both the fire and the silence assertions live in this one test, in order, and every test in
+  // this file uses distinct effect kinds so no two share a key.
+  it('WARNS that an unregistered chain returned false without writing dest, then stays quiet', () => {
+    const state = createState();
+    enableGlRenderEffectGuards(state);
+
+    const entries = captureLog(() => {
+      expect(applyChain(state, ['test.unregistered-a'])).toBe(false);
+    });
+    expect(entries.length).toBe(1);
+    // The consequence is the point: dest is never written, so the caller samples a stale texture.
+    expect(messageOf(entries[0])).toContain('NEVER WRITTEN');
+    expect(messageOf(entries[0])).toContain('registerGlRenderEffect');
+
+    // Same observation again is suppressed — the miss recurs every frame and must not flood.
+    const repeat = captureLog(() => {
+      expect(applyChain(state, ['test.unregistered-a'])).toBe(false);
+    });
+    expect(repeat.length).toBe(0);
+  });
+
+  it('WARNS that a partially registered chain silently DROPPED the effects it could not run', () => {
+    const state = createState();
+    registerGlRenderEffect(state, 'test.registered-b', noopRunner);
+    enableGlRenderEffectGuards(state);
+
+    const entries = captureLog(() => {
+      // It succeeds — which is exactly why this one is invisible without a crumb.
+      expect(applyChain(state, ['test.registered-b', 'test.unregistered-b'])).toBe(true);
+    });
+
+    expect(entries.length).toBe(1);
+    expect(messageOf(entries[0])).toContain('SKIPPED');
+    expect(messageOf(entries[0])).toContain('test.unregistered-b');
+  });
+
+  it('WARNS when a failed chain leaves a previously published destination stale', () => {
+    const state = createState();
+    enableGlRenderEffectGuards(state);
+
+    const entries = captureLog(() => {
+      expect(applyChain(state, ['test.stale-destination'], true)).toBe(false);
+    });
+
+    expect(entries.length).toBe(1);
+    expect(messageOf(entries[0])).toContain('STALE DESTINATION');
+    expect(messageOf(entries[0])).toContain('handle the false return');
+  });
+
+  it('stays SILENT for an empty chain, which is a no-op the caller asked for rather than a miss', () => {
+    const state = createState();
+    enableGlRenderEffectGuards(state);
+
+    const entries = captureLog(() => {
+      expect(applyChain(state, [])).toBe(false);
+    });
+
+    // Reporting this would train readers to ignore the crumb.
+    expect(entries.length).toBe(0);
+  });
+
+  it('stays SILENT when every requested effect has a runner', () => {
+    const state = createState();
+    registerGlRenderEffect(state, 'test.registered-c', noopRunner);
+    enableGlRenderEffectGuards(state);
+
+    const entries = captureLog(() => {
+      expect(applyChain(state, ['test.registered-c'])).toBe(true);
+    });
+
+    expect(entries.length).toBe(0);
+  });
+});
+
+function applyChain(state: GlRenderState, kinds: readonly string[], publishDestination = false): boolean {
+  const pool = createGlRenderTexturePool();
+  const source = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+  const dest = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+  const scratch = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+  // Realize the source so `source-unavailable` is not what is being measured here.
+  writeGlRenderTextureTarget(state, source, () => {});
+  if (publishDestination) writeGlRenderTextureTarget(state, dest, () => {});
+  const effects = kinds.map((kind) => ({ kind }) as unknown as Readonly<RenderEffect>);
+  return applyGlRenderEffectsToRenderTexture(state, pool, source, dest, scratch, effects);
+}
+
+function captureLog(run: () => void): readonly LogEntry[] {
+  const sink = createMemoryLogSink(8);
+  addLogSink(sink.sink);
+  try {
+    run();
+    return getMemoryLogSinkEntries(sink);
+  } finally {
+    removeLogSink(sink.sink);
+  }
+}
+
+function createState(): GlRenderState {
+  const canvas = document.createElement('canvas');
+  canvas.width = 32;
+  canvas.height = 24;
+  return createGlRenderState(canvas);
+}
+
+function messageOf(entry: Readonly<LogEntry>): string {
+  const data = entry.data;
+  return typeof data === 'string' ? data : String(data.message);
+}
+
+const noopRunner: GlRenderEffectRunner = () => {};

package/src/glBevelEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyBevelEffectToGl, defaultGlBevelEffectRunner } from './glBevelEffect';
+import { applyBevelEffectToGl, defaultGlBevelEffectRunner, registerGlBevelEffect } from './glBevelEffect';
 
 describe('applyBevelEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlBevelEffectRunner', () => {
     expect(typeof defaultGlBevelEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlBevelEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlBevelEffect).toBeTypeOf('function');
+  });
+});

package/src/glBlendEffect.test.ts

@@ -4,8 +4,10 @@ import { AdvancedBlendMode } from '@flighthq/types/contract';
 import {
   applyBlendEffectToGl,
   defaultGlBlendEffectRunner,
+  BLEND_FRAGMENT_SRC,
   getBlendEffectModeIndex,
   getGlBlendEffectBackdrop,
+  registerGlBlendEffect,
   registerGlBlendEffectBackdrop,
   unregisterGlBlendEffectBackdrop,
 } from './glBlendEffect';
@@ -62,6 +64,24 @@ describe('getBlendEffectModeIndex', () => {
   });
 });
 
+// The index table and the shader's branch switch are two hand-maintained lists that must agree; a mode
+// assigned an index with no matching branch silently renders Normal passthrough instead of the blend the
+// caller asked for. Reading the module source is crude, but it is the only thing that actually pins the
+// two together — and it covers every mode rather than whichever one was added last.
+describe('getBlendEffectModeIndex shader lockstep', () => {
+  const source = BLEND_FRAGMENT_SRC;
+
+  it('has a shader branch for every index the table assigns', () => {
+    for (const mode of Object.values(AdvancedBlendMode)) {
+      const index = getBlendEffectModeIndex(mode);
+      expect(index).toBeGreaterThanOrEqual(0);
+      expect(source, `{mode} maps to index ${index} with no shader branch`.replace('{mode}', mode)).toContain(
+        `mode == ${index}`,
+      );
+    }
+  });
+});
+
 describe('getGlBlendEffectBackdrop', () => {
   it('returns null for a null key', () => {
     expect(getGlBlendEffectBackdrop(makeState(), null)).toBeNull();
@@ -86,6 +106,12 @@ describe('getGlBlendEffectBackdrop', () => {
   });
 });
 
+describe('registerGlBlendEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlBlendEffect).toBeTypeOf('function');
+  });
+});
+
 describe('registerGlBlendEffectBackdrop', () => {
   it('is last-write-wins for a given key', () => {
     const state = makeState();

package/src/glBloomEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyBloomEffectToGl, defaultGlBloomEffectRunner } from './glBloomEffect';
+import { applyBloomEffectToGl, defaultGlBloomEffectRunner, registerGlBloomEffect } from './glBloomEffect';
 
 describe('applyBloomEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlBloomEffectRunner', () => {
     expect(typeof defaultGlBloomEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlBloomEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlBloomEffect).toBeTypeOf('function');
+  });
+});

package/src/glBlurEffect.test.ts

@@ -1,4 +1,24 @@
-import { applyBlurEffectToGl, applyGaussianBlurToGl, defaultGlBlurEffectRunner } from './glBlurEffect';
+import {
+  acquireGlRenderTexture,
+  createGlRenderState,
+  createGlRenderTexturePool,
+  isGlRenderTextureReady,
+  writeGlRenderTextureTarget,
+} from '@flighthq/render-gl/contract';
+
+import {
+  applyBlurEffectToGl,
+  applyBlurEffectToGlRenderTextures,
+  applyGaussianBlurToGl,
+  applyGaussianBlurToGlRenderTextures,
+  defaultGlBlurEffectRunner,
+  registerGlBlurEffect,
+} from './glBlurEffect';
+import { getGlRenderEffectRunner } from './glRenderEffectRegistry';
+
+function createGlState() {
+  return { state: createGlRenderState(document.createElement('canvas')) };
+}
 
 describe('applyBlurEffectToGl', () => {
   it('is a function', () => {
@@ -6,14 +26,62 @@ describe('applyBlurEffectToGl', () => {
   });
 });
 
+describe('applyBlurEffectToGlRenderTextures', () => {
+  it('publishes destination and scratch handles after applying the blur descriptor', () => {
+    const { state } = createGlState();
+    const pool = createGlRenderTexturePool();
+    const source = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    const dest = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    const scratch = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    writeGlRenderTextureTarget(state, source, () => {});
+
+    expect(
+      applyBlurEffectToGlRenderTextures(state, source, dest, scratch, {
+        blurX: 2,
+        blurY: 3,
+        kind: 'BlurEffect',
+      }),
+    ).toBe(true);
+    expect(isGlRenderTextureReady(state, dest)).toBe(true);
+    expect(isGlRenderTextureReady(state, scratch)).toBe(true);
+  });
+});
+
 describe('applyGaussianBlurToGl', () => {
   it('is a function', () => {
     expect(typeof applyGaussianBlurToGl).toBe('function');
   });
 });
 
+describe('applyGaussianBlurToGlRenderTextures', () => {
+  it('publishes destination and scratch handles after the two Gaussian target passes', () => {
+    const { state } = createGlState();
+    const pool = createGlRenderTexturePool();
+    const source = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    const dest = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    const scratch = acquireGlRenderTexture(state, pool, { width: 16, height: 12 });
+    writeGlRenderTextureTarget(state, source, () => {});
+
+    expect(applyGaussianBlurToGlRenderTextures(state, source, dest, scratch, { blurX: 2, blurY: 3 })).toBe(true);
+    expect(isGlRenderTextureReady(state, dest)).toBe(true);
+    expect(isGlRenderTextureReady(state, scratch)).toBe(true);
+  });
+});
+
 describe('defaultGlBlurEffectRunner', () => {
   it('is a function', () => {
     expect(typeof defaultGlBlurEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlBlurEffect', () => {
+  it('registers the default blur runner on only the supplied state', () => {
+    const { state } = createGlState();
+    const { state: other } = createGlState();
+
+    registerGlBlurEffect(state);
+
+    expect(getGlRenderEffectRunner(state, 'BlurEffect')).toBe(defaultGlBlurEffectRunner);
+    expect(getGlRenderEffectRunner(other, 'BlurEffect')).toBeNull();
+  });
+});

package/src/glBokehDepthOfFieldEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyBokehDepthOfFieldEffectToGl, defaultGlBokehDepthOfFieldEffectRunner } from './glBokehDepthOfFieldEffect';
+import {
+  applyBokehDepthOfFieldEffectToGl,
+  defaultGlBokehDepthOfFieldEffectRunner,
+  registerGlBokehDepthOfFieldEffect,
+} from './glBokehDepthOfFieldEffect';
 
 describe('applyBokehDepthOfFieldEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlBokehDepthOfFieldEffectRunner', () => {
     expect(typeof defaultGlBokehDepthOfFieldEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlBokehDepthOfFieldEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlBokehDepthOfFieldEffect).toBeTypeOf('function');
+  });
+});

package/src/glCameraMotionBlurEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyCameraMotionBlurEffectToGl, defaultGlCameraMotionBlurEffectRunner } from './glCameraMotionBlurEffect';
+import {
+  applyCameraMotionBlurEffectToGl,
+  defaultGlCameraMotionBlurEffectRunner,
+  registerGlCameraMotionBlurEffect,
+} from './glCameraMotionBlurEffect';
 
 describe('applyCameraMotionBlurEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlCameraMotionBlurEffectRunner', () => {
     expect(typeof defaultGlCameraMotionBlurEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlCameraMotionBlurEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlCameraMotionBlurEffect).toBeTypeOf('function');
+  });
+});

package/src/glChromaticAberrationEffect.test.ts

@@ -1,6 +1,7 @@
 import {
   applyChromaticAberrationEffectToGl,
   defaultGlChromaticAberrationEffectRunner,
+  registerGlChromaticAberrationEffect,
 } from './glChromaticAberrationEffect';
 
 describe('applyChromaticAberrationEffectToGl', () => {
@@ -14,3 +15,9 @@ describe('defaultGlChromaticAberrationEffectRunner', () => {
     expect(typeof defaultGlChromaticAberrationEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlChromaticAberrationEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlChromaticAberrationEffect).toBeTypeOf('function');
+  });
+});

package/src/glCompositeEffect.test.ts

@@ -4,6 +4,7 @@ import {
   applyCompositeEffectToGl,
   defaultGlCompositeEffectRunner,
   getCompositeEffectOperatorIndex,
+  registerGlCompositeEffect,
 } from './glCompositeEffect';
 
 // The pure operator→index mapping is asserted here; the compile/draw path is exercised pixel-for-pixel by
@@ -37,3 +38,9 @@ describe('getCompositeEffectOperatorIndex', () => {
     expect(getCompositeEffectOperatorIndex('acme.custom')).toBe(0);
   });
 });
+
+describe('registerGlCompositeEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlCompositeEffect).toBeTypeOf('function');
+  });
+});

package/src/glContactShadowsEffect.test.ts

@@ -0,0 +1,43 @@
+vi.mock('./glSsaoEffect', () => ({ applySsaoEffectToGl: vi.fn() }));
+
+import { createGlRenderState } from '@flighthq/render-gl/contract';
+
+import {
+  applyContactShadowsEffectToGl,
+  defaultGlContactShadowsEffectRunner,
+  registerGlContactShadowsEffect,
+} from './glContactShadowsEffect';
+import { getGlRenderEffectRunner } from './glRenderEffectRegistry';
+import { applySsaoEffectToGl } from './glSsaoEffect';
+
+describe('applyContactShadowsEffectToGl', () => {
+  it('maps the contact descriptor into the shared local-occlusion realization', () => {
+    applyContactShadowsEffectToGl({} as never, {} as never, {} as never, {
+      distance: 3,
+      kind: 'ContactShadowsEffect',
+      opacity: 0.75,
+      samples: 24,
+    });
+
+    expect(applySsaoEffectToGl).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), {
+      intensity: 0.75,
+      kind: 'SsaoEffect',
+      radius: 3,
+      samples: 24,
+    });
+  });
+});
+
+describe('defaultGlContactShadowsEffectRunner', () => {
+  it('is a function', () => {
+    expect(typeof defaultGlContactShadowsEffectRunner).toBe('function');
+  });
+});
+
+describe('registerGlContactShadowsEffect', () => {
+  it('installs the contact-shadows runner on the supplied state', () => {
+    const state = createGlRenderState(document.createElement('canvas'));
+    registerGlContactShadowsEffect(state);
+    expect(getGlRenderEffectRunner(state, 'ContactShadowsEffect')).toBe(defaultGlContactShadowsEffectRunner);
+  });
+});

package/src/glConvolutionEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyConvolutionEffectToGl, defaultGlConvolutionEffectRunner } from './glConvolutionEffect';
+import {
+  applyConvolutionEffectToGl,
+  defaultGlConvolutionEffectRunner,
+  registerGlConvolutionEffect,
+} from './glConvolutionEffect';
 
 describe('applyConvolutionEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlConvolutionEffectRunner', () => {
     expect(typeof defaultGlConvolutionEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlConvolutionEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlConvolutionEffect).toBeTypeOf('function');
+  });
+});

package/src/glCrtEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyCrtEffectToGl, defaultGlCrtEffectRunner } from './glCrtEffect';
+import { applyCrtEffectToGl, defaultGlCrtEffectRunner, registerGlCrtEffect } from './glCrtEffect';
 
 describe('applyCrtEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlCrtEffectRunner', () => {
     expect(typeof defaultGlCrtEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlCrtEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlCrtEffect).toBeTypeOf('function');
+  });
+});

package/src/glCustomShaderEffect.test.ts

@@ -5,6 +5,7 @@ import {
   defaultGlCustomShaderEffectRunner,
   getGlCustomShaderSource,
   registerGlCustomShaderSource,
+  registerGlCustomShaderEffect,
 } from './glCustomShaderEffect';
 
 // The source registry is a plain WeakMap keyed by the render state, with no GL calls, so a bare
@@ -51,6 +52,12 @@ describe('getGlCustomShaderSource', () => {
   });
 });
 
+describe('registerGlCustomShaderEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlCustomShaderEffect).toBeTypeOf('function');
+  });
+});
+
 describe('registerGlCustomShaderSource', () => {
   it('registers a source that getGlCustomShaderSource then resolves', () => {
     const state = makeState();

package/src/glDirectionalBlurEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyDirectionalBlurEffectToGl, defaultGlDirectionalBlurEffectRunner } from './glDirectionalBlurEffect';
+import {
+  applyDirectionalBlurEffectToGl,
+  defaultGlDirectionalBlurEffectRunner,
+  registerGlDirectionalBlurEffect,
+} from './glDirectionalBlurEffect';
 
 describe('applyDirectionalBlurEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlDirectionalBlurEffectRunner', () => {
     expect(typeof defaultGlDirectionalBlurEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlDirectionalBlurEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlDirectionalBlurEffect).toBeTypeOf('function');
+  });
+});

package/src/glDisplacementEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyDisplacementEffectToGl, defaultGlDisplacementEffectRunner } from './glDisplacementEffect';
+import {
+  applyDisplacementEffectToGl,
+  defaultGlDisplacementEffectRunner,
+  registerGlDisplacementEffect,
+} from './glDisplacementEffect';
 
 describe('applyDisplacementEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlDisplacementEffectRunner', () => {
     expect(typeof defaultGlDisplacementEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlDisplacementEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlDisplacementEffect).toBeTypeOf('function');
+  });
+});

package/src/glDitherEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyDitherEffectToGl, defaultGlDitherEffectRunner } from './glDitherEffect';
+import { applyDitherEffectToGl, defaultGlDitherEffectRunner, registerGlDitherEffect } from './glDitherEffect';
 
 describe('applyDitherEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlDitherEffectRunner', () => {
     expect(typeof defaultGlDitherEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlDitherEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlDitherEffect).toBeTypeOf('function');
+  });
+});

package/src/glDropShadowEffect.test.ts

@@ -29,7 +29,11 @@ vi.mock('./glEffectTintShader', () => ({
   applyGlEffectTintPass: vi.fn(),
 }));
 
-import { applyDropShadowEffectToGl, defaultGlDropShadowEffectRunner } from './glDropShadowEffect';
+import {
+  applyDropShadowEffectToGl,
+  defaultGlDropShadowEffectRunner,
+  registerGlDropShadowEffect,
+} from './glDropShadowEffect';
 import { applyGlEffectBlitPass, applyGlEffectErasePass } from './glEffectBlitShader';
 
 describe('applyDropShadowEffectToGl', () => {
@@ -84,14 +88,6 @@ beforeEach(() => {
   vi.clearAllMocks();
 });
 
-afterAll(() => {
-  vi.doUnmock('@flighthq/render-gl');
-  vi.doUnmock('./glEffectBlitShader');
-  vi.doUnmock('./glEffectBoxBlur');
-  vi.doUnmock('./glEffectTintShader');
-  vi.resetModules();
-});
-
 function createState(): never {
   return { gl: {} } as never;
 }
@@ -103,3 +99,9 @@ function createPool(): never {
 function createTarget(id: string): never {
   return { id, width: 32, height: 16, format: 'rgba8', texture: {} } as never;
 }
+
+describe('registerGlDropShadowEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlDropShadowEffect).toBeTypeOf('function');
+  });
+});

package/src/glEffectBoxBlur.test.ts

@@ -43,11 +43,6 @@ beforeEach(() => {
   vi.clearAllMocks();
 });
 
-afterAll(() => {
-  vi.doUnmock('@flighthq/render-gl');
-  vi.resetModules();
-});
-
 function createState(): never {
   return { gl: { getUniformLocation: vi.fn((_program, name) => name) } } as never;
 }

package/src/glFilmGrainEffect.test.ts

@@ -1,4 +1,8 @@
-import { applyFilmGrainEffectToGl, defaultGlFilmGrainEffectRunner } from './glFilmGrainEffect';
+import {
+  applyFilmGrainEffectToGl,
+  defaultGlFilmGrainEffectRunner,
+  registerGlFilmGrainEffect,
+} from './glFilmGrainEffect';
 
 describe('applyFilmGrainEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +15,9 @@ describe('defaultGlFilmGrainEffectRunner', () => {
     expect(typeof defaultGlFilmGrainEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlFilmGrainEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlFilmGrainEffect).toBeTypeOf('function');
+  });
+});

package/src/glFxaaEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyFxaaEffectToGl, defaultGlFxaaEffectRunner } from './glFxaaEffect';
+import { applyFxaaEffectToGl, defaultGlFxaaEffectRunner, registerGlFxaaEffect } from './glFxaaEffect';
 
 describe('applyFxaaEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlFxaaEffectRunner', () => {
     expect(typeof defaultGlFxaaEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlFxaaEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlFxaaEffect).toBeTypeOf('function');
+  });
+});

package/src/glGlitchEffect.test.ts

@@ -1,4 +1,4 @@
-import { applyGlitchEffectToGl, defaultGlGlitchEffectRunner } from './glGlitchEffect';
+import { applyGlitchEffectToGl, defaultGlGlitchEffectRunner, registerGlGlitchEffect } from './glGlitchEffect';
 
 describe('applyGlitchEffectToGl', () => {
   it('is a function', () => {
@@ -11,3 +11,9 @@ describe('defaultGlGlitchEffectRunner', () => {
     expect(typeof defaultGlGlitchEffectRunner).toBe('function');
   });
 });
+
+describe('registerGlGlitchEffect', () => {
+  it('is a separately importable registration primitive', () => {
+    expect(registerGlGlitchEffect).toBeTypeOf('function');
+  });
+});