@flighthq/effects 0.1.0 → 0.2.1-next.410.a23f189

package/dist/bevelEffect.d.ts

@@ -0,0 +1,3 @@
+import type { BevelEffect } from '@flighthq/types';
+export declare function createBevelEffect(options?: Readonly<Omit<BevelEffect, 'kind'>>): BevelEffect;
+//# sourceMappingURL=bevelEffect.d.ts.map

package/dist/bevelEffect.d.ts.map

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

package/dist/bevelEffect.js

@@ -0,0 +1,5 @@
+// Bevel composite effect: the directional gradient of the blurred silhouette drives a highlight/shadow edge band, clipped by bevelType, then applies sourceMode compositing.
+export function createBevelEffect(options = {}) {
+    return { kind: 'BevelEffect', ...options };
+}
+//# sourceMappingURL=bevelEffect.js.map

package/dist/bevelEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bevelEffect.js","sourceRoot":"","sources":["../src/bevelEffect.ts"],"names":[],"mappings":"AAEA,6KAA6K;AAC7K,MAAM,UAAU,iBAAiB,CAAC,UAA+C,EAAE;IACjF,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,OAAO,EAAE,CAAC;AAC7C,CAAC"}

package/dist/blendEffect.d.ts

@@ -0,0 +1,3 @@
+import type { AdvancedBlendMode, BlendEffect } from '@flighthq/types';
+export declare function createBlendEffect(mode: AdvancedBlendMode, options?: Readonly<Omit<BlendEffect, 'kind' | 'mode'>>): BlendEffect;
+//# sourceMappingURL=blendEffect.d.ts.map

package/dist/blendEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendEffect.d.ts","sourceRoot":"","sources":["../src/blendEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAQtE,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,EACvB,OAAO,GAAE,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC,CAAM,GACzD,WAAW,CAEb"}

package/dist/blendEffect.js

@@ -0,0 +1,10 @@
+// Advanced-blend composite effect: blends the incoming pipeline layer over a registered backdrop using
+// a destination-reading / non-separable mode (the AdvancedBlendMode vocabulary the fixed-function
+// BlendMode enum deliberately excludes). `mode` is required; `backdropKey` names the per-state backdrop
+// texture the backend samples (registerGlBlendEffectBackdrop), and `opacity` scales the layer's
+// contribution 0..1 (default 1). The backend bounces this through an offscreen and samples layer +
+// backdrop — it is an effect you apply explicitly, not a cheap node property.
+export function createBlendEffect(mode, options = {}) {
+    return { kind: 'BlendEffect', mode, ...options };
+}
+//# sourceMappingURL=blendEffect.js.map

package/dist/blendEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendEffect.js","sourceRoot":"","sources":["../src/blendEffect.ts"],"names":[],"mappings":"AAEA,uGAAuG;AACvG,kGAAkG;AAClG,wGAAwG;AACxG,gGAAgG;AAChG,mGAAmG;AACnG,8EAA8E;AAC9E,MAAM,UAAU,iBAAiB,CAC/B,IAAuB,EACvB,UAAwD,EAAE;IAE1D,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC;AACnD,CAAC"}

package/dist/blendModeMath.d.ts

@@ -0,0 +1,6 @@
+import { AdvancedBlendMode } from '@flighthq/types';
+export declare function blendNonSeparableRgb(mode: AdvancedBlendMode, cbR: number, cbG: number, cbB: number, csR: number, csG: number, csB: number, out: [number, number, number] | Float32Array | number[]): void;
+export declare function getAdvancedBlendRgb(mode: AdvancedBlendMode, cbR: number, cbG: number, cbB: number, csR: number, csG: number, csB: number, out: [number, number, number] | Float32Array | number[]): void;
+export declare function getSeparableBlendChannel(mode: AdvancedBlendMode, cb: number, cs: number): number;
+export declare function isNonSeparableBlendMode(mode: AdvancedBlendMode): boolean;
+//# sourceMappingURL=blendModeMath.d.ts.map

package/dist/blendModeMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendModeMath.d.ts","sourceRoot":"","sources":["../src/blendModeMath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAiBpD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,GAAG,MAAM,EAAE,GACtD,IAAI,CAgCN;AAKD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,GAAG,MAAM,EAAE,GACtD,IAAI,CAWN;AAID,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CA4BhG;AAID,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAOxE"}

package/dist/blendModeMath.js

@@ -0,0 +1,172 @@
+import { AdvancedBlendMode } from '@flighthq/types';
+// Pure blend-mode math — the substrate-agnostic ground truth the GL (and any future) backend shaders
+// mirror, so the composite-recipe fragment source can be verified against plain numbers. All values are
+// normalized 0..1 (backdrop `cb`, source `cs`). The formulas follow the W3C Compositing and Blending
+// spec: the seven separable modes blend each channel independently (getSeparableBlendChannel); the four
+// non-separable HSL modes blend a whole RGB triple by transplanting one HSL attribute
+// (blendNonSeparableRgb). getAdvancedBlendRgb dispatches either path by mode, writing into `out`.
+//
+// This is the blend function B(cb, cs) alone — the caller composites B into the final pixel with the
+// backdrop/source alphas (Porter-Duff source-over of the blended color), which is a separate step the
+// backend's alpha compositing performs. Unknown modes fall through to Normal (the source color).
+// The four non-separable HSL blend modes on 0..1 RGB, following the W3C spec's Hue/Sat/Color/Lum
+// primitives (Lum via a luminosity-preserving clip, Sat via setSat on sorted channels). Writes the
+// blended triple into `out[0..2]`. Alias-safe: reads all inputs before writing `out`. Unknown modes
+// fall through to the source triple (Normal).
+export function blendNonSeparableRgb(mode, cbR, cbG, cbB, csR, csG, csB, out) {
+    let r;
+    let g;
+    let b;
+    switch (mode) {
+        case AdvancedBlendMode.Hue:
+            // Source hue, backdrop saturation, backdrop luminosity.
+            [r, g, b] = setBlendSaturation(csR, csG, csB, blendSaturation(cbR, cbG, cbB));
+            [r, g, b] = setBlendLuminosity(r, g, b, blendLuminosity(cbR, cbG, cbB));
+            break;
+        case AdvancedBlendMode.Saturation:
+            // Backdrop hue, source saturation, backdrop luminosity.
+            [r, g, b] = setBlendSaturation(cbR, cbG, cbB, blendSaturation(csR, csG, csB));
+            [r, g, b] = setBlendLuminosity(r, g, b, blendLuminosity(cbR, cbG, cbB));
+            break;
+        case AdvancedBlendMode.Color:
+            // Source hue + saturation, backdrop luminosity.
+            [r, g, b] = setBlendLuminosity(csR, csG, csB, blendLuminosity(cbR, cbG, cbB));
+            break;
+        case AdvancedBlendMode.Luminosity:
+            // Backdrop hue + saturation, source luminosity.
+            [r, g, b] = setBlendLuminosity(cbR, cbG, cbB, blendLuminosity(csR, csG, csB));
+            break;
+        default:
+            r = csR;
+            g = csG;
+            b = csB;
+            break;
+    }
+    out[0] = r;
+    out[1] = g;
+    out[2] = b;
+}
+// Dispatches the advanced blend for a whole RGB triple, writing the blended (pre-alpha-composite) color
+// into `out[0..2]`. Separable modes reduce to three getSeparableBlendChannel calls; the HSL modes route
+// to blendNonSeparableRgb. Alias-safe: reads all six inputs before writing `out`.
+export function getAdvancedBlendRgb(mode, cbR, cbG, cbB, csR, csG, csB, out) {
+    if (isNonSeparableBlendMode(mode)) {
+        blendNonSeparableRgb(mode, cbR, cbG, cbB, csR, csG, csB, out);
+        return;
+    }
+    const r = getSeparableBlendChannel(mode, cbR, csR);
+    const g = getSeparableBlendChannel(mode, cbG, csG);
+    const b = getSeparableBlendChannel(mode, cbB, csB);
+    out[0] = r;
+    out[1] = g;
+    out[2] = b;
+}
+// Separable per-channel blend on 0..1 values (backdrop `cb`, source `cs`). Covers the seven separable
+// AdvancedBlendMode members; any non-separable or unknown mode returns the source channel (Normal).
+export function getSeparableBlendChannel(mode, cb, cs) {
+    switch (mode) {
+        case AdvancedBlendMode.Overlay:
+            // Overlay = HardLight with operands swapped: hard-light the backdrop by the source.
+            return cb <= 0.5 ? 2 * cb * cs : 1 - 2 * (1 - cb) * (1 - cs);
+        case AdvancedBlendMode.HardLight:
+            return cs <= 0.5 ? 2 * cb * cs : 1 - 2 * (1 - cb) * (1 - cs);
+        case AdvancedBlendMode.SoftLight: {
+            const d = cb <= 0.25 ? ((16 * cb - 12) * cb + 4) * cb : Math.sqrt(cb);
+            return cs <= 0.5 ? cb - (1 - 2 * cs) * cb * (1 - cb) : cb + (2 * cs - 1) * (d - cb);
+        }
+        case AdvancedBlendMode.Difference:
+            return Math.abs(cb - cs);
+        case AdvancedBlendMode.Exclusion:
+            return cb + cs - 2 * cb * cs;
+        case AdvancedBlendMode.ColorDodge:
+            // W3C: 0→0, source==1→1, else min(1, backdrop / (1 - source)).
+            if (cb <= 0)
+                return 0;
+            if (cs >= 1)
+                return 1;
+            return Math.min(1, cb / (1 - cs));
+        case AdvancedBlendMode.ColorBurn:
+            // W3C: 1→1, source==0→0, else 1 - min(1, (1 - backdrop) / source).
+            if (cb >= 1)
+                return 1;
+            if (cs <= 0)
+                return 0;
+            return 1 - Math.min(1, (1 - cb) / cs);
+        default:
+            return cs;
+    }
+}
+// True for the four non-separable HSL blend modes (Hue/Saturation/Color/Luminosity), which cannot be
+// computed per channel because they transplant a whole HSL attribute from one triple to the other.
+export function isNonSeparableBlendMode(mode) {
+    return (mode === AdvancedBlendMode.Hue ||
+        mode === AdvancedBlendMode.Saturation ||
+        mode === AdvancedBlendMode.Color ||
+        mode === AdvancedBlendMode.Luminosity);
+}
+// W3C lum(): the Rec.601 luma of an RGB triple.
+function blendLuminosity(r, g, b) {
+    return 0.3 * r + 0.59 * g + 0.11 * b;
+}
+// W3C sat(): the chroma range (max - min) of an RGB triple.
+function blendSaturation(r, g, b) {
+    return Math.max(r, g, b) - Math.min(r, g, b);
+}
+// W3C ClipColor(): pull any out-of-gamut channel back toward the color's luminosity so the result stays
+// in 0..1 without shifting perceived brightness.
+function clipBlendColor(r, g, b) {
+    const l = blendLuminosity(r, g, b);
+    const min = Math.min(r, g, b);
+    const max = Math.max(r, g, b);
+    let cr = r;
+    let cg = g;
+    let cb = b;
+    if (min < 0) {
+        const denom = l - min;
+        cr = l + ((cr - l) * l) / denom;
+        cg = l + ((cg - l) * l) / denom;
+        cb = l + ((cb - l) * l) / denom;
+    }
+    if (max > 1) {
+        const denom = max - l;
+        cr = l + ((cr - l) * (1 - l)) / denom;
+        cg = l + ((cg - l) * (1 - l)) / denom;
+        cb = l + ((cb - l) * (1 - l)) / denom;
+    }
+    return [cr, cg, cb];
+}
+// W3C SetLum(): shift an RGB triple to the target luminosity, then clip back into gamut.
+function setBlendLuminosity(r, g, b, target) {
+    const d = target - blendLuminosity(r, g, b);
+    return clipBlendColor(r + d, g + d, b + d);
+}
+// W3C SetSat(): rescale an RGB triple's mid/max channels to the target saturation while pinning its
+// minimum to black, preserving hue. Operates by resolving the sorted (min, mid, max) positions.
+function setBlendSaturation(r, g, b, target) {
+    const out = [r, g, b];
+    // Indices of the min / mid / max channels.
+    let iMin = 0;
+    let iMax = 0;
+    for (let i = 1; i < 3; i++) {
+        if (out[i] < out[iMin])
+            iMin = i;
+        if (out[i] > out[iMax])
+            iMax = i;
+    }
+    if (iMin === iMax) {
+        // All channels equal after a degenerate sort — pick a distinct mid deterministically.
+        iMax = (iMin + 1) % 3;
+    }
+    const iMid = 3 - iMin - iMax;
+    if (out[iMax] > out[iMin]) {
+        out[iMid] = ((out[iMid] - out[iMin]) * target) / (out[iMax] - out[iMin]);
+        out[iMax] = target;
+    }
+    else {
+        out[iMid] = 0;
+        out[iMax] = 0;
+    }
+    out[iMin] = 0;
+    return out;
+}
+//# sourceMappingURL=blendModeMath.js.map

package/dist/blendModeMath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendModeMath.js","sourceRoot":"","sources":["../src/blendModeMath.ts"],"names":[],"mappings":"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"}

package/dist/blurDownsample.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the power-of-two downsample level to apply before blurring with standard deviation
+ * `sigma`, following Skia's scale-then-blur strategy: large blurs are cheaper if the source is first
+ * halved in each dimension `level` times and blurred with a proportionally smaller residual sigma.
+ * The level is the smallest non-negative integer such that `sigma / 2^level` falls at or below
+ * `BLUR_DOWNSAMPLE_MAX_SIGMA`, i.e. `ceil(log2(sigma / max))` clamped to `>= 0`. Blurs at or below
+ * that threshold run at full resolution (level 0). `sigma <= 0` returns 0.
+ */
+export declare function getBlurDownsampleLevel(sigma: number): number;
+/**
+ * Returns the residual standard deviation to blur with after downsampling by `level` power-of-two
+ * steps: `sigma / 2^level`. Blurring a `2^level`-times-downsampled image with this residual sigma
+ * reproduces a full-resolution blur of `sigma`, because a blur at half resolution covers twice the
+ * distance in source space. `sigma <= 0` returns 0.
+ */
+export declare function getBlurResidualSigma(sigma: number, level: number): number;
+//# sourceMappingURL=blurDownsample.d.ts.map

package/dist/blurDownsample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blurDownsample.d.ts","sourceRoot":"","sources":["../src/blurDownsample.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGzE"}

package/dist/blurDownsample.js

@@ -0,0 +1,35 @@
+// Scale-then-blur downsample selection for large blurs. Substrate-agnostic recipe math.
+//
+// Copied verbatim from filters-math during the filters→effects migration — effects is the
+// canonical home for the spatial-effect blur math (effect-adjustment-architecture.md, migration
+// step 4). filters-math keeps its copy until the filters* packages retire; the duplicate is
+// deliberate for the duration (mirrors the Phase 1 colorMatrixMath port).
+/**
+ * Returns the power-of-two downsample level to apply before blurring with standard deviation
+ * `sigma`, following Skia's scale-then-blur strategy: large blurs are cheaper if the source is first
+ * halved in each dimension `level` times and blurred with a proportionally smaller residual sigma.
+ * The level is the smallest non-negative integer such that `sigma / 2^level` falls at or below
+ * `BLUR_DOWNSAMPLE_MAX_SIGMA`, i.e. `ceil(log2(sigma / max))` clamped to `>= 0`. Blurs at or below
+ * that threshold run at full resolution (level 0). `sigma <= 0` returns 0.
+ */
+export function getBlurDownsampleLevel(sigma) {
+    if (sigma <= BLUR_DOWNSAMPLE_MAX_SIGMA)
+        return 0;
+    return Math.ceil(Math.log2(sigma / BLUR_DOWNSAMPLE_MAX_SIGMA));
+}
+/**
+ * Returns the residual standard deviation to blur with after downsampling by `level` power-of-two
+ * steps: `sigma / 2^level`. Blurring a `2^level`-times-downsampled image with this residual sigma
+ * reproduces a full-resolution blur of `sigma`, because a blur at half resolution covers twice the
+ * distance in source space. `sigma <= 0` returns 0.
+ */
+export function getBlurResidualSigma(sigma, level) {
+    if (sigma <= 0)
+        return 0;
+    return sigma / 2 ** level;
+}
+// The largest residual sigma a downsample level is allowed to leave. Matches Skia's GPU blur cap:
+// beyond ~4 the box/Gaussian passes gain little accuracy per pixel touched, so halving resolution
+// and blurring the smaller image is the better trade.
+const BLUR_DOWNSAMPLE_MAX_SIGMA = 4;
+//# sourceMappingURL=blurDownsample.js.map

package/dist/blurDownsample.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blurDownsample.js","sourceRoot":"","sources":["../src/blurDownsample.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,EAAE;AACF,0FAA0F;AAC1F,gGAAgG;AAChG,4FAA4F;AAC5F,0EAA0E;AAE1E;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAa;IAClD,IAAI,KAAK,IAAI,yBAAyB;QAAE,OAAO,CAAC,CAAC;IACjD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,yBAAyB,CAAC,CAAC,CAAC;AACjE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAa,EAAE,KAAa;IAC/D,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACzB,OAAO,KAAK,GAAG,CAAC,IAAI,KAAK,CAAC;AAC5B,CAAC;AAED,kGAAkG;AAClG,kGAAkG;AAClG,sDAAsD;AACtD,MAAM,yBAAyB,GAAG,CAAC,CAAC"}

package/dist/blurEffect.d.ts

@@ -0,0 +1,3 @@
+import type { BlurEffect } from '@flighthq/types';
+export declare function createBlurEffect(options?: Readonly<Omit<BlurEffect, 'kind'>>): BlurEffect;
+//# sourceMappingURL=blurEffect.d.ts.map

package/dist/blurEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blurEffect.d.ts","sourceRoot":"","sources":["../src/blurEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAKlD,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAM,GAAG,UAAU,CAE7F"}

package/dist/blurEffect.js

@@ -0,0 +1,7 @@
+// Plain separable Gaussian blur intent. `blurX`/`blurY` are the per-axis Gaussian standard deviations
+// in pixels; the backends realize them as a two-pass separable blur bouncing through an offscreen
+// target. The spatial-effect sibling of the directional/radial/motion blur variants.
+export function createBlurEffect(options = {}) {
+    return { kind: 'BlurEffect', ...options };
+}
+//# sourceMappingURL=blurEffect.js.map

package/dist/blurEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blurEffect.js","sourceRoot":"","sources":["../src/blurEffect.ts"],"names":[],"mappings":"AAEA,sGAAsG;AACtG,kGAAkG;AAClG,qFAAqF;AACrF,MAAM,UAAU,gBAAgB,CAAC,UAA8C,EAAE;IAC/E,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,OAAO,EAAE,CAAC;AAC5C,CAAC"}

package/dist/boxBlurMath.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Returns the box-blur radius for pass `pass` of `passes`, using two adjacent
+ * odd box widths so the combined variance tracks a Gaussian of standard
+ * deviation `sigma`. The lower passes use the smaller width and the remaining
+ * passes use the next odd width up; this avoids the overshoot that repeating a
+ * single rounded radius `passes` times accumulates. Radii are non-decreasing in
+ * `pass`. Use this for backends that can vary the radius per pass (such as the
+ * Gl separable passes); `computeBoxBlurRadius` covers backends that apply one
+ * uniform radius across every pass.
+ */
+export declare function computeBoxBlurPassRadius(sigma: number, passes: number, pass: number): number;
+/**
+ * Converts sigma to the single box-blur radius whose repeated application
+ * (`passes` times) has the same variance as a Gaussian with standard deviation
+ * `sigma`. Use this for backends that apply one uniform radius across every
+ * pass; for backends that can vary the radius per pass, `computeBoxBlurPassRadius`
+ * tracks `sigma` more closely.
+ */
+export declare function computeBoxBlurRadius(sigma: number, passes: number): number;
+/**
+ * Converts a box-blur radius to the approximate Gaussian sigma that a single-pass box blur of
+ * that radius corresponds to. Inverse of the `computeBoxBlurRadius` uniform-pass formula:
+ * sigma = sqrt(passes * (2*radius + 1)^2 / 12). Useful for the reverse mapping (e.g. to feed a
+ * sigma-based backend from a Flash `blurX` value).
+ */
+export declare function computeGaussianSigmaForBlurRadius(radius: number, passes: number): number;
+//# sourceMappingURL=boxBlurMath.d.ts.map

package/dist/boxBlurMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxBlurMath.d.ts","sourceRoot":"","sources":["../src/boxBlurMath.ts"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAM5F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAG1E;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAIxF"}

package/dist/boxBlurMath.js

@@ -0,0 +1,64 @@
+// Box-blur radius/sigma recipe math. Substrate-agnostic: every backend derives identical box-blur
+// pass radii from the same sigma so the GL, WGPU, and CPU spreads match.
+//
+// Copied verbatim from filters-math during the filters→effects migration — effects is the
+// canonical home for the spatial-effect blur math (effect-adjustment-architecture.md, migration
+// step 4). filters-math keeps its copy until the filters* packages retire; the duplicate is
+// deliberate for the duration (mirrors the Phase 1 colorMatrixMath port).
+/**
+ * Returns the box-blur radius for pass `pass` of `passes`, using two adjacent
+ * odd box widths so the combined variance tracks a Gaussian of standard
+ * deviation `sigma`. The lower passes use the smaller width and the remaining
+ * passes use the next odd width up; this avoids the overshoot that repeating a
+ * single rounded radius `passes` times accumulates. Radii are non-decreasing in
+ * `pass`. Use this for backends that can vary the radius per pass (such as the
+ * Gl separable passes); `computeBoxBlurRadius` covers backends that apply one
+ * uniform radius across every pass.
+ */
+export function computeBoxBlurPassRadius(sigma, passes, pass) {
+    if (sigma <= 0)
+        return 0;
+    const lowerWidth = computeBoxBlurLowerWidth(sigma, passes);
+    const lowerCount = computeBoxBlurLowerPassCount(sigma, passes, lowerWidth);
+    const width = pass < lowerCount ? lowerWidth : lowerWidth + 2;
+    return Math.max(0, (width - 1) / 2);
+}
+/**
+ * Converts sigma to the single box-blur radius whose repeated application
+ * (`passes` times) has the same variance as a Gaussian with standard deviation
+ * `sigma`. Use this for backends that apply one uniform radius across every
+ * pass; for backends that can vary the radius per pass, `computeBoxBlurPassRadius`
+ * tracks `sigma` more closely.
+ */
+export function computeBoxBlurRadius(sigma, passes) {
+    if (sigma <= 0)
+        return 0;
+    return Math.max(0, Math.round((-1 + Math.sqrt(1 + (12 * sigma * sigma) / passes)) / 2));
+}
+/**
+ * Converts a box-blur radius to the approximate Gaussian sigma that a single-pass box blur of
+ * that radius corresponds to. Inverse of the `computeBoxBlurRadius` uniform-pass formula:
+ * sigma = sqrt(passes * (2*radius + 1)^2 / 12). Useful for the reverse mapping (e.g. to feed a
+ * sigma-based backend from a Flash `blurX` value).
+ */
+export function computeGaussianSigmaForBlurRadius(radius, passes) {
+    if (radius <= 0 || passes <= 0)
+        return 0;
+    const width = 2 * radius + 1;
+    return Math.sqrt((passes * width * width) / 12);
+}
+// Largest odd box width whose `passes`-fold variance stays at or below a Gaussian
+// of standard deviation `sigma`. Odd keeps the radius (width - 1) / 2 integral.
+function computeBoxBlurLowerWidth(sigma, passes) {
+    let width = Math.floor(Math.sqrt((12 * sigma * sigma) / passes + 1));
+    if (width % 2 === 0)
+        width -= 1;
+    return width;
+}
+// Number of passes that use `lowerWidth`; the remaining passes use the next odd
+// width up so the combined variance tracks sigma. Derived from
+// m·(wl² - 1)/12 + (passes - m)·(wu² - 1)/12 = σ², with wu = wl + 2.
+function computeBoxBlurLowerPassCount(sigma, passes, lowerWidth) {
+    return Math.round((12 * sigma * sigma - passes * (lowerWidth * lowerWidth + 4 * lowerWidth + 3)) / (-4 * lowerWidth - 4));
+}
+//# sourceMappingURL=boxBlurMath.js.map

package/dist/boxBlurMath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxBlurMath.js","sourceRoot":"","sources":["../src/boxBlurMath.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,yEAAyE;AACzE,EAAE;AACF,0FAA0F;AAC1F,gGAAgG;AAChG,4FAA4F;AAC5F,0EAA0E;AAE1E;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAa,EAAE,MAAc,EAAE,IAAY;IAClF,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACzB,MAAM,UAAU,GAAG,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC3D,MAAM,UAAU,GAAG,4BAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;IAC3E,MAAM,KAAK,GAAG,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC;IAC9D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAa,EAAE,MAAc;IAChE,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACzB,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,GAAG,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC1F,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iCAAiC,CAAC,MAAc,EAAE,MAAc;IAC9E,IAAI,MAAM,IAAI,CAAC,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACzC,MAAM,KAAK,GAAG,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;IAC7B,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;AAClD,CAAC;AAED,kFAAkF;AAClF,gFAAgF;AAChF,SAAS,wBAAwB,CAAC,KAAa,EAAE,MAAc;IAC7D,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,KAAK,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IACrE,IAAI,KAAK,GAAG,CAAC,KAAK,CAAC;QAAE,KAAK,IAAI,CAAC,CAAC;IAChC,OAAO,KAAK,CAAC;AACf,CAAC;AAED,gFAAgF;AAChF,+DAA+D;AAC/D,qEAAqE;AACrE,SAAS,4BAA4B,CAAC,KAAa,EAAE,MAAc,EAAE,UAAkB;IACrF,OAAO,IAAI,CAAC,KAAK,CACf,CAAC,EAAE,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,CAAC,UAAU,GAAG,UAAU,GAAG,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC,CACvG,CAAC;AACJ,CAAC"}

package/dist/compositeEffect.d.ts

@@ -0,0 +1,3 @@
+import type { CompositeEffect, CompositeOperator } from '@flighthq/types';
+export declare function createCompositeEffect(operator: CompositeOperator, options?: Readonly<Omit<CompositeEffect, 'kind' | 'operator'>>): CompositeEffect;
+//# sourceMappingURL=compositeEffect.d.ts.map

package/dist/compositeEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositeEffect.d.ts","sourceRoot":"","sources":["../src/compositeEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAQ1E,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,GAAE,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,GAAG,UAAU,CAAC,CAAM,GACjE,eAAe,CAEjB"}

package/dist/compositeEffect.js

@@ -0,0 +1,10 @@
+// Porter-Duff composite effect: merges the incoming pipeline layer over a registered backdrop with a
+// coverage operator (the CompositeOperator vocabulary — Erase = DestinationOut, Alpha = DestinationIn,
+// and the rest of the set). `operator` is required; `backdropKey` names the per-state backdrop texture the
+// backend samples. It is the cheap sibling of createBlendEffect: a fixed-function coverage combine rather
+// than a shader blend, but still an explicit effect because a non-source-over operator is only meaningful
+// against an isolated layer.
+export function createCompositeEffect(operator, options = {}) {
+    return { kind: 'CompositeEffect', operator, ...options };
+}
+//# sourceMappingURL=compositeEffect.js.map

package/dist/compositeEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositeEffect.js","sourceRoot":"","sources":["../src/compositeEffect.ts"],"names":[],"mappings":"AAEA,qGAAqG;AACrG,uGAAuG;AACvG,2GAA2G;AAC3G,0GAA0G;AAC1G,0GAA0G;AAC1G,6BAA6B;AAC7B,MAAM,UAAU,qBAAqB,CACnC,QAA2B,EAC3B,UAAgE,EAAE;IAElE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC;AAC3D,CAAC"}

package/dist/compositeOperatorMath.d.ts

@@ -0,0 +1,3 @@
+import { CompositeOperator } from '@flighthq/types';
+export declare function getCompositeOperatorFactors(operator: CompositeOperator, sourceAlpha: number, backdropAlpha: number, out: [number, number] | Float32Array | number[]): void;
+//# sourceMappingURL=compositeOperatorMath.d.ts.map

package/dist/compositeOperatorMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositeOperatorMath.d.ts","sourceRoot":"","sources":["../src/compositeOperatorMath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAUpD,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,iBAAiB,EAC3B,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,GAAG,MAAM,EAAE,GAC9C,IAAI,CAsDN"}

package/dist/compositeOperatorMath.js

@@ -0,0 +1,65 @@
+import { CompositeOperator } from '@flighthq/types';
+// Premultiplied Porter-Duff coverage factors — the substrate-agnostic ground truth for how an isolated
+// layer (`source`) merges into its backdrop. The composited pixel is `Fa*source + Fb*backdrop` applied to
+// premultiplied color (rgb and a alike), where Fa/Fb depend only on the operator and the two coverage
+// alphas (`sourceAlpha` = as, `backdropAlpha` = ab). The GL fixed-function blendFunc factor pairs and the
+// Canvas globalCompositeOperation names both mirror these, so every backend is verifiable against plain
+// numbers. This is a closed set (the eleven Porter-Duff operators); custom operators are wired per-backend
+// (registerGlCompositeOperator) with their own factors, so an unknown operator here falls through to
+// SourceOver. Writes [Fa, Fb] into `out`; alias-safe (reads inputs before writing).
+export function getCompositeOperatorFactors(operator, sourceAlpha, backdropAlpha, out) {
+    const as = sourceAlpha;
+    const ab = backdropAlpha;
+    let fa;
+    let fb;
+    switch (operator) {
+        case CompositeOperator.Clear:
+            fa = 0;
+            fb = 0;
+            break;
+        case CompositeOperator.Copy:
+            fa = 1;
+            fb = 0;
+            break;
+        case CompositeOperator.DestinationAtop:
+            fa = 1 - ab;
+            fb = as;
+            break;
+        case CompositeOperator.DestinationIn:
+            fa = 0;
+            fb = as;
+            break;
+        case CompositeOperator.DestinationOut:
+            fa = 0;
+            fb = 1 - as;
+            break;
+        case CompositeOperator.DestinationOver:
+            fa = 1 - ab;
+            fb = 1;
+            break;
+        case CompositeOperator.SourceAtop:
+            fa = ab;
+            fb = 1 - as;
+            break;
+        case CompositeOperator.SourceIn:
+            fa = ab;
+            fb = 0;
+            break;
+        case CompositeOperator.SourceOut:
+            fa = 1 - ab;
+            fb = 0;
+            break;
+        case CompositeOperator.Xor:
+            fa = 1 - ab;
+            fb = 1 - as;
+            break;
+        default:
+            // SourceOver: source over backdrop.
+            fa = 1;
+            fb = 1 - as;
+            break;
+    }
+    out[0] = fa;
+    out[1] = fb;
+}
+//# sourceMappingURL=compositeOperatorMath.js.map

package/dist/compositeOperatorMath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositeOperatorMath.js","sourceRoot":"","sources":["../src/compositeOperatorMath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,uGAAuG;AACvG,0GAA0G;AAC1G,sGAAsG;AACtG,0GAA0G;AAC1G,wGAAwG;AACxG,2GAA2G;AAC3G,qGAAqG;AACrG,oFAAoF;AACpF,MAAM,UAAU,2BAA2B,CACzC,QAA2B,EAC3B,WAAmB,EACnB,aAAqB,EACrB,GAA+C;IAE/C,MAAM,EAAE,GAAG,WAAW,CAAC;IACvB,MAAM,EAAE,GAAG,aAAa,CAAC;IACzB,IAAI,EAAU,CAAC;IACf,IAAI,EAAU,CAAC;IACf,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,iBAAiB,CAAC,KAAK;YAC1B,EAAE,GAAG,CAAC,CAAC;YACP,EAAE,GAAG,CAAC,CAAC;YACP,MAAM;QACR,KAAK,iBAAiB,CAAC,IAAI;YACzB,EAAE,GAAG,CAAC,CAAC;YACP,EAAE,GAAG,CAAC,CAAC;YACP,MAAM;QACR,KAAK,iBAAiB,CAAC,eAAe;YACpC,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;YACZ,EAAE,GAAG,EAAE,CAAC;YACR,MAAM;QACR,KAAK,iBAAiB,CAAC,aAAa;YAClC,EAAE,GAAG,CAAC,CAAC;YACP,EAAE,GAAG,EAAE,CAAC;YACR,MAAM;QACR,KAAK,iBAAiB,CAAC,cAAc;YACnC,EAAE,GAAG,CAAC,CAAC;YACP,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;YACZ,MAAM;QACR,KAAK,iBAAiB,CAAC,eAAe;YACpC,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;YACZ,EAAE,GAAG,CAAC,CAAC;YACP,MAAM;QACR,KAAK,iBAAiB,CAAC,UAAU;YAC/B,EAAE,GAAG,EAAE,CAAC;YACR,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;YACZ,MAAM;QACR,KAAK,iBAAiB,CAAC,QAAQ;YAC7B,EAAE,GAAG,EAAE,CAAC;YACR,EAAE,GAAG,CAAC,CAAC;YACP,MAAM;QACR,KAAK,iBAAiB,CAAC,SAAS;YAC9B,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;YACZ,EAAE,GAAG,CAAC,CAAC;YACP,MAAM;QACR,KAAK,iBAAiB,CAAC,GAAG;YACxB,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;YACZ,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;YACZ,MAAM;QACR;YACE,oCAAoC;YACpC,EAAE,GAAG,CAAC,CAAC;YACP,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;YACZ,MAAM;IACV,CAAC;IACD,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;IACZ,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AACd,CAAC"}

package/dist/convolutionEffect.d.ts

@@ -0,0 +1,3 @@
+import type { ConvolutionEffect } from '@flighthq/types';
+export declare function createConvolutionEffect(options: Readonly<Omit<ConvolutionEffect, 'kind'>>): ConvolutionEffect;
+//# sourceMappingURL=convolutionEffect.d.ts.map

package/dist/convolutionEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convolutionEffect.d.ts","sourceRoot":"","sources":["../src/convolutionEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC,GAAG,iBAAiB,CAE7G"}

package/dist/convolutionEffect.js

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

package/dist/convolutionEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convolutionEffect.js","sourceRoot":"","sources":["../src/convolutionEffect.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,uBAAuB,CAAC,OAAkD;IACxF,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,GAAG,OAAO,EAAE,CAAC;AACnD,CAAC"}

package/dist/dropShadowEffect.d.ts

@@ -0,0 +1,3 @@
+import type { DropShadowEffect } from '@flighthq/types';
+export declare function createDropShadowEffect(options?: Readonly<Omit<DropShadowEffect, 'kind'>>): DropShadowEffect;
+//# sourceMappingURL=dropShadowEffect.d.ts.map

package/dist/dropShadowEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropShadowEffect.d.ts","sourceRoot":"","sources":["../src/dropShadowEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxD,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAM,GAAG,gBAAgB,CAE/G"}

package/dist/dropShadowEffect.js

@@ -0,0 +1,5 @@
+// Drop-shadow composite effect: tint the scene silhouette, blur it, offset it by angle/distance, then apply sourceMode compositing.
+export function createDropShadowEffect(options = {}) {
+    return { kind: 'DropShadowEffect', ...options };
+}
+//# sourceMappingURL=dropShadowEffect.js.map

package/dist/dropShadowEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropShadowEffect.js","sourceRoot":"","sources":["../src/dropShadowEffect.ts"],"names":[],"mappings":"AAEA,oIAAoI;AACpI,MAAM,UAAU,sBAAsB,CAAC,UAAoD,EAAE;IAC3F,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,GAAG,OAAO,EAAE,CAAC;AAClD,CAAC"}

package/dist/gaussianKernel.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Fills `out` with the 1D discrete Gaussian kernel weights for standard deviation `sigma`,
+ * normalized so the emitted weights sum to exactly 1. The kernel is symmetric with `out.length`
+ * set to `getGaussianKernelSize(sigma)` (an odd length), the center entry the largest. Because the
+ * kernel is truncated at radius `ceil(3 * sigma)`, the raw Gaussian samples are renormalized by
+ * their own truncated sum rather than the analytic 1/(sqrt(2π)·sigma) factor, so the discrete tail
+ * loss is absorbed and the taps a separable blur applies sum to 1. `sigma <= 0` yields a single
+ * unit weight (`[1]`), the identity kernel. Returns `out`.
+ */
+export declare function computeGaussianKernelWeights(sigma: number, out: number[]): number[];
+/**
+ * Returns the length of the discrete Gaussian kernel for standard deviation `sigma`: the odd count
+ * `radius * 2 + 1` where `radius = ceil(3 * sigma)`. Three standard deviations capture ~99.7% of the
+ * Gaussian mass, the conventional truncation point. `sigma <= 0` returns 1 (the identity kernel).
+ */
+export declare function getGaussianKernelSize(sigma: number): number;
+//# sourceMappingURL=gaussianKernel.d.ts.map

package/dist/gaussianKernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianKernel.d.ts","sourceRoot":"","sources":["../src/gaussianKernel.ts"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAqBnF;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI3D"}