@flighthq/effects 0.1.0

package/src/edgeDetectMath.test.ts

@@ -0,0 +1,84 @@
+import {
+  computeOutlineEdgeParams,
+  computeOutlineThicknessPx,
+  computeSketchEdgeParams,
+  getSobelKernelCoefficients,
+} from './edgeDetectMath';
+import { createOutlineEffect } from './outlineEffect';
+import { createSketchEffect } from './sketchEffect';
+
+describe('computeOutlineEdgeParams', () => {
+  it('writes threshold, feather, and color into out', () => {
+    const out: [number, number, number, number, number, number] = [0, 0, 0, 0, 0, 0];
+    computeOutlineEdgeParams(createOutlineEffect({ threshold: 0.2, color: 0xff0000ff }), out);
+    expect(out[0]).toBeCloseTo(0.2, 6); // threshold
+    expect(out[1]).toBeCloseTo(0.1, 6); // feather = threshold * 0.5
+    expect(out[2]).toBeCloseTo(1, 5); // r
+    expect(out[3]).toBeCloseTo(0, 5); // g
+    expect(out[4]).toBeCloseTo(0, 5); // b
+    expect(out[5]).toBeCloseTo(1, 5); // a
+  });
+  it('defaults to black outline', () => {
+    const out: [number, number, number, number, number, number] = [0, 0, 0, 0, 0, 0];
+    computeOutlineEdgeParams(createOutlineEffect(), out);
+    expect(out[2]).toBeCloseTo(0, 5); // r
+    expect(out[3]).toBeCloseTo(0, 5); // g
+    expect(out[4]).toBeCloseTo(0, 5); // b
+    expect(out[5]).toBeCloseTo(1, 5); // a
+  });
+});
+
+describe('computeOutlineThicknessPx', () => {
+  it('returns default 1', () => {
+    expect(computeOutlineThicknessPx(createOutlineEffect())).toBe(1);
+  });
+  it('rounds to integer', () => {
+    expect(computeOutlineThicknessPx(createOutlineEffect({ thickness: 2.7 }))).toBe(3);
+  });
+});
+
+describe('computeSketchEdgeParams', () => {
+  it('writes threshold inversely proportional to strength', () => {
+    const out: [number, number] = [0, 0];
+    computeSketchEdgeParams(createSketchEffect({ strength: 1 }), out);
+    const threshold1 = out[0];
+    computeSketchEdgeParams(createSketchEffect({ strength: 0.5 }), out);
+    const threshold05 = out[0];
+    expect(threshold05).toBeGreaterThan(threshold1);
+  });
+  it('strength=1 produces minimum threshold', () => {
+    const out: [number, number] = [0, 0];
+    computeSketchEdgeParams(createSketchEffect({ strength: 1 }), out);
+    expect(out[0]).toBeCloseTo(0.05, 2);
+    expect(out[1]).toBe(1);
+  });
+  it('strength=0 produces threshold at or near 1', () => {
+    const out: [number, number] = [0, 0];
+    computeSketchEdgeParams(createSketchEffect({ strength: 0 }), out);
+    expect(out[0]).toBeCloseTo(1, 5);
+    expect(out[1]).toBe(0);
+  });
+});
+
+describe('getSobelKernelCoefficients', () => {
+  it('writes 18 coefficients', () => {
+    const out = new Float32Array(18);
+    getSobelKernelCoefficients(out);
+    // Gx center column is 0
+    expect(out[1]).toBe(0);
+    expect(out[4]).toBe(0);
+    expect(out[7]).toBe(0);
+    // Gy center row is 0
+    expect(out[12]).toBe(0);
+    expect(out[13]).toBe(0);
+    expect(out[14]).toBe(0);
+  });
+  it('Gx and Gy are antisymmetric', () => {
+    const out = new Float32Array(18);
+    getSobelKernelCoefficients(out);
+    // Gx[0,0] = -Gx[0,2]
+    expect(out[0]).toBe(-out[2]);
+    // Gy[0,0] = -Gy[2,0]
+    expect(out[9]).toBe(-out[15]);
+  });
+});

package/src/exposureEffect.test.ts

@@ -0,0 +1,7 @@
+import { createExposureEffect } from './exposureEffect';
+
+describe('createExposureEffect', () => {
+  it('tags the intent type', () => {
+    expect(createExposureEffect({ exposure: 1 }).kind).toBe('ExposureEffect');
+  });
+});

package/src/filmEmulationEffect.test.ts

@@ -0,0 +1,14 @@
+import { createFilmEmulationEffect } from './filmEmulationEffect';
+
+describe('createFilmEmulationEffect', () => {
+  it('carries options', () => {
+    expect(createFilmEmulationEffect({ grainIntensity: 0.2, halationStrength: 0.4 })).toMatchObject({
+      grainIntensity: 0.2,
+      halationStrength: 0.4,
+    });
+  });
+
+  it('tags the intent type', () => {
+    expect(createFilmEmulationEffect().kind).toBe('FilmEmulationEffect');
+  });
+});

package/src/filmGrainEffect.test.ts

@@ -0,0 +1,15 @@
+import { createFilmGrainEffect } from './filmGrainEffect';
+
+describe('createFilmGrainEffect', () => {
+  it('tags the intent type', () => {
+    expect(createFilmGrainEffect().kind).toBe('FilmGrainEffect');
+  });
+
+  it('carries options', () => {
+    expect(createFilmGrainEffect({ intensity: 0.3, size: 2, seed: 7 })).toMatchObject({
+      intensity: 0.3,
+      size: 2,
+      seed: 7,
+    });
+  });
+});

package/src/fxaaEffect.test.ts

@@ -0,0 +1,14 @@
+import { createFxaaEffect } from './fxaaEffect';
+
+describe('createFxaaEffect', () => {
+  it('tags the intent type', () => {
+    expect(createFxaaEffect().kind).toBe('FxaaEffect');
+  });
+
+  it('carries options', () => {
+    expect(createFxaaEffect({ edgeThreshold: 0.05, subpixel: 0.75 })).toMatchObject({
+      edgeThreshold: 0.05,
+      subpixel: 0.75,
+    });
+  });
+});

package/src/gaussianMath.test.ts

@@ -0,0 +1,93 @@
+import {
+  computeGaussianRadiusFromSigma,
+  computeGaussianSigmaFromRadius,
+  computeSeparableBlurPassCount,
+  createGaussianKernelWeights,
+} from './gaussianMath';
+
+describe('computeGaussianRadiusFromSigma', () => {
+  it('returns 0 for zero sigma', () => {
+    expect(computeGaussianRadiusFromSigma(0)).toBe(0);
+  });
+  it('returns ceil(3 * sigma)', () => {
+    expect(computeGaussianRadiusFromSigma(2)).toBe(6);
+    expect(computeGaussianRadiusFromSigma(2.5)).toBe(8);
+  });
+  it('clamps negative sigma to 0', () => {
+    expect(computeGaussianRadiusFromSigma(-1)).toBe(0);
+  });
+  it('round-trips with computeGaussianSigmaFromRadius', () => {
+    const sigma = 2;
+    const radius = computeGaussianRadiusFromSigma(sigma);
+    // sigma -> radius -> sigma may not be exact due to ceil, but should be close.
+    expect(computeGaussianSigmaFromRadius(radius)).toBeCloseTo(sigma, 0);
+  });
+});
+
+describe('computeGaussianSigmaFromRadius', () => {
+  it('returns 0 for zero radius', () => {
+    expect(computeGaussianSigmaFromRadius(0)).toBe(0);
+  });
+  it('returns radius / 3', () => {
+    expect(computeGaussianSigmaFromRadius(6)).toBeCloseTo(2);
+    expect(computeGaussianSigmaFromRadius(9)).toBeCloseTo(3);
+  });
+  it('clamps negative radius to 0', () => {
+    expect(computeGaussianSigmaFromRadius(-3)).toBe(0);
+  });
+  it('round-trips with computeGaussianRadiusFromSigma', () => {
+    const radius = 8;
+    const sigma = computeGaussianSigmaFromRadius(radius);
+    expect(computeGaussianRadiusFromSigma(sigma)).toBe(radius);
+  });
+});
+
+describe('computeSeparableBlurPassCount', () => {
+  it('defaults to 1 when samples is undefined', () => {
+    expect(computeSeparableBlurPassCount(undefined)).toBe(1);
+  });
+  it('returns at least 1', () => {
+    expect(computeSeparableBlurPassCount(0)).toBe(1);
+    expect(computeSeparableBlurPassCount(-5)).toBe(1);
+  });
+  it('rounds fractional samples', () => {
+    expect(computeSeparableBlurPassCount(2.4)).toBe(2);
+    expect(computeSeparableBlurPassCount(2.6)).toBe(3);
+  });
+  it('returns integer pass count', () => {
+    expect(computeSeparableBlurPassCount(4)).toBe(4);
+  });
+});
+
+describe('createGaussianKernelWeights', () => {
+  it('writes radius + 1 weights and returns that count', () => {
+    const out = new Float32Array(10);
+    const count = createGaussianKernelWeights(4, 1.5, out);
+    expect(count).toBe(5);
+  });
+  it('normalized weights sum to 1 (center + 2 * each side)', () => {
+    const radius = 4;
+    const sigma = 1.5;
+    const out = new Float32Array(radius + 1);
+    const count = createGaussianKernelWeights(radius, sigma, out);
+    let sum = out[0];
+    for (let i = 1; i < count; i++) {
+      sum += 2 * out[i];
+    }
+    expect(sum).toBeCloseTo(1, 5);
+  });
+  it('center weight is the largest', () => {
+    const out = new Float32Array(10);
+    const count = createGaussianKernelWeights(5, 2, out);
+    for (let i = 1; i < count; i++) {
+      expect(out[0]).toBeGreaterThan(out[i]);
+    }
+  });
+  it('weights decrease monotonically from center', () => {
+    const out = new Float32Array(10);
+    const count = createGaussianKernelWeights(5, 2, out);
+    for (let i = 1; i < count; i++) {
+      expect(out[i - 1]).toBeGreaterThan(out[i]);
+    }
+  });
+});

package/src/glitchEffect.test.ts

@@ -0,0 +1,16 @@
+import { createGlitchEffect } from './glitchEffect';
+
+describe('createGlitchEffect', () => {
+  it('tags the intent type', () => {
+    expect(createGlitchEffect().kind).toBe('GlitchEffect');
+  });
+
+  it('carries options', () => {
+    expect(createGlitchEffect({ intensity: 0.7, blockSize: 22, colorShift: 12, seed: 3 })).toMatchObject({
+      intensity: 0.7,
+      blockSize: 22,
+      colorShift: 12,
+      seed: 3,
+    });
+  });
+});

package/src/godRaysEffect.test.ts

@@ -0,0 +1,15 @@
+import { createGodRaysEffect } from './godRaysEffect';
+
+describe('createGodRaysEffect', () => {
+  it('tags the intent type', () => {
+    expect(createGodRaysEffect().kind).toBe('GodRaysEffect');
+  });
+
+  it('carries options', () => {
+    expect(createGodRaysEffect({ centerX: 0.5, centerY: 0.25, density: 0.9 })).toMatchObject({
+      centerX: 0.5,
+      centerY: 0.25,
+      density: 0.9,
+    });
+  });
+});

package/src/godRaysMath.test.ts

@@ -0,0 +1,63 @@
+import { createGodRaysEffect } from './godRaysEffect';
+import {
+  computeGodRaysAccumulationScale,
+  computeGodRaysLightCenter,
+  computeGodRaysSampleWeight,
+  computeGodRaysStepSize,
+} from './godRaysMath';
+
+describe('computeGodRaysAccumulationScale', () => {
+  it('is finite and positive for default parameters', () => {
+    const scale = computeGodRaysAccumulationScale(createGodRaysEffect());
+    expect(scale).toBeGreaterThan(0);
+    expect(isFinite(scale)).toBe(true);
+  });
+  it('is 1/(samples*weight*exposure) for explicit values', () => {
+    const effect = createGodRaysEffect({ samples: 50, weight: 0.5, exposure: 0.2 });
+    expect(computeGodRaysAccumulationScale(effect)).toBeCloseTo(1 / (50 * 0.5 * 0.2), 6);
+  });
+});
+
+describe('computeGodRaysLightCenter', () => {
+  it('defaults to [0.5, 0.5]', () => {
+    const out: [number, number] = [0, 0];
+    computeGodRaysLightCenter(createGodRaysEffect(), out);
+    expect(out[0]).toBe(0.5);
+    expect(out[1]).toBe(0.5);
+  });
+  it('clamps to [0..1]', () => {
+    const out: [number, number] = [0, 0];
+    computeGodRaysLightCenter(createGodRaysEffect({ centerX: -1, centerY: 2 }), out);
+    expect(out[0]).toBe(0);
+    expect(out[1]).toBe(1);
+  });
+});
+
+describe('computeGodRaysSampleWeight', () => {
+  it('decreases with sample index due to decay', () => {
+    const effect = createGodRaysEffect({ decay: 0.9, weight: 1, exposure: 1 });
+    const w0 = computeGodRaysSampleWeight(effect, 0);
+    const w5 = computeGodRaysSampleWeight(effect, 5);
+    expect(w0).toBeGreaterThan(w5);
+  });
+  it('sample 0 equals weight*exposure when decay applied once', () => {
+    const effect = createGodRaysEffect({ decay: 0.96, weight: 0.4, exposure: 0.1 });
+    expect(computeGodRaysSampleWeight(effect, 0)).toBeCloseTo(0.4 * 0.1, 6);
+  });
+});
+
+describe('computeGodRaysStepSize', () => {
+  it('returns zero step when pixel is at the light center', () => {
+    const out: [number, number] = [1, 1];
+    computeGodRaysStepSize(createGodRaysEffect({ centerX: 0.5, centerY: 0.5 }), 0.5, 0.5, out);
+    expect(out[0]).toBeCloseTo(0, 6);
+    expect(out[1]).toBeCloseTo(0, 6);
+  });
+  it('step direction points toward light center', () => {
+    const out: [number, number] = [0, 0];
+    // pixel at top-left (0, 0), light at center (0.5, 0.5) => step should be positive
+    computeGodRaysStepSize(createGodRaysEffect({ centerX: 0.5, centerY: 0.5, density: 1, samples: 10 }), 0, 0, out);
+    expect(out[0]).toBeGreaterThan(0);
+    expect(out[1]).toBeGreaterThan(0);
+  });
+});

package/src/grayscaleEffect.test.ts

@@ -0,0 +1,11 @@
+import { createGrayscaleEffect } from './grayscaleEffect';
+
+describe('createGrayscaleEffect', () => {
+  it('tags the intent type', () => {
+    expect(createGrayscaleEffect().kind).toBe('GrayscaleEffect');
+  });
+
+  it('carries options', () => {
+    expect(createGrayscaleEffect({ intensity: 0.5 })).toMatchObject({ intensity: 0.5 });
+  });
+});

package/src/halftoneEffect.test.ts

@@ -0,0 +1,11 @@
+import { createHalftoneEffect } from './halftoneEffect';
+
+describe('createHalftoneEffect', () => {
+  it('tags the intent type', () => {
+    expect(createHalftoneEffect().kind).toBe('HalftoneEffect');
+  });
+
+  it('carries options', () => {
+    expect(createHalftoneEffect({ scale: 6, angle: 0.5 })).toMatchObject({ scale: 6, angle: 0.5 });
+  });
+});

package/src/hueSaturationEffect.test.ts

@@ -0,0 +1,15 @@
+import { createHueSaturationEffect } from './hueSaturationEffect';
+
+describe('createHueSaturationEffect', () => {
+  it('tags the intent type', () => {
+    expect(createHueSaturationEffect().kind).toBe('HueSaturationEffect');
+  });
+
+  it('carries options', () => {
+    expect(createHueSaturationEffect({ hue: 90, saturation: 1.4, lightness: 0.1 })).toMatchObject({
+      hue: 90,
+      saturation: 1.4,
+      lightness: 0.1,
+    });
+  });
+});

package/src/invertEffect.test.ts

@@ -0,0 +1,11 @@
+import { createInvertEffect } from './invertEffect';
+
+describe('createInvertEffect', () => {
+  it('tags the intent type', () => {
+    expect(createInvertEffect().kind).toBe('InvertEffect');
+  });
+
+  it('carries options', () => {
+    expect(createInvertEffect({ intensity: 0.75 })).toMatchObject({ intensity: 0.75 });
+  });
+});

package/src/kuwaharaEffect.test.ts

@@ -0,0 +1,11 @@
+import { createKuwaharaEffect } from './kuwaharaEffect';
+
+describe('createKuwaharaEffect', () => {
+  it('tags the intent type', () => {
+    expect(createKuwaharaEffect().kind).toBe('KuwaharaEffect');
+  });
+
+  it('carries options', () => {
+    expect(createKuwaharaEffect({ radius: 3 })).toMatchObject({ radius: 3 });
+  });
+});

package/src/kuwaharaMath.test.ts

@@ -0,0 +1,65 @@
+import { createKuwaharaEffect } from './kuwaharaEffect';
+import {
+  computeKuwaharaGaussianWeights,
+  computeKuwaharaSectorOffsets,
+  computeKuwaharaSectorPixelCount,
+  computeKuwaharaSectorSize,
+} from './kuwaharaMath';
+
+describe('computeKuwaharaGaussianWeights', () => {
+  it('returns normalized weights summing to ~1', () => {
+    const out = new Float32Array(16);
+    const n = computeKuwaharaGaussianWeights(3, out);
+    let sum = 0;
+    for (let i = 0; i < n; i++) sum += out[i];
+    expect(sum).toBeCloseTo(1, 5);
+  });
+  it('returns (radius+1)^2 weights', () => {
+    const out = new Float32Array(25);
+    const n = computeKuwaharaGaussianWeights(4, out);
+    expect(n).toBe(25); // (4+1)^2
+  });
+  it('center weight (0,0) is largest for radius >= 1', () => {
+    const r = 3;
+    const size = r + 1;
+    const out = new Float32Array(size * size);
+    computeKuwaharaGaussianWeights(r, out);
+    const center = out[0]; // top-left corner is the closest to center of sector
+    expect(center).toBeGreaterThan(0);
+  });
+});
+
+describe('computeKuwaharaSectorOffsets', () => {
+  it('writes 8 values into out', () => {
+    const out: [number, number, number, number, number, number, number, number] = [0, 0, 0, 0, 0, 0, 0, 0];
+    computeKuwaharaSectorOffsets(3, out);
+    // top-left starts at (-3, -3)
+    expect(out[0]).toBe(-3);
+    expect(out[1]).toBe(-3);
+    // top-right starts at (0, -3)
+    expect(out[2]).toBe(0);
+    expect(out[3]).toBe(-3);
+    // bottom-left starts at (-3, 0)
+    expect(out[4]).toBe(-3);
+    expect(out[5]).toBe(0);
+    // bottom-right starts at (0, 0)
+    expect(out[6]).toBe(0);
+    expect(out[7]).toBe(0);
+  });
+});
+
+describe('computeKuwaharaSectorPixelCount', () => {
+  it('returns (radius+1)^2 for default radius 3', () => {
+    expect(computeKuwaharaSectorPixelCount(createKuwaharaEffect())).toBe(16);
+  });
+});
+
+describe('computeKuwaharaSectorSize', () => {
+  it('returns radius+1', () => {
+    expect(computeKuwaharaSectorSize(createKuwaharaEffect({ radius: 3 }))).toBe(4);
+    expect(computeKuwaharaSectorSize(createKuwaharaEffect({ radius: 5 }))).toBe(6);
+  });
+  it('minimum is 2 (radius 1)', () => {
+    expect(computeKuwaharaSectorSize(createKuwaharaEffect({ radius: 1 }))).toBe(2);
+  });
+});

package/src/lensDirtEffect.test.ts

@@ -0,0 +1,15 @@
+import { createLensDirtEffect } from './lensDirtEffect';
+
+describe('createLensDirtEffect', () => {
+  it('tags the intent type', () => {
+    expect(createLensDirtEffect().kind).toBe('LensDirtEffect');
+  });
+
+  it('carries options', () => {
+    expect(createLensDirtEffect({ intensity: 1.5, threshold: 0.45, seed: 4 })).toMatchObject({
+      intensity: 1.5,
+      threshold: 0.45,
+      seed: 4,
+    });
+  });
+});

package/src/lensDistortionEffect.test.ts

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

package/src/lensFlareEffect.test.ts

@@ -0,0 +1,16 @@
+import { createLensFlareEffect } from './lensFlareEffect';
+
+describe('createLensFlareEffect', () => {
+  it('tags the intent type', () => {
+    expect(createLensFlareEffect().kind).toBe('LensFlareEffect');
+  });
+
+  it('carries options', () => {
+    expect(createLensFlareEffect({ threshold: 0.8, intensity: 2, ghosts: 4, halo: 0.5 })).toMatchObject({
+      threshold: 0.8,
+      intensity: 2,
+      ghosts: 4,
+      halo: 0.5,
+    });
+  });
+});

package/src/liftGammaGainEffect.test.ts

@@ -0,0 +1,15 @@
+import { createLiftGammaGainEffect } from './liftGammaGainEffect';
+
+describe('createLiftGammaGainEffect', () => {
+  it('tags the intent type', () => {
+    expect(createLiftGammaGainEffect().kind).toBe('LiftGammaGainEffect');
+  });
+
+  it('carries options', () => {
+    expect(createLiftGammaGainEffect({ lift: 0x808080ff, gamma: 0x808080ff, gain: 0x808080ff })).toMatchObject({
+      lift: 0x808080ff,
+      gamma: 0x808080ff,
+      gain: 0x808080ff,
+    });
+  });
+});

package/src/lookupTableGradeEffect.test.ts

@@ -0,0 +1,11 @@
+import { createLookupTableGradeEffect } from './lookupTableGradeEffect';
+
+describe('createLookupTableGradeEffect', () => {
+  it('tags the intent type', () => {
+    expect(createLookupTableGradeEffect().kind).toBe('LookupTableGradeEffect');
+  });
+
+  it('carries options', () => {
+    expect(createLookupTableGradeEffect({ size: 32, strength: 0.8 })).toMatchObject({ size: 32, strength: 0.8 });
+  });
+});

package/src/lutMath.test.ts

@@ -0,0 +1,67 @@
+import { computeLookupTableCoord, getLookupTableTileLayout } from './lutMath';
+
+describe('computeLookupTableCoord', () => {
+  it('writes two values into out', () => {
+    const out: [number, number] = [0, 0];
+    computeLookupTableCoord(0.5, 0.5, 0.5, 16, out);
+    expect(typeof out[0]).toBe('number');
+    expect(typeof out[1]).toBe('number');
+  });
+  it('black (0,0,0) maps to near (0, 0)', () => {
+    const out: [number, number] = [0, 0];
+    computeLookupTableCoord(0, 0, 0, 16, out);
+    expect(out[0]).toBeGreaterThanOrEqual(0);
+    expect(out[1]).toBeGreaterThanOrEqual(0);
+  });
+  it('U and V are in [0, 1] range for valid input', () => {
+    const out: [number, number] = [0, 0];
+    computeLookupTableCoord(0.5, 0.5, 0.5, 16, out);
+    expect(out[0]).toBeGreaterThanOrEqual(0);
+    expect(out[0]).toBeLessThanOrEqual(1);
+    expect(out[1]).toBeGreaterThanOrEqual(0);
+    expect(out[1]).toBeLessThanOrEqual(1);
+  });
+  it('high G shifts V up', () => {
+    const outLow: [number, number] = [0, 0];
+    const outHigh: [number, number] = [0, 0];
+    computeLookupTableCoord(0.5, 0.1, 0.5, 16, outLow);
+    computeLookupTableCoord(0.5, 0.9, 0.5, 16, outHigh);
+    expect(outHigh[1]).toBeGreaterThan(outLow[1]);
+  });
+  it('high B shifts U right', () => {
+    const outLow: [number, number] = [0, 0];
+    const outHigh: [number, number] = [0, 0];
+    computeLookupTableCoord(0.5, 0.5, 0.1, 16, outLow);
+    computeLookupTableCoord(0.5, 0.5, 0.9, 16, outHigh);
+    expect(outHigh[0]).toBeGreaterThan(outLow[0]);
+  });
+  it('clamps out-of-range input', () => {
+    const out1: [number, number] = [0, 0];
+    const out2: [number, number] = [0, 0];
+    computeLookupTableCoord(0, 0, 0, 16, out1);
+    computeLookupTableCoord(-0.5, -0.5, -0.5, 16, out2);
+    expect(out1[0]).toBeCloseTo(out2[0], 5);
+    expect(out1[1]).toBeCloseTo(out2[1], 5);
+  });
+});
+
+describe('getLookupTableTileLayout', () => {
+  it('returns [size², size] for a given LUT size', () => {
+    const out: [number, number] = [0, 0];
+    getLookupTableTileLayout(16, out);
+    expect(out[0]).toBe(256); // 16 * 16
+    expect(out[1]).toBe(16);
+  });
+  it('works for size 32', () => {
+    const out: [number, number] = [0, 0];
+    getLookupTableTileLayout(32, out);
+    expect(out[0]).toBe(1024);
+    expect(out[1]).toBe(32);
+  });
+  it('handles size 1 without dividing by zero', () => {
+    const out: [number, number] = [0, 0];
+    getLookupTableTileLayout(1, out);
+    expect(out[0]).toBe(1);
+    expect(out[1]).toBe(1);
+  });
+});

package/src/motionBlurEffect.test.ts

@@ -0,0 +1,11 @@
+import { createMotionBlurEffect } from './motionBlurEffect';
+
+describe('createMotionBlurEffect', () => {
+  it('tags the intent type', () => {
+    expect(createMotionBlurEffect().kind).toBe('MotionBlurEffect');
+  });
+
+  it('carries options', () => {
+    expect(createMotionBlurEffect({ intensity: 0.8, samples: 12 })).toMatchObject({ intensity: 0.8, samples: 12 });
+  });
+});

package/src/outlineEffect.test.ts

@@ -0,0 +1,15 @@
+import { createOutlineEffect } from './outlineEffect';
+
+describe('createOutlineEffect', () => {
+  it('tags the intent type', () => {
+    expect(createOutlineEffect().kind).toBe('OutlineEffect');
+  });
+
+  it('carries options', () => {
+    expect(createOutlineEffect({ threshold: 0.2, thickness: 1.5, color: 0x000000ff })).toMatchObject({
+      threshold: 0.2,
+      thickness: 1.5,
+      color: 0x000000ff,
+    });
+  });
+});

package/src/panniniProjectionEffect.test.ts

@@ -0,0 +1,14 @@
+import { createPanniniProjectionEffect } from './panniniProjectionEffect';
+
+describe('createPanniniProjectionEffect', () => {
+  it('carries options', () => {
+    expect(createPanniniProjectionEffect({ compression: 0.7, crop: 0.1 })).toMatchObject({
+      compression: 0.7,
+      crop: 0.1,
+    });
+  });
+
+  it('tags the intent type', () => {
+    expect(createPanniniProjectionEffect().kind).toBe('PanniniProjectionEffect');
+  });
+});

package/src/pixelateEffect.test.ts

@@ -0,0 +1,11 @@
+import { createPixelateEffect } from './pixelateEffect';
+
+describe('createPixelateEffect', () => {
+  it('tags the intent type', () => {
+    expect(createPixelateEffect().kind).toBe('PixelateEffect');
+  });
+
+  it('carries options', () => {
+    expect(createPixelateEffect({ size: 8 })).toMatchObject({ size: 8 });
+  });
+});