react-native-parity-blur 0.1.0

package/lib/module/pipeline/androidCalibration.js

@@ -0,0 +1,55 @@
+"use strict";
+
+/**
+ * Android RenderEffect calibration (plan §5.2).
+ *
+ * INTERNAL MODULE. The single place the HWUI sigma<->radius relation lives on
+ * the TypeScript side; the Kotlin `AndroidBlurCalibration` must mirror it
+ * exactly. Verified on a Pixel 6a (API 36) in M0: radiusForSigma(10) exactly
+ * equals 16.454486... (matching the on-device measurement 16.45449).
+ *
+ * Relation (HWUI):  sigma = SLOPE * radiusPlatform + INTERCEPT
+ * Inverse:          radiusPlatform = (sigma - INTERCEPT) / SLOPE
+ *
+ * When sigmaSnapshot <= INTERCEPT (0.5) the inverse is non-positive, so we
+ * clamp to a no-blur passthrough rather than feeding a bogus radius to
+ * RenderEffect.createBlurEffect (plan §5.2 "no-op blur" for very small sigma).
+ */
+
+import { ANDROID_MIN_BLUR_SIGMA, HWUI_SIGMA_INTERCEPT, HWUI_SIGMA_SLOPE } from "./constants.js";
+/**
+ * Forward relation, exposed for tests/verification: the sigma that HWUI
+ * produces for a given platform radius.
+ */
+export function sigmaForRadius(radiusPlatform) {
+  return HWUI_SIGMA_SLOPE * radiusPlatform + HWUI_SIGMA_INTERCEPT;
+}
+
+/**
+ * Inverse relation: the platform radius required to achieve a target
+ * snapshot-domain sigma. Below the intercept this returns a no-blur result.
+ * Monotonically non-decreasing in sigmaSnapshot.
+ */
+export function radiusForSigma(sigmaSnapshot) {
+  if (!Number.isFinite(sigmaSnapshot) || sigmaSnapshot <= ANDROID_MIN_BLUR_SIGMA) {
+    return {
+      noBlur: true,
+      radiusPlatform: 0
+    };
+  }
+  return {
+    noBlur: false,
+    radiusPlatform: (sigmaSnapshot - HWUI_SIGMA_INTERCEPT) / HWUI_SIGMA_SLOPE
+  };
+}
+
+/**
+ * iOS MPSImageGaussianBlur takes the snapshot-domain sigma directly (plan §5.3).
+ * Provided here for symmetry so both platform mappings live in the reference.
+ * Sigma at or below 0 means no blur.
+ */
+export function iosSigmaForSigma(sigmaSnapshot) {
+  if (!Number.isFinite(sigmaSnapshot) || sigmaSnapshot <= 0) return 0;
+  return sigmaSnapshot;
+}
+//# sourceMappingURL=androidCalibration.js.map

package/lib/module/pipeline/androidCalibration.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ANDROID_MIN_BLUR_SIGMA","HWUI_SIGMA_INTERCEPT","HWUI_SIGMA_SLOPE","sigmaForRadius","radiusPlatform","radiusForSigma","sigmaSnapshot","Number","isFinite","noBlur","iosSigmaForSigma"],"sourceRoot":"../../../src","sources":["pipeline/androidCalibration.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SACEA,sBAAsB,EACtBC,oBAAoB,EACpBC,gBAAgB,QACX,gBAAa;AAYpB;AACA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAACC,cAAsB,EAAU;EAC7D,OAAOF,gBAAgB,GAAGE,cAAc,GAAGH,oBAAoB;AACjE;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASI,cAAcA,CAACC,aAAqB,EAAoB;EACtE,IAAI,CAACC,MAAM,CAACC,QAAQ,CAACF,aAAa,CAAC,IAAIA,aAAa,IAAIN,sBAAsB,EAAE;IAC9E,OAAO;MAAES,MAAM,EAAE,IAAI;MAAEL,cAAc,EAAE;IAAE,CAAC;EAC5C;EACA,OAAO;IACLK,MAAM,EAAE,KAAK;IACbL,cAAc,EAAE,CAACE,aAAa,GAAGL,oBAAoB,IAAIC;EAC3D,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASQ,gBAAgBA,CAACJ,aAAqB,EAAU;EAC9D,IAAI,CAACC,MAAM,CAACC,QAAQ,CAACF,aAAa,CAAC,IAAIA,aAAa,IAAI,CAAC,EAAE,OAAO,CAAC;EACnE,OAAOA,aAAa;AACtB","ignoreList":[]}

package/lib/module/pipeline/captureRect.js

@@ -0,0 +1,151 @@
+"use strict";
+
+/**
+ * Capture-rect math (plan §7, §12).
+ *
+ * INTERNAL MODULE. All rectangles here are in TARGET-LOCAL DEVICE PIXELS unless
+ * a field/return is explicitly documented as snapshot pixels.
+ *
+ * Pipeline of this module:
+ *   1. supportMarginPx  — Gaussian support margin = ceil(K * sigmaPx)
+ *   2. expandCaptureRect — expand visible rect by margin, clamp to target bounds
+ *   3. snapshotRectFor   — map the clamped device-px rect into integer snapshot
+ *                          pixels (floor origin, ceil far edge = conservative
+ *                          cover)
+ *   4. cropRectFor       — the sub-region of the snapshot that maps back to the
+ *                          visible rect (fractional, snapshot px)
+ *   5. cropRectToViewPx  — inverse mapping used to prove round-tripping
+ *
+ * Rounding rule (LOCKED): in the snapshot domain the origin FLOORS and the far
+ * edge CEILS, so `size = ceil(farEdge/D) - floor(origin/D)`. This is the
+ * conservative reading of "floor for origin, ceil for size": it guarantees
+ * every device pixel of the clamped capture rect is covered by the snapshot
+ * rect, at the cost of at most one extra snapshot pixel per side. A naive
+ * `floor(origin), ceil(width)` would fail to cover the far edge and is NOT used.
+ */
+
+import { CAPTURE_SUPPORT_K } from "./constants.js";
+/** Gaussian support margin in device px (plan §7): ceil(K * sigmaPx). */
+export function supportMarginPx(sigmaPx, k = CAPTURE_SUPPORT_K) {
+  if (!Number.isFinite(sigmaPx) || sigmaPx <= 0) return 0;
+  return Math.ceil(k * sigmaPx);
+}
+
+/** Intersection of two rects; empty (zero-size) rect if they do not overlap. */
+export function intersectRect(a, b) {
+  const x0 = Math.max(a.x, b.x);
+  const y0 = Math.max(a.y, b.y);
+  const x1 = Math.min(a.x + a.width, b.x + b.width);
+  const y1 = Math.min(a.y + a.height, b.y + b.height);
+  const width = Math.max(0, x1 - x0);
+  const height = Math.max(0, y1 - y0);
+  if (width === 0 || height === 0) {
+    return {
+      x: x0,
+      y: y0,
+      width: 0,
+      height: 0
+    };
+  }
+  return {
+    x: x0,
+    y: y0,
+    width,
+    height
+  };
+}
+
+/**
+ * Expand the visible blur rect by the Gaussian support margin and clamp to the
+ * target bounds. Returns a float device-px rect (plan §7). The margin only
+ * covers content that exists inside the target; CLAMP handles the outer edge
+ * where the margin was cut off (plan §8).
+ */
+export function expandCaptureRect(visibleRect, targetBounds, sigmaPx, k = CAPTURE_SUPPORT_K) {
+  const margin = supportMarginPx(sigmaPx, k);
+  const expanded = {
+    x: visibleRect.x - margin,
+    y: visibleRect.y - margin,
+    width: visibleRect.width + 2 * margin,
+    height: visibleRect.height + 2 * margin
+  };
+  return intersectRect(expanded, targetBounds);
+}
+
+/** Area of a rect in device px^2 (helper for downsample selection). */
+export function rectArea(r) {
+  return r.width * r.height;
+}
+
+/**
+ * Map a clamped device-px capture rect into integer snapshot pixels for
+ * downsample factor D. Floor the origin, ceil the far edge (conservative
+ * cover). The returned rect is in SNAPSHOT PIXELS (indices), so its device-px
+ * footprint is `snapshotRect * D`.
+ */
+export function snapshotRectFor(captureRectPx, downsample) {
+  const x = Math.floor(captureRectPx.x / downsample);
+  const y = Math.floor(captureRectPx.y / downsample);
+  const farX = Math.ceil((captureRectPx.x + captureRectPx.width) / downsample);
+  const farY = Math.ceil((captureRectPx.y + captureRectPx.height) / downsample);
+  return {
+    x,
+    y,
+    width: Math.max(0, farX - x),
+    height: Math.max(0, farY - y)
+  };
+}
+
+/**
+ * The fractional crop rect, in SNAPSHOT PIXELS, that selects the visible region
+ * out of the (larger) snapshot rect after blur. Because the snapshot origin was
+ * floored, the crop origin carries a fractional remainder in [0, 1) snapshot px
+ * which the upsample step resolves with bilinear sampling (plan §12).
+ *
+ *   cropX = visibleRect.x / D  -  snapshotRect.x
+ *   cropW = visibleRect.width / D
+ */
+export function cropRectFor(visibleRect, snapshotRect, downsample) {
+  return {
+    x: visibleRect.x / downsample - snapshotRect.x,
+    y: visibleRect.y / downsample - snapshotRect.y,
+    width: visibleRect.width / downsample,
+    height: visibleRect.height / downsample
+  };
+}
+
+/**
+ * Inverse of {@link cropRectFor}: map a snapshot-px crop rect back to
+ * target-local device px. Used to verify round-tripping (should recover the
+ * original visible rect within half a snapshot pixel = D/2 device px).
+ */
+export function cropRectToViewPx(cropRect, snapshotRect, downsample) {
+  return {
+    x: (snapshotRect.x + cropRect.x) * downsample,
+    y: (snapshotRect.y + cropRect.y) * downsample,
+    width: cropRect.width * downsample,
+    height: cropRect.height * downsample
+  };
+}
+/**
+ * Assemble the full capture plan for a given visible rect, target bounds,
+ * sigmaPx and pre-resolved downsample factor. Downsample resolution lives in
+ * downsample.ts and takes `captureAreaPx` from this same computation, so the
+ * caller sequences: expand -> area -> resolveDownsample -> buildCapturePlan.
+ */
+export function buildCapturePlan(visibleRect, targetBounds, sigmaPx, downsample, k = CAPTURE_SUPPORT_K) {
+  const marginPx = supportMarginPx(sigmaPx, k);
+  const captureRectPx = expandCaptureRect(visibleRect, targetBounds, sigmaPx, k);
+  const snapshotRect = snapshotRectFor(captureRectPx, downsample);
+  const cropRect = cropRectFor(visibleRect, snapshotRect, downsample);
+  return {
+    visibleRect,
+    marginPx,
+    captureRectPx,
+    captureAreaPx: rectArea(captureRectPx),
+    downsample,
+    snapshotRect,
+    cropRect
+  };
+}
+//# sourceMappingURL=captureRect.js.map

package/lib/module/pipeline/captureRect.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CAPTURE_SUPPORT_K","supportMarginPx","sigmaPx","k","Number","isFinite","Math","ceil","intersectRect","a","b","x0","max","x","y0","y","x1","min","width","y1","height","expandCaptureRect","visibleRect","targetBounds","margin","expanded","rectArea","r","snapshotRectFor","captureRectPx","downsample","floor","farX","farY","cropRectFor","snapshotRect","cropRectToViewPx","cropRect","buildCapturePlan","marginPx","captureAreaPx"],"sourceRoot":"../../../src","sources":["pipeline/captureRect.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,iBAAiB,QAAQ,gBAAa;AAG/C;AACA,OAAO,SAASC,eAAeA,CAACC,OAAe,EAAEC,CAAS,GAAGH,iBAAiB,EAAU;EACtF,IAAI,CAACI,MAAM,CAACC,QAAQ,CAACH,OAAO,CAAC,IAAIA,OAAO,IAAI,CAAC,EAAE,OAAO,CAAC;EACvD,OAAOI,IAAI,CAACC,IAAI,CAACJ,CAAC,GAAGD,OAAO,CAAC;AAC/B;;AAEA;AACA,OAAO,SAASM,aAAaA,CAACC,CAAO,EAAEC,CAAO,EAAQ;EACpD,MAAMC,EAAE,GAAGL,IAAI,CAACM,GAAG,CAACH,CAAC,CAACI,CAAC,EAAEH,CAAC,CAACG,CAAC,CAAC;EAC7B,MAAMC,EAAE,GAAGR,IAAI,CAACM,GAAG,CAACH,CAAC,CAACM,CAAC,EAAEL,CAAC,CAACK,CAAC,CAAC;EAC7B,MAAMC,EAAE,GAAGV,IAAI,CAACW,GAAG,CAACR,CAAC,CAACI,CAAC,GAAGJ,CAAC,CAACS,KAAK,EAAER,CAAC,CAACG,CAAC,GAAGH,CAAC,CAACQ,KAAK,CAAC;EACjD,MAAMC,EAAE,GAAGb,IAAI,CAACW,GAAG,CAACR,CAAC,CAACM,CAAC,GAAGN,CAAC,CAACW,MAAM,EAAEV,CAAC,CAACK,CAAC,GAAGL,CAAC,CAACU,MAAM,CAAC;EACnD,MAAMF,KAAK,GAAGZ,IAAI,CAACM,GAAG,CAAC,CAAC,EAAEI,EAAE,GAAGL,EAAE,CAAC;EAClC,MAAMS,MAAM,GAAGd,IAAI,CAACM,GAAG,CAAC,CAAC,EAAEO,EAAE,GAAGL,EAAE,CAAC;EACnC,IAAII,KAAK,KAAK,CAAC,IAAIE,MAAM,KAAK,CAAC,EAAE;IAC/B,OAAO;MAAEP,CAAC,EAAEF,EAAE;MAAEI,CAAC,EAAED,EAAE;MAAEI,KAAK,EAAE,CAAC;MAAEE,MAAM,EAAE;IAAE,CAAC;EAC9C;EACA,OAAO;IAAEP,CAAC,EAAEF,EAAE;IAAEI,CAAC,EAAED,EAAE;IAAEI,KAAK;IAAEE;EAAO,CAAC;AACxC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,WAAiB,EACjBC,YAAkB,EAClBrB,OAAe,EACfC,CAAS,GAAGH,iBAAiB,EACvB;EACN,MAAMwB,MAAM,GAAGvB,eAAe,CAACC,OAAO,EAAEC,CAAC,CAAC;EAC1C,MAAMsB,QAAc,GAAG;IACrBZ,CAAC,EAAES,WAAW,CAACT,CAAC,GAAGW,MAAM;IACzBT,CAAC,EAAEO,WAAW,CAACP,CAAC,GAAGS,MAAM;IACzBN,KAAK,EAAEI,WAAW,CAACJ,KAAK,GAAG,CAAC,GAAGM,MAAM;IACrCJ,MAAM,EAAEE,WAAW,CAACF,MAAM,GAAG,CAAC,GAAGI;EACnC,CAAC;EACD,OAAOhB,aAAa,CAACiB,QAAQ,EAAEF,YAAY,CAAC;AAC9C;;AAEA;AACA,OAAO,SAASG,QAAQA,CAACC,CAAO,EAAU;EACxC,OAAOA,CAAC,CAACT,KAAK,GAAGS,CAAC,CAACP,MAAM;AAC3B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASQ,eAAeA,CAACC,aAAmB,EAAEC,UAAsB,EAAQ;EACjF,MAAMjB,CAAC,GAAGP,IAAI,CAACyB,KAAK,CAACF,aAAa,CAAChB,CAAC,GAAGiB,UAAU,CAAC;EAClD,MAAMf,CAAC,GAAGT,IAAI,CAACyB,KAAK,CAACF,aAAa,CAACd,CAAC,GAAGe,UAAU,CAAC;EAClD,MAAME,IAAI,GAAG1B,IAAI,CAACC,IAAI,CAAC,CAACsB,aAAa,CAAChB,CAAC,GAAGgB,aAAa,CAACX,KAAK,IAAIY,UAAU,CAAC;EAC5E,MAAMG,IAAI,GAAG3B,IAAI,CAACC,IAAI,CAAC,CAACsB,aAAa,CAACd,CAAC,GAAGc,aAAa,CAACT,MAAM,IAAIU,UAAU,CAAC;EAC7E,OAAO;IAAEjB,CAAC;IAAEE,CAAC;IAAEG,KAAK,EAAEZ,IAAI,CAACM,GAAG,CAAC,CAAC,EAAEoB,IAAI,GAAGnB,CAAC,CAAC;IAAEO,MAAM,EAAEd,IAAI,CAACM,GAAG,CAAC,CAAC,EAAEqB,IAAI,GAAGlB,CAAC;EAAE,CAAC;AAC9E;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASmB,WAAWA,CACzBZ,WAAiB,EACjBa,YAAkB,EAClBL,UAAsB,EAChB;EACN,OAAO;IACLjB,CAAC,EAAES,WAAW,CAACT,CAAC,GAAGiB,UAAU,GAAGK,YAAY,CAACtB,CAAC;IAC9CE,CAAC,EAAEO,WAAW,CAACP,CAAC,GAAGe,UAAU,GAAGK,YAAY,CAACpB,CAAC;IAC9CG,KAAK,EAAEI,WAAW,CAACJ,KAAK,GAAGY,UAAU;IACrCV,MAAM,EAAEE,WAAW,CAACF,MAAM,GAAGU;EAC/B,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASM,gBAAgBA,CAC9BC,QAAc,EACdF,YAAkB,EAClBL,UAAsB,EAChB;EACN,OAAO;IACLjB,CAAC,EAAE,CAACsB,YAAY,CAACtB,CAAC,GAAGwB,QAAQ,CAACxB,CAAC,IAAIiB,UAAU;IAC7Cf,CAAC,EAAE,CAACoB,YAAY,CAACpB,CAAC,GAAGsB,QAAQ,CAACtB,CAAC,IAAIe,UAAU;IAC7CZ,KAAK,EAAEmB,QAAQ,CAACnB,KAAK,GAAGY,UAAU;IAClCV,MAAM,EAAEiB,QAAQ,CAACjB,MAAM,GAAGU;EAC5B,CAAC;AACH;AAmBA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASQ,gBAAgBA,CAC9BhB,WAAiB,EACjBC,YAAkB,EAClBrB,OAAe,EACf4B,UAAsB,EACtB3B,CAAS,GAAGH,iBAAiB,EAChB;EACb,MAAMuC,QAAQ,GAAGtC,eAAe,CAACC,OAAO,EAAEC,CAAC,CAAC;EAC5C,MAAM0B,aAAa,GAAGR,iBAAiB,CAACC,WAAW,EAAEC,YAAY,EAAErB,OAAO,EAAEC,CAAC,CAAC;EAC9E,MAAMgC,YAAY,GAAGP,eAAe,CAACC,aAAa,EAAEC,UAAU,CAAC;EAC/D,MAAMO,QAAQ,GAAGH,WAAW,CAACZ,WAAW,EAAEa,YAAY,EAAEL,UAAU,CAAC;EACnE,OAAO;IACLR,WAAW;IACXiB,QAAQ;IACRV,aAAa;IACbW,aAAa,EAAEd,QAAQ,CAACG,aAAa,CAAC;IACtCC,UAAU;IACVK,YAAY;IACZE;EACF,CAAC;AACH","ignoreList":[]}

package/lib/module/pipeline/color.js

@@ -0,0 +1,82 @@
+"use strict";
+
+/**
+ * Color parsing for the overlay prop.
+ *
+ * INTERNAL MODULE. Parses the subset of CSS color syntaxes React Native
+ * accepts for a string color prop into straight-alpha RGBA in [0,1]:
+ *   - 'transparent'
+ *   - #rgb / #rgba / #rrggbb / #rrggbbaa
+ *   - rgb(r,g,b) / rgba(r,g,b,a)   (r,g,b integer 0-255, a float 0-1)
+ *
+ * Any unrecognised value returns a fully-transparent color (no overlay), which
+ * is the documented default (plan §11). The native backends parse the same
+ * prop with their platform color parsers; this reference fixes the expected
+ * numeric result for parity fixtures.
+ */
+
+export const TRANSPARENT = {
+  r: 0,
+  g: 0,
+  b: 0,
+  a: 0
+};
+function clamp01(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function hexPair(s) {
+  return parseInt(s, 16) / 255;
+}
+
+/** Parse a color string into straight-alpha RGBA. Unrecognised -> transparent. */
+export function parseColor(input) {
+  if (input == null) return TRANSPARENT;
+  const s = input.trim().toLowerCase();
+  if (s === 'transparent') return TRANSPARENT;
+  if (s.startsWith('#')) {
+    const hex = s.slice(1);
+    if (hex.length === 3 || hex.length === 4) {
+      const r = hexPair(hex[0] + hex[0]);
+      const g = hexPair(hex[1] + hex[1]);
+      const b = hexPair(hex[2] + hex[2]);
+      const a = hex.length === 4 ? hexPair(hex[3] + hex[3]) : 1;
+      return {
+        r,
+        g,
+        b,
+        a
+      };
+    }
+    if (hex.length === 6 || hex.length === 8) {
+      const r = hexPair(hex.slice(0, 2));
+      const g = hexPair(hex.slice(2, 4));
+      const b = hexPair(hex.slice(4, 6));
+      const a = hex.length === 8 ? hexPair(hex.slice(6, 8)) : 1;
+      return {
+        r,
+        g,
+        b,
+        a
+      };
+    }
+    return TRANSPARENT;
+  }
+  const m = s.match(/^rgba?\(([^)]+)\)$/);
+  if (m) {
+    const parts = m[1].split(',').map(p => p.trim());
+    if (parts.length === 3 || parts.length === 4) {
+      const r = clamp01(parseFloat(parts[0]) / 255);
+      const g = clamp01(parseFloat(parts[1]) / 255);
+      const b = clamp01(parseFloat(parts[2]) / 255);
+      const a = parts.length === 4 ? clamp01(parseFloat(parts[3])) : 1;
+      if ([r, g, b, a].every(v => Number.isFinite(v))) return {
+        r,
+        g,
+        b,
+        a
+      };
+    }
+  }
+  return TRANSPARENT;
+}
+//# sourceMappingURL=color.js.map

package/lib/module/pipeline/color.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TRANSPARENT","r","g","b","a","clamp01","v","hexPair","s","parseInt","parseColor","input","trim","toLowerCase","startsWith","hex","slice","length","m","match","parts","split","map","p","parseFloat","every","Number","isFinite"],"sourceRoot":"../../../src","sources":["pipeline/color.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/pipeline/constants.js

@@ -0,0 +1,65 @@
+"use strict";
+
+/**
+ * Locked calibration constants for the canonical pipeline.
+ *
+ * INTERNAL MODULE. These are the single source of truth for the reference
+ * implementation. Native backends must mirror these exact values. Per the
+ * plan (§5.2, §38) constants remain provisional until the parity milestone,
+ * but M0 device verification already confirmed the HWUI relation on API 36.
+ */
+
+/**
+ * HWUI RenderEffect Gaussian relation, verified exact on a Pixel 6a (API 36)
+ * in M0: `sigma = HWUI_SIGMA_SLOPE * radiusPlatform + HWUI_SIGMA_INTERCEPT`.
+ * Isolated here so a future version-aware calibration can override it in one
+ * place (plan §5.2). Do NOT inline these anywhere else.
+ */
+export const HWUI_SIGMA_SLOPE = 0.57735;
+export const HWUI_SIGMA_INTERCEPT = 0.5;
+
+/**
+ * Below this snapshot-domain sigma the Android RenderEffect relation inverts
+ * to a non-positive radius, so we emit a no-blur passthrough instead. Equal to
+ * HWUI_SIGMA_INTERCEPT by construction (radius 0 <=> sigma 0.5).
+ */
+export const ANDROID_MIN_BLUR_SIGMA = HWUI_SIGMA_INTERCEPT;
+
+/** Gaussian support multiplier for capture expansion (plan §7). */
+export const CAPTURE_SUPPORT_K = 3;
+
+/**
+ * Auto-downsample: target lower bound on snapshot-domain sigma. Keeping
+ * sigmaSnapshot at or above this prevents over-downsampling that would make
+ * the kernel degenerate (plan §12). 1 snapshot px.
+ */
+export const MIN_SIGMA_SNAPSHOT = 1.0;
+
+/**
+ * Auto-downsample: captures with area (device px^2) below this are considered
+ * "small" and are never downsampled beyond 2x — aggressive reduction of a tiny
+ * region buys no meaningful performance while degrading quality.
+ * 256 * 256 device px.
+ */
+export const SMALL_CAPTURE_AREA_PX = 256 * 256;
+
+/**
+ * Auto-downsample: per-quality ceiling on the downsample factor (plan §13).
+ *   high        -> prefer 1x or 2x
+ *   balanced    -> prefer 2x or 4x
+ *   performance -> prefer 4x or 8x
+ */
+export const QUALITY_MAX_DOWNSAMPLE = {
+  high: 2,
+  balanced: 4,
+  performance: 8
+};
+
+/**
+ * Rec. 709 luminance coefficients (plan §10). Sum to 1.0. Used for the
+ * saturation matrix on both platforms.
+ */
+export const LUMA_R = 0.2126;
+export const LUMA_G = 0.7152;
+export const LUMA_B = 0.0722;
+//# sourceMappingURL=constants.js.map

package/lib/module/pipeline/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["HWUI_SIGMA_SLOPE","HWUI_SIGMA_INTERCEPT","ANDROID_MIN_BLUR_SIGMA","CAPTURE_SUPPORT_K","MIN_SIGMA_SNAPSHOT","SMALL_CAPTURE_AREA_PX","QUALITY_MAX_DOWNSAMPLE","high","balanced","performance","LUMA_R","LUMA_G","LUMA_B"],"sourceRoot":"../../../src","sources":["pipeline/constants.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,gBAAgB,GAAG,OAAO;AACvC,OAAO,MAAMC,oBAAoB,GAAG,GAAG;;AAEvC;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,GAAGD,oBAAoB;;AAE1D;AACA,OAAO,MAAME,iBAAiB,GAAG,CAAC;;AAElC;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kBAAkB,GAAG,GAAG;;AAErC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,qBAAqB,GAAG,GAAG,GAAG,GAAG;;AAE9C;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,sBAGZ,GAAG;EACFC,IAAI,EAAE,CAAC;EACPC,QAAQ,EAAE,CAAC;EACXC,WAAW,EAAE;AACf,CAAC;;AAED;AACA;AACA;AACA;AACA,OAAO,MAAMC,MAAM,GAAG,MAAM;AAC5B,OAAO,MAAMC,MAAM,GAAG,MAAM;AAC5B,OAAO,MAAMC,MAAM,GAAG,MAAM","ignoreList":[]}

package/lib/module/pipeline/downsample.js

@@ -0,0 +1,61 @@
+"use strict";
+
+/**
+ * Auto downsample selection (plan §12, §13).
+ *
+ * INTERNAL MODULE. Deterministic function of (sigmaPx, captureAreaPx, quality)
+ * -> D in {1,2,4,8}. Both backends must select identically for identical input.
+ *
+ * The chosen factor is the largest allowed value that satisfies ALL of three
+ * independent ceilings, then snapped down to a real factor in {1,2,4,8}:
+ *
+ *   1. quality ceiling   — QUALITY_MAX_DOWNSAMPLE[quality]
+ *   2. sigma floor        — keep sigmaSnapshot = sigmaPx / D >= MIN_SIGMA_SNAPSHOT,
+ *                            i.e. D <= floor(sigmaPx / MIN_SIGMA_SNAPSHOT)
+ *   3. area ceiling       — tiny captures (< SMALL_CAPTURE_AREA_PX) never exceed 2x
+ *
+ * See docs/PIPELINE_SPEC.md for the locked decision table.
+ */
+
+import { MIN_SIGMA_SNAPSHOT, QUALITY_MAX_DOWNSAMPLE, SMALL_CAPTURE_AREA_PX } from "./constants.js";
+import { DOWNSAMPLE_FACTORS } from "./types.js";
+
+/** Largest allowed factor in {8,4,2,1} that is <= cap (never below 1). */
+function largestFactorAtMost(cap) {
+  for (const factor of DOWNSAMPLE_FACTORS) {
+    if (factor <= cap) return factor;
+  }
+  return 1;
+}
+
+/**
+ * Resolve the auto-selected downsample factor.
+ *
+ * @param sigmaPx      device-pixel sigma (blurRadius * displayScale)
+ * @param captureAreaPx expanded capture area in device px^2
+ * @param quality      quality tier
+ */
+export function autoDownsample(sigmaPx, captureAreaPx, quality) {
+  // No blur requested -> never downsample.
+  if (!Number.isFinite(sigmaPx) || sigmaPx <= 0) return 1;
+  const maxByQuality = QUALITY_MAX_DOWNSAMPLE[quality];
+
+  // Sigma floor: keep snapshot sigma at/above the minimum useful value.
+  const maxBySigma = Math.floor(sigmaPx / MIN_SIGMA_SNAPSHOT);
+
+  // Area ceiling: small captures are capped at 2x.
+  const area = Number.isFinite(captureAreaPx) ? captureAreaPx : 0;
+  const maxByArea = area < SMALL_CAPTURE_AREA_PX ? 2 : 8;
+  const cap = Math.min(maxByQuality, maxBySigma, maxByArea);
+  return largestFactorAtMost(cap);
+}
+
+/**
+ * Resolve a public `downsample` prop to a concrete factor. An explicit numeric
+ * value is honoured verbatim; 'auto' delegates to {@link autoDownsample}.
+ */
+export function resolveDownsample(prop, sigmaPx, captureAreaPx, quality) {
+  if (prop === 'auto') return autoDownsample(sigmaPx, captureAreaPx, quality);
+  return prop;
+}
+//# sourceMappingURL=downsample.js.map

package/lib/module/pipeline/downsample.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MIN_SIGMA_SNAPSHOT","QUALITY_MAX_DOWNSAMPLE","SMALL_CAPTURE_AREA_PX","DOWNSAMPLE_FACTORS","largestFactorAtMost","cap","factor","autoDownsample","sigmaPx","captureAreaPx","quality","Number","isFinite","maxByQuality","maxBySigma","Math","floor","area","maxByArea","min","resolveDownsample","prop"],"sourceRoot":"../../../src","sources":["pipeline/downsample.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SACEA,kBAAkB,EAClBC,sBAAsB,EACtBC,qBAAqB,QAChB,gBAAa;AAEpB,SAASC,kBAAkB,QAAQ,YAAS;;AAE5C;AACA,SAASC,mBAAmBA,CAACC,GAAW,EAAc;EACpD,KAAK,MAAMC,MAAM,IAAIH,kBAAkB,EAAE;IACvC,IAAIG,MAAM,IAAID,GAAG,EAAE,OAAOC,MAAM;EAClC;EACA,OAAO,CAAC;AACV;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAC5BC,OAAe,EACfC,aAAqB,EACrBC,OAAoB,EACR;EACZ;EACA,IAAI,CAACC,MAAM,CAACC,QAAQ,CAACJ,OAAO,CAAC,IAAIA,OAAO,IAAI,CAAC,EAAE,OAAO,CAAC;EAEvD,MAAMK,YAAY,GAAGZ,sBAAsB,CAACS,OAAO,CAAC;;EAEpD;EACA,MAAMI,UAAU,GAAGC,IAAI,CAACC,KAAK,CAACR,OAAO,GAAGR,kBAAkB,CAAC;;EAE3D;EACA,MAAMiB,IAAI,GAAGN,MAAM,CAACC,QAAQ,CAACH,aAAa,CAAC,GAAGA,aAAa,GAAG,CAAC;EAC/D,MAAMS,SAAS,GAAGD,IAAI,GAAGf,qBAAqB,GAAG,CAAC,GAAG,CAAC;EAEtD,MAAMG,GAAG,GAAGU,IAAI,CAACI,GAAG,CAACN,YAAY,EAAEC,UAAU,EAAEI,SAAS,CAAC;EACzD,OAAOd,mBAAmB,CAACC,GAAG,CAAC;AACjC;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASe,iBAAiBA,CAC/BC,IAAoB,EACpBb,OAAe,EACfC,aAAqB,EACrBC,OAAoB,EACR;EACZ,IAAIW,IAAI,KAAK,MAAM,EAAE,OAAOd,cAAc,CAACC,OAAO,EAAEC,aAAa,EAAEC,OAAO,CAAC;EAC3E,OAAOW,IAAI;AACb","ignoreList":[]}

package/lib/module/pipeline/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+/**
+ * Canonical pipeline reference implementation — INTERNAL barrel.
+ *
+ * This module is the executable form of docs/PIPELINE_SPEC.md: pure TypeScript,
+ * no react-native imports, no side effects. Native backends (Kotlin / Swift)
+ * must reproduce these exact rules.
+ *
+ * IMPORTANT: this barrel is intentionally NOT re-exported from src/index.ts.
+ * It is a spec/testing artifact, not part of the package's public API.
+ */
+
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./units.js";
+export * from "./androidCalibration.js";
+export * from "./downsample.js";
+export * from "./captureRect.js";
+export * from "./saturation.js";
+export * from "./color.js";
+export * from "./overlay.js";
+//# sourceMappingURL=index.js.map

package/lib/module/pipeline/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["pipeline/index.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,cAAc,YAAS;AACvB,cAAc,gBAAa;AAC3B,cAAc,YAAS;AACvB,cAAc,yBAAsB;AACpC,cAAc,iBAAc;AAC5B,cAAc,kBAAe;AAC7B,cAAc,iBAAc;AAC5B,cAAc,YAAS;AACvB,cAAc,cAAW","ignoreList":[]}

package/lib/module/pipeline/overlay.js

@@ -0,0 +1,56 @@
+"use strict";
+
+/**
+ * Overlay source-over compositing (plan §11).
+ *
+ * INTERNAL MODULE. The overlay color (straight alpha, parsed from the prop) is
+ * the SOURCE; the saturated blur result is the DESTINATION. Applied AFTER
+ * saturation, BEFORE final clipping (plan §6 step 10). This is the only tint in
+ * the pipeline — no hidden platform tint is permitted.
+ *
+ * Straight-alpha (non-premultiplied) source-over, per channel:
+ *
+ *   outA = srcA + dstA * (1 - srcA)
+ *   outC = (srcC*srcA + dstC*dstA*(1 - srcA)) / outA    (outA > 0)
+ *          0                                             (outA = 0)
+ *
+ * In v1 the capture surface is an opaque backdrop, so dstA = 1 and this reduces
+ * to the familiar linear blend  outC = srcC*srcA + dstC*(1 - srcA), outA = 1.
+ * The general form is implemented so the reference stays correct if a future
+ * version captures translucent backdrops.
+ */
+
+/**
+ * Source-over composite of a straight-alpha source over a straight-alpha
+ * destination. Returns straight-alpha RGBA.
+ */
+export function sourceOver(src, dst) {
+  const outA = src.a + dst.a * (1 - src.a);
+  if (outA <= 0) return {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 0
+  };
+  const blend = (sc, dc) => (sc * src.a + dc * dst.a * (1 - src.a)) / outA;
+  return {
+    r: blend(src.r, dst.r),
+    g: blend(src.g, dst.g),
+    b: blend(src.b, dst.b),
+    a: outA
+  };
+}
+
+/**
+ * Convenience: composite an overlay color over an opaque (alpha=1) blurred
+ * pixel — the v1 case. Equivalent to sourceOver(overlay, {..dst, a:1}).
+ */
+export function overlayOnOpaque(overlay, dst) {
+  return sourceOver(overlay, {
+    r: dst.r,
+    g: dst.g,
+    b: dst.b,
+    a: 1
+  });
+}
+//# sourceMappingURL=overlay.js.map

package/lib/module/pipeline/overlay.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["sourceOver","src","dst","outA","a","r","g","b","blend","sc","dc","overlayOnOpaque","overlay"],"sourceRoot":"../../../src","sources":["pipeline/overlay.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA,OAAO,SAASA,UAAUA,CAACC,GAAS,EAAEC,GAAS,EAAQ;EACrD,MAAMC,IAAI,GAAGF,GAAG,CAACG,CAAC,GAAGF,GAAG,CAACE,CAAC,IAAI,CAAC,GAAGH,GAAG,CAACG,CAAC,CAAC;EACxC,IAAID,IAAI,IAAI,CAAC,EAAE,OAAO;IAAEE,CAAC,EAAE,CAAC;IAAEC,CAAC,EAAE,CAAC;IAAEC,CAAC,EAAE,CAAC;IAAEH,CAAC,EAAE;EAAE,CAAC;EAChD,MAAMI,KAAK,GAAGA,CAACC,EAAU,EAAEC,EAAU,KACnC,CAACD,EAAE,GAAGR,GAAG,CAACG,CAAC,GAAGM,EAAE,GAAGR,GAAG,CAACE,CAAC,IAAI,CAAC,GAAGH,GAAG,CAACG,CAAC,CAAC,IAAID,IAAI;EAChD,OAAO;IACLE,CAAC,EAAEG,KAAK,CAACP,GAAG,CAACI,CAAC,EAAEH,GAAG,CAACG,CAAC,CAAC;IACtBC,CAAC,EAAEE,KAAK,CAACP,GAAG,CAACK,CAAC,EAAEJ,GAAG,CAACI,CAAC,CAAC;IACtBC,CAAC,EAAEC,KAAK,CAACP,GAAG,CAACM,CAAC,EAAEL,GAAG,CAACK,CAAC,CAAC;IACtBH,CAAC,EAAED;EACL,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASQ,eAAeA,CAACC,OAAa,EAAEV,GAAS,EAAQ;EAC9D,OAAOF,UAAU,CAACY,OAAO,EAAE;IAAEP,CAAC,EAAEH,GAAG,CAACG,CAAC;IAAEC,CAAC,EAAEJ,GAAG,CAACI,CAAC;IAAEC,CAAC,EAAEL,GAAG,CAACK,CAAC;IAAEH,CAAC,EAAE;EAAE,CAAC,CAAC;AACpE","ignoreList":[]}

package/lib/module/pipeline/saturation.js

@@ -0,0 +1,52 @@
+"use strict";
+
+/**
+ * Saturation color matrix (plan §10).
+ *
+ * INTERNAL MODULE. One canonical 4x5 color matrix (Android ColorMatrix layout:
+ * 4 output rows R,G,B,A; 5 columns R,G,B,A,offset) using Rec.709 luminance
+ * coefficients. Applied AFTER blur, BEFORE overlay (plan §6 step 9).
+ *
+ * For saturation s and luma coefficients (lr,lg,lb) with t = 1 - s:
+ *
+ *   R' = (t*lr + s)*R +  t*lg*G     +  t*lb*B
+ *   G' =  t*lr*R     + (t*lg + s)*G +  t*lb*B
+ *   B' =  t*lr*R     +  t*lg*G      + (t*lb + s)*B
+ *   A' = A
+ *
+ *   s = 1 -> identity;  s = 0 -> luminance grayscale;  s > 1 -> more saturated.
+ *
+ * The alpha row is untouched and there is no offset column (all offsets 0).
+ * The matrix operates on the same channel representation the backend blurs in
+ * (gamma-space, straight color for the opaque v1 backdrop). It does NOT itself
+ * premultiply — see docs/PIPELINE_SPEC.md §Color.
+ */
+
+import { LUMA_B, LUMA_G, LUMA_R } from "./constants.js";
+
+/**
+ * Row-major 4x5 saturation matrix (20 numbers), matching Android's
+ * ColorMatrix and directly transcribable to a Metal 4x4 + bias.
+ */
+export function saturationMatrix(s, lr = LUMA_R, lg = LUMA_G, lb = LUMA_B) {
+  const t = 1 - s;
+  return [t * lr + s, t * lg, t * lb, 0, 0, t * lr, t * lg + s, t * lb, 0, 0, t * lr, t * lg, t * lb + s, 0, 0, 0, 0, 0, 1, 0];
+}
+
+/**
+ * Apply a 4x5 saturation matrix to a straight-alpha RGBA tuple (channels in
+ * [0,1]). Returned RGB is clamped to [0,1]; alpha is passed through untouched.
+ * Reference for backend parity tests.
+ */
+export function applySaturation(matrix, r, g, b, a) {
+  const clamp01 = v => v < 0 ? 0 : v > 1 ? 1 : v;
+  const m = matrix;
+  return {
+    // Indices per row-major 4x5 layout.
+    r: clamp01(m[0] * r + m[1] * g + m[2] * b + m[3] * a + m[4]),
+    g: clamp01(m[5] * r + m[6] * g + m[7] * b + m[8] * a + m[9]),
+    b: clamp01(m[10] * r + m[11] * g + m[12] * b + m[13] * a + m[14]),
+    a: m[15] * r + m[16] * g + m[17] * b + m[18] * a + m[19]
+  };
+}
+//# sourceMappingURL=saturation.js.map

package/lib/module/pipeline/saturation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LUMA_B","LUMA_G","LUMA_R","saturationMatrix","s","lr","lg","lb","t","applySaturation","matrix","r","g","b","a","clamp01","v","m"],"sourceRoot":"../../../src","sources":["pipeline/saturation.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,MAAM,EAAEC,MAAM,EAAEC,MAAM,QAAQ,gBAAa;;AAEpD;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAC9BC,CAAS,EACTC,EAAU,GAAGH,MAAM,EACnBI,EAAU,GAAGL,MAAM,EACnBM,EAAU,GAAGP,MAAM,EACT;EACV,MAAMQ,CAAC,GAAG,CAAC,GAAGJ,CAAC;EACf,OAAO,CACLI,CAAC,GAAGH,EAAE,GAAGD,CAAC,EAAEI,CAAC,GAAGF,EAAE,EAAEE,CAAC,GAAGD,EAAE,EAAE,CAAC,EAAE,CAAC,EAChCC,CAAC,GAAGH,EAAE,EAAEG,CAAC,GAAGF,EAAE,GAAGF,CAAC,EAAEI,CAAC,GAAGD,EAAE,EAAE,CAAC,EAAE,CAAC,EAChCC,CAAC,GAAGH,EAAE,EAAEG,CAAC,GAAGF,EAAE,EAAEE,CAAC,GAAGD,EAAE,GAAGH,CAAC,EAAE,CAAC,EAAE,CAAC,EAChC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CACd;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASK,eAAeA,CAC7BC,MAAgB,EAChBC,CAAS,EACTC,CAAS,EACTC,CAAS,EACTC,CAAS,EACuC;EAChD,MAAMC,OAAO,GAAIC,CAAS,IAAMA,CAAC,GAAG,CAAC,GAAG,CAAC,GAAGA,CAAC,GAAG,CAAC,GAAG,CAAC,GAAGA,CAAE;EAC1D,MAAMC,CAAC,GAAGP,MAAM;EAChB,OAAO;IACL;IACAC,CAAC,EAAEI,OAAO,CAACE,CAAC,CAAC,CAAC,CAAC,GAAIN,CAAC,GAAGM,CAAC,CAAC,CAAC,CAAC,GAAIL,CAAC,GAAGK,CAAC,CAAC,CAAC,CAAC,GAAIJ,CAAC,GAAGI,CAAC,CAAC,CAAC,CAAC,GAAIH,CAAC,GAAGG,CAAC,CAAC,CAAC,CAAE,CAAC;IACjEL,CAAC,EAAEG,OAAO,CAACE,CAAC,CAAC,CAAC,CAAC,GAAIN,CAAC,GAAGM,CAAC,CAAC,CAAC,CAAC,GAAIL,CAAC,GAAGK,CAAC,CAAC,CAAC,CAAC,GAAIJ,CAAC,GAAGI,CAAC,CAAC,CAAC,CAAC,GAAIH,CAAC,GAAGG,CAAC,CAAC,CAAC,CAAE,CAAC;IACjEJ,CAAC,EAAEE,OAAO,CAACE,CAAC,CAAC,EAAE,CAAC,GAAIN,CAAC,GAAGM,CAAC,CAAC,EAAE,CAAC,GAAIL,CAAC,GAAGK,CAAC,CAAC,EAAE,CAAC,GAAIJ,CAAC,GAAGI,CAAC,CAAC,EAAE,CAAC,GAAIH,CAAC,GAAGG,CAAC,CAAC,EAAE,CAAE,CAAC;IACtEH,CAAC,EAAEG,CAAC,CAAC,EAAE,CAAC,GAAIN,CAAC,GAAGM,CAAC,CAAC,EAAE,CAAC,GAAIL,CAAC,GAAGK,CAAC,CAAC,EAAE,CAAC,GAAIJ,CAAC,GAAGI,CAAC,CAAC,EAAE,CAAC,GAAIH,CAAC,GAAGG,CAAC,CAAC,EAAE;EAC7D,CAAC;AACH","ignoreList":[]}

package/lib/module/pipeline/types.js

@@ -0,0 +1,23 @@
+"use strict";
+
+/**
+ * Shared value types for the canonical pipeline reference implementation.
+ *
+ * INTERNAL MODULE. Nothing here is re-exported from src/index.ts. These types
+ * describe the language-neutral contract that both native backends implement;
+ * they are the executable form of docs/PIPELINE_SPEC.md.
+ */
+
+/** Integer downsample factor actually used by the pipeline (never 'auto'). */
+
+/** The four concrete downsample factors, largest first (selection order). */
+export const DOWNSAMPLE_FACTORS = [8, 4, 2, 1];
+
+/**
+ * Axis-aligned rectangle. Units are documented per-field by the producing
+ * function (device px in target-local space, or snapshot px). Origin is the
+ * top-left corner; width/height grow right/down.
+ */
+
+/** Straight-alpha RGBA colour, all channels normalised to [0, 1]. */
+//# sourceMappingURL=types.js.map

package/lib/module/pipeline/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DOWNSAMPLE_FACTORS"],"sourceRoot":"../../../src","sources":["pipeline/types.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;;AAGA;AACA,OAAO,MAAMA,kBAAyC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;;AAErE;AACA;AACA;AACA;AACA;;AAQA","ignoreList":[]}

package/lib/module/pipeline/units.js

@@ -0,0 +1,33 @@
+"use strict";
+
+/**
+ * Canonical unit conversions (plan §5.1).
+ *
+ * INTERNAL MODULE. Pure functions, no side effects, no react-native imports.
+ *
+ *   blurRadius   = Gaussian sigma in dp (public unit)
+ *   sigmaPx      = blurRadius * displayScale         (device pixels)
+ *   sigmaSnapshot= sigmaPx / D                        (downsampled snapshot px)
+ *
+ * The blur backend always receives a parameter derived from sigmaSnapshot.
+ */
+
+/**
+ * Convert the public blurRadius (sigma in dp) to sigma in device pixels.
+ * Non-finite or negative inputs clamp to 0 (plan §28 safe clamping).
+ */
+export function sigmaPxFromDp(blurRadiusDp, displayScale) {
+  if (!Number.isFinite(blurRadiusDp) || blurRadiusDp <= 0) return 0;
+  if (!Number.isFinite(displayScale) || displayScale <= 0) return 0;
+  return blurRadiusDp * displayScale;
+}
+
+/**
+ * Convert device-pixel sigma to snapshot-domain sigma given a downsample
+ * factor D. D is a positive integer in {1,2,4,8}.
+ */
+export function sigmaSnapshotFromPx(sigmaPx, downsample) {
+  if (!Number.isFinite(sigmaPx) || sigmaPx <= 0) return 0;
+  return sigmaPx / downsample;
+}
+//# sourceMappingURL=units.js.map