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

package/src/convolutionEffect.test.ts

@@ -1,4 +1,10 @@
-import { createConvolutionEffect } from './convolutionEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createConvolutionEffect,
+  getConvolutionEffectPadding,
+  registerConvolutionEffectPaddingResolver,
+} from './convolutionEffect';
 
 describe('createConvolutionEffect', () => {
   it('tags the intent type', () => {
@@ -18,3 +24,24 @@ describe('createConvolutionEffect', () => {
     expect(effect).toMatchObject({ bias: 8, preserveAlpha: false });
   });
 });
+
+describe('getConvolutionEffectPadding', () => {
+  it('preserves the exact asymmetric reach of even kernels', () => {
+    expect(getConvolutionEffectPadding(createConvolutionEffect({ matrix: [1, 1], matrixX: 2, matrixY: 1 }))).toEqual({
+      bottom: 0,
+      left: 0,
+      right: 1,
+      top: 0,
+    });
+  });
+});
+
+describe('registerConvolutionEffectPaddingResolver', () => {
+  it('registers the convolution footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerConvolutionEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('ConvolutionEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/directionalBlurEffect.test.ts

@@ -1,4 +1,10 @@
-import { createDirectionalBlurEffect } from './directionalBlurEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createDirectionalBlurEffect,
+  getDirectionalBlurEffectPadding,
+  registerDirectionalBlurEffectPaddingResolver,
+} from './directionalBlurEffect';
 
 describe('createDirectionalBlurEffect', () => {
   it('tags the intent type', () => {
@@ -9,3 +15,24 @@ describe('createDirectionalBlurEffect', () => {
     expect(createDirectionalBlurEffect({ angle: 1, length: 8 })).toMatchObject({ angle: 1, length: 8 });
   });
 });
+
+describe('getDirectionalBlurEffectPadding', () => {
+  it('projects the centered half-length onto both axes', () => {
+    expect(getDirectionalBlurEffectPadding(createDirectionalBlurEffect({ angle: Math.PI / 2, length: 9 }))).toEqual({
+      bottom: 5,
+      left: 0,
+      right: 0,
+      top: 5,
+    });
+  });
+});
+
+describe('registerDirectionalBlurEffectPaddingResolver', () => {
+  it('registers the directional-blur footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerDirectionalBlurEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('DirectionalBlurEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/displacementEffect.test.ts

@@ -1,4 +1,10 @@
-import { createDisplacementEffect } from './displacementEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createDisplacementEffect,
+  getDisplacementEffectPadding,
+  registerDisplacementEffectPaddingResolver,
+} from './displacementEffect';
 
 describe('createDisplacementEffect', () => {
   it('tags the intent type', () => {
@@ -13,3 +19,24 @@ describe('createDisplacementEffect', () => {
     });
   });
 });
+
+describe('getDisplacementEffectPadding', () => {
+  it('covers the shader maximum two-axis sine warp', () => {
+    expect(getDisplacementEffectPadding(createDisplacementEffect({ intensity: 5 }))).toEqual({
+      bottom: 5,
+      left: 8,
+      right: 8,
+      top: 5,
+    });
+  });
+});
+
+describe('registerDisplacementEffectPaddingResolver', () => {
+  it('registers the displacement footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerDisplacementEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('DisplacementEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/dropShadowEffect.test.ts

@@ -1,4 +1,10 @@
-import { createDropShadowEffect } from './dropShadowEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createDropShadowEffect,
+  getDropShadowEffectPadding,
+  registerDropShadowEffectPaddingResolver,
+} from './dropShadowEffect';
 
 describe('createDropShadowEffect', () => {
   it('tags the intent type', () => {
@@ -12,3 +18,24 @@ describe('createDropShadowEffect', () => {
     });
   });
 });
+
+describe('getDropShadowEffectPadding', () => {
+  it('adds the offset only to the reached side of the Gaussian footprint', () => {
+    expect(getDropShadowEffectPadding(createDropShadowEffect({ angle: 0, blurX: 2, blurY: 3, distance: 5 }))).toEqual({
+      bottom: 9,
+      left: 6,
+      right: 11,
+      top: 9,
+    });
+  });
+});
+
+describe('registerDropShadowEffectPaddingResolver', () => {
+  it('registers the drop-shadow footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerDropShadowEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('DropShadowEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/glitchEffect.test.ts

@@ -1,4 +1,6 @@
-import { createGlitchEffect } from './glitchEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import { createGlitchEffect, getGlitchEffectPadding, registerGlitchEffectPaddingResolver } from './glitchEffect';
 
 describe('createGlitchEffect', () => {
   it('tags the intent type', () => {
@@ -14,3 +16,24 @@ describe('createGlitchEffect', () => {
     });
   });
 });
+
+describe('getGlitchEffectPadding', () => {
+  it('covers horizontal tears and the maximum RGB channel separation', () => {
+    expect(getGlitchEffectPadding(createGlitchEffect({ colorShift: 10, intensity: 0.5 }))).toEqual({
+      bottom: 0,
+      left: 34,
+      right: 34,
+      top: 0,
+    });
+  });
+});
+
+describe('registerGlitchEffectPaddingResolver', () => {
+  it('registers the glitch footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerGlitchEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('GlitchEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/gradientBevelEffect.test.ts

@@ -1,4 +1,10 @@
-import { createGradientBevelEffect } from './gradientBevelEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createGradientBevelEffect,
+  getGradientBevelEffectPadding,
+  registerGradientBevelEffectPaddingResolver,
+} from './gradientBevelEffect';
 
 describe('createGradientBevelEffect', () => {
   it('tags the intent type', () => {
@@ -19,3 +25,28 @@ describe('createGradientBevelEffect', () => {
     ).toMatchObject({ sourceMode: 'hide', strength: 2 });
   });
 });
+
+describe('getGradientBevelEffectPadding', () => {
+  it('adds the directional offset only to the reached sides of the Gaussian footprint', () => {
+    const effect = createGradientBevelEffect({
+      alphas: [1, 1],
+      angle: -90,
+      blurX: 2,
+      blurY: 3,
+      colors: [0xff0000, 0x00ff00],
+      distance: 5,
+      ratios: [0, 255],
+    });
+    expect(getGradientBevelEffectPadding(effect)).toEqual({ bottom: 9, left: 6, right: 6, top: 14 });
+  });
+});
+
+describe('registerGradientBevelEffectPaddingResolver', () => {
+  it('registers the gradient-bevel footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerGradientBevelEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('GradientBevelEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/gradientGlowEffect.test.ts

@@ -1,4 +1,10 @@
-import { createGradientGlowEffect } from './gradientGlowEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createGradientGlowEffect,
+  getGradientGlowEffectPadding,
+  registerGradientGlowEffectPaddingResolver,
+} from './gradientGlowEffect';
 
 describe('createGradientGlowEffect', () => {
   it('tags the intent type', () => {
@@ -19,3 +25,23 @@ describe('createGradientGlowEffect', () => {
     ).toMatchObject({ sourceMode: 'knockout', strength: 2 });
   });
 });
+
+describe('getGradientGlowEffectPadding', () => {
+  it('uses the three-sigma extent independently on both axes', () => {
+    expect(
+      getGradientGlowEffectPadding(
+        createGradientGlowEffect({ alphas: [1], blurX: 2.1, blurY: 3, colors: [0xffffff], ratios: [0] }),
+      ),
+    ).toEqual({ bottom: 9, left: 7, right: 7, top: 9 });
+  });
+});
+
+describe('registerGradientGlowEffectPaddingResolver', () => {
+  it('registers the gradient-glow footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerGradientGlowEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('GradientGlowEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/innerGlowEffect.test.ts

@@ -1,4 +1,10 @@
-import { createInnerGlowEffect } from './innerGlowEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createInnerGlowEffect,
+  getInnerGlowEffectPadding,
+  registerInnerGlowEffectPaddingResolver,
+} from './innerGlowEffect';
 
 describe('createInnerGlowEffect', () => {
   it('tags the intent type', () => {
@@ -13,3 +19,24 @@ describe('createInnerGlowEffect', () => {
     expect(createInnerGlowEffect({ sourceMode: 'hide' })).toMatchObject({ sourceMode: 'hide' });
   });
 });
+
+describe('getInnerGlowEffectPadding', () => {
+  it('uses a three-sigma Gaussian footprint', () => {
+    expect(getInnerGlowEffectPadding(createInnerGlowEffect({ blurX: 2, blurY: 3 }))).toEqual({
+      bottom: 9,
+      left: 6,
+      right: 6,
+      top: 9,
+    });
+  });
+});
+
+describe('registerInnerGlowEffectPaddingResolver', () => {
+  it('registers the inner-glow footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerInnerGlowEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('InnerGlowEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/innerShadowEffect.test.ts

@@ -1,4 +1,10 @@
-import { createInnerShadowEffect } from './innerShadowEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createInnerShadowEffect,
+  getInnerShadowEffectPadding,
+  registerInnerShadowEffectPaddingResolver,
+} from './innerShadowEffect';
 
 describe('createInnerShadowEffect', () => {
   it('tags the intent type', () => {
@@ -13,3 +19,26 @@ describe('createInnerShadowEffect', () => {
     expect(createInnerShadowEffect({ sourceMode: 'hide' })).toMatchObject({ sourceMode: 'hide' });
   });
 });
+
+describe('getInnerShadowEffectPadding', () => {
+  it('preserves the directional exterior samples needed by the clipped inner pass', () => {
+    expect(
+      getInnerShadowEffectPadding(createInnerShadowEffect({ angle: 90, blurX: 2, blurY: 3, distance: 5 })),
+    ).toEqual({
+      bottom: 14,
+      left: 6,
+      right: 6,
+      top: 9,
+    });
+  });
+});
+
+describe('registerInnerShadowEffectPaddingResolver', () => {
+  it('registers the inner-shadow footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerInnerShadowEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('InnerShadowEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/medianEffect.test.ts

@@ -1,4 +1,6 @@
-import { createMedianEffect } from './medianEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import { createMedianEffect, getMedianEffectPadding, registerMedianEffectPaddingResolver } from './medianEffect';
 
 describe('createMedianEffect', () => {
   it('tags the intent type', () => {
@@ -9,3 +11,24 @@ describe('createMedianEffect', () => {
     expect(createMedianEffect({ radius: 2 })).toMatchObject({ radius: 2 });
   });
 });
+
+describe('getMedianEffectPadding', () => {
+  it('uses the rounded neighborhood radius on every side', () => {
+    expect(getMedianEffectPadding(createMedianEffect({ radius: 1.6 }))).toEqual({
+      bottom: 2,
+      left: 2,
+      right: 2,
+      top: 2,
+    });
+  });
+});
+
+describe('registerMedianEffectPaddingResolver', () => {
+  it('registers the median footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerMedianEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('MedianEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/outerGlowEffect.test.ts

@@ -1,4 +1,10 @@
-import { createOuterGlowEffect } from './outerGlowEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createOuterGlowEffect,
+  getOuterGlowEffectPadding,
+  registerOuterGlowEffectPaddingResolver,
+} from './outerGlowEffect';
 
 describe('createOuterGlowEffect', () => {
   it('tags the intent type', () => {
@@ -12,3 +18,24 @@ describe('createOuterGlowEffect', () => {
     });
   });
 });
+
+describe('getOuterGlowEffectPadding', () => {
+  it('uses a three-sigma Gaussian footprint', () => {
+    expect(getOuterGlowEffectPadding(createOuterGlowEffect({ blurX: 2, blurY: 3 }))).toEqual({
+      bottom: 9,
+      left: 6,
+      right: 6,
+      top: 9,
+    });
+  });
+});
+
+describe('registerOuterGlowEffectPaddingResolver', () => {
+  it('registers the outer-glow footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerOuterGlowEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('OuterGlowEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/outlineEffect.test.ts

@@ -1,4 +1,6 @@
-import { createOutlineEffect } from './outlineEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import { createOutlineEffect, getOutlineEffectPadding, registerOutlineEffectPaddingResolver } from './outlineEffect';
 
 describe('createOutlineEffect', () => {
   it('tags the intent type', () => {
@@ -13,3 +15,24 @@ describe('createOutlineEffect', () => {
     });
   });
 });
+
+describe('getOutlineEffectPadding', () => {
+  it('uses the Sobel sampling thickness on every side', () => {
+    expect(getOutlineEffectPadding(createOutlineEffect({ thickness: 1.5 }))).toEqual({
+      bottom: 2,
+      left: 2,
+      right: 2,
+      top: 2,
+    });
+  });
+});
+
+describe('registerOutlineEffectPaddingResolver', () => {
+  it('registers the outline footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerOutlineEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('OutlineEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});

package/src/renderEffectPadding.test.ts

@@ -0,0 +1,114 @@
+import { createRenderState, enableRenderRegistrySignals, getRenderStateRuntime } from '@flighthq/render/contract';
+import { connectSignal } from '@flighthq/signals/contract';
+import type { RenderEffect, RenderState } from '@flighthq/types/contract';
+import { RenderRegistry } from '@flighthq/types/contract';
+
+import { createBlurEffect, registerBlurEffectPaddingResolver } from './blurEffect';
+import {
+  computeRenderEffectPadding,
+  explainRenderEffectPadding,
+  getDirectionalRenderEffectPadding,
+  getGaussianRenderEffectPadding,
+  registerRenderEffectPaddingResolver,
+} from './renderEffectPadding';
+
+describe('computeRenderEffectPadding', () => {
+  let state: RenderState;
+
+  beforeEach(() => {
+    state = createRenderState();
+    registerBlurEffectPaddingResolver(state);
+    registerRenderEffectPaddingResolver(state, 'acme.Pointwise', () => ({
+      bottom: 0,
+      left: 0,
+      right: 0,
+      top: 0,
+    }));
+  });
+
+  it('adds each side across a sequential effect chain while pointwise effects add zero', () => {
+    expect(
+      computeRenderEffectPadding(state, [
+        createBlurEffect({ blurX: 2, blurY: 1 }),
+        { kind: 'acme.Pointwise' } as RenderEffect,
+        createBlurEffect({ blurX: 1, blurY: 4 }),
+      ]),
+    ).toEqual({ bottom: 15, left: 9, right: 9, top: 15 });
+  });
+
+  it('returns a zero sentinel for an unregistered kind', () => {
+    const effect = { kind: 'acme.Missing' } as RenderEffect;
+    expect(computeRenderEffectPadding(state, effect)).toEqual({ bottom: 0, left: 0, right: 0, top: 0 });
+  });
+
+  it('emits a shared registry miss only when the signal seam is enabled', () => {
+    const misses: Array<readonly [RenderRegistry, string]> = [];
+    connectSignal(enableRenderRegistrySignals(state).onRegistryMiss, (registry, kind) => {
+      misses.push([registry, kind]);
+    });
+    expect(computeRenderEffectPadding(state, { kind: 'acme.Missing' } as RenderEffect)).toEqual({
+      bottom: 0,
+      left: 0,
+      right: 0,
+      top: 0,
+    });
+    expect(misses).toEqual([[RenderRegistry.EffectPaddingResolver, 'acme.Missing']]);
+  });
+});
+
+describe('explainRenderEffectPadding', () => {
+  it('reports every missing resolver kind while preserving resolved padding', () => {
+    const state = createRenderState();
+    registerBlurEffectPaddingResolver(state);
+
+    expect(
+      explainRenderEffectPadding(state, [
+        createBlurEffect({ blurX: 2, blurY: 3 }),
+        { kind: 'acme.Missing' } as RenderEffect,
+      ]),
+    ).toEqual({
+      missingKinds: ['acme.Missing'],
+      padding: { bottom: 9, left: 6, right: 6, top: 9 },
+      status: 'missing-resolver',
+    });
+  });
+});
+
+describe('getDirectionalRenderEffectPadding', () => {
+  it('adds positive screen-space offsets only to the reached sides', () => {
+    expect(getDirectionalRenderEffectPadding(2, 3, 4.25, 5.5)).toEqual({
+      bottom: 15,
+      left: 6,
+      right: 11,
+      top: 9,
+    });
+  });
+
+  it('adds negative screen-space offsets only to left and top', () => {
+    expect(getDirectionalRenderEffectPadding(1, 1, -2.5, -4.25)).toEqual({
+      bottom: 3,
+      left: 6,
+      right: 3,
+      top: 8,
+    });
+  });
+});
+
+describe('getGaussianRenderEffectPadding', () => {
+  it('uses a sanitized three-sigma extent on each axis', () => {
+    expect(getGaussianRenderEffectPadding(2.1, -4)).toEqual({ bottom: 0, left: 7, right: 7, top: 0 });
+  });
+});
+
+describe('registerRenderEffectPaddingResolver', () => {
+  it('adds and removes a state-local resolver', () => {
+    const state = createRenderState();
+    const resolver = vi.fn(() => ({ bottom: 1, left: 2, right: 3, top: 4 }));
+
+    registerRenderEffectPaddingResolver(state, 'acme.Effect', resolver);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.get('acme.Effect')).toBe(resolver);
+
+    registerRenderEffectPaddingResolver(state, 'acme.Effect', null);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('acme.Effect')).toBe(false);
+  });
+});

package/src/tiltShiftEffect.test.ts

@@ -1,4 +1,10 @@
-import { createTiltShiftEffect } from './tiltShiftEffect';
+import { createRenderState, getRenderStateRuntime } from '@flighthq/render/contract';
+
+import {
+  createTiltShiftEffect,
+  getTiltShiftEffectPadding,
+  registerTiltShiftEffectPaddingResolver,
+} from './tiltShiftEffect';
 
 describe('createTiltShiftEffect', () => {
   it('tags the intent type', () => {
@@ -13,3 +19,24 @@ describe('createTiltShiftEffect', () => {
     });
   });
 });
+
+describe('getTiltShiftEffectPadding', () => {
+  it('covers the seven-tap vertical blur reach', () => {
+    expect(getTiltShiftEffectPadding(createTiltShiftEffect({ blur: 2.5 }))).toEqual({
+      bottom: 8,
+      left: 0,
+      right: 0,
+      top: 8,
+    });
+  });
+});
+
+describe('registerTiltShiftEffectPaddingResolver', () => {
+  it('registers the tilt-shift footprint on only the supplied state', () => {
+    const state = createRenderState();
+    const other = createRenderState();
+    registerTiltShiftEffectPaddingResolver(state);
+    expect(getRenderStateRuntime(state).renderEffectPaddingResolverRegistry?.has('TiltShiftEffect')).toBe(true);
+    expect(getRenderStateRuntime(other).renderEffectPaddingResolverRegistry).toBeNull();
+  });
+});