react-native-webrtc-kaleidoscope 2.0.0 → 2.1.0

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Native entry point. Metro picks this up via package.json \"react-native\"\n// and the \".\" subpath export's \"react-native\" condition.\n//\n// Thin facade over `track._setVideoEffects(names)` from react-native-webrtc.\n// Native frame processors are registered at app boot by the Expo Module's\n// OnCreate hook (see android/.../KaleidoscopeModule.kt and ios/.../KaleidoscopeModule.swift);\n// this facade just dispatches into the existing upstream registry.\n\nimport { requireNativeModule } from 'expo-modules-core';\nimport { Platform } from 'react-native';\nimport { BACKGROUND_PRESETS } from './backgrounds';\nimport { type ApplyVideoEffects, toEffectSpec } from './types';\n\ninterface KaleidoscopeNativeModule {\n  setBlurSigma: (value: number) => void;\n  setMaskHardness: (value: number) => void;\n  setMaskThreshold: (value: number) => void;\n  setSegmentationTargetShortSide: (value: number) => void;\n  setDebugTiming: (value: boolean) => void;\n  resetEffectTuning: () => void;\n}\n\n// Lazy because the module is not available during pure-JS tests; the\n// getter throws if you call a setter outside a real native runtime, which\n// is the right failure mode.\nconst nativeModule = (): KaleidoscopeNativeModule =>\n  requireNativeModule<KaleidoscopeNativeModule>('RnWebrtcKaleidoscope');\n\n/**\n * Set the Gaussian sigma for the blur effect. Higher = softer blur.\n * Clamped to [0.5, 7] (the useful range before the linear-sampled kernel\n * truncates and bands). Default 5.\n */\nexport const setBlurSigma = (value: number): void => {\n  nativeModule().setBlurSigma(value);\n};\n\n/**\n * Set the mask smoothstep hardness for blur and background-image\n * composites, in [0, 1]. 0 = soft halo, 1 = near-step edge. Default 0.5.\n */\nexport const setMaskHardness = (value: number): void => {\n  nativeModule().setMaskHardness(value);\n};\n\n/**\n * Set the mask smoothstep threshold (center of the transition) in\n * [0.05, 0.95]. 0.5 is neutral. Higher values reject low-confidence\n * pixels (helps tighten the silhouette against chair-edge noise);\n * lower values are more inclusive. Optimal value is platform-specific:\n * all three platforms run MediaPipe selfie segmentation, but the input\n * downscale and API variant differ and produce different confidence\n * distributions.\n */\nexport const setMaskThreshold = (value: number): void => {\n  nativeModule().setMaskThreshold(value);\n};\n\n/**\n * Set the segmentation input short-side (px). The person mask is computed from\n * an input downscaled to this; lower = cheaper segmentation (helps on older\n * devices like the A11), softer mask edge. Default 384, clamped [128, 1080]\n * identically on both native platforms. Native only; the web pipeline ignores it.\n */\nexport const setSegmentationTargetShortSide = (value: number): void => {\n  nativeModule().setSegmentationTargetShortSide(value);\n};\n\n/**\n * Toggle native per-frame GPU/segmentation timing logs (off by default). iOS\n * logs under os_log \"Perf\"; Android under the \"Perf\" logcat tag.\n */\nexport const setDebugTiming = (value: boolean): void => {\n  nativeModule().setDebugTiming(value);\n};\n\n/**\n * Reset all effect tuning parameters to library defaults.\n */\nexport const resetEffectTuning = (): void => {\n  nativeModule().resetEffectTuning();\n};\n\nexport type { BackgroundPresetName } from './backgrounds';\nexport type {\n  ApplyVideoEffects,\n  BackgroundImageSpec,\n  BlurSpec,\n  EffectInput,\n  EffectName,\n  EffectSpec,\n  TransformName,\n  TransformSpec,\n} from './types';\n\ninterface WebRTCTrackExtensions {\n  remote?: boolean;\n  // Upstream's typed signature is `string[]`, but the platforms diverge on\n  // how to clear effects:\n  //   - Android: passing `null` takes the\n  //     `videoSource.setVideoProcessor(null)` branch (the only correct clear\n  //     path); passing `[]` crashes EglRenderer.\n  //   - iOS: the Obj-C method declares `names` as `nonnull NSArray<NSString *>`,\n  //     so `null` violates the bridge contract; `[]` is the supported clear\n  //     value (iOS's `VideoEffectProcessor` with no processors is a\n  //     passthrough).\n  // We type the parameter as the union so the facade can platform-split at\n  // the call site. See `applyVideoEffects` below.\n  _setVideoEffects?: (names: ReadonlyArray<string> | null) => void;\n}\n\n// Effect names registered native-side in Registration.kt / Registration.swift.\n// Anything not in this list gets filtered out before reaching upstream,\n// because rn-webrtc's setVideoEffects calls ProcessorProvider.getProcessor()\n// and filters nulls into an empty list, which then hits the\n// VideoEffectProcessor empty-processors-list bug (refcount goes negative,\n// EglRenderer crashes one frame later). Until each effect ships a native\n// factory, dropping its name here is the safe behavior.\n//\n// Background-image preset names come from src/backgrounds.ts; the encoder\n// turns `{name:'background-image', source:'dark-office'}` into the flat-string\n// `'background-image-dark-office'` because the rn-webrtc native registry is\n// keyed by flat strings (parameterization via uniforms is a follow-up).\n//\n// iOS registers the same effects via ios/.../Registration.swift. Each\n// platform's allowlist matches exactly what its native Registration installs;\n// anything else is filtered out before reaching upstream so a name with no\n// registered processor never triggers the empty-processors-list crash.\n// The four geometric transform ops share one native processor per platform\n// (TransformFactory on Android, TransformProcessor on iOS); each is a flat name.\nconst TRANSFORM_EFFECTS: readonly string[] = ['flip-x', 'flip-y', 'rotate-cw', 'rotate-ccw'];\n\n// Android (Registration.kt) and iOS (Registration.swift) install an identical\n// effect set, so one list covers both natives. If the platforms ever diverge,\n// split this back into per-platform lists keyed off Platform.OS.\nconst NATIVE_REGISTERED_EFFECTS_LIST: readonly string[] = [\n  ...TRANSFORM_EFFECTS,\n  'blur',\n  ...BACKGROUND_PRESETS.map((name) => `background-image-${name}`),\n];\n\nconst registeredForPlatform = (): readonly string[] =>\n  Platform.OS === 'android' || Platform.OS === 'ios' ? NATIVE_REGISTERED_EFFECTS_LIST : [];\n\nconst NATIVE_REGISTERED_EFFECTS: ReadonlySet<string> = new Set(registeredForPlatform());\n\nconst specToNativeName = (spec: ReturnType<typeof toEffectSpec>): string => {\n  // background-image uses one registered factory per source preset.\n  // {name: 'background-image', source: 'dark-office'} -> 'background-image-dark-office'\n  if (spec.name === 'background-image') {\n    return `background-image-${spec.source}`;\n  }\n  return spec.name;\n};\n\n// Last effect set applied to each track, as a stable signature. Used to skip\n// redundant native calls: rn-webrtc rebuilds the native frame processors on\n// EVERY _setVideoEffects call (Android constructs a fresh processor per call),\n// so re-issuing an unchanged set (a React re-render, an idempotent effect\n// hook) churns GL + segmentation resources for no reason. The WeakMap lets the\n// entry be collected when the track is.\nconst lastAppliedSignatureByTrack = new WeakMap<object, string>();\n\nexport const applyVideoEffects: ApplyVideoEffects = (track, effects) => {\n  const t = track as MediaStreamTrack & WebRTCTrackExtensions;\n  if (t.remote) {\n    throw new Error('kaleidoscope: cannot apply effects to remote tracks');\n  }\n  if (typeof t._setVideoEffects !== 'function') {\n    throw new Error(\n      'kaleidoscope: track has no _setVideoEffects method (is react-native-webrtc >=124 installed?)',\n    );\n  }\n  // Native side currently only consumes effect names. Spec parameters (blur\n  // sigma, etc.) are dropped here; they wire through in a follow-up commit\n  // once the GPU effects accept uniforms.\n  const allNames = effects.map((e) => specToNativeName(toEffectSpec(e)));\n  const names = allNames.filter((n) => NATIVE_REGISTERED_EFFECTS.has(n));\n\n  // Dedup against the last set applied to this track. Order is significant\n  // (effects chain in array order), so the signature preserves it. Skip the\n  // native call when nothing changed; the first call for any given set always\n  // proceeds (no prior entry).\n  const signature = names.join('\\n');\n  if (lastAppliedSignatureByTrack.get(track) === signature) {\n    return track;\n  }\n  lastAppliedSignatureByTrack.set(track, signature);\n\n  const dropped = allNames.filter((n) => !NATIVE_REGISTERED_EFFECTS.has(n));\n  if (dropped.length > 0) {\n    console.warn(\n      `kaleidoscope: dropping effects not registered on this native platform: ${dropped.join(', ')}. ` +\n        'Web has its own registry; this is a native-only filter.',\n    );\n  }\n  // Platforms diverge on how to clear effects:\n  //   - Android: rn-webrtc 124 has a bug where passing `[]` installs a\n  //     VideoEffectProcessor with an empty processors list, whose\n  //     onFrameCaptured then double-releases the input frame (retain once,\n  //     release twice) and crashes EglRenderer one frame later. The only\n  //     correct clear is `null`, which takes the upstream else-branch that\n  //     resets the processor via `videoSource.setVideoProcessor(null)`.\n  //   - iOS: the upstream Obj-C `_setVideoEffects` method declares\n  //     `names` as `(nonnull NSArray<NSString *> *)`, so passing `null`\n  //     violates the React Native bridge's nonnull contract. The supported\n  //     clear value is `[]`, which iOS's VideoEffectProcessor treats as a\n  //     passthrough (no double-release bug on this platform).\n  // The explicit type annotation is required — without it TS widens the\n  // empty-array literal to `never[] | null`.\n  const clearValue: ReadonlyArray<string> | null = Platform.OS === 'ios' ? [] : null;\n  t._setVideoEffects(names.length === 0 ? clearValue : names);\n  return track;\n};\n"]}

package/dist/index.web.d.ts

@@ -1,49 +0,0 @@
-import { type ApplyVideoEffects, type EffectInput } from './types';
-import { type DisposablePipeline } from './web/insertable-streams';
-/**
- * Set the Gaussian sigma for the blur effect. Higher = softer blur.
- * Clamped to [0.5, 7] (the useful range before the linear-sampled kernel
- * truncates and bands). Default 5.
- */
-export declare const setBlurSigma: (value: number) => void;
-/**
- * Set the mask smoothstep hardness for blur and background-image
- * composites, in [0, 1]. 0 = soft halo, 1 = near-step edge. Default 0.5.
- */
-export declare const setMaskHardness: (value: number) => void;
-/**
- * Set the mask smoothstep threshold (center of the transition) in
- * [0.05, 0.95]. 0.5 is neutral. Higher values reject low-confidence
- * pixels; lower values are more inclusive. Optimal value is platform-
- * specific because each segmentation model has a different confidence
- * distribution.
- */
-export declare const setMaskThreshold: (value: number) => void;
-/**
- * Set the segmentation input short-side (px). Native-only knob (lower =
- * cheaper segmentation on older devices); stored on web for API parity but
- * the web MediaPipe pipeline does not consume it.
- */
-export declare const setSegmentationTargetShortSide: (value: number) => void;
-/**
- * Toggle native per-frame timing logs (off by default). No-op effect on web
- * beyond storing the flag.
- */
-export declare const setDebugTiming: (value: boolean) => void;
-/**
- * Reset all effect tuning parameters to library defaults.
- */
-export declare const resetEffectTuning: () => void;
-export type { BackgroundPresetName } from './backgrounds';
-export type { ApplyVideoEffects, BackgroundImageSpec, BlurSpec, EffectInput, EffectName, EffectSpec, TransformName, TransformSpec, } from './types';
-/**
- * Like `applyVideoEffects`, but also returns a `dispose()` that tears down every
- * Insertable-Streams stage (stops each generator and aborts each pipe). The
- * LiveKit adapter (`react-native-webrtc-kaleidoscope/livekit`) uses this so a
- * camera flip (restart) or unpublish (destroy) does not leak generators. The
- * page-shared segmenter and WebGL state are module singletons reused across
- * stages, so they are intentionally NOT torn down here.
- */
-export declare const applyVideoEffectsDisposable: (track: MediaStreamTrack, effects: ReadonlyArray<EffectInput>) => DisposablePipeline;
-export declare const applyVideoEffects: ApplyVideoEffects;
-//# sourceMappingURL=index.web.d.ts.map

package/dist/index.web.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.web.d.ts","sourceRoot":"","sources":["../src/index.web.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,WAAW,EAAiC,MAAM,SAAS,CAAC;AAIlG,OAAO,EAEL,KAAK,kBAAkB,EAExB,MAAM,0BAA0B,CAAC;AAGlC;;;;GAIG;AACH,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,IAE5C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,UAAW,MAAM,KAAG,IAE/C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,UAAW,MAAM,KAAG,IAEhD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,UAAW,MAAM,KAAG,IAE9D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,UAAW,OAAO,KAAG,IAE/C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAO,IAEpC,CAAC;AAEF,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,YAAY,EACV,iBAAiB,EACjB,mBAAmB,EACnB,QAAQ,EACR,WAAW,EACX,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,GACd,MAAM,SAAS,CAAC;AAkBjB;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,UAC/B,gBAAgB,WACd,aAAa,CAAC,WAAW,CAAC,KAClC,kBA0BF,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,iBACmB,CAAC","sourcesContent":["// Web entry point (source). This builds to `dist/index.web.js`, which web\n// bundlers resolve through the package's `browser` export condition. With an\n// `exports` map present, that condition supersedes platform-extension\n// resolution; the `.web.ts` suffix here is just our source convention, not what\n// selects this file at consume time.\n//\n// applyVideoEffects(track, effects) wires an Insertable-Streams pipeline that\n// chains each effect's transform and returns a new MediaStreamTrack carrying\n// the transformed frames. Pass the returned track to a `<video>` element or\n// to `RTCRtpSender.replaceTrack(...)`.\n\nimport { type ApplyVideoEffects, type EffectInput, type EffectSpec, toEffectSpec } from './types';\nimport { makeBackgroundImage } from './web/effects/background-image';\nimport { blur } from './web/effects/blur';\nimport { makeTransform } from './web/effects/transform';\nimport {\n  applyEffectToTrack,\n  type DisposablePipeline,\n  type FrameTransform,\n} from './web/insertable-streams';\nimport { tuning } from './web/tuning';\n\n/**\n * Set the Gaussian sigma for the blur effect. Higher = softer blur.\n * Clamped to [0.5, 7] (the useful range before the linear-sampled kernel\n * truncates and bands). Default 5.\n */\nexport const setBlurSigma = (value: number): void => {\n  tuning.setBlurSigma(value);\n};\n\n/**\n * Set the mask smoothstep hardness for blur and background-image\n * composites, in [0, 1]. 0 = soft halo, 1 = near-step edge. Default 0.5.\n */\nexport const setMaskHardness = (value: number): void => {\n  tuning.setMaskHardness(value);\n};\n\n/**\n * Set the mask smoothstep threshold (center of the transition) in\n * [0.05, 0.95]. 0.5 is neutral. Higher values reject low-confidence\n * pixels; lower values are more inclusive. Optimal value is platform-\n * specific because each segmentation model has a different confidence\n * distribution.\n */\nexport const setMaskThreshold = (value: number): void => {\n  tuning.setMaskThreshold(value);\n};\n\n/**\n * Set the segmentation input short-side (px). Native-only knob (lower =\n * cheaper segmentation on older devices); stored on web for API parity but\n * the web MediaPipe pipeline does not consume it.\n */\nexport const setSegmentationTargetShortSide = (value: number): void => {\n  tuning.setSegmentationTargetShortSide(value);\n};\n\n/**\n * Toggle native per-frame timing logs (off by default). No-op effect on web\n * beyond storing the flag.\n */\nexport const setDebugTiming = (value: boolean): void => {\n  tuning.setDebugTiming(value);\n};\n\n/**\n * Reset all effect tuning parameters to library defaults.\n */\nexport const resetEffectTuning = (): void => {\n  tuning.reset();\n};\n\nexport type { BackgroundPresetName } from './backgrounds';\nexport type {\n  ApplyVideoEffects,\n  BackgroundImageSpec,\n  BlurSpec,\n  EffectInput,\n  EffectName,\n  EffectSpec,\n  TransformName,\n  TransformSpec,\n} from './types';\n\nconst specToTransform = (spec: EffectSpec): FrameTransform => {\n  switch (spec.name) {\n    case 'flip-x':\n    case 'flip-y':\n    case 'rotate-cw':\n    case 'rotate-ccw':\n      return makeTransform(spec.name);\n    case 'blur':\n      // Blur strength comes from the global tuning state (setBlurSigma), not\n      // the spec; the spec carries no parameters.\n      return blur;\n    case 'background-image':\n      return makeBackgroundImage(spec.source);\n  }\n};\n\n/**\n * Like `applyVideoEffects`, but also returns a `dispose()` that tears down every\n * Insertable-Streams stage (stops each generator and aborts each pipe). The\n * LiveKit adapter (`react-native-webrtc-kaleidoscope/livekit`) uses this so a\n * camera flip (restart) or unpublish (destroy) does not leak generators. The\n * page-shared segmenter and WebGL state are module singletons reused across\n * stages, so they are intentionally NOT torn down here.\n */\nexport const applyVideoEffectsDisposable = (\n  track: MediaStreamTrack,\n  effects: ReadonlyArray<EffectInput>,\n): DisposablePipeline => {\n  if (!track || track.kind !== 'video') {\n    throw new Error('kaleidoscope: applyVideoEffects requires a video MediaStreamTrack');\n  }\n  if (effects.length === 0) {\n    return { track, dispose: () => {} };\n  }\n\n  let current = track;\n  const disposers: Array<() => void> = [];\n  for (const input of effects) {\n    const spec = toEffectSpec(input);\n    const transform = specToTransform(spec);\n    const stage = applyEffectToTrack(current, transform);\n    current = stage.track;\n    disposers.push(stage.dispose);\n  }\n  return {\n    track: current,\n    dispose: () => {\n      // Tear down in reverse so downstream stages stop before their sources.\n      for (const dispose of disposers.reverse()) {\n        dispose();\n      }\n    },\n  };\n};\n\nexport const applyVideoEffects: ApplyVideoEffects = (track, effects) =>\n  applyVideoEffectsDisposable(track, effects).track;\n"]}

package/dist/index.web.js

@@ -1,113 +0,0 @@
-// Web entry point (source). This builds to `dist/index.web.js`, which web
-// bundlers resolve through the package's `browser` export condition. With an
-// `exports` map present, that condition supersedes platform-extension
-// resolution; the `.web.ts` suffix here is just our source convention, not what
-// selects this file at consume time.
-//
-// applyVideoEffects(track, effects) wires an Insertable-Streams pipeline that
-// chains each effect's transform and returns a new MediaStreamTrack carrying
-// the transformed frames. Pass the returned track to a `<video>` element or
-// to `RTCRtpSender.replaceTrack(...)`.
-import { toEffectSpec } from './types';
-import { makeBackgroundImage } from './web/effects/background-image';
-import { blur } from './web/effects/blur';
-import { makeTransform } from './web/effects/transform';
-import { applyEffectToTrack, } from './web/insertable-streams';
-import { tuning } from './web/tuning';
-/**
- * Set the Gaussian sigma for the blur effect. Higher = softer blur.
- * Clamped to [0.5, 7] (the useful range before the linear-sampled kernel
- * truncates and bands). Default 5.
- */
-export const setBlurSigma = (value) => {
-    tuning.setBlurSigma(value);
-};
-/**
- * Set the mask smoothstep hardness for blur and background-image
- * composites, in [0, 1]. 0 = soft halo, 1 = near-step edge. Default 0.5.
- */
-export const setMaskHardness = (value) => {
-    tuning.setMaskHardness(value);
-};
-/**
- * Set the mask smoothstep threshold (center of the transition) in
- * [0.05, 0.95]. 0.5 is neutral. Higher values reject low-confidence
- * pixels; lower values are more inclusive. Optimal value is platform-
- * specific because each segmentation model has a different confidence
- * distribution.
- */
-export const setMaskThreshold = (value) => {
-    tuning.setMaskThreshold(value);
-};
-/**
- * Set the segmentation input short-side (px). Native-only knob (lower =
- * cheaper segmentation on older devices); stored on web for API parity but
- * the web MediaPipe pipeline does not consume it.
- */
-export const setSegmentationTargetShortSide = (value) => {
-    tuning.setSegmentationTargetShortSide(value);
-};
-/**
- * Toggle native per-frame timing logs (off by default). No-op effect on web
- * beyond storing the flag.
- */
-export const setDebugTiming = (value) => {
-    tuning.setDebugTiming(value);
-};
-/**
- * Reset all effect tuning parameters to library defaults.
- */
-export const resetEffectTuning = () => {
-    tuning.reset();
-};
-const specToTransform = (spec) => {
-    switch (spec.name) {
-        case 'flip-x':
-        case 'flip-y':
-        case 'rotate-cw':
-        case 'rotate-ccw':
-            return makeTransform(spec.name);
-        case 'blur':
-            // Blur strength comes from the global tuning state (setBlurSigma), not
-            // the spec; the spec carries no parameters.
-            return blur;
-        case 'background-image':
-            return makeBackgroundImage(spec.source);
-    }
-};
-/**
- * Like `applyVideoEffects`, but also returns a `dispose()` that tears down every
- * Insertable-Streams stage (stops each generator and aborts each pipe). The
- * LiveKit adapter (`react-native-webrtc-kaleidoscope/livekit`) uses this so a
- * camera flip (restart) or unpublish (destroy) does not leak generators. The
- * page-shared segmenter and WebGL state are module singletons reused across
- * stages, so they are intentionally NOT torn down here.
- */
-export const applyVideoEffectsDisposable = (track, effects) => {
-    if (!track || track.kind !== 'video') {
-        throw new Error('kaleidoscope: applyVideoEffects requires a video MediaStreamTrack');
-    }
-    if (effects.length === 0) {
-        return { track, dispose: () => { } };
-    }
-    let current = track;
-    const disposers = [];
-    for (const input of effects) {
-        const spec = toEffectSpec(input);
-        const transform = specToTransform(spec);
-        const stage = applyEffectToTrack(current, transform);
-        current = stage.track;
-        disposers.push(stage.dispose);
-    }
-    return {
-        track: current,
-        dispose: () => {
-            // Tear down in reverse so downstream stages stop before their sources.
-            for (const dispose of disposers.reverse()) {
-                dispose();
-            }
-        },
-    };
-};
-export const applyVideoEffects = (track, effects) => applyVideoEffectsDisposable(track, effects).track;
-//# sourceMappingURL=index.web.js.map

package/dist/index.web.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.web.js","sourceRoot":"","sources":["../src/index.web.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,6EAA6E;AAC7E,sEAAsE;AACtE,gFAAgF;AAChF,qCAAqC;AACrC,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,4EAA4E;AAC5E,uCAAuC;AAEvC,OAAO,EAA6D,YAAY,EAAE,MAAM,SAAS,CAAC;AAClG,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EACL,kBAAkB,GAGnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAa,EAAQ,EAAE;IAClD,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAa,EAAQ,EAAE;IACrD,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAQ,EAAE;IACtD,MAAM,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;AACjC,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,KAAa,EAAQ,EAAE;IACpE,MAAM,CAAC,8BAA8B,CAAC,KAAK,CAAC,CAAC;AAC/C,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAc,EAAQ,EAAE;IACrD,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAS,EAAE;IAC1C,MAAM,CAAC,KAAK,EAAE,CAAC;AACjB,CAAC,CAAC;AAcF,MAAM,eAAe,GAAG,CAAC,IAAgB,EAAkB,EAAE;IAC3D,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ,CAAC;QACd,KAAK,WAAW,CAAC;QACjB,KAAK,YAAY;YACf,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClC,KAAK,MAAM;YACT,uEAAuE;YACvE,4CAA4C;YAC5C,OAAO,IAAI,CAAC;QACd,KAAK,kBAAkB;YACrB,OAAO,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACzC,KAAuB,EACvB,OAAmC,EACf,EAAE;IACtB,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;IACvF,CAAC;IACD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC,EAAE,CAAC;IACtC,CAAC;IAED,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,SAAS,GAAsB,EAAE,CAAC;IACxC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QACjC,MAAM,SAAS,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;QACxC,MAAM,KAAK,GAAG,kBAAkB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACrD,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC;QACtB,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;IACD,OAAO;QACL,KAAK,EAAE,OAAO;QACd,OAAO,EAAE,GAAG,EAAE;YACZ,uEAAuE;YACvE,KAAK,MAAM,OAAO,IAAI,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC;gBAC1C,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CACrE,2BAA2B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC","sourcesContent":["// Web entry point (source). This builds to `dist/index.web.js`, which web\n// bundlers resolve through the package's `browser` export condition. With an\n// `exports` map present, that condition supersedes platform-extension\n// resolution; the `.web.ts` suffix here is just our source convention, not what\n// selects this file at consume time.\n//\n// applyVideoEffects(track, effects) wires an Insertable-Streams pipeline that\n// chains each effect's transform and returns a new MediaStreamTrack carrying\n// the transformed frames. Pass the returned track to a `<video>` element or\n// to `RTCRtpSender.replaceTrack(...)`.\n\nimport { type ApplyVideoEffects, type EffectInput, type EffectSpec, toEffectSpec } from './types';\nimport { makeBackgroundImage } from './web/effects/background-image';\nimport { blur } from './web/effects/blur';\nimport { makeTransform } from './web/effects/transform';\nimport {\n  applyEffectToTrack,\n  type DisposablePipeline,\n  type FrameTransform,\n} from './web/insertable-streams';\nimport { tuning } from './web/tuning';\n\n/**\n * Set the Gaussian sigma for the blur effect. Higher = softer blur.\n * Clamped to [0.5, 7] (the useful range before the linear-sampled kernel\n * truncates and bands). Default 5.\n */\nexport const setBlurSigma = (value: number): void => {\n  tuning.setBlurSigma(value);\n};\n\n/**\n * Set the mask smoothstep hardness for blur and background-image\n * composites, in [0, 1]. 0 = soft halo, 1 = near-step edge. Default 0.5.\n */\nexport const setMaskHardness = (value: number): void => {\n  tuning.setMaskHardness(value);\n};\n\n/**\n * Set the mask smoothstep threshold (center of the transition) in\n * [0.05, 0.95]. 0.5 is neutral. Higher values reject low-confidence\n * pixels; lower values are more inclusive. Optimal value is platform-\n * specific because each segmentation model has a different confidence\n * distribution.\n */\nexport const setMaskThreshold = (value: number): void => {\n  tuning.setMaskThreshold(value);\n};\n\n/**\n * Set the segmentation input short-side (px). Native-only knob (lower =\n * cheaper segmentation on older devices); stored on web for API parity but\n * the web MediaPipe pipeline does not consume it.\n */\nexport const setSegmentationTargetShortSide = (value: number): void => {\n  tuning.setSegmentationTargetShortSide(value);\n};\n\n/**\n * Toggle native per-frame timing logs (off by default). No-op effect on web\n * beyond storing the flag.\n */\nexport const setDebugTiming = (value: boolean): void => {\n  tuning.setDebugTiming(value);\n};\n\n/**\n * Reset all effect tuning parameters to library defaults.\n */\nexport const resetEffectTuning = (): void => {\n  tuning.reset();\n};\n\nexport type { BackgroundPresetName } from './backgrounds';\nexport type {\n  ApplyVideoEffects,\n  BackgroundImageSpec,\n  BlurSpec,\n  EffectInput,\n  EffectName,\n  EffectSpec,\n  TransformName,\n  TransformSpec,\n} from './types';\n\nconst specToTransform = (spec: EffectSpec): FrameTransform => {\n  switch (spec.name) {\n    case 'flip-x':\n    case 'flip-y':\n    case 'rotate-cw':\n    case 'rotate-ccw':\n      return makeTransform(spec.name);\n    case 'blur':\n      // Blur strength comes from the global tuning state (setBlurSigma), not\n      // the spec; the spec carries no parameters.\n      return blur;\n    case 'background-image':\n      return makeBackgroundImage(spec.source);\n  }\n};\n\n/**\n * Like `applyVideoEffects`, but also returns a `dispose()` that tears down every\n * Insertable-Streams stage (stops each generator and aborts each pipe). The\n * LiveKit adapter (`react-native-webrtc-kaleidoscope/livekit`) uses this so a\n * camera flip (restart) or unpublish (destroy) does not leak generators. The\n * page-shared segmenter and WebGL state are module singletons reused across\n * stages, so they are intentionally NOT torn down here.\n */\nexport const applyVideoEffectsDisposable = (\n  track: MediaStreamTrack,\n  effects: ReadonlyArray<EffectInput>,\n): DisposablePipeline => {\n  if (!track || track.kind !== 'video') {\n    throw new Error('kaleidoscope: applyVideoEffects requires a video MediaStreamTrack');\n  }\n  if (effects.length === 0) {\n    return { track, dispose: () => {} };\n  }\n\n  let current = track;\n  const disposers: Array<() => void> = [];\n  for (const input of effects) {\n    const spec = toEffectSpec(input);\n    const transform = specToTransform(spec);\n    const stage = applyEffectToTrack(current, transform);\n    current = stage.track;\n    disposers.push(stage.dispose);\n  }\n  return {\n    track: current,\n    dispose: () => {\n      // Tear down in reverse so downstream stages stop before their sources.\n      for (const dispose of disposers.reverse()) {\n        dispose();\n      }\n    },\n  };\n};\n\nexport const applyVideoEffects: ApplyVideoEffects = (track, effects) =>\n  applyVideoEffectsDisposable(track, effects).track;\n"]}

package/dist/livekit.d.ts

@@ -1,24 +0,0 @@
-import type { ProcessorOptions, Track, TrackProcessor } from 'livekit-client';
-import type { EffectInput } from './types';
-/**
- * A LiveKit `TrackProcessor` that applies Kaleidoscope video effects to a local
- * camera track. Construct it with the same effect inputs `applyVideoEffects`
- * accepts (bare names like `'blur'` or full `EffectSpec` objects), then pass it
- * to `localTrack.setProcessor(processor)`.
- *
- * `restart` (camera flip / source change) and `destroy` (unpublish) tear down
- * the prior Insertable-Streams pipeline, so repeated flips do not leak
- * generators. The page-shared segmenter and WebGL state are module singletons
- * reused across pipelines, so they are intentionally retained.
- */
-export declare class KaleidoscopeProcessor implements TrackProcessor<Track.Kind.Video> {
-    readonly name = "kaleidoscope";
-    processedTrack?: MediaStreamTrack;
-    private readonly effects;
-    private disposePipeline;
-    constructor(effects: ReadonlyArray<EffectInput>);
-    init(opts: ProcessorOptions<Track.Kind.Video>): Promise<void>;
-    restart(opts: ProcessorOptions<Track.Kind.Video>): Promise<void>;
-    destroy(): Promise<void>;
-}
-//# sourceMappingURL=livekit.d.ts.map

package/dist/livekit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"livekit.d.ts","sourceRoot":"","sources":["../src/livekit.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,qBAAa,qBAAsB,YAAW,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;IAC5E,QAAQ,CAAC,IAAI,kBAAkB;IAC/B,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAElC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,eAAe,CAA6B;IAEpD,YAAY,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,EAE9C;IAEK,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAIlE;IAEK,OAAO,CAAC,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAGrE;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAI7B;CACF","sourcesContent":["// Opt-in LiveKit adapter, exported from the `react-native-webrtc-kaleidoscope/livekit`\n// subpath. It wraps the web Insertable-Streams pipeline in LiveKit's\n// TrackProcessor interface so consumers do not have to hand-write the glue.\n//\n// Why this exists: the core web API is `applyVideoEffects(track) -> newTrack`,\n// which assumes the caller owns the RTCRtpSender and calls replaceTrack itself.\n// LiveKit owns the sender, so consumers go through `track.setProcessor(...)`\n// instead. This adapter is that bridge:\n//\n//   import { KaleidoscopeProcessor } from 'react-native-webrtc-kaleidoscope/livekit';\n//   await localVideoTrack.setProcessor(new KaleidoscopeProcessor(['blur']));\n//\n// `livekit-client` is an OPTIONAL peer dependency: the import below is type-only\n// (erased at build), so the published JS has no runtime dependency on LiveKit\n// and the agnostic core stays decoupled. Only consumers that import this subpath\n// need livekit-client installed (they already have it).\n//\n// This adapter is web-only: it builds on MediaStreamTrackProcessor /\n// MediaStreamTrackGenerator (Insertable Streams), which exist in Chromium-based\n// browsers. On unsupported environments the underlying pipeline throws a typed\n// error at init().\n\nimport type { ProcessorOptions, Track, TrackProcessor } from 'livekit-client';\nimport { applyVideoEffectsDisposable } from './index.web';\nimport type { EffectInput } from './types';\n\n/**\n * A LiveKit `TrackProcessor` that applies Kaleidoscope video effects to a local\n * camera track. Construct it with the same effect inputs `applyVideoEffects`\n * accepts (bare names like `'blur'` or full `EffectSpec` objects), then pass it\n * to `localTrack.setProcessor(processor)`.\n *\n * `restart` (camera flip / source change) and `destroy` (unpublish) tear down\n * the prior Insertable-Streams pipeline, so repeated flips do not leak\n * generators. The page-shared segmenter and WebGL state are module singletons\n * reused across pipelines, so they are intentionally retained.\n */\nexport class KaleidoscopeProcessor implements TrackProcessor<Track.Kind.Video> {\n  readonly name = 'kaleidoscope';\n  processedTrack?: MediaStreamTrack;\n\n  private readonly effects: ReadonlyArray<EffectInput>;\n  private disposePipeline: (() => void) | null = null;\n\n  constructor(effects: ReadonlyArray<EffectInput>) {\n    this.effects = effects;\n  }\n\n  async init(opts: ProcessorOptions<Track.Kind.Video>): Promise<void> {\n    const { track, dispose } = applyVideoEffectsDisposable(opts.track, this.effects);\n    this.processedTrack = track;\n    this.disposePipeline = dispose;\n  }\n\n  async restart(opts: ProcessorOptions<Track.Kind.Video>): Promise<void> {\n    await this.destroy();\n    await this.init(opts);\n  }\n\n  async destroy(): Promise<void> {\n    this.disposePipeline?.();\n    this.disposePipeline = null;\n    this.processedTrack = undefined;\n  }\n}\n"]}

package/dist/livekit.js

@@ -1,57 +0,0 @@
-// Opt-in LiveKit adapter, exported from the `react-native-webrtc-kaleidoscope/livekit`
-// subpath. It wraps the web Insertable-Streams pipeline in LiveKit's
-// TrackProcessor interface so consumers do not have to hand-write the glue.
-//
-// Why this exists: the core web API is `applyVideoEffects(track) -> newTrack`,
-// which assumes the caller owns the RTCRtpSender and calls replaceTrack itself.
-// LiveKit owns the sender, so consumers go through `track.setProcessor(...)`
-// instead. This adapter is that bridge:
-//
-//   import { KaleidoscopeProcessor } from 'react-native-webrtc-kaleidoscope/livekit';
-//   await localVideoTrack.setProcessor(new KaleidoscopeProcessor(['blur']));
-//
-// `livekit-client` is an OPTIONAL peer dependency: the import below is type-only
-// (erased at build), so the published JS has no runtime dependency on LiveKit
-// and the agnostic core stays decoupled. Only consumers that import this subpath
-// need livekit-client installed (they already have it).
-//
-// This adapter is web-only: it builds on MediaStreamTrackProcessor /
-// MediaStreamTrackGenerator (Insertable Streams), which exist in Chromium-based
-// browsers. On unsupported environments the underlying pipeline throws a typed
-// error at init().
-import { applyVideoEffectsDisposable } from './index.web';
-/**
- * A LiveKit `TrackProcessor` that applies Kaleidoscope video effects to a local
- * camera track. Construct it with the same effect inputs `applyVideoEffects`
- * accepts (bare names like `'blur'` or full `EffectSpec` objects), then pass it
- * to `localTrack.setProcessor(processor)`.
- *
- * `restart` (camera flip / source change) and `destroy` (unpublish) tear down
- * the prior Insertable-Streams pipeline, so repeated flips do not leak
- * generators. The page-shared segmenter and WebGL state are module singletons
- * reused across pipelines, so they are intentionally retained.
- */
-export class KaleidoscopeProcessor {
-    name = 'kaleidoscope';
-    processedTrack;
-    effects;
-    disposePipeline = null;
-    constructor(effects) {
-        this.effects = effects;
-    }
-    async init(opts) {
-        const { track, dispose } = applyVideoEffectsDisposable(opts.track, this.effects);
-        this.processedTrack = track;
-        this.disposePipeline = dispose;
-    }
-    async restart(opts) {
-        await this.destroy();
-        await this.init(opts);
-    }
-    async destroy() {
-        this.disposePipeline?.();
-        this.disposePipeline = null;
-        this.processedTrack = undefined;
-    }
-}
-//# sourceMappingURL=livekit.js.map

package/dist/livekit.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"livekit.js","sourceRoot":"","sources":["../src/livekit.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,qEAAqE;AACrE,4EAA4E;AAC5E,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,6EAA6E;AAC7E,wCAAwC;AACxC,EAAE;AACF,sFAAsF;AACtF,6EAA6E;AAC7E,EAAE;AACF,iFAAiF;AACjF,8EAA8E;AAC9E,iFAAiF;AACjF,wDAAwD;AACxD,EAAE;AACF,qEAAqE;AACrE,gFAAgF;AAChF,+EAA+E;AAC/E,mBAAmB;AAGnB,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAG1D;;;;;;;;;;GAUG;AACH,MAAM,OAAO,qBAAqB;IACvB,IAAI,GAAG,cAAc,CAAC;IAC/B,cAAc,CAAoB;IAEjB,OAAO,CAA6B;IAC7C,eAAe,GAAwB,IAAI,CAAC;IAEpD,YAAY,OAAmC;QAC7C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,IAAwC;QACjD,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,2BAA2B,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACjF,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,IAAwC;QACpD,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACrB,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,OAAO;QACX,IAAI,CAAC,eAAe,EAAE,EAAE,CAAC;QACzB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;IAClC,CAAC;CACF","sourcesContent":["// Opt-in LiveKit adapter, exported from the `react-native-webrtc-kaleidoscope/livekit`\n// subpath. It wraps the web Insertable-Streams pipeline in LiveKit's\n// TrackProcessor interface so consumers do not have to hand-write the glue.\n//\n// Why this exists: the core web API is `applyVideoEffects(track) -> newTrack`,\n// which assumes the caller owns the RTCRtpSender and calls replaceTrack itself.\n// LiveKit owns the sender, so consumers go through `track.setProcessor(...)`\n// instead. This adapter is that bridge:\n//\n//   import { KaleidoscopeProcessor } from 'react-native-webrtc-kaleidoscope/livekit';\n//   await localVideoTrack.setProcessor(new KaleidoscopeProcessor(['blur']));\n//\n// `livekit-client` is an OPTIONAL peer dependency: the import below is type-only\n// (erased at build), so the published JS has no runtime dependency on LiveKit\n// and the agnostic core stays decoupled. Only consumers that import this subpath\n// need livekit-client installed (they already have it).\n//\n// This adapter is web-only: it builds on MediaStreamTrackProcessor /\n// MediaStreamTrackGenerator (Insertable Streams), which exist in Chromium-based\n// browsers. On unsupported environments the underlying pipeline throws a typed\n// error at init().\n\nimport type { ProcessorOptions, Track, TrackProcessor } from 'livekit-client';\nimport { applyVideoEffectsDisposable } from './index.web';\nimport type { EffectInput } from './types';\n\n/**\n * A LiveKit `TrackProcessor` that applies Kaleidoscope video effects to a local\n * camera track. Construct it with the same effect inputs `applyVideoEffects`\n * accepts (bare names like `'blur'` or full `EffectSpec` objects), then pass it\n * to `localTrack.setProcessor(processor)`.\n *\n * `restart` (camera flip / source change) and `destroy` (unpublish) tear down\n * the prior Insertable-Streams pipeline, so repeated flips do not leak\n * generators. The page-shared segmenter and WebGL state are module singletons\n * reused across pipelines, so they are intentionally retained.\n */\nexport class KaleidoscopeProcessor implements TrackProcessor<Track.Kind.Video> {\n  readonly name = 'kaleidoscope';\n  processedTrack?: MediaStreamTrack;\n\n  private readonly effects: ReadonlyArray<EffectInput>;\n  private disposePipeline: (() => void) | null = null;\n\n  constructor(effects: ReadonlyArray<EffectInput>) {\n    this.effects = effects;\n  }\n\n  async init(opts: ProcessorOptions<Track.Kind.Video>): Promise<void> {\n    const { track, dispose } = applyVideoEffectsDisposable(opts.track, this.effects);\n    this.processedTrack = track;\n    this.disposePipeline = dispose;\n  }\n\n  async restart(opts: ProcessorOptions<Track.Kind.Video>): Promise<void> {\n    await this.destroy();\n    await this.init(opts);\n  }\n\n  async destroy(): Promise<void> {\n    this.disposePipeline?.();\n    this.disposePipeline = null;\n    this.processedTrack = undefined;\n  }\n}\n"]}

package/dist/types.d.ts

@@ -1,74 +0,0 @@
-/**
- * Effect specs are parameterized objects. Each effect's shape carries the
- * uniforms its shader needs; the library exposes one shader per effect family
- * (blur, background-image, etc.) and consumers pick uniform values per call.
- */
-import type { BackgroundPresetName } from './backgrounds';
-/**
- * Geometric reorientation of the frame: an axis flip or a 90-degree rotation.
- * The operation IS the effect name (parameterless), which keeps it compatible
- * with the bare-string input form and the flat-string native registry. On web
- * these run in display space (the reference behavior); native pipelines correct
- * for the camera buffer's rotation so the on-screen result matches everywhere.
- */
-export type TransformName = 'flip-x' | 'flip-y' | 'rotate-cw' | 'rotate-ccw';
-export type TransformSpec = {
-    readonly name: TransformName;
-};
-export type BlurSpec = {
-    readonly name: 'blur';
-};
-export type BackgroundImageSpec = {
-    readonly name: 'background-image';
-    /**
-     * Either a bundled preset name (autocompleted; see src/backgrounds.ts) or
-     * a free-form URL / data URI. Web accepts both; native only resolves
-     * bundled preset names because the upstream rn-webrtc registry takes flat
-     * strings, not URIs.
-     *
-     * The `string & {}` trick preserves preset-name autocomplete while still
-     * permitting arbitrary URL inputs without a separate union branch.
-     *
-     * SECURITY (web): a URL/data-URI `source` is fetched in the page origin and
-     * decoded to a texture. If you wire this from end-user input, validate the
-     * URL yourself; the library does not allowlist fetch targets. Decoded
-     * dimensions are capped and the per-source cache is bounded, but an
-     * unvalidated `source` can still issue a same-origin request you did not
-     * intend.
-     */
-    readonly source: BackgroundPresetName | (string & {});
-};
-export type EffectSpec = TransformSpec | BlurSpec | BackgroundImageSpec;
-/**
- * Legacy alias for the discriminant. Useful for typed switch statements and
- * the bare-string call shape (`applyVideoEffects(track, ['blur'])`).
- */
-export type EffectName = EffectSpec['name'];
-/**
- * applyVideoEffects accepts either a bare effect name (no params; library
- * picks sensible defaults) or a full EffectSpec object with parameters.
- */
-export type EffectInput = EffectSpec | EffectName;
-/**
- * Apply zero or more effects to a local `MediaStreamTrack`.
- *
- * - Native: thin facade over `track._setVideoEffects(names)` from
- *   `react-native-webrtc`. Returns the same track reference; mutation is in place.
- *   Effects are tuned globally via the tuning setters (setBlurSigma, etc.),
- *   not via per-call spec parameters.
- * - Web: builds an Insertable-Streams pipeline with `MediaStreamTrackProcessor`
- *   and `MediaStreamTrackGenerator` and returns a NEW track carrying the
- *   transformed frames. Replace the upstream sender's track with the return value
- *   (`sender.replaceTrack(returnedTrack)`) to apply effects to a peer connection,
- *   or attach it to a `<video>` element for local preview.
- *
- * Throws on remote tracks, unknown effect names, missing platform capabilities
- * (web: Insertable Streams; native: peer-dep `_setVideoEffects`), or non-video
- * tracks.
- */
-export type ApplyVideoEffects = (track: MediaStreamTrack, effects: ReadonlyArray<EffectInput>) => MediaStreamTrack;
-/**
- * Normalize an EffectInput (bare name or spec) into an EffectSpec.
- */
-export declare const toEffectSpec: (input: EffectInput) => EffectSpec;
-//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,GAAG,YAAY,CAAC;AAE7E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CAGvB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,MAAM,EAAE,oBAAoB,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;CACvD,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,QAAQ,GAAG,mBAAmB,CAAC;AAExE;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;AAE5C;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;AAElD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,KAChC,gBAAgB,CAAC;AAEtB;;GAEG;AACH,eAAO,MAAM,YAAY,UAAW,WAAW,KAAG,UACmB,CAAC","sourcesContent":["/**\n * Effect specs are parameterized objects. Each effect's shape carries the\n * uniforms its shader needs; the library exposes one shader per effect family\n * (blur, background-image, etc.) and consumers pick uniform values per call.\n */\n\nimport type { BackgroundPresetName } from './backgrounds';\n\n/**\n * Geometric reorientation of the frame: an axis flip or a 90-degree rotation.\n * The operation IS the effect name (parameterless), which keeps it compatible\n * with the bare-string input form and the flat-string native registry. On web\n * these run in display space (the reference behavior); native pipelines correct\n * for the camera buffer's rotation so the on-screen result matches everywhere.\n */\nexport type TransformName = 'flip-x' | 'flip-y' | 'rotate-cw' | 'rotate-ccw';\n\nexport type TransformSpec = {\n  readonly name: TransformName;\n};\n\nexport type BlurSpec = {\n  readonly name: 'blur';\n  // Blur strength is tuned globally via the tuning setters (setBlurSigma),\n  // not per-call; there is no per-spec parameter.\n};\n\nexport type BackgroundImageSpec = {\n  readonly name: 'background-image';\n  /**\n   * Either a bundled preset name (autocompleted; see src/backgrounds.ts) or\n   * a free-form URL / data URI. Web accepts both; native only resolves\n   * bundled preset names because the upstream rn-webrtc registry takes flat\n   * strings, not URIs.\n   *\n   * The `string & {}` trick preserves preset-name autocomplete while still\n   * permitting arbitrary URL inputs without a separate union branch.\n   *\n   * SECURITY (web): a URL/data-URI `source` is fetched in the page origin and\n   * decoded to a texture. If you wire this from end-user input, validate the\n   * URL yourself; the library does not allowlist fetch targets. Decoded\n   * dimensions are capped and the per-source cache is bounded, but an\n   * unvalidated `source` can still issue a same-origin request you did not\n   * intend.\n   */\n  readonly source: BackgroundPresetName | (string & {});\n};\n\nexport type EffectSpec = TransformSpec | BlurSpec | BackgroundImageSpec;\n\n/**\n * Legacy alias for the discriminant. Useful for typed switch statements and\n * the bare-string call shape (`applyVideoEffects(track, ['blur'])`).\n */\nexport type EffectName = EffectSpec['name'];\n\n/**\n * applyVideoEffects accepts either a bare effect name (no params; library\n * picks sensible defaults) or a full EffectSpec object with parameters.\n */\nexport type EffectInput = EffectSpec | EffectName;\n\n/**\n * Apply zero or more effects to a local `MediaStreamTrack`.\n *\n * - Native: thin facade over `track._setVideoEffects(names)` from\n *   `react-native-webrtc`. Returns the same track reference; mutation is in place.\n *   Effects are tuned globally via the tuning setters (setBlurSigma, etc.),\n *   not via per-call spec parameters.\n * - Web: builds an Insertable-Streams pipeline with `MediaStreamTrackProcessor`\n *   and `MediaStreamTrackGenerator` and returns a NEW track carrying the\n *   transformed frames. Replace the upstream sender's track with the return value\n *   (`sender.replaceTrack(returnedTrack)`) to apply effects to a peer connection,\n *   or attach it to a `<video>` element for local preview.\n *\n * Throws on remote tracks, unknown effect names, missing platform capabilities\n * (web: Insertable Streams; native: peer-dep `_setVideoEffects`), or non-video\n * tracks.\n */\nexport type ApplyVideoEffects = (\n  track: MediaStreamTrack,\n  effects: ReadonlyArray<EffectInput>,\n) => MediaStreamTrack;\n\n/**\n * Normalize an EffectInput (bare name or spec) into an EffectSpec.\n */\nexport const toEffectSpec = (input: EffectInput): EffectSpec =>\n  typeof input === 'string' ? ({ name: input } as EffectSpec) : input;\n"]}

package/dist/types.js

@@ -1,10 +0,0 @@
-/**
- * Effect specs are parameterized objects. Each effect's shape carries the
- * uniforms its shader needs; the library exposes one shader per effect family
- * (blur, background-image, etc.) and consumers pick uniform values per call.
- */
-/**
- * Normalize an EffectInput (bare name or spec) into an EffectSpec.
- */
-export const toEffectSpec = (input) => typeof input === 'string' ? { name: input } : input;
-//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAgFH;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAkB,EAAc,EAAE,CAC7D,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAE,EAAE,IAAI,EAAE,KAAK,EAAiB,CAAC,CAAC,CAAC,KAAK,CAAC","sourcesContent":["/**\n * Effect specs are parameterized objects. Each effect's shape carries the\n * uniforms its shader needs; the library exposes one shader per effect family\n * (blur, background-image, etc.) and consumers pick uniform values per call.\n */\n\nimport type { BackgroundPresetName } from './backgrounds';\n\n/**\n * Geometric reorientation of the frame: an axis flip or a 90-degree rotation.\n * The operation IS the effect name (parameterless), which keeps it compatible\n * with the bare-string input form and the flat-string native registry. On web\n * these run in display space (the reference behavior); native pipelines correct\n * for the camera buffer's rotation so the on-screen result matches everywhere.\n */\nexport type TransformName = 'flip-x' | 'flip-y' | 'rotate-cw' | 'rotate-ccw';\n\nexport type TransformSpec = {\n  readonly name: TransformName;\n};\n\nexport type BlurSpec = {\n  readonly name: 'blur';\n  // Blur strength is tuned globally via the tuning setters (setBlurSigma),\n  // not per-call; there is no per-spec parameter.\n};\n\nexport type BackgroundImageSpec = {\n  readonly name: 'background-image';\n  /**\n   * Either a bundled preset name (autocompleted; see src/backgrounds.ts) or\n   * a free-form URL / data URI. Web accepts both; native only resolves\n   * bundled preset names because the upstream rn-webrtc registry takes flat\n   * strings, not URIs.\n   *\n   * The `string & {}` trick preserves preset-name autocomplete while still\n   * permitting arbitrary URL inputs without a separate union branch.\n   *\n   * SECURITY (web): a URL/data-URI `source` is fetched in the page origin and\n   * decoded to a texture. If you wire this from end-user input, validate the\n   * URL yourself; the library does not allowlist fetch targets. Decoded\n   * dimensions are capped and the per-source cache is bounded, but an\n   * unvalidated `source` can still issue a same-origin request you did not\n   * intend.\n   */\n  readonly source: BackgroundPresetName | (string & {});\n};\n\nexport type EffectSpec = TransformSpec | BlurSpec | BackgroundImageSpec;\n\n/**\n * Legacy alias for the discriminant. Useful for typed switch statements and\n * the bare-string call shape (`applyVideoEffects(track, ['blur'])`).\n */\nexport type EffectName = EffectSpec['name'];\n\n/**\n * applyVideoEffects accepts either a bare effect name (no params; library\n * picks sensible defaults) or a full EffectSpec object with parameters.\n */\nexport type EffectInput = EffectSpec | EffectName;\n\n/**\n * Apply zero or more effects to a local `MediaStreamTrack`.\n *\n * - Native: thin facade over `track._setVideoEffects(names)` from\n *   `react-native-webrtc`. Returns the same track reference; mutation is in place.\n *   Effects are tuned globally via the tuning setters (setBlurSigma, etc.),\n *   not via per-call spec parameters.\n * - Web: builds an Insertable-Streams pipeline with `MediaStreamTrackProcessor`\n *   and `MediaStreamTrackGenerator` and returns a NEW track carrying the\n *   transformed frames. Replace the upstream sender's track with the return value\n *   (`sender.replaceTrack(returnedTrack)`) to apply effects to a peer connection,\n *   or attach it to a `<video>` element for local preview.\n *\n * Throws on remote tracks, unknown effect names, missing platform capabilities\n * (web: Insertable Streams; native: peer-dep `_setVideoEffects`), or non-video\n * tracks.\n */\nexport type ApplyVideoEffects = (\n  track: MediaStreamTrack,\n  effects: ReadonlyArray<EffectInput>,\n) => MediaStreamTrack;\n\n/**\n * Normalize an EffectInput (bare name or spec) into an EffectSpec.\n */\nexport const toEffectSpec = (input: EffectInput): EffectSpec =>\n  typeof input === 'string' ? ({ name: input } as EffectSpec) : input;\n"]}

package/dist/web/blur-kernel.d.ts

@@ -1,6 +0,0 @@
-export declare const KERNEL_TAPS = 5;
-export declare const computeBlurKernel: (sigma: number) => {
-    weights: Float32Array;
-    offsets: Float32Array;
-};
-//# sourceMappingURL=blur-kernel.d.ts.map

package/dist/web/blur-kernel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blur-kernel.d.ts","sourceRoot":"","sources":["../../src/web/blur-kernel.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,WAAW,IAAI,CAAC;AAU7B,eAAO,MAAM,iBAAiB,UACrB,MAAM,KACZ;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAsBhD,CAAC","sourcesContent":["// Pure 9-tap separable Gaussian kernel math. Extracted so it is unit-testable\n// in isolation (no WebGL/DOM imports) and shared by the web blur effect.\n//\n// Mirrors Android's BlurFactory.ensureKernel exactly so web, Android, and iOS\n// run the identical blur.frag: tap spacing 2.0, weight = exp(-x^2 / 2σ^2),\n// normalized by (w0 + 2·Σ w[1..]) because the shader samples vUv ± offset and\n// adds each side tap twice. Given a sigma it returns fresh arrays; the caller\n// caches by sigma (the kernel only changes when the blur slider moves).\n\nexport const KERNEL_TAPS = 5;\n\n// Linear-sampled separable Gaussian. A dense Gaussian over texels 0..8 is\n// collapsed into 5 entries: the center plus 4 bilinear pairs of adjacent\n// texels (1,2), (3,4), (5,6), (7,8). Each pair becomes one fractional-offset\n// fetch whose bilinear blend reproduces the two texels' weighted sum, so the\n// shader issues 9 fetches per pass instead of 17. offsets[0] is the center\n// (0). Normalized so center + 2*Σ(pairs) == 1 (the shader samples vUv ±\n// offset and adds each side). Mirrors Android BlurFactory.ensureKernel and iOS\n// BlurKernel.ensure exactly.\nexport const computeBlurKernel = (\n  sigma: number,\n): { weights: Float32Array; offsets: Float32Array } => {\n  const g = (t: number): number => Math.exp(-(t * t) / (2 * sigma * sigma));\n  const offsets = new Float32Array(KERNEL_TAPS);\n  const raw = new Array<number>(KERNEL_TAPS);\n  offsets[0] = 0;\n  raw[0] = g(0);\n  let sum = raw[0];\n  for (let p = 1; p < KERNEL_TAPS; p++) {\n    const a = 2 * p - 1;\n    const b = 2 * p;\n    const wa = g(a);\n    const wb = g(b);\n    const w = wa + wb;\n    offsets[p] = (a * wa + b * wb) / w;\n    raw[p] = w;\n    sum += 2 * w;\n  }\n  const weights = new Float32Array(KERNEL_TAPS);\n  for (let i = 0; i < KERNEL_TAPS; i++) {\n    weights[i] = (raw[i] ?? 0) / sum;\n  }\n  return { weights, offsets };\n};\n"]}

package/dist/web/blur-kernel.js

@@ -1,41 +0,0 @@
-// Pure 9-tap separable Gaussian kernel math. Extracted so it is unit-testable
-// in isolation (no WebGL/DOM imports) and shared by the web blur effect.
-//
-// Mirrors Android's BlurFactory.ensureKernel exactly so web, Android, and iOS
-// run the identical blur.frag: tap spacing 2.0, weight = exp(-x^2 / 2σ^2),
-// normalized by (w0 + 2·Σ w[1..]) because the shader samples vUv ± offset and
-// adds each side tap twice. Given a sigma it returns fresh arrays; the caller
-// caches by sigma (the kernel only changes when the blur slider moves).
-export const KERNEL_TAPS = 5;
-// Linear-sampled separable Gaussian. A dense Gaussian over texels 0..8 is
-// collapsed into 5 entries: the center plus 4 bilinear pairs of adjacent
-// texels (1,2), (3,4), (5,6), (7,8). Each pair becomes one fractional-offset
-// fetch whose bilinear blend reproduces the two texels' weighted sum, so the
-// shader issues 9 fetches per pass instead of 17. offsets[0] is the center
-// (0). Normalized so center + 2*Σ(pairs) == 1 (the shader samples vUv ±
-// offset and adds each side). Mirrors Android BlurFactory.ensureKernel and iOS
-// BlurKernel.ensure exactly.
-export const computeBlurKernel = (sigma) => {
-    const g = (t) => Math.exp(-(t * t) / (2 * sigma * sigma));
-    const offsets = new Float32Array(KERNEL_TAPS);
-    const raw = new Array(KERNEL_TAPS);
-    offsets[0] = 0;
-    raw[0] = g(0);
-    let sum = raw[0];
-    for (let p = 1; p < KERNEL_TAPS; p++) {
-        const a = 2 * p - 1;
-        const b = 2 * p;
-        const wa = g(a);
-        const wb = g(b);
-        const w = wa + wb;
-        offsets[p] = (a * wa + b * wb) / w;
-        raw[p] = w;
-        sum += 2 * w;
-    }
-    const weights = new Float32Array(KERNEL_TAPS);
-    for (let i = 0; i < KERNEL_TAPS; i++) {
-        weights[i] = (raw[i] ?? 0) / sum;
-    }
-    return { weights, offsets };
-};
-//# sourceMappingURL=blur-kernel.js.map

package/dist/web/blur-kernel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"blur-kernel.js","sourceRoot":"","sources":["../../src/web/blur-kernel.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,yEAAyE;AACzE,EAAE;AACF,8EAA8E;AAC9E,2EAA2E;AAC3E,8EAA8E;AAC9E,8EAA8E;AAC9E,wEAAwE;AAExE,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAE7B,0EAA0E;AAC1E,yEAAyE;AACzE,6EAA6E;AAC7E,6EAA6E;AAC7E,2EAA2E;AAC3E,wEAAwE;AACxE,+EAA+E;AAC/E,6BAA6B;AAC7B,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,KAAa,EACqC,EAAE;IACpD,MAAM,CAAC,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;IAC1E,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,WAAW,CAAC,CAAC;IAC9C,MAAM,GAAG,GAAG,IAAI,KAAK,CAAS,WAAW,CAAC,CAAC;IAC3C,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACf,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACd,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChB,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAChB,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAChB,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;QAClB,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;QACnC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;IACf,CAAC;IACD,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,WAAW,CAAC,CAAC;IAC9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC;IACnC,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAC9B,CAAC,CAAC","sourcesContent":["// Pure 9-tap separable Gaussian kernel math. Extracted so it is unit-testable\n// in isolation (no WebGL/DOM imports) and shared by the web blur effect.\n//\n// Mirrors Android's BlurFactory.ensureKernel exactly so web, Android, and iOS\n// run the identical blur.frag: tap spacing 2.0, weight = exp(-x^2 / 2σ^2),\n// normalized by (w0 + 2·Σ w[1..]) because the shader samples vUv ± offset and\n// adds each side tap twice. Given a sigma it returns fresh arrays; the caller\n// caches by sigma (the kernel only changes when the blur slider moves).\n\nexport const KERNEL_TAPS = 5;\n\n// Linear-sampled separable Gaussian. A dense Gaussian over texels 0..8 is\n// collapsed into 5 entries: the center plus 4 bilinear pairs of adjacent\n// texels (1,2), (3,4), (5,6), (7,8). Each pair becomes one fractional-offset\n// fetch whose bilinear blend reproduces the two texels' weighted sum, so the\n// shader issues 9 fetches per pass instead of 17. offsets[0] is the center\n// (0). Normalized so center + 2*Σ(pairs) == 1 (the shader samples vUv ±\n// offset and adds each side). Mirrors Android BlurFactory.ensureKernel and iOS\n// BlurKernel.ensure exactly.\nexport const computeBlurKernel = (\n  sigma: number,\n): { weights: Float32Array; offsets: Float32Array } => {\n  const g = (t: number): number => Math.exp(-(t * t) / (2 * sigma * sigma));\n  const offsets = new Float32Array(KERNEL_TAPS);\n  const raw = new Array<number>(KERNEL_TAPS);\n  offsets[0] = 0;\n  raw[0] = g(0);\n  let sum = raw[0];\n  for (let p = 1; p < KERNEL_TAPS; p++) {\n    const a = 2 * p - 1;\n    const b = 2 * p;\n    const wa = g(a);\n    const wb = g(b);\n    const w = wa + wb;\n    offsets[p] = (a * wa + b * wb) / w;\n    raw[p] = w;\n    sum += 2 * w;\n  }\n  const weights = new Float32Array(KERNEL_TAPS);\n  for (let i = 0; i < KERNEL_TAPS; i++) {\n    weights[i] = (raw[i] ?? 0) / sum;\n  }\n  return { weights, offsets };\n};\n"]}

package/dist/web/effects/background-image.d.ts

@@ -1,3 +0,0 @@
-import type { FrameTransform } from '../insertable-streams';
-export declare const makeBackgroundImage: (source: string) => FrameTransform;
-//# sourceMappingURL=background-image.d.ts.map

package/dist/web/effects/background-image.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"background-image.d.ts","sourceRoot":"","sources":["../../../src/web/effects/background-image.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAiP5D,eAAO,MAAM,mBAAmB,WAAY,MAAM,KAAG,cA8GpD,CAAC","sourcesContent":["// Web background-image effect. Same composite pattern as the blur effect:\n// MediaPipe Selfie Segmentation produces a person mask, then a WebGL2\n// composite shader mixes the original camera frame and the background image\n// based on the mask.\n//\n// Difference from blur: instead of generating the background from two\n// Gaussian passes on the camera, the background is a still image loaded\n// once from the URL the consumer passes in. Cached per-source URL.\n//\n// Shader source lives in src/web/shaders.ts; MediaPipe loader in\n// src/web/segmenter.ts.\n\nimport type { FrameTransform } from '../insertable-streams';\nimport { getLatestMask, loadSegmenter, requestMaskIfIdle } from '../segmenter';\nimport { COMPOSITE_FRAG_SRC, PASSTHROUGH_VERT_SRC } from '../shaders';\nimport { maskSmoothstepRange, tuning } from '../tuning';\n\n// Uniform locations queried once at link, not via getUniformLocation per frame\n// (mirrors src/web/effects/blur.ts; the composite shader is identical).\ntype CompositeProgram = {\n  prog: WebGLProgram;\n  uOriginal: WebGLUniformLocation | null;\n  uBackground: WebGLUniformLocation | null;\n  uMask: WebGLUniformLocation | null;\n  uBgUvScale: WebGLUniformLocation | null;\n  uBgUvOffset: WebGLUniformLocation | null;\n  uMaskUvScale: WebGLUniformLocation | null;\n  uMaskUvOffset: WebGLUniformLocation | null;\n  uMaskLo: WebGLUniformLocation | null;\n  uMaskHi: WebGLUniformLocation | null;\n};\n\ntype GpuState = {\n  gl: WebGL2RenderingContext;\n  canvas: OffscreenCanvas;\n  width: number;\n  height: number;\n  program: CompositeProgram;\n  textures: {\n    original: WebGLTexture;\n    mask: WebGLTexture;\n    background: WebGLTexture;\n  };\n};\n\nconst compileShader = (gl: WebGL2RenderingContext, type: number, source: string): WebGLShader => {\n  const shader = gl.createShader(type);\n  if (!shader) throw new Error('kaleidoscope: gl.createShader returned null');\n  gl.shaderSource(shader, source);\n  gl.compileShader(shader);\n  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {\n    const log = gl.getShaderInfoLog(shader) ?? '(no info log)';\n    gl.deleteShader(shader);\n    throw new Error(`kaleidoscope: shader compile failed: ${log}\\n---\\n${source}`);\n  }\n  return shader;\n};\n\nconst linkProgram = (\n  gl: WebGL2RenderingContext,\n  vertSrc: string,\n  fragSrc: string,\n): WebGLProgram => {\n  const vs = compileShader(gl, gl.VERTEX_SHADER, vertSrc);\n  const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragSrc);\n  const prog = gl.createProgram();\n  if (!prog) throw new Error('kaleidoscope: gl.createProgram returned null');\n  gl.attachShader(prog, vs);\n  gl.attachShader(prog, fs);\n  gl.linkProgram(prog);\n  gl.detachShader(prog, vs);\n  gl.detachShader(prog, fs);\n  gl.deleteShader(vs);\n  gl.deleteShader(fs);\n  if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) {\n    const log = gl.getProgramInfoLog(prog) ?? '(no info log)';\n    gl.deleteProgram(prog);\n    throw new Error(`kaleidoscope: program link failed: ${log}`);\n  }\n  return prog;\n};\n\nconst linkCompositeProgram = (gl: WebGL2RenderingContext): CompositeProgram => {\n  const prog = linkProgram(gl, PASSTHROUGH_VERT_SRC, COMPOSITE_FRAG_SRC);\n  return {\n    prog,\n    uOriginal: gl.getUniformLocation(prog, 'uOriginal'),\n    uBackground: gl.getUniformLocation(prog, 'uBackground'),\n    uMask: gl.getUniformLocation(prog, 'uMask'),\n    uBgUvScale: gl.getUniformLocation(prog, 'uBgUvScale'),\n    uBgUvOffset: gl.getUniformLocation(prog, 'uBgUvOffset'),\n    uMaskUvScale: gl.getUniformLocation(prog, 'uMaskUvScale'),\n    uMaskUvOffset: gl.getUniformLocation(prog, 'uMaskUvOffset'),\n    uMaskLo: gl.getUniformLocation(prog, 'uMaskLo'),\n    uMaskHi: gl.getUniformLocation(prog, 'uMaskHi'),\n  };\n};\n\nconst createTexture = (gl: WebGL2RenderingContext, width: number, height: number): WebGLTexture => {\n  const tex = gl.createTexture();\n  if (!tex) throw new Error('kaleidoscope: gl.createTexture returned null');\n  gl.bindTexture(gl.TEXTURE_2D, tex);\n  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n  return tex;\n};\n\nconst uploadTexture = (\n  gl: WebGL2RenderingContext,\n  tex: WebGLTexture,\n  source: TexImageSource,\n  flipY: boolean,\n): void => {\n  gl.bindTexture(gl.TEXTURE_2D, tex);\n  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);\n  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);\n  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);\n};\n\n// --- Per-source caching ----------------------------------------------------\n\ntype CacheEntry = {\n  state: GpuState | null;\n  // The bg image is staged onto an OffscreenCanvas at load time because\n  // UNPACK_FLIP_Y_WEBGL is silently a no-op on ImageBitmaps; we want\n  // flipY to actually flip on upload, and it works on canvas sources.\n  imagePromise: Promise<{ canvas: OffscreenCanvas; width: number; height: number }>;\n  inputCanvas2D: OffscreenCanvas | null;\n  inputCtx2D: OffscreenCanvasRenderingContext2D | null;\n};\n\nconst cache = new Map<string, CacheEntry>();\n\n// SECURITY: `source` is consumer-supplied and may be an arbitrary URL or data\n// URI (see BackgroundImageSpec.source). Two bounds keep an untrusted source\n// from becoming a memory-pressure DoS:\n//   - MAX_BG_DIMENSION caps the RETAINED raster and the GPU upload so a\n//     \"decompression bomb\" (a small file that decodes to hundreds of\n//     megapixels) is downscaled rather than held full-size. A background is\n//     cover-fit anyway, so the cap costs nothing visible. NOTE: createImageBitmap\n//     decodes the full image before this downscale runs, so the transient decode\n//     peak is bounded by the browser's own createImageBitmap limits, not by this\n//     cap; the cap bounds sustained memory + GPU pressure, not the decode spike.\n//   - MAX_CACHE_ENTRIES bounds the per-source cache so a stream of distinct\n//     URLs cannot grow it without limit.\n// Consumers wiring `source` from end-user input should still validate the URL\n// themselves; this library does not fetch-allowlist.\nconst MAX_BG_DIMENSION = 4096;\nconst MAX_CACHE_ENTRIES = 32;\n\nconst loadImage = (\n  source: string,\n): Promise<{ canvas: OffscreenCanvas; width: number; height: number }> =>\n  fetch(source, { mode: 'cors' })\n    .then((r) => {\n      if (!r.ok) throw new Error(`kaleidoscope: failed to fetch background image: ${r.status}`);\n      return r.blob();\n    })\n    .then((blob) => createImageBitmap(blob))\n    .then((bitmap) => {\n      const longSide = Math.max(bitmap.width, bitmap.height);\n      const scale = longSide > MAX_BG_DIMENSION ? MAX_BG_DIMENSION / longSide : 1;\n      const width = Math.max(1, Math.round(bitmap.width * scale));\n      const height = Math.max(1, Math.round(bitmap.height * scale));\n      const canvas = new OffscreenCanvas(width, height);\n      const ctx = canvas.getContext('2d');\n      if (!ctx) throw new Error('kaleidoscope: bg OffscreenCanvas 2D context unavailable');\n      ctx.drawImage(bitmap, 0, 0, width, height);\n      bitmap.close();\n      return { canvas, width, height };\n    });\n\n// Free an entry's GL resources before dropping it from the cache.\nconst disposeEntry = (entry: CacheEntry): void => {\n  if (!entry.state) return;\n  const { gl, program, textures } = entry.state;\n  gl.deleteProgram(program.prog);\n  gl.deleteTexture(textures.original);\n  gl.deleteTexture(textures.mask);\n  gl.deleteTexture(textures.background);\n  entry.state = null;\n};\n\nconst ensureState = (\n  entry: CacheEntry,\n  width: number,\n  height: number,\n  bg: { canvas: OffscreenCanvas; width: number; height: number },\n): GpuState => {\n  if (entry.state && entry.state.width === width && entry.state.height === height) {\n    return entry.state;\n  }\n  if (entry.state) {\n    const { gl } = entry.state;\n    gl.deleteProgram(entry.state.program.prog);\n    gl.deleteTexture(entry.state.textures.original);\n    gl.deleteTexture(entry.state.textures.mask);\n    gl.deleteTexture(entry.state.textures.background);\n  }\n\n  const canvas = entry.state?.canvas ?? new OffscreenCanvas(width, height);\n  canvas.width = width;\n  canvas.height = height;\n  const gl = canvas.getContext('webgl2');\n  if (!gl) {\n    throw new Error(\n      'kaleidoscope: WebGL2 not available; background-image requires a WebGL2-capable browser',\n    );\n  }\n\n  entry.state = {\n    gl,\n    canvas,\n    width,\n    height,\n    program: linkCompositeProgram(gl),\n    textures: {\n      original: createTexture(gl, width, height),\n      mask: createTexture(gl, width, height),\n      background: createTexture(gl, width, height),\n    },\n  };\n  // Static background: upload once, here, not per frame. Re-runs only when\n  // this state is rebuilt (resolution change). flipY=true matches the\n  // original's DOM-coord → GL v=1 convention.\n  uploadTexture(gl, entry.state.textures.background, bg.canvas as unknown as TexImageSource, true);\n  return entry.state;\n};\n\nconst ensureInputCanvas = (\n  entry: CacheEntry,\n  width: number,\n  height: number,\n): OffscreenCanvasRenderingContext2D => {\n  if (\n    !entry.inputCanvas2D ||\n    entry.inputCanvas2D.width !== width ||\n    entry.inputCanvas2D.height !== height\n  ) {\n    entry.inputCanvas2D = new OffscreenCanvas(width, height);\n    entry.inputCtx2D = entry.inputCanvas2D.getContext('2d');\n    if (!entry.inputCtx2D) {\n      throw new Error('kaleidoscope: OffscreenCanvas 2D context unavailable');\n    }\n  }\n  return entry.inputCtx2D as OffscreenCanvasRenderingContext2D;\n};\n\n// --- The effect factory ----------------------------------------------------\n\nexport const makeBackgroundImage = (source: string): FrameTransform => {\n  let entry = cache.get(source);\n  if (!entry) {\n    // Bound the cache: evict the oldest entry (Map preserves insertion order)\n    // and free its GL resources before inserting a new source.\n    while (cache.size >= MAX_CACHE_ENTRIES) {\n      const oldestKey = cache.keys().next().value;\n      if (oldestKey === undefined) break;\n      const oldest = cache.get(oldestKey);\n      if (oldest) disposeEntry(oldest);\n      cache.delete(oldestKey);\n    }\n    entry = {\n      state: null,\n      imagePromise: loadImage(source),\n      inputCanvas2D: null,\n      inputCtx2D: null,\n    };\n    cache.set(source, entry);\n  }\n  const e = entry;\n\n  return async (frame) => {\n    const bg = await e.imagePromise;\n    await loadSegmenter(); // ensure loaded; cached after first call.\n    const w = frame.displayWidth;\n    const h = frame.displayHeight;\n\n    const inputCtx = ensureInputCanvas(e, w, h);\n    inputCtx.drawImage(frame, 0, 0, w, h);\n    const inputCanvas = e.inputCanvas2D as unknown as CanvasImageSource;\n\n    // Decoupled segmentation; see blur.ts for the rationale. Forward the\n    // original frame until the first mask lands.\n    requestMaskIfIdle(inputCanvas);\n    const results = getLatestMask();\n    if (!results) {\n      const passthrough = new VideoFrame(e.inputCanvas2D as unknown as CanvasImageSource, {\n        timestamp: frame.timestamp,\n        ...(frame.duration != null ? { duration: frame.duration } : {}),\n      });\n      frame.close();\n      return passthrough;\n    }\n\n    const s = ensureState(e, w, h, bg);\n    const { gl, canvas, program, textures } = s;\n\n    // Upload original with flipY=true (DOM-coord → GL v=1 = top). The static\n    // background is uploaded once in ensureState (flipped the same way), not\n    // per frame. Mask is uploaded with flipY=false for the same reason\n    // (no-op on MediaPipe's segmentationMask source) AND to preserve the soft\n    // confidence values — canvas premultiplied-alpha math would collapse them\n    // to near-binary. The composite shader compensates via\n    // uMaskUvScale=(1,-1) / uMaskUvOffset=(0,1) set below.\n    uploadTexture(gl, textures.original, inputCanvas as unknown as TexImageSource, true);\n    uploadTexture(gl, textures.mask, results.segmentationMask as unknown as TexImageSource, false);\n\n    gl.disable(gl.BLEND);\n    gl.disable(gl.DEPTH_TEST);\n\n    gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n    gl.viewport(0, 0, w, h);\n    // biome-ignore lint/correctness/useHookAtTopLevel: gl.useProgram is a WebGL call, not a React hook (the early return above tripped the use* heuristic).\n    gl.useProgram(program.prog);\n    gl.activeTexture(gl.TEXTURE0);\n    gl.bindTexture(gl.TEXTURE_2D, textures.original);\n    gl.uniform1i(program.uOriginal, 0);\n    gl.activeTexture(gl.TEXTURE1);\n    gl.bindTexture(gl.TEXTURE_2D, textures.background);\n    gl.uniform1i(program.uBackground, 1);\n    gl.activeTexture(gl.TEXTURE2);\n    gl.bindTexture(gl.TEXTURE_2D, textures.mask);\n    gl.uniform1i(program.uMask, 2);\n    // Cover-fit center crop: scale the smaller axis to fit, offset to\n    // center. Mirrors android/.../effects/BackgroundImageFactory.kt.\n    const outAspect = w / h;\n    const bgAspect = bg.width / bg.height;\n    let bgScaleX: number;\n    let bgScaleY: number;\n    let bgOffsetX: number;\n    let bgOffsetY: number;\n    if (bgAspect > outAspect) {\n      bgScaleX = outAspect / bgAspect;\n      bgScaleY = 1.0;\n      bgOffsetX = (1 - bgScaleX) * 0.5;\n      bgOffsetY = 0;\n    } else {\n      bgScaleX = 1.0;\n      bgScaleY = bgAspect / outAspect;\n      bgOffsetX = 0;\n      bgOffsetY = (1 - bgScaleY) * 0.5;\n    }\n    gl.uniform2f(program.uBgUvScale, bgScaleX, bgScaleY);\n    gl.uniform2f(program.uBgUvOffset, bgOffsetX, bgOffsetY);\n    // Mask V-flip via sampling uniforms; see comment on the upload above.\n    gl.uniform2f(program.uMaskUvScale, 1, -1);\n    gl.uniform2f(program.uMaskUvOffset, 0, 1);\n    const [maskLo, maskHi] = maskSmoothstepRange(tuning.maskHardness, tuning.maskThreshold);\n    gl.uniform1f(program.uMaskLo, maskLo);\n    gl.uniform1f(program.uMaskHi, maskHi);\n    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);\n\n    const out = new VideoFrame(canvas as unknown as CanvasImageSource, {\n      timestamp: frame.timestamp,\n      ...(frame.duration != null ? { duration: frame.duration } : {}),\n    });\n    frame.close();\n    return out;\n  };\n};\n"]}