@flighthq/effects 0.1.0

package/dist/whiteBalanceEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whiteBalanceEffect.d.ts","sourceRoot":"","sources":["../src/whiteBalanceEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,QAAQ,CAAC,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAM,GAAG,kBAAkB,CAErH"}

package/dist/whiteBalanceEffect.js

@@ -0,0 +1,4 @@
+export function createWhiteBalanceEffect(options = {}) {
+    return { kind: 'WhiteBalanceEffect', ...options };
+}
+//# sourceMappingURL=whiteBalanceEffect.js.map

package/dist/whiteBalanceEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whiteBalanceEffect.js","sourceRoot":"","sources":["../src/whiteBalanceEffect.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,wBAAwB,CAAC,UAAsD,EAAE;IAC/F,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,GAAG,OAAO,EAAE,CAAC;AACpD,CAAC"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@flighthq/effects",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Render-effect intents and substrate-agnostic recipe math",
+  "sideEffects": false
+}

package/src/autoExposureEffect.test.ts

@@ -0,0 +1,11 @@
+import { createAutoExposureEffect } from './autoExposureEffect';
+
+describe('createAutoExposureEffect', () => {
+  it('carries options', () => {
+    expect(createAutoExposureEffect({ adaptationSpeed: 2 })).toMatchObject({ adaptationSpeed: 2 });
+  });
+
+  it('tags the intent type', () => {
+    expect(createAutoExposureEffect().kind).toBe('AutoExposureEffect');
+  });
+});

package/src/barrelDistortionEffect.test.ts

@@ -0,0 +1,11 @@
+import { createBarrelDistortionEffect } from './barrelDistortionEffect';
+
+describe('createBarrelDistortionEffect', () => {
+  it('carries options', () => {
+    expect(createBarrelDistortionEffect({ amount: 0.3 })).toMatchObject({ amount: 0.3 });
+  });
+
+  it('tags the intent type', () => {
+    expect(createBarrelDistortionEffect().kind).toBe('BarrelDistortionEffect');
+  });
+});

package/src/bloomEffect.test.ts

@@ -0,0 +1,41 @@
+import { computeBloomBlurRadius, computeBloomIntensity, computeBloomThreshold, createBloomEffect } from './bloomEffect';
+
+describe('computeBloomBlurRadius', () => {
+  it('defaults to 8 when radius is unset', () => {
+    expect(computeBloomBlurRadius(createBloomEffect())).toBe(8);
+  });
+
+  it('clamps negative radius to zero', () => {
+    expect(computeBloomBlurRadius(createBloomEffect({ radius: -4 }))).toBe(0);
+  });
+});
+
+describe('computeBloomIntensity', () => {
+  it('defaults to 1 when intensity is unset', () => {
+    expect(computeBloomIntensity(createBloomEffect())).toBe(1);
+  });
+
+  it('passes through an explicit intensity', () => {
+    expect(computeBloomIntensity(createBloomEffect({ intensity: 2.5 }))).toBe(2.5);
+  });
+});
+
+describe('computeBloomThreshold', () => {
+  it('defaults to 0.8 when threshold is unset', () => {
+    expect(computeBloomThreshold(createBloomEffect())).toBe(0.8);
+  });
+
+  it('passes through an explicit threshold', () => {
+    expect(computeBloomThreshold(createBloomEffect({ threshold: 0.25 }))).toBe(0.25);
+  });
+});
+
+describe('createBloomEffect', () => {
+  it('tags the intent type', () => {
+    expect(createBloomEffect().kind).toBe('BloomEffect');
+  });
+
+  it('carries options', () => {
+    expect(createBloomEffect({ threshold: 0.5, intensity: 2 })).toMatchObject({ threshold: 0.5, intensity: 2 });
+  });
+});

package/src/bokehDepthOfFieldEffect.test.ts

@@ -0,0 +1,15 @@
+import { createBokehDepthOfFieldEffect } from './bokehDepthOfFieldEffect';
+
+describe('createBokehDepthOfFieldEffect', () => {
+  it('tags the intent type', () => {
+    expect(createBokehDepthOfFieldEffect().kind).toBe('BokehDepthOfFieldEffect');
+  });
+
+  it('carries options', () => {
+    expect(createBokehDepthOfFieldEffect({ focusDistance: 0.5, focusRange: 0.2, maxBlur: 4 })).toMatchObject({
+      focusDistance: 0.5,
+      focusRange: 0.2,
+      maxBlur: 4,
+    });
+  });
+});

package/src/brightnessContrastEffect.test.ts

@@ -0,0 +1,14 @@
+import { createBrightnessContrastEffect } from './brightnessContrastEffect';
+
+describe('createBrightnessContrastEffect', () => {
+  it('tags the intent type', () => {
+    expect(createBrightnessContrastEffect().kind).toBe('BrightnessContrastEffect');
+  });
+
+  it('carries options', () => {
+    expect(createBrightnessContrastEffect({ brightness: 0.2, contrast: 1.5 })).toMatchObject({
+      brightness: 0.2,
+      contrast: 1.5,
+    });
+  });
+});

package/src/cameraMotionBlurEffect.test.ts

@@ -0,0 +1,14 @@
+import { createCameraMotionBlurEffect } from './cameraMotionBlurEffect';
+
+describe('createCameraMotionBlurEffect', () => {
+  it('tags the intent type', () => {
+    expect(createCameraMotionBlurEffect().kind).toBe('CameraMotionBlurEffect');
+  });
+
+  it('carries options', () => {
+    expect(createCameraMotionBlurEffect({ intensity: 0.5, samples: 12 })).toMatchObject({
+      intensity: 0.5,
+      samples: 12,
+    });
+  });
+});

package/src/channelMixerEffect.test.ts

@@ -0,0 +1,12 @@
+import { createChannelMixerEffect } from './channelMixerEffect';
+
+describe('createChannelMixerEffect', () => {
+  it('tags the intent type', () => {
+    expect(createChannelMixerEffect({ matrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0] }).kind).toBe('ChannelMixerEffect');
+  });
+
+  it('carries the matrix', () => {
+    const matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0];
+    expect(createChannelMixerEffect({ matrix }).matrix).toBe(matrix);
+  });
+});

package/src/chromaticAberrationEffect.test.ts

@@ -0,0 +1,14 @@
+import { createChromaticAberrationEffect } from './chromaticAberrationEffect';
+
+describe('createChromaticAberrationEffect', () => {
+  it('tags the intent type', () => {
+    expect(createChromaticAberrationEffect().kind).toBe('ChromaticAberrationEffect');
+  });
+
+  it('carries options', () => {
+    expect(createChromaticAberrationEffect({ intensity: 0.01, radial: false })).toMatchObject({
+      intensity: 0.01,
+      radial: false,
+    });
+  });
+});

package/src/colorBlindSimulationEffect.test.ts

@@ -0,0 +1,13 @@
+import { createColorBlindSimulationEffect } from './colorBlindSimulationEffect';
+
+describe('createColorBlindSimulationEffect', () => {
+  it('carries options', () => {
+    expect(createColorBlindSimulationEffect({ type: 'protanopia' })).toMatchObject({
+      type: 'protanopia',
+    });
+  });
+
+  it('tags the intent type', () => {
+    expect(createColorBlindSimulationEffect().kind).toBe('ColorBlindSimulationEffect');
+  });
+});

package/src/colorGradeEffect.test.ts

@@ -0,0 +1,11 @@
+import { createColorGradeEffect } from './colorGradeEffect';
+
+describe('createColorGradeEffect', () => {
+  it('tags the intent type', () => {
+    expect(createColorGradeEffect().kind).toBe('ColorGradeEffect');
+  });
+
+  it('carries options', () => {
+    expect(createColorGradeEffect({ exposure: 1, saturation: 1.2 })).toMatchObject({ exposure: 1, saturation: 1.2 });
+  });
+});

package/src/colorScienceMath.test.ts

@@ -0,0 +1,160 @@
+import {
+  computeHslToRgb,
+  computeLinearToSrgb,
+  computeOklabToRgb,
+  computeRgbToHsl,
+  computeRgbToOklab,
+  computeSrgbToLinear,
+  getRec709LuminanceWeights,
+  getRec2020LuminanceWeights,
+} from './colorScienceMath';
+
+describe('computeHslToRgb', () => {
+  it('hue=0, full saturation, mid lightness → red', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeHslToRgb(0, 1, 0.5, out);
+    expect(out[0]).toBeCloseTo(1, 4);
+    expect(out[1]).toBeCloseTo(0, 4);
+    expect(out[2]).toBeCloseTo(0, 4);
+  });
+  it('round-trips with computeRgbToHsl', () => {
+    const r = 0.3;
+    const g = 0.7;
+    const b = 0.1;
+    const hsl: [number, number, number] = [0, 0, 0];
+    computeRgbToHsl(r, g, b, hsl);
+    const rgb: [number, number, number] = [0, 0, 0];
+    computeHslToRgb(hsl[0], hsl[1], hsl[2], rgb);
+    expect(rgb[0]).toBeCloseTo(r, 4);
+    expect(rgb[1]).toBeCloseTo(g, 4);
+    expect(rgb[2]).toBeCloseTo(b, 4);
+  });
+});
+
+describe('computeLinearToSrgb', () => {
+  it('0 maps to 0', () => {
+    expect(computeLinearToSrgb(0)).toBeCloseTo(0, 5);
+  });
+  it('1 maps to 1', () => {
+    expect(computeLinearToSrgb(1)).toBeCloseTo(1, 5);
+  });
+  it('round-trips with computeSrgbToLinear', () => {
+    const linear = 0.5;
+    expect(computeSrgbToLinear(computeLinearToSrgb(linear))).toBeCloseTo(linear, 4);
+  });
+  it('clamps negative values to 0', () => {
+    expect(computeLinearToSrgb(-1)).toBeCloseTo(0, 5);
+  });
+});
+
+describe('computeOklabToRgb', () => {
+  it('round-trips with computeRgbToOklab for a mid-gray', () => {
+    const r = 0.5;
+    const g = 0.5;
+    const b = 0.5;
+    const lab: [number, number, number] = [0, 0, 0];
+    computeRgbToOklab(r, g, b, lab);
+    const rgb: [number, number, number] = [0, 0, 0];
+    computeOklabToRgb(lab[0], lab[1], lab[2], rgb);
+    expect(rgb[0]).toBeCloseTo(r, 3);
+    expect(rgb[1]).toBeCloseTo(g, 3);
+    expect(rgb[2]).toBeCloseTo(b, 3);
+  });
+  it('round-trips with computeRgbToOklab for a saturated color', () => {
+    const r = 0.8;
+    const g = 0.2;
+    const b = 0.1;
+    const lab: [number, number, number] = [0, 0, 0];
+    computeRgbToOklab(r, g, b, lab);
+    const rgb: [number, number, number] = [0, 0, 0];
+    computeOklabToRgb(lab[0], lab[1], lab[2], rgb);
+    expect(rgb[0]).toBeCloseTo(r, 3);
+    expect(rgb[1]).toBeCloseTo(g, 3);
+    expect(rgb[2]).toBeCloseTo(b, 3);
+  });
+});
+
+describe('computeRgbToHsl', () => {
+  it('red (1,0,0) has hue 0°', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeRgbToHsl(1, 0, 0, out);
+    expect(out[0]).toBeCloseTo(0, 2);
+    expect(out[1]).toBeCloseTo(1, 2);
+    expect(out[2]).toBeCloseTo(0.5, 2);
+  });
+  it('green (0,1,0) has hue 120°', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeRgbToHsl(0, 1, 0, out);
+    expect(out[0]).toBeCloseTo(120, 2);
+  });
+  it('white (1,1,1) has lightness 1 and saturation 0', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeRgbToHsl(1, 1, 1, out);
+    expect(out[1]).toBeCloseTo(0, 4);
+    expect(out[2]).toBeCloseTo(1, 5);
+  });
+  it('black (0,0,0) has lightness 0 and saturation 0', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeRgbToHsl(0, 0, 0, out);
+    expect(out[1]).toBeCloseTo(0, 4);
+    expect(out[2]).toBeCloseTo(0, 5);
+  });
+});
+
+describe('computeRgbToOklab', () => {
+  it('black (0,0,0) maps to L=0', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeRgbToOklab(0, 0, 0, out);
+    expect(out[0]).toBeCloseTo(0, 4);
+  });
+  it('white (1,1,1) maps to L~1, a~0, b~0', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeRgbToOklab(1, 1, 1, out);
+    expect(out[0]).toBeCloseTo(1, 2);
+    expect(out[1]).toBeCloseTo(0, 3);
+    expect(out[2]).toBeCloseTo(0, 3);
+  });
+});
+
+describe('computeSrgbToLinear', () => {
+  it('0 maps to 0', () => {
+    expect(computeSrgbToLinear(0)).toBeCloseTo(0, 5);
+  });
+  it('1 maps to 1', () => {
+    expect(computeSrgbToLinear(1)).toBeCloseTo(1, 5);
+  });
+  it('round-trips with computeLinearToSrgb', () => {
+    const srgb = 0.5;
+    expect(computeLinearToSrgb(computeSrgbToLinear(srgb))).toBeCloseTo(srgb, 4);
+  });
+});
+
+describe('getRec2020LuminanceWeights', () => {
+  it('weights sum to 1', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    getRec2020LuminanceWeights(out);
+    expect(out[0] + out[1] + out[2]).toBeCloseTo(1, 5);
+  });
+  it('returns canonical Rec.2020 values', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    getRec2020LuminanceWeights(out);
+    expect(out[0]).toBeCloseTo(0.2627, 4);
+    expect(out[1]).toBeCloseTo(0.678, 4);
+    expect(out[2]).toBeCloseTo(0.0593, 4);
+  });
+});
+
+describe('getRec709LuminanceWeights', () => {
+  it('weights sum to 1', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    getRec709LuminanceWeights(out);
+    expect(out[0] + out[1] + out[2]).toBeCloseTo(1, 5);
+  });
+  it('returns canonical Rec.709 values', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    getRec709LuminanceWeights(out);
+    expect(out[0]).toBeCloseTo(0.2126, 4);
+    expect(out[1]).toBeCloseTo(0.7152, 4);
+    expect(out[2]).toBeCloseTo(0.0722, 4);
+  });
+});

package/src/colorTemperatureMath.test.ts

@@ -0,0 +1,67 @@
+import { computeColorTemperatureRgb, computeWhiteBalanceMultipliers } from './colorTemperatureMath';
+
+describe('computeColorTemperatureRgb', () => {
+  it('returns values in [0, 1] range', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeColorTemperatureRgb(6500, out);
+    expect(out[0]).toBeGreaterThanOrEqual(0);
+    expect(out[0]).toBeLessThanOrEqual(1);
+    expect(out[1]).toBeGreaterThanOrEqual(0);
+    expect(out[1]).toBeLessThanOrEqual(1);
+    expect(out[2]).toBeGreaterThanOrEqual(0);
+    expect(out[2]).toBeLessThanOrEqual(1);
+  });
+  it('warm color (2700 K) has high red, low blue', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeColorTemperatureRgb(2700, out);
+    expect(out[0]).toBeGreaterThan(out[2]);
+  });
+  it('cool color (10000 K) has low red, high blue', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeColorTemperatureRgb(10000, out);
+    expect(out[2]).toBeGreaterThan(out[0]);
+  });
+  it('clamps to [1000, 40000] K range', () => {
+    const out1: [number, number, number] = [0, 0, 0];
+    const out2: [number, number, number] = [0, 0, 0];
+    computeColorTemperatureRgb(500, out1);
+    computeColorTemperatureRgb(1000, out2);
+    expect(out1).toEqual(out2);
+  });
+  it('writes result to out without reading from it (alias-safe)', () => {
+    const out: [number, number, number] = [99, 99, 99];
+    computeColorTemperatureRgb(6500, out);
+    expect(out[0]).not.toBe(99);
+  });
+});
+
+describe('computeWhiteBalanceMultipliers', () => {
+  it('neutral (0, 0) returns non-zero multipliers', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeWhiteBalanceMultipliers(0, 0, out);
+    expect(out[0]).toBeGreaterThan(0);
+    expect(out[1]).toBeGreaterThan(0);
+    expect(out[2]).toBeGreaterThan(0);
+  });
+  it('warm temperature increases red relative to cool', () => {
+    const warmOut: [number, number, number] = [0, 0, 0];
+    const coolOut: [number, number, number] = [0, 0, 0];
+    computeWhiteBalanceMultipliers(0.5, 0, warmOut);
+    computeWhiteBalanceMultipliers(-0.5, 0, coolOut);
+    expect(warmOut[0]).toBeGreaterThan(coolOut[0]);
+  });
+  it('positive tint (magenta) reduces green relative to negative tint (green)', () => {
+    const magentaOut: [number, number, number] = [0, 0, 0];
+    const greenOut: [number, number, number] = [0, 0, 0];
+    computeWhiteBalanceMultipliers(0, 0.5, magentaOut);
+    computeWhiteBalanceMultipliers(0, -0.5, greenOut);
+    expect(greenOut[1]).toBeGreaterThan(magentaOut[1]);
+  });
+  it('all output channels are non-negative', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeWhiteBalanceMultipliers(-1, -1, out);
+    expect(out[0]).toBeGreaterThanOrEqual(0);
+    expect(out[1]).toBeGreaterThanOrEqual(0);
+    expect(out[2]).toBeGreaterThanOrEqual(0);
+  });
+});

package/src/contactShadowsEffect.test.ts

@@ -0,0 +1,14 @@
+import { createContactShadowsEffect } from './contactShadowsEffect';
+
+describe('createContactShadowsEffect', () => {
+  it('carries options', () => {
+    expect(createContactShadowsEffect({ opacity: 0.8, samples: 32 })).toMatchObject({
+      opacity: 0.8,
+      samples: 32,
+    });
+  });
+
+  it('tags the intent type', () => {
+    expect(createContactShadowsEffect().kind).toBe('ContactShadowsEffect');
+  });
+});

package/src/crtEffect.test.ts

@@ -0,0 +1,16 @@
+import { createCrtEffect } from './crtEffect';
+
+describe('createCrtEffect', () => {
+  it('tags the intent type', () => {
+    expect(createCrtEffect().kind).toBe('CrtEffect');
+  });
+
+  it('carries options', () => {
+    expect(createCrtEffect({ curvature: 0.2, scanlineIntensity: 0.5, vignette: 0.3, aberration: 0.01 })).toMatchObject({
+      curvature: 0.2,
+      scanlineIntensity: 0.5,
+      vignette: 0.3,
+      aberration: 0.01,
+    });
+  });
+});

package/src/customShaderEffect.test.ts

@@ -0,0 +1,14 @@
+import { createCustomShaderEffect } from './customShaderEffect';
+
+describe('createCustomShaderEffect', () => {
+  it('carries options', () => {
+    expect(createCustomShaderEffect({ shaderKey: 'myEffect', uniforms: { intensity: 0.5 } })).toMatchObject({
+      shaderKey: 'myEffect',
+      uniforms: { intensity: 0.5 },
+    });
+  });
+
+  it('tags the intent type', () => {
+    expect(createCustomShaderEffect({ shaderKey: 'test' }).kind).toBe('CustomShaderEffect');
+  });
+});

package/src/depthMath.test.ts

@@ -0,0 +1,71 @@
+import { computeDepthOfFieldCoc, computeLinearDepthFromNonlinear, computeSsaoSampleKernel } from './depthMath';
+
+describe('computeDepthOfFieldCoc', () => {
+  it('returns 0 when depth equals focusDistance', () => {
+    expect(computeDepthOfFieldCoc(5, 5, 1.8, 50)).toBeCloseTo(0, 4);
+  });
+  it('behind-focus depth returns positive CoC', () => {
+    expect(computeDepthOfFieldCoc(10, 5, 1.8, 50)).toBeGreaterThan(0);
+  });
+  it('in-front-of-focus depth returns negative CoC', () => {
+    expect(computeDepthOfFieldCoc(2, 5, 1.8, 50)).toBeLessThan(0);
+  });
+  it('larger aperture increases CoC magnitude', () => {
+    const coc14 = Math.abs(computeDepthOfFieldCoc(10, 5, 1.4, 50));
+    const coc8 = Math.abs(computeDepthOfFieldCoc(10, 5, 8, 50));
+    expect(coc14).toBeGreaterThan(coc8);
+  });
+});
+
+describe('computeLinearDepthFromNonlinear', () => {
+  it('depth=0 returns near plane', () => {
+    expect(computeLinearDepthFromNonlinear(0, 0.1, 1000)).toBeCloseTo(0.1, 3);
+  });
+  it('depth=1 returns far plane', () => {
+    expect(computeLinearDepthFromNonlinear(1, 0.1, 1000)).toBeCloseTo(1000, 0);
+  });
+  it('depth=0.5 returns a value between near and far', () => {
+    const linear = computeLinearDepthFromNonlinear(0.5, 0.1, 100);
+    expect(linear).toBeGreaterThan(0.1);
+    expect(linear).toBeLessThan(100);
+  });
+  it('uses the standard hyperbolic depth formula', () => {
+    // near=1, far=10, depth=0 → result == (1*10)/(10-0) = 1
+    expect(computeLinearDepthFromNonlinear(0, 1, 10)).toBeCloseTo(1, 5);
+  });
+});
+
+describe('computeSsaoSampleKernel', () => {
+  it('returns the requested sample count', () => {
+    const out = new Float32Array(16 * 3);
+    const count = computeSsaoSampleKernel(16, out);
+    expect(count).toBe(16);
+  });
+  it('all Z components are non-negative (hemisphere along +Z)', () => {
+    const out = new Float32Array(16 * 3);
+    const count = computeSsaoSampleKernel(16, out);
+    for (let i = 0; i < count; i++) {
+      expect(out[i * 3 + 2]).toBeGreaterThanOrEqual(0);
+    }
+  });
+  it('all samples are within the unit sphere', () => {
+    const out = new Float32Array(16 * 3);
+    const count = computeSsaoSampleKernel(16, out);
+    for (let i = 0; i < count; i++) {
+      const x = out[i * 3 + 0];
+      const y = out[i * 3 + 1];
+      const z = out[i * 3 + 2];
+      const len = Math.sqrt(x * x + y * y + z * z);
+      expect(len).toBeLessThanOrEqual(1 + 1e-6);
+    }
+  });
+  it('is deterministic (same output on repeated calls)', () => {
+    const out1 = new Float32Array(8 * 3);
+    const out2 = new Float32Array(8 * 3);
+    computeSsaoSampleKernel(8, out1);
+    computeSsaoSampleKernel(8, out2);
+    for (let i = 0; i < out1.length; i++) {
+      expect(out1[i]).toBeCloseTo(out2[i], 5);
+    }
+  });
+});

package/src/directionalBlurEffect.test.ts

@@ -0,0 +1,11 @@
+import { createDirectionalBlurEffect } from './directionalBlurEffect';
+
+describe('createDirectionalBlurEffect', () => {
+  it('tags the intent type', () => {
+    expect(createDirectionalBlurEffect().kind).toBe('DirectionalBlurEffect');
+  });
+
+  it('carries options', () => {
+    expect(createDirectionalBlurEffect({ angle: 1, length: 8 })).toMatchObject({ angle: 1, length: 8 });
+  });
+});

package/src/displacementEffect.test.ts

@@ -0,0 +1,15 @@
+import { createDisplacementEffect } from './displacementEffect';
+
+describe('createDisplacementEffect', () => {
+  it('tags the intent type', () => {
+    expect(createDisplacementEffect().kind).toBe('DisplacementEffect');
+  });
+
+  it('carries options', () => {
+    expect(createDisplacementEffect({ intensity: 10, frequency: 14, seed: 2 })).toMatchObject({
+      intensity: 10,
+      frequency: 14,
+      seed: 2,
+    });
+  });
+});

package/src/ditherEffect.test.ts

@@ -0,0 +1,11 @@
+import { createDitherEffect } from './ditherEffect';
+
+describe('createDitherEffect', () => {
+  it('tags the intent type', () => {
+    expect(createDitherEffect().kind).toBe('DitherEffect');
+  });
+
+  it('carries options', () => {
+    expect(createDitherEffect({ levels: 4 })).toMatchObject({ levels: 4 });
+  });
+});