@flighthq/effects 0.1.0

package/src/posterizeEffect.test.ts

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

package/src/radialBlurEffect.test.ts

@@ -0,0 +1,15 @@
+import { createRadialBlurEffect } from './radialBlurEffect';
+
+describe('createRadialBlurEffect', () => {
+  it('tags the intent type', () => {
+    expect(createRadialBlurEffect().kind).toBe('RadialBlurEffect');
+  });
+
+  it('carries options', () => {
+    expect(createRadialBlurEffect({ centerX: 0.5, centerY: 0.5, strength: 0.2 })).toMatchObject({
+      centerX: 0.5,
+      centerY: 0.5,
+      strength: 0.2,
+    });
+  });
+});

package/src/renderEffectDefaults.test.ts

@@ -0,0 +1,70 @@
+import type { BloomEffect, GrayscaleEffect, RenderEffect, ToneMapEffect, VignetteEffect } from '@flighthq/types';
+
+import { createBloomEffect } from './bloomEffect';
+import { createGrayscaleEffect } from './grayscaleEffect';
+import { getRenderEffectDefaults, normalizeRenderEffect } from './renderEffectDefaults';
+import { createToneMapEffect } from './toneMapEffect';
+import { createVignetteEffect } from './vignetteEffect';
+
+describe('getRenderEffectDefaults', () => {
+  it('returns documented defaults for BloomEffect', () => {
+    const d = getRenderEffectDefaults('BloomEffect');
+    expect(d.brightness).toBe(1);
+    expect(d.threshold).toBe(0.8);
+    expect(d.thresholdKnee).toBe(0.5);
+    expect(d.radius).toBe(8);
+    expect(d.passes).toBe(1);
+  });
+  it('returns documented defaults for ToneMapEffect', () => {
+    const d = getRenderEffectDefaults('ToneMapEffect');
+    expect(d.operator).toBe('aces');
+    expect(d.exposure).toBe(0);
+  });
+  it('returns a fresh copy each call (mutations do not persist)', () => {
+    const d1 = getRenderEffectDefaults('BloomEffect');
+    const d2 = getRenderEffectDefaults('BloomEffect');
+    d1.threshold = 99;
+    expect(d2.threshold).toBe(0.8);
+  });
+  it('returns empty object for unknown kind', () => {
+    expect(getRenderEffectDefaults('acme.UnknownEffect')).toEqual({});
+  });
+});
+
+describe('normalizeRenderEffect', () => {
+  it('fills in missing fields from defaults', () => {
+    const effect = createBloomEffect({ threshold: 0.9 });
+    const out = { kind: 'BloomEffect' } as BloomEffect;
+    const ok = normalizeRenderEffect(effect, out);
+    expect(ok).toBe(true);
+    expect(out.threshold).toBe(0.9); // preserved
+    expect((out as unknown as Record<string, unknown>).brightness).toBe(1); // filled from defaults
+    expect(out.radius).toBe(8); // filled from defaults
+  });
+  it('preserves explicitly set zero and false', () => {
+    const effect = createGrayscaleEffect({ intensity: 0 });
+    const out = { kind: 'GrayscaleEffect' } as GrayscaleEffect;
+    normalizeRenderEffect(effect, out);
+    expect(out.intensity).toBe(0); // 0 is explicit, should not be replaced by default 1
+  });
+  it('carries over fields not in the defaults table', () => {
+    const effect = createVignetteEffect({ intensity: 0.3 });
+    const out = { kind: 'VignetteEffect' } as VignetteEffect;
+    normalizeRenderEffect(effect, out);
+    expect(out.intensity).toBe(0.3);
+    expect(out.radius).toBe(1);
+    expect(out.softness).toBe(0.5);
+  });
+  it('returns false for unknown kind', () => {
+    const effect = { kind: 'acme.UnknownEffect' } as RenderEffect;
+    const out = { kind: 'acme.UnknownEffect' } as RenderEffect;
+    expect(normalizeRenderEffect(effect, out)).toBe(false);
+  });
+  it('is alias-safe when out === effect', () => {
+    const effect = createToneMapEffect({ exposure: 1 }) as ToneMapEffect;
+    const ok = normalizeRenderEffect(effect, effect);
+    expect(ok).toBe(true);
+    expect(effect.exposure).toBe(1);
+    expect(effect.operator).toBe('aces');
+  });
+});

package/src/renderEffectInputs.test.ts

@@ -0,0 +1,60 @@
+import { createBloomEffect } from './bloomEffect';
+import { createBokehDepthOfFieldEffect } from './bokehDepthOfFieldEffect';
+import { createColorGradeEffect } from './colorGradeEffect';
+import { createGrayscaleEffect } from './grayscaleEffect';
+import { getRenderEffectInputs, getRenderEffectKinds, RENDER_EFFECT_KINDS } from './renderEffectInputs';
+import { createSsaoEffect } from './ssaoEffect';
+import { createTaaEffect } from './taaEffect';
+import { createToneMapEffect } from './toneMapEffect';
+
+describe('getRenderEffectInputs', () => {
+  it('returns Hdr for BloomEffect', () => {
+    expect(getRenderEffectInputs(createBloomEffect())).toEqual(['Hdr']);
+  });
+
+  it('returns Hdr for ToneMapEffect', () => {
+    expect(getRenderEffectInputs(createToneMapEffect())).toEqual(['Hdr']);
+  });
+
+  it('returns Depth for SsaoEffect', () => {
+    expect(getRenderEffectInputs(createSsaoEffect())).toEqual(['Depth']);
+  });
+
+  it('returns Depth for BokehDepthOfFieldEffect', () => {
+    expect(getRenderEffectInputs(createBokehDepthOfFieldEffect())).toEqual(['Depth']);
+  });
+
+  it('returns Temporal for TaaEffect', () => {
+    expect(getRenderEffectInputs(createTaaEffect())).toEqual(['Temporal']);
+  });
+
+  it('returns empty array for effects that need only the color buffer', () => {
+    expect(getRenderEffectInputs(createGrayscaleEffect())).toEqual([]);
+    expect(getRenderEffectInputs(createColorGradeEffect())).toEqual([]);
+  });
+
+  it('returns empty array for unknown kind', () => {
+    expect(getRenderEffectInputs({ kind: 'acme.UnknownEffect' } as never)).toEqual([]);
+  });
+});
+
+describe('getRenderEffectKinds', () => {
+  it('returns an array containing known effect kinds', () => {
+    const kinds = getRenderEffectKinds();
+    expect(kinds).toContain('BloomEffect');
+    expect(kinds).toContain('ToneMapEffect');
+    expect(kinds).toContain('SsaoEffect');
+    expect(kinds).toContain('GrayscaleEffect');
+  });
+
+  it('returns the same reference as RENDER_EFFECT_KINDS', () => {
+    expect(getRenderEffectKinds()).toBe(RENDER_EFFECT_KINDS);
+  });
+
+  it('kinds are in alphabetical order', () => {
+    const kinds = getRenderEffectKinds();
+    for (let i = 1; i < kinds.length; i++) {
+      expect(kinds[i - 1].localeCompare(kinds[i])).toBeLessThan(0);
+    }
+  });
+});

package/src/renderEffectInterpolation.test.ts

@@ -0,0 +1,71 @@
+import type { GrayscaleEffect } from '@flighthq/types';
+
+import { createBloomEffect } from './bloomEffect';
+import { createColorGradeEffect } from './colorGradeEffect';
+import { createGrayscaleEffect } from './grayscaleEffect';
+import { canLerpRenderEffects, lerpRenderEffect } from './renderEffectInterpolation';
+
+describe('canLerpRenderEffects', () => {
+  it('returns true for same kind', () => {
+    expect(canLerpRenderEffects(createBloomEffect(), createBloomEffect())).toBe(true);
+  });
+  it('returns false for different kinds', () => {
+    expect(canLerpRenderEffects(createBloomEffect(), createColorGradeEffect())).toBe(false);
+  });
+});
+
+describe('lerpRenderEffect', () => {
+  it('returns false and leaves out unchanged for mismatched kinds', () => {
+    const a = createBloomEffect({ threshold: 0.5 });
+    const b = createColorGradeEffect({ exposure: 1 });
+    const out = createBloomEffect({ threshold: 0.99 });
+    const result = lerpRenderEffect(a, b, 0.5, out);
+    expect(result).toBe(false);
+    expect(out.threshold).toBe(0.99);
+  });
+  it('at t=0 writes a values', () => {
+    const a = createBloomEffect({ threshold: 0.2, radius: 4 });
+    const b = createBloomEffect({ threshold: 0.8, radius: 16 });
+    const out = createBloomEffect();
+    lerpRenderEffect(a, b, 0, out);
+    expect(out.threshold).toBeCloseTo(0.2, 5);
+    expect(out.radius).toBeCloseTo(4, 5);
+  });
+  it('at t=1 writes b values', () => {
+    const a = createBloomEffect({ threshold: 0.2, radius: 4 });
+    const b = createBloomEffect({ threshold: 0.8, radius: 16 });
+    const out = createBloomEffect();
+    lerpRenderEffect(a, b, 1, out);
+    expect(out.threshold).toBeCloseTo(0.8, 5);
+    expect(out.radius).toBeCloseTo(16, 5);
+  });
+  it('at t=0.5 interpolates numeric fields', () => {
+    const a = createBloomEffect({ threshold: 0, radius: 0 });
+    const b = createBloomEffect({ threshold: 1, radius: 10 });
+    const out = createBloomEffect();
+    lerpRenderEffect(a, b, 0.5, out);
+    expect(out.threshold).toBeCloseTo(0.5, 5);
+    expect(out.radius).toBeCloseTo(5, 5);
+  });
+  it('returns true on success', () => {
+    const a = createBloomEffect();
+    const b = createBloomEffect();
+    const out = createBloomEffect();
+    expect(lerpRenderEffect(a, b, 0.5, out)).toBe(true);
+  });
+  it('is alias-safe when out === a', () => {
+    const a = createBloomEffect({ threshold: 0, radius: 0 });
+    const b = createBloomEffect({ threshold: 1, radius: 10 });
+    lerpRenderEffect(a, b, 0.5, a);
+    expect(a.threshold).toBeCloseTo(0.5, 5);
+  });
+  it('boolean fields snap at t=0.5 boundary', () => {
+    const a = createGrayscaleEffect({ enabled: false } as Partial<GrayscaleEffect>);
+    const b = createGrayscaleEffect({ enabled: true } as Partial<GrayscaleEffect>);
+    const out = createGrayscaleEffect();
+    lerpRenderEffect(a, b, 0.4, out);
+    expect((out as unknown as Record<string, unknown>).enabled).toBe(false);
+    lerpRenderEffect(a, b, 0.5, out);
+    expect((out as unknown as Record<string, unknown>).enabled).toBe(true);
+  });
+});

package/src/renderEffectValidation.test.ts

@@ -0,0 +1,37 @@
+import { createBloomEffect } from './bloomEffect';
+import { createColorGradeEffect } from './colorGradeEffect';
+import { validateRenderEffectList } from './renderEffectValidation';
+import { createSsaoEffect } from './ssaoEffect';
+import { createToneMapEffect } from './toneMapEffect';
+
+describe('validateRenderEffectList', () => {
+  it('returns null when all required inputs are available', () => {
+    const effects = [createBloomEffect(), createSsaoEffect()];
+    expect(validateRenderEffectList(effects, ['Hdr', 'Depth'])).toBeNull();
+  });
+
+  it('returns null for effects that need only the color buffer', () => {
+    const effects = [createColorGradeEffect()];
+    expect(validateRenderEffectList(effects, [])).toBeNull();
+  });
+
+  it('returns the missing input when Hdr is required but unavailable', () => {
+    const effects = [createToneMapEffect()];
+    expect(validateRenderEffectList(effects, [])).toBe('Hdr');
+  });
+
+  it('returns the missing input when Depth is required but unavailable', () => {
+    const effects = [createSsaoEffect()];
+    expect(validateRenderEffectList(effects, ['Hdr'])).toBe('Depth');
+  });
+
+  it('returns null for an empty effect list', () => {
+    expect(validateRenderEffectList([], [])).toBeNull();
+  });
+
+  it('returns the first missing input in order', () => {
+    const effects = [createBloomEffect(), createSsaoEffect()];
+    // Only Hdr available — Bloom ok, Ssao fails.
+    expect(validateRenderEffectList(effects, ['Hdr'])).toBe('Depth');
+  });
+});

package/src/scanlinesEffect.test.ts

@@ -0,0 +1,11 @@
+import { createScanlinesEffect } from './scanlinesEffect';
+
+describe('createScanlinesEffect', () => {
+  it('tags the intent type', () => {
+    expect(createScanlinesEffect().kind).toBe('ScanlinesEffect');
+  });
+
+  it('carries options', () => {
+    expect(createScanlinesEffect({ count: 240, intensity: 0.4 })).toMatchObject({ count: 240, intensity: 0.4 });
+  });
+});

package/src/screenSpaceFogEffect.test.ts

@@ -0,0 +1,14 @@
+import { createScreenSpaceFogEffect } from './screenSpaceFogEffect';
+
+describe('createScreenSpaceFogEffect', () => {
+  it('tags the intent type', () => {
+    expect(createScreenSpaceFogEffect().kind).toBe('ScreenSpaceFogEffect');
+  });
+
+  it('carries options', () => {
+    expect(createScreenSpaceFogEffect({ color: 0xaabbccff, density: 0.4 })).toMatchObject({
+      color: 0xaabbccff,
+      density: 0.4,
+    });
+  });
+});

package/src/sepiaEffect.test.ts

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

package/src/sharpenEffect.test.ts

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

package/src/sketchEffect.test.ts

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

package/src/smaaEffect.test.ts

@@ -0,0 +1,11 @@
+import { createSmaaEffect } from './smaaEffect';
+
+describe('createSmaaEffect', () => {
+  it('tags the intent type', () => {
+    expect(createSmaaEffect().kind).toBe('SmaaEffect');
+  });
+
+  it('carries options', () => {
+    expect(createSmaaEffect({ threshold: 0.1 })).toMatchObject({ threshold: 0.1 });
+  });
+});

package/src/ssaoEffect.test.ts

@@ -0,0 +1,11 @@
+import { createSsaoEffect } from './ssaoEffect';
+
+describe('createSsaoEffect', () => {
+  it('tags the intent type', () => {
+    expect(createSsaoEffect().kind).toBe('SsaoEffect');
+  });
+
+  it('carries options', () => {
+    expect(createSsaoEffect({ radius: 4, intensity: 1.5 })).toMatchObject({ radius: 4, intensity: 1.5 });
+  });
+});

package/src/ssrEffect.test.ts

@@ -0,0 +1,11 @@
+import { createSsrEffect } from './ssrEffect';
+
+describe('createSsrEffect', () => {
+  it('tags the intent type', () => {
+    expect(createSsrEffect().kind).toBe('SsrEffect');
+  });
+
+  it('carries options', () => {
+    expect(createSsrEffect({ maxDistance: 10, steps: 32 })).toMatchObject({ maxDistance: 10, steps: 32 });
+  });
+});

package/src/stylizeMath.test.ts

@@ -0,0 +1,99 @@
+import {
+  computeCrtMaskParams,
+  computeHalftoneCellParams,
+  computeScanlineParams,
+  createBayerMatrix,
+} from './stylizeMath';
+
+describe('computeCrtMaskParams', () => {
+  it('writes two values', () => {
+    const out: [number, number] = [0, 0];
+    computeCrtMaskParams(720, 0.5, out);
+    expect(typeof out[0]).toBe('number');
+    expect(typeof out[1]).toBe('number');
+  });
+  it('higher resolution produces larger mask scale', () => {
+    const out1: [number, number] = [0, 0];
+    const out2: [number, number] = [0, 0];
+    computeCrtMaskParams(360, 0, out1);
+    computeCrtMaskParams(720, 0, out2);
+    expect(out2[0]).toBeGreaterThan(out1[0]);
+  });
+  it('curvature is clamped to [0, 0.1]', () => {
+    const out: [number, number] = [0, 0];
+    computeCrtMaskParams(360, 2, out);
+    expect(out[1]).toBeCloseTo(0.1, 5);
+  });
+});
+
+describe('computeHalftoneCellParams', () => {
+  it('writes cellSize, cosAngle, sinAngle', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeHalftoneCellParams(1 / 8, Math.PI / 4, out);
+    expect(out[0]).toBeCloseTo(8, 4);
+    expect(out[1]).toBeCloseTo(Math.SQRT1_2, 4);
+    expect(out[2]).toBeCloseTo(Math.SQRT1_2, 4);
+  });
+  it('0 angle produces cos=1, sin=0', () => {
+    const out: [number, number, number] = [0, 0, 0];
+    computeHalftoneCellParams(1 / 4, 0, out);
+    expect(out[1]).toBeCloseTo(1, 5);
+    expect(out[2]).toBeCloseTo(0, 5);
+  });
+});
+
+describe('computeScanlineParams', () => {
+  it('writes scale and intensity', () => {
+    const out: [number, number] = [0, 0];
+    computeScanlineParams(480, 0.5, out);
+    expect(out[0]).toBeCloseTo(1, 4);
+    expect(out[1]).toBeCloseTo(0.5, 4);
+  });
+  it('clamps intensity to [0, 1]', () => {
+    const out: [number, number] = [0, 0];
+    computeScanlineParams(480, 2, out);
+    expect(out[1]).toBeCloseTo(1, 5);
+  });
+});
+
+describe('createBayerMatrix', () => {
+  it('returns size 2 for order 1', () => {
+    const out = new Float32Array(4);
+    const size = createBayerMatrix(1, out);
+    expect(size).toBe(2);
+  });
+  it('returns size 4 for order 2', () => {
+    const out = new Float32Array(16);
+    const size = createBayerMatrix(2, out);
+    expect(size).toBe(4);
+  });
+  it('all values are in [0, 1)', () => {
+    const out = new Float32Array(16);
+    const size = createBayerMatrix(2, out);
+    for (let i = 0; i < size * size; i++) {
+      expect(out[i]).toBeGreaterThanOrEqual(0);
+      expect(out[i]).toBeLessThan(1);
+    }
+  });
+  it('all values in 2x2 matrix are unique', () => {
+    const out = new Float32Array(4);
+    createBayerMatrix(1, out);
+    const unique = new Set(Array.from(out));
+    expect(unique.size).toBe(4);
+  });
+  it('all values in 4x4 matrix are unique', () => {
+    const out = new Float32Array(16);
+    createBayerMatrix(2, out);
+    const unique = new Set(Array.from(out));
+    expect(unique.size).toBe(16);
+  });
+  it('is deterministic', () => {
+    const out1 = new Float32Array(16);
+    const out2 = new Float32Array(16);
+    createBayerMatrix(2, out1);
+    createBayerMatrix(2, out2);
+    for (let i = 0; i < 16; i++) {
+      expect(out1[i]).toBeCloseTo(out2[i], 5);
+    }
+  });
+});

package/src/taaEffect.test.ts

@@ -0,0 +1,11 @@
+import { createTaaEffect } from './taaEffect';
+
+describe('createTaaEffect', () => {
+  it('tags the intent type', () => {
+    expect(createTaaEffect().kind).toBe('TaaEffect');
+  });
+
+  it('carries options', () => {
+    expect(createTaaEffect({ feedback: 0.9 })).toMatchObject({ feedback: 0.9 });
+  });
+});

package/src/tiltShiftEffect.test.ts

@@ -0,0 +1,15 @@
+import { createTiltShiftEffect } from './tiltShiftEffect';
+
+describe('createTiltShiftEffect', () => {
+  it('tags the intent type', () => {
+    expect(createTiltShiftEffect().kind).toBe('TiltShiftEffect');
+  });
+
+  it('carries options', () => {
+    expect(createTiltShiftEffect({ center: 0.5, width: 0.2, blur: 4 })).toMatchObject({
+      center: 0.5,
+      width: 0.2,
+      blur: 4,
+    });
+  });
+});

package/src/toneMapEffect.test.ts

@@ -0,0 +1,7 @@
+import { createToneMapEffect } from './toneMapEffect';
+
+describe('createToneMapEffect', () => {
+  it('tags the intent type and operator', () => {
+    expect(createToneMapEffect({ operator: 'aces' })).toMatchObject({ kind: 'ToneMapEffect', operator: 'aces' });
+  });
+});

package/src/toneMapMath.test.ts

@@ -0,0 +1,145 @@
+import {
+  computeAcesToneMap,
+  computeAgxToneMap,
+  computeExposureScale,
+  computeFilmicToneMap,
+  computeReinhardExtendedToneMap,
+  computeReinhardToneMap,
+  computeUncharted2ToneMap,
+  getAcesInputMatrix,
+  getAcesOutputMatrix,
+} from './toneMapMath';
+
+describe('computeAcesToneMap', () => {
+  it('maps 0 to approximately 0', () => {
+    expect(computeAcesToneMap(0)).toBeCloseTo(0, 2);
+  });
+  it('output is clamped to [0, 1]', () => {
+    expect(computeAcesToneMap(100)).toBeLessThanOrEqual(1);
+    expect(computeAcesToneMap(-1)).toBeGreaterThanOrEqual(0);
+  });
+  it('x=1 returns a known reference value', () => {
+    // At x=1: (2.51 + 0.03) / (2.43 + 0.59 + 0.14) ≈ 0.8016
+    const v = computeAcesToneMap(1);
+    expect(v).toBeGreaterThan(0.7);
+    expect(v).toBeLessThan(0.9);
+  });
+});
+
+describe('computeAgxToneMap', () => {
+  it('output is in [0, 1] range', () => {
+    expect(computeAgxToneMap(0.5)).toBeGreaterThanOrEqual(0);
+    expect(computeAgxToneMap(0.5)).toBeLessThanOrEqual(1);
+    expect(computeAgxToneMap(100)).toBeLessThanOrEqual(1.1); // allow slight overshoot on sigmoid endpoints
+  });
+  it('increases monotonically in the normal range', () => {
+    expect(computeAgxToneMap(1)).toBeGreaterThan(computeAgxToneMap(0.5));
+  });
+  it('matches default when options is undefined', () => {
+    expect(computeAgxToneMap(0.5)).toBeCloseTo(computeAgxToneMap(0.5, undefined), 10);
+    expect(computeAgxToneMap(0.5)).toBeCloseTo(computeAgxToneMap(0.5, {}), 10);
+  });
+  it('custom EV range shifts the output', () => {
+    const defaultVal = computeAgxToneMap(0.5);
+    const narrow = computeAgxToneMap(0.5, { minEv: -6, maxEv: 2 });
+    expect(narrow).not.toBeCloseTo(defaultVal, 2);
+  });
+});
+
+describe('computeExposureScale', () => {
+  it('EV=0 returns 1', () => {
+    expect(computeExposureScale(0)).toBeCloseTo(1, 5);
+  });
+  it('EV=1 doubles brightness', () => {
+    expect(computeExposureScale(1)).toBeCloseTo(2, 5);
+  });
+  it('EV=-1 halves brightness', () => {
+    expect(computeExposureScale(-1)).toBeCloseTo(0.5, 5);
+  });
+});
+
+describe('computeFilmicToneMap', () => {
+  it('output is non-negative for non-negative input', () => {
+    expect(computeFilmicToneMap(0)).toBeGreaterThanOrEqual(0);
+    expect(computeFilmicToneMap(1)).toBeGreaterThanOrEqual(0);
+  });
+  it('output increases with input in the linear range', () => {
+    expect(computeFilmicToneMap(0.5)).toBeGreaterThan(computeFilmicToneMap(0.1));
+  });
+  it('matches default when options is undefined', () => {
+    expect(computeFilmicToneMap(0.5)).toBeCloseTo(computeFilmicToneMap(0.5, undefined), 10);
+    expect(computeFilmicToneMap(0.5)).toBeCloseTo(computeFilmicToneMap(0.5, {}), 10);
+  });
+  it('higher contrast steepens the curve', () => {
+    const defaultVal = computeFilmicToneMap(0.5);
+    const highContrast = computeFilmicToneMap(0.5, { contrast: 2.0 });
+    expect(highContrast).not.toBeCloseTo(defaultVal, 2);
+  });
+  it('pedestal lifts the black level', () => {
+    const noPedestal = computeFilmicToneMap(0.01);
+    const withPedestal = computeFilmicToneMap(0.01, { pedestal: 0.05 });
+    expect(withPedestal).toBeGreaterThan(noPedestal);
+  });
+});
+
+describe('computeReinhardExtendedToneMap', () => {
+  it('maps 0 to 0', () => {
+    expect(computeReinhardExtendedToneMap(0, 10)).toBeCloseTo(0, 5);
+  });
+  it('at white point x==w output is 1', () => {
+    expect(computeReinhardExtendedToneMap(10, 10)).toBeCloseTo(1, 4);
+  });
+});
+
+describe('computeReinhardToneMap', () => {
+  it('maps 0 to 0', () => {
+    expect(computeReinhardToneMap(0)).toBeCloseTo(0, 5);
+  });
+  it('output is always < 1 for positive input', () => {
+    expect(computeReinhardToneMap(1)).toBeLessThan(1);
+    expect(computeReinhardToneMap(100)).toBeLessThan(1);
+  });
+  it('x=1 maps to 0.5', () => {
+    expect(computeReinhardToneMap(1)).toBeCloseTo(0.5, 5);
+  });
+});
+
+describe('computeUncharted2ToneMap', () => {
+  it('output at x=0 is near 0', () => {
+    expect(Math.abs(computeUncharted2ToneMap(0))).toBeLessThan(0.1);
+  });
+  it('output increases with input', () => {
+    expect(computeUncharted2ToneMap(2)).toBeGreaterThan(computeUncharted2ToneMap(1));
+  });
+});
+
+describe('getAcesInputMatrix', () => {
+  it('writes 9 values', () => {
+    const out = new Float32Array(9);
+    getAcesInputMatrix(out);
+    let sum = 0;
+    for (let i = 0; i < 9; i++) {
+      sum += out[i];
+    }
+    expect(sum).toBeGreaterThan(0);
+  });
+  it('diagonal values are largest in each column', () => {
+    const out = new Float32Array(9);
+    getAcesInputMatrix(out);
+    // Column 0: out[0] > out[1], out[0] > out[2]
+    expect(out[0]).toBeGreaterThan(out[1]);
+    expect(out[0]).toBeGreaterThan(out[2]);
+  });
+});
+
+describe('getAcesOutputMatrix', () => {
+  it('writes 9 values', () => {
+    const out = new Float32Array(9);
+    getAcesOutputMatrix(out);
+    let hasNonZero = false;
+    for (let i = 0; i < 9; i++) {
+      if (out[i] !== 0) hasNonZero = true;
+    }
+    expect(hasNonZero).toBe(true);
+  });
+});

package/src/vignetteEffect.test.ts

@@ -0,0 +1,16 @@
+import { createVignetteEffect } from './vignetteEffect';
+
+describe('createVignetteEffect', () => {
+  it('tags the intent type', () => {
+    expect(createVignetteEffect().kind).toBe('VignetteEffect');
+  });
+
+  it('carries options', () => {
+    expect(createVignetteEffect({ intensity: 1, radius: 0.7, softness: 0.4, color: 0x000000ff })).toMatchObject({
+      intensity: 1,
+      radius: 0.7,
+      softness: 0.4,
+      color: 0x000000ff,
+    });
+  });
+});