react-native-parity-blur 0.1.0

package/ios/PipelineMath.swift

@@ -0,0 +1,177 @@
+import Foundation
+
+/// Swift mirror of the canonical pipeline reference (docs/PIPELINE_SPEC.md; src/pipeline/*.ts).
+/// Pure math, no UIKit/Metal imports — the SPM fixture suite (swift-tests/) compiles this same
+/// file against test/pipeline-fixtures.json, exactly like the Kotlin PipelineMath JVM tests.
+/// When the spec changes, change TS + Kotlin + this file in the same commit.
+public enum PipelineMath {
+
+  // MARK: - Constants (PIPELINE_SPEC §2, §3, §4, §7 — single home on the iOS side)
+
+  /// Gaussian support multiplier for capture expansion (spec §3.1).
+  public static let captureSupportK = 3.0
+  /// Auto-downsample: keep sigmaSnapshot >= this many snapshot px (spec §4).
+  public static let minSigmaSnapshot = 1.0
+  /// Auto-downsample: captures below this area (device px^2) never exceed 2x (spec §4).
+  public static let smallCaptureAreaPx = 256.0 * 256.0
+  /// Rec. 709 luma coefficients (spec §7).
+  public static let lumaR = 0.2126
+  public static let lumaG = 0.7152
+  public static let lumaB = 0.0722
+
+  public struct Rect: Equatable {
+    public var x: Double
+    public var y: Double
+    public var width: Double
+    public var height: Double
+    public init(x: Double, y: Double, width: Double, height: Double) {
+      self.x = x; self.y = y; self.width = width; self.height = height
+    }
+  }
+
+  public struct RGBA: Equatable {
+    public var r: Double
+    public var g: Double
+    public var b: Double
+    public var a: Double
+    public init(r: Double, g: Double, b: Double, a: Double) {
+      self.r = r; self.g = g; self.b = b; self.a = a
+    }
+  }
+
+  // MARK: - Units (spec §1)
+
+  public static func sigmaPxFromDp(_ blurRadiusDp: Double, displayScale: Double) -> Double {
+    guard blurRadiusDp.isFinite, blurRadiusDp > 0 else { return 0 }
+    guard displayScale.isFinite, displayScale > 0 else { return 0 }
+    return blurRadiusDp * displayScale
+  }
+
+  public static func sigmaSnapshotFromPx(_ sigmaPx: Double, downsample: Int) -> Double {
+    guard sigmaPx.isFinite, sigmaPx > 0 else { return 0 }
+    return sigmaPx / Double(downsample)
+  }
+
+  /// iOS blur parameter (spec §2): MPSImageGaussianBlur takes the snapshot sigma directly.
+  public static func iosSigmaForSigma(_ sigmaSnapshot: Double) -> Double {
+    guard sigmaSnapshot.isFinite, sigmaSnapshot > 0 else { return 0 }
+    return sigmaSnapshot
+  }
+
+  // MARK: - Downsample selection (spec §4)
+
+  public static func autoDownsample(sigmaPx: Double, captureAreaPx: Double, quality: String) -> Int {
+    guard sigmaPx.isFinite, sigmaPx > 0 else { return 1 }
+    let maxByQuality: Int
+    switch quality {
+    case "high": maxByQuality = 2
+    case "performance": maxByQuality = 8
+    default: maxByQuality = 4 // balanced
+    }
+    let maxBySigma = Int((sigmaPx / minSigmaSnapshot).rounded(.down))
+    let area = captureAreaPx.isFinite ? captureAreaPx : 0
+    let maxByArea = area < smallCaptureAreaPx ? 2 : 8
+    let cap = min(maxByQuality, min(maxBySigma, maxByArea))
+    for factor in [8, 4, 2, 1] where factor <= cap {
+      return factor
+    }
+    return 1
+  }
+
+  public static func resolveDownsample(
+    prop: Int, sigmaPx: Double, captureAreaPx: Double, quality: String
+  ) -> Int {
+    // 0 = the 'auto' sentinel (see ParityBlurViewNativeComponent.ts).
+    if prop == 1 || prop == 2 || prop == 4 || prop == 8 { return prop }
+    return autoDownsample(sigmaPx: sigmaPx, captureAreaPx: captureAreaPx, quality: quality)
+  }
+
+  // MARK: - Capture-rect math (spec §3); all rects in target-local DEVICE PX
+
+  public static func supportMarginPx(_ sigmaPx: Double, k: Double = captureSupportK) -> Double {
+    guard sigmaPx.isFinite, sigmaPx > 0 else { return 0 }
+    return (k * sigmaPx).rounded(.up)
+  }
+
+  public static func intersect(_ a: Rect, _ b: Rect) -> Rect {
+    let x0 = max(a.x, b.x)
+    let y0 = max(a.y, b.y)
+    let x1 = min(a.x + a.width, b.x + b.width)
+    let y1 = min(a.y + a.height, b.y + b.height)
+    let w = max(0, x1 - x0)
+    let h = max(0, y1 - y0)
+    if w == 0 || h == 0 { return Rect(x: x0, y: y0, width: 0, height: 0) }
+    return Rect(x: x0, y: y0, width: w, height: h)
+  }
+
+  public static func expandCaptureRect(
+    visible: Rect, targetBounds: Rect, sigmaPx: Double, k: Double = captureSupportK
+  ) -> Rect {
+    let m = supportMarginPx(sigmaPx, k: k)
+    let expanded = Rect(
+      x: visible.x - m, y: visible.y - m,
+      width: visible.width + 2 * m, height: visible.height + 2 * m
+    )
+    return intersect(expanded, targetBounds)
+  }
+
+  public static func rectArea(_ r: Rect) -> Double { r.width * r.height }
+
+  /// Snapshot rect in INTEGER snapshot px: origin FLOORS, far edge CEILS (locked rule, spec §3.3).
+  public static func snapshotRectFor(_ captureRectPx: Rect, downsample: Int) -> Rect {
+    let d = Double(downsample)
+    let x = (captureRectPx.x / d).rounded(.down)
+    let y = (captureRectPx.y / d).rounded(.down)
+    let farX = ((captureRectPx.x + captureRectPx.width) / d).rounded(.up)
+    let farY = ((captureRectPx.y + captureRectPx.height) / d).rounded(.up)
+    return Rect(x: x, y: y, width: max(0, farX - x), height: max(0, farY - y))
+  }
+
+  /// Fractional crop rect in SNAPSHOT PX selecting the visible region (spec §3.4).
+  public static func cropRectFor(visible: Rect, snapshotRect: Rect, downsample: Int) -> Rect {
+    let d = Double(downsample)
+    return Rect(
+      x: visible.x / d - snapshotRect.x,
+      y: visible.y / d - snapshotRect.y,
+      width: visible.width / d,
+      height: visible.height / d
+    )
+  }
+
+  // MARK: - Saturation matrix (spec §7): row-major 4x5, Android ColorMatrix layout
+
+  public static func saturationMatrix(
+    _ s: Double, lr: Double = lumaR, lg: Double = lumaG, lb: Double = lumaB
+  ) -> [Double] {
+    let 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,
+    ]
+  }
+
+  public static func applySaturation(
+    matrix m: [Double], r: Double, g: Double, b: Double, a: Double
+  ) -> RGBA {
+    func c01(_ v: Double) -> Double { v < 0 ? 0 : (v > 1 ? 1 : v) }
+    return RGBA(
+      r: c01(m[0] * r + m[1] * g + m[2] * b + m[3] * a + m[4]),
+      g: c01(m[5] * r + m[6] * g + m[7] * b + m[8] * a + m[9]),
+      b: c01(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]
+    )
+  }
+
+  // MARK: - Overlay source-over (spec §8), straight alpha
+
+  public static func sourceOver(src: RGBA, dst: RGBA) -> RGBA {
+    let outA = src.a + dst.a * (1 - src.a)
+    guard outA > 0 else { return RGBA(r: 0, g: 0, b: 0, a: 0) }
+    func blend(_ sc: Double, _ dc: Double) -> Double {
+      (sc * src.a + dc * dst.a * (1 - src.a)) / outA
+    }
+    return RGBA(r: blend(src.r, dst.r), g: blend(src.g, dst.g), b: blend(src.b, dst.b), a: outA)
+  }
+}

package/ios/SnapshotProvider.swift

@@ -0,0 +1,128 @@
+import Foundation
+import UIKit
+
+/// Exclusion registry (plan §16): every ParityBlur presentation surface registers here and is
+/// hidden at the MODEL-layer level for the duration of a capture pass, restored before the
+/// runloop commits — the render server never sees the hidden state (M0-verified flicker-free;
+/// presentation-layer probe measured 0 leaks).
+final class BlurSurfaceRegistry {
+  static let shared = BlurSurfaceRegistry()
+  private let table = NSHashTable<UIView>.weakObjects()
+  func register(_ v: UIView) { table.add(v) }
+  func unregister(_ v: UIView) { table.remove(v) }
+  var all: [UIView] { table.allObjects }
+}
+
+/// Reusable CPU snapshot buffer: BGRA8, premultiplied, sRGB-ENCODED bytes. The bytes are
+/// uploaded to a non-sRGB (.bgra8Unorm) texture so the GPU convolves the encoded values —
+/// gamma-space blur, matching Android/Skia (spec §6; M0 color-domain proof).
+final class SnapshotBuffer {
+  private(set) var width = 0
+  private(set) var height = 0
+  private(set) var bytesPerRow = 0
+  private(set) var data: UnsafeMutableRawPointer?
+  private(set) var context: CGContext?
+
+  func ensure(width w: Int, height h: Int) -> Bool {
+    guard w > 0, h > 0 else { return false }
+    if w == width && h == height, context != nil { return true }
+    release()
+    bytesPerRow = ((w * 4 + 63) / 64) * 64
+    guard let mem = malloc(bytesPerRow * h) else { return false }
+    data = mem
+    let space = CGColorSpace(name: CGColorSpace.sRGB)!
+    let info = CGImageAlphaInfo.premultipliedFirst.rawValue | CGBitmapInfo.byteOrder32Little.rawValue
+    guard let ctx = CGContext(
+      data: mem, width: w, height: h, bitsPerComponent: 8,
+      bytesPerRow: bytesPerRow, space: space, bitmapInfo: info
+    ) else {
+      release()
+      return false
+    }
+    context = ctx
+    width = w
+    height = h
+    return true
+  }
+
+  func release() {
+    free(data)
+    data = nil
+    context = nil
+    width = 0
+    height = 0
+    bytesPerRow = 0
+  }
+
+  deinit { free(data) }
+}
+
+/// Capture request: everything is expressed in the SNAPSHOT-PIXEL grid derived by PipelineMath
+/// (spec §3): the buffer's pixel (0,0) is snapshotRect's origin, honoring the locked
+/// floor-origin/ceil-far-edge rounding.
+struct SnapshotRequest {
+  let target: UIView
+  /// Integer snapshot-pixel rect (PipelineMath.snapshotRectFor output).
+  let snapshotRect: PipelineMath.Rect
+  /// Downsample factor D.
+  let downsample: Int
+  /// Device pixels per point (UIScreen scale).
+  let displayScale: CGFloat
+}
+
+/// Snapshot provider abstraction (plan §15.3). v1 ships the model-state provider as default;
+/// a committed-state drawHierarchy provider can slot in later for structurally-separate targets
+/// (M0: drawHierarchy renders the last committed frame and cannot honor model-layer exclusion).
+protocol SnapshotProvider: AnyObject {
+  var buffer: SnapshotBuffer { get }
+  @discardableResult
+  func capture(_ req: SnapshotRequest, excluding: [UIView]) -> Bool
+}
+
+/// Default provider (M0 finding 1): CALayer.render(in:) renders MODEL state, so registry
+/// exclusion works in-tree, and the mandatory clip keeps cost proportional to the capture
+/// region (M0: 4.8x cheaper with the clip).
+final class LayerRenderSnapshotProvider: SnapshotProvider {
+  let buffer = SnapshotBuffer()
+
+  @discardableResult
+  func capture(_ req: SnapshotRequest, excluding: [UIView]) -> Bool {
+    let w = Int(req.snapshotRect.width)
+    let h = Int(req.snapshotRect.height)
+    guard buffer.ensure(width: w, height: h), let ctx = buffer.context else { return false }
+
+    var saved: [(CALayer, Bool)] = []
+    for v in excluding {
+      saved.append((v.layer, v.layer.isHidden))
+      v.layer.isHidden = true
+    }
+    defer {
+      // Restore within the same runloop turn — never committed (plan §16.5/§16.6).
+      for (layer, wasHidden) in saved { layer.isHidden = wasHidden }
+    }
+
+    // Points-per-snapshot-pixel and the buffer origin in target-local points.
+    let d = Double(req.downsample)
+    let scale = Double(req.displayScale)
+    let pxPerPoint = scale / d // snapshot px per point
+    let originPtX = req.snapshotRect.x * d / scale
+    let originPtY = req.snapshotRect.y * d / scale
+    let capturePtRect = CGRect(
+      x: originPtX, y: originPtY,
+      width: Double(w) / pxPerPoint, height: Double(h) / pxPerPoint
+    )
+
+    ctx.saveGState()
+    ctx.clear(CGRect(x: 0, y: 0, width: CGFloat(w), height: CGFloat(h)))
+    // Flip to UIKit coordinates, then map the capture rect onto the buffer.
+    ctx.translateBy(x: 0, y: CGFloat(h))
+    ctx.scaleBy(x: 1, y: -1)
+    ctx.scaleBy(x: CGFloat(pxPerPoint), y: CGFloat(pxPerPoint))
+    ctx.translateBy(x: CGFloat(-originPtX), y: CGFloat(-originPtY))
+    // Mandatory clip (M0 finding 2): lets CoreGraphics cull content outside the region.
+    ctx.clip(to: capturePtRect)
+    req.target.layer.render(in: ctx)
+    ctx.restoreGState()
+    return true
+  }
+}

package/ios/WindowBlurContext.swift

@@ -0,0 +1,111 @@
+import Foundation
+import UIKit
+
+/// Per-window active-view registry + capture scheduling (plan §15.2, §20, §21, §39).
+///
+/// STATIC mode: capture requests coalesce to ONE capture per view on the next main-runloop
+/// turn (plan §29, §45.8).
+///
+/// LIVE mode (Milestone 6): ONE shared CADisplayLink per window — never one per view (plan
+/// §45.6) — created when the first live view registers and torn down when the last leaves
+/// (plan §24/§27: zero frame work while no live blur is visible). Each tick filters by the
+/// visibility heuristic and each view's own maxFps throttle + in-flight backpressure
+/// (plan §21/§22: at most 1 in-flight GPU pass per view, latest-wins, stale frames dropped).
+/// The link pauses while the app is inactive (plan §21 app/scene lifecycle pause).
+final class WindowBlurContext {
+
+  /// Attached ParityBlur core views in this window (weak bookkeeping).
+  private let activeViews = NSHashTable<ParityBlurCoreView>.weakObjects()
+
+  private var pendingCaptures = NSHashTable<ParityBlurCoreView>.weakObjects()
+  private var flushScheduled = false
+
+  // ------------------------------------------------------------------- live (Milestone 6)
+
+  private let liveViews = NSHashTable<ParityBlurCoreView>.weakObjects()
+  private var displayLink: CADisplayLink?
+  private var lifecycleObservers: [NSObjectProtocol] = []
+
+  /// CADisplayLink retains its target; this proxy breaks the cycle so the context (and its
+  /// window) can deallocate naturally.
+  private final class LinkProxy {
+    weak var context: WindowBlurContext?
+    init(_ c: WindowBlurContext) { context = c }
+    @objc func tick(_ link: CADisplayLink) { context?.liveTick(link) }
+  }
+
+  deinit {
+    displayLink?.invalidate()
+    for o in lifecycleObservers { NotificationCenter.default.removeObserver(o) }
+  }
+
+  func register(_ view: ParityBlurCoreView) {
+    activeViews.add(view)
+  }
+
+  func unregister(_ view: ParityBlurCoreView) {
+    activeViews.remove(view)
+    pendingCaptures.remove(view)
+    unregisterLive(view)
+  }
+
+  func registerLive(_ view: ParityBlurCoreView) {
+    liveViews.add(view)
+    ensureDisplayLink()
+  }
+
+  func unregisterLive(_ view: ParityBlurCoreView) {
+    liveViews.remove(view)
+    if liveViews.count == 0 {
+      displayLink?.invalidate()
+      displayLink = nil
+      ParityBlurDebug.log("scheduler-uninstall window=\(ObjectIdentifier(self))")
+    }
+  }
+
+  private func ensureDisplayLink() {
+    guard displayLink == nil else { return }
+    let link = CADisplayLink(target: LinkProxy(self), selector: #selector(LinkProxy.tick(_:)))
+    // Cap the link at the highest maxFps among live views; per-view throttles refine below it.
+    let cap = Float(liveViews.allObjects.map(\.maxFps).max() ?? 30)
+    link.preferredFrameRateRange = CAFrameRateRange(minimum: 10, maximum: cap, preferred: cap)
+    link.add(to: .main, forMode: .common)
+    displayLink = link
+    ParityBlurDebug.log("scheduler-install window=\(ObjectIdentifier(self))")
+
+    if lifecycleObservers.isEmpty {
+      let nc = NotificationCenter.default
+      lifecycleObservers.append(nc.addObserver(
+        forName: UIApplication.willResignActiveNotification, object: nil, queue: .main
+      ) { [weak self] _ in self?.displayLink?.isPaused = true })
+      lifecycleObservers.append(nc.addObserver(
+        forName: UIApplication.didBecomeActiveNotification, object: nil, queue: .main
+      ) { [weak self] _ in self?.displayLink?.isPaused = false })
+    }
+  }
+
+  private func liveTick(_ link: CADisplayLink) {
+    let now = link.timestamp
+    for view in liveViews.allObjects where view.isLiveEligible(now: now) {
+      view.performLiveTick(now: now)
+    }
+  }
+
+  /// Coalesce a static capture request to the next main-runloop turn (plan §20).
+  func scheduleCapture(_ view: ParityBlurCoreView) {
+    pendingCaptures.add(view)
+    guard !flushScheduled else { return }
+    flushScheduled = true
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      self.flushScheduled = false
+      let batch = self.pendingCaptures.allObjects
+      self.pendingCaptures.removeAllObjects()
+      for v in batch where v.window != nil {
+        v.performScheduledCapture()
+      }
+    }
+  }
+
+  var isEmpty: Bool { activeViews.count == 0 }
+}

package/lib/module/BlurView.js

@@ -0,0 +1,124 @@
+"use strict";
+
+import * as React from 'react';
+import NativeParityBlurView, { Commands as NativeCommands } from './ParityBlurViewNativeComponent';
+import { DEFAULT_BLUR_RADIUS, DEFAULT_DOWNSAMPLE, DEFAULT_MAX_FPS, DEFAULT_MODE, DEFAULT_OVERLAY_COLOR, DEFAULT_QUALITY, DEFAULT_SATURATION, MAX_MAX_FPS, MIN_MAX_FPS } from "./defaults.js";
+import { BlurPresets } from "./presets.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const LOG_TAG = '[react-native-parity-blur]';
+function clampBlurRadius(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return DEFAULT_BLUR_RADIUS;
+  }
+  return value < 0 ? 0 : value;
+}
+function clampSaturation(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return DEFAULT_SATURATION;
+  }
+  return value < 0 ? 0 : value;
+}
+function clampMaxFps(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return DEFAULT_MAX_FPS;
+  }
+  return Math.min(MAX_MAX_FPS, Math.max(MIN_MAX_FPS, value));
+}
+
+/**
+ * Normalizes the public `downsample` prop (`'auto' | 1 | 2 | 4 | 8`) into the
+ * Int32 the native Fabric prop accepts, where `0` is a sentinel for `'auto'`.
+ * See the deviation note in ParityBlurViewNativeComponent.ts for why this
+ * isn't a string/numeric enum.
+ */
+function normalizeDownsample(value) {
+  if (value === undefined || value === 'auto') {
+    return 0;
+  }
+  if (value === 1 || value === 2 || value === 4 || value === 8) {
+    return value;
+  }
+  if (__DEV__) {
+    console.warn(`${LOG_TAG} Invalid "downsample" value: ${JSON.stringify(value)}. Expected 'auto' | 1 | 2 | 4 | 8. Falling back to '${DEFAULT_DOWNSAMPLE}'.`);
+  }
+  return 0;
+}
+/**
+ * Public backdrop blur component (plan §28/§29/§30).
+ *
+ * Renders the native ParityBlurView host view backed by a real blur on both
+ * platforms: Android API 31+ real-time `RenderEffect` Gaussian blur (older
+ * Android renders `fallbackColor` instead — real CPU blur is intentionally
+ * out of scope, plan §44), iOS `MPSImageGaussianBlur`. `refresh()` is fully
+ * wired to a native coalesced recapture (plan §29). See
+ * docs/PIPELINE_SPEC.md for the canonical pipeline both backends implement
+ * and docs/CALIBRATION_REPORT.md for measured cross-platform parity.
+ */
+export const BlurView = /*#__PURE__*/React.forwardRef(function BlurView(props, ref) {
+  const {
+    preset,
+    blurRadius,
+    mode = DEFAULT_MODE,
+    overlayColor,
+    saturation,
+    quality = DEFAULT_QUALITY,
+    downsample,
+    maxFps,
+    fallbackColor,
+    // Accepted for public-API shape stability (plan §18); not yet wired
+    // to native capture logic. Deferred to v1.1 — see docs/LIMITATIONS.md.
+    blurTarget: _blurTarget,
+    children,
+    style
+  } = props;
+
+  // A preset (plan §11) is pure JS sugar for a base
+  // { blurRadius, saturation, overlayColor } bundle — resolved here,
+  // client-side, with no native awareness of presets at all. Any of
+  // those three props passed explicitly above still wins per-prop.
+  const presetProps = preset ? BlurPresets[preset] : undefined;
+  const resolvedBlurRadius = blurRadius ?? presetProps?.blurRadius;
+  const resolvedSaturation = saturation ?? presetProps?.saturation;
+  const resolvedOverlayColor = overlayColor ?? presetProps?.overlayColor ?? DEFAULT_OVERLAY_COLOR;
+  const nativeRef = React.useRef(null);
+  React.useImperativeHandle(ref, () => ({
+    refresh() {
+      if (nativeRef.current) {
+        NativeCommands.refresh(nativeRef.current);
+      }
+    }
+  }), []);
+  if (__DEV__) {
+    if (preset !== undefined && !(preset in BlurPresets)) {
+      console.warn(`${LOG_TAG} Unknown "preset" value: ${JSON.stringify(preset)}. Ignoring.`);
+    }
+    if (blurRadius !== undefined && (typeof blurRadius !== 'number' || !Number.isFinite(blurRadius) || blurRadius < 0)) {
+      console.warn(`${LOG_TAG} "blurRadius" must be a finite number >= 0. Received: ${blurRadius}. Clamping to ${clampBlurRadius(blurRadius)}.`);
+    }
+    if (saturation !== undefined && (typeof saturation !== 'number' || !Number.isFinite(saturation) || saturation < 0)) {
+      console.warn(`${LOG_TAG} "saturation" must be a finite number >= 0. Received: ${saturation}. Clamping to ${clampSaturation(saturation)}.`);
+    }
+    if (maxFps !== undefined && (typeof maxFps !== 'number' || !Number.isFinite(maxFps) || maxFps < MIN_MAX_FPS || maxFps > MAX_MAX_FPS)) {
+      console.warn(`${LOG_TAG} "maxFps" must be a finite number between ${MIN_MAX_FPS} and ${MAX_MAX_FPS}. Received: ${maxFps}. Clamping to ${clampMaxFps(maxFps)}.`);
+    }
+  }
+  const safeBlurRadius = clampBlurRadius(resolvedBlurRadius);
+  const safeSaturation = clampSaturation(resolvedSaturation);
+  const safeMaxFps = clampMaxFps(maxFps);
+  const safeDownsample = normalizeDownsample(downsample);
+  return /*#__PURE__*/_jsx(NativeParityBlurView, {
+    ref: nativeRef,
+    style: style,
+    blurRadius: safeBlurRadius,
+    mode: mode,
+    overlayColor: resolvedOverlayColor,
+    saturation: safeSaturation,
+    quality: quality,
+    downsample: safeDownsample,
+    maxFps: safeMaxFps,
+    fallbackColor: fallbackColor,
+    children: children
+  });
+});
+export default BlurView;
+//# sourceMappingURL=BlurView.js.map

package/lib/module/BlurView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","NativeParityBlurView","Commands","NativeCommands","DEFAULT_BLUR_RADIUS","DEFAULT_DOWNSAMPLE","DEFAULT_MAX_FPS","DEFAULT_MODE","DEFAULT_OVERLAY_COLOR","DEFAULT_QUALITY","DEFAULT_SATURATION","MAX_MAX_FPS","MIN_MAX_FPS","BlurPresets","jsx","_jsx","LOG_TAG","clampBlurRadius","value","Number","isFinite","clampSaturation","clampMaxFps","Math","min","max","normalizeDownsample","undefined","__DEV__","console","warn","JSON","stringify","BlurView","forwardRef","props","ref","preset","blurRadius","mode","overlayColor","saturation","quality","downsample","maxFps","fallbackColor","blurTarget","_blurTarget","children","style","presetProps","resolvedBlurRadius","resolvedSaturation","resolvedOverlayColor","nativeRef","useRef","useImperativeHandle","refresh","current","safeBlurRadius","safeSaturation","safeMaxFps","safeDownsample"],"sourceRoot":"../../src","sources":["BlurView.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/ParityBlurViewNativeComponent.ts

@@ -0,0 +1,82 @@
+/**
+ * Fabric codegen spec for the ParityBlurView native host view.
+ *
+ * Every public prop from plan §28 is plumbed through to native, and the
+ * `refresh()` Fabric command is wired end-to-end to a real coalesced
+ * recapture. Both native backends (Android Kotlin, iOS Swift) implement the
+ * real capture/blur/saturate/overlay pipeline defined in
+ * docs/PIPELINE_SPEC.md — this file only declares the codegen shape, not
+ * the behavior.
+ *
+ * Deviation from plan §28 (documented in the Milestone 1 report): the public
+ * `downsample` prop is `'auto' | 1 | 2 | 4 | 8` (see src/types.ts). Fabric
+ * codegen's TypeScript parser rejects a union that mixes string and numeric
+ * literals for one prop ("Mixed types are not supported"), and a plain
+ * string enum with numeric-looking values ('1', '2', ...) is also unsafe
+ * because the iOS/C++ generator turns each enum option into a bare
+ * identifier (`ParityBlurViewDownsample::1` is not valid C++). Instead this
+ * native prop is a plain Int32 where `0` is a sentinel for `'auto'` and
+ * `1 | 2 | 4 | 8` pass through unchanged. `src/BlurView.tsx` performs the
+ * 'auto' <-> 0 translation; native code treats 0 as "auto".
+ *
+ * Note: this file deliberately imports everything from the 'react-native'
+ * package root rather than deep 'react-native/Libraries/...' paths. This
+ * project's tsconfig opts into the `react-native-strict-api` custom
+ * condition, and react-native's package.json `exports` map explicitly
+ * blocks deep `Libraries/*` subpath imports under that condition -- so
+ * `codegenNativeCommands`, `codegenNativeComponent`, and the CodegenTypes
+ * (Double/Int32/WithDefault) must come from the root barrel, which
+ * re-exports all three for exactly this reason.
+ *
+ * Also note: do NOT re-export `CodegenTypes.WithDefault`/`Double`/`Int32` as
+ * local generic type aliases (an earlier draft of this file did, to shorten
+ * the qualified names). @react-native/codegen's alias resolution does plain
+ * textual substitution with no generic instantiation, so a chain like
+ * `NativeBlurMode -> WithDefault<'static'|'live','static'> -> (local
+ * `WithDefault<Type,Value>` alias) -> CodegenTypes.WithDefault<Type,Value>`
+ * loses the real type arguments and fails with "The default value in
+ * WithDefault must be string, number, boolean or null." Referencing
+ * `CodegenTypes.WithDefault<...>` directly (qualified) avoids the extra
+ * alias hop and keeps the real arguments intact.
+ */
+import {
+  codegenNativeCommands,
+  codegenNativeComponent,
+  type CodegenTypes,
+  type ColorValue,
+  type HostComponent,
+  type ViewProps,
+} from 'react-native';
+import type * as React from 'react';
+
+type NativeBlurMode = CodegenTypes.WithDefault<'static' | 'live', 'static'>;
+type NativeBlurQuality = CodegenTypes.WithDefault<
+  'high' | 'balanced' | 'performance',
+  'balanced'
+>;
+
+export interface NativeProps extends ViewProps {
+  blurRadius?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  mode?: NativeBlurMode;
+  overlayColor?: ColorValue;
+  saturation?: CodegenTypes.WithDefault<CodegenTypes.Double, 1>;
+  quality?: NativeBlurQuality;
+  // 0 = 'auto' sentinel; see file-level deviation note above.
+  downsample?: CodegenTypes.WithDefault<CodegenTypes.Int32, 0>;
+  maxFps?: CodegenTypes.WithDefault<CodegenTypes.Int32, 30>;
+  fallbackColor?: ColorValue;
+}
+
+type ComponentType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  refresh: (viewRef: React.ComponentRef<ComponentType>) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['refresh'],
+});
+
+export default codegenNativeComponent<NativeProps>(
+  'ParityBlurView'
+) as ComponentType;

package/lib/module/defaults.js

@@ -0,0 +1,13 @@
+"use strict";
+
+export const DEFAULT_BLUR_RADIUS = 0;
+export const DEFAULT_MODE = 'static';
+export const DEFAULT_OVERLAY_COLOR = 'transparent';
+export const DEFAULT_SATURATION = 1;
+export const DEFAULT_QUALITY = 'balanced';
+export const DEFAULT_DOWNSAMPLE = 'auto';
+export const DEFAULT_MAX_FPS = 30;
+export const MIN_MAX_FPS = 1;
+export const MAX_MAX_FPS = 120;
+export const ALLOWED_DOWNSAMPLE_VALUES = ['auto', 1, 2, 4, 8];
+//# sourceMappingURL=defaults.js.map

package/lib/module/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DEFAULT_BLUR_RADIUS","DEFAULT_MODE","DEFAULT_OVERLAY_COLOR","DEFAULT_SATURATION","DEFAULT_QUALITY","DEFAULT_DOWNSAMPLE","DEFAULT_MAX_FPS","MIN_MAX_FPS","MAX_MAX_FPS","ALLOWED_DOWNSAMPLE_VALUES"],"sourceRoot":"../../src","sources":["defaults.ts"],"mappings":";;AAEA,OAAO,MAAMA,mBAAmB,GAAG,CAAC;AACpC,OAAO,MAAMC,YAAsB,GAAG,QAAQ;AAC9C,OAAO,MAAMC,qBAAqB,GAAG,aAAa;AAClD,OAAO,MAAMC,kBAAkB,GAAG,CAAC;AACnC,OAAO,MAAMC,eAA4B,GAAG,UAAU;AACtD,OAAO,MAAMC,kBAAkC,GAAG,MAAM;AACxD,OAAO,MAAMC,eAAe,GAAG,EAAE;AAEjC,OAAO,MAAMC,WAAW,GAAG,CAAC;AAC5B,OAAO,MAAMC,WAAW,GAAG,GAAG;AAE9B,OAAO,MAAMC,yBAAwD,GAAG,CACtE,MAAM,EACN,CAAC,EACD,CAAC,EACD,CAAC,EACD,CAAC,CACF","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export { BlurView, default } from "./BlurView.js";
+export { BlurPresets } from "./presets.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BlurView","default","BlurPresets"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,QAAQ,EAAEC,OAAO,QAAQ,eAAY;AAQ9C,SAASC,WAAW,QAAQ,cAAW","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}