react-native-webrtc-kaleidoscope 2.0.0 → 2.1.0

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

@@ -0,0 +1,32 @@
+import { type DisposablePipeline } from '../web-driver';
+import type { EffectInput } from './kaleidoscope/effect.types';
+import type { KaleidoscopeBinding, KaleidoscopeBindOptions } from './kaleidoscope/types';
+import type { KaleidoscopePresetBook } from './kaleidoscope.preset-book.types';
+export type { CatalogImageId } from '../catalog/images';
+export type { AnamorphicLensFlareUniforms, BlurUniforms, CloudsUniforms, CorporateBlobsUniforms, FirefliesUniforms, GodraysUniforms, LayerShaderName, LayerShaderOptions, LightBeamsAndMotesUniforms, NebulaUniforms, PatchableShaderName, PlasmaUniforms, ShaderUniformsMap, SimianlightsUniforms, UniformControl, } from '../catalog/shaders';
+export { ANAMORPHIC_LENSFLARE_CONTROLS, BLUR_CONTROLS, CLOUDS_CONTROLS, CORPORATE_BLOBS_CONTROLS, defaultUniforms, FIREFLIES_CONTROLS, GODRAYS_CONTROLS, LIGHT_BEAMS_AND_MOTES_CONTROLS, NEBULA_CONTROLS, PLASMA_CONTROLS, SIMIANLIGHTS_CONTROLS, } from '../catalog/shaders';
+export type { CompositeSpec, EffectInput, EffectName, EffectSpec, TransformName, TransformSpec, } from './kaleidoscope/effect.types';
+export type { KaleidoscopeBinding, KaleidoscopeBindOptions, MaskInput, PatchesFor, PatchFor, TransformInput, } from './kaleidoscope/types';
+export type { KaleidoscopeBlendMode, KaleidoscopeControls, KaleidoscopeLayer, KaleidoscopeLayerTarget, KaleidoscopePreset, KaleidoscopePresetBook, KaleidoscopePresetEntry, KaleidoscopeTaxonomy, } from './kaleidoscope.preset-book.types';
+export type { RGB } from './lib/primitives.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;
+/**
+ * Bind a track and a preset book; get the three verbs back
+ * (`{ kaleidoscope, transform, mask }`). Presets live in the consumer's
+ * project; these verbs drive them. On web each `kaleidoscope` preset switch and
+ * each `transform` command rebuilds the Insertable-Streams pipeline and yields a
+ * new output track, so read the live track from `onTrack` (or `controls.track`);
+ * the prior pipeline is disposed each command and on `dispose()`. A `kaleidoscope`
+ * patch of the active preset and `mask` both update what the running pipeline
+ * reads per frame (no rebuild).
+ */
+export declare const bindKaleidoscope: <P extends KaleidoscopePresetBook>(track: MediaStreamTrack, options: KaleidoscopeBindOptions<P>) => KaleidoscopeBinding<P>;
+//# sourceMappingURL=index.web.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.web.d.ts","sourceRoot":"","sources":["../../src/index.web.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,KAAK,kBAAkB,EAOxB,MAAM,eAAe,CAAC;AASvB,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,6BAA6B,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAQ/E,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,YAAY,EACV,2BAA2B,EAC3B,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,0BAA0B,EAC1B,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,6BAA6B,EAC7B,aAAa,EACb,eAAe,EACf,wBAAwB,EACxB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,8BAA8B,EAC9B,eAAe,EACf,eAAe,EACf,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,aAAa,EACb,WAAW,EACX,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,GACd,MAAM,6BAA6B,CAAC;AACrC,YAAY,EACV,mBAAmB,EACnB,uBAAuB,EACvB,SAAS,EACT,UAAU,EACV,QAAQ,EACR,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAiBlD;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,UAC/B,gBAAgB,WACd,aAAa,CAAC,WAAW,CAAC,KAClC,kBA0BF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,sBAAsB,SACxD,gBAAgB,WACd,uBAAuB,CAAC,CAAC,CAAC,KAClC,mBAAmB,CAAC,CAAC,CA4BvB,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// Every visual effect is one composite (a layer stack) or one transform. A\n// composite wires an Insertable-Streams stage that runs the whole layer stack\n// through the compositor and returns a new MediaStreamTrack carrying the\n// transformed frames. Pass the returned track to a `<video>` element or to\n// `RTCRtpSender.replaceTrack(...)`.\n\nimport {\n  applyEffectToTrack,\n  type DisposablePipeline,\n  type FrameTransform,\n  makeComposite,\n  makeTransform,\n  resetLayerUniforms as resetCompositeLayerUniforms,\n  setLayerUniforms as setCompositeLayerUniforms,\n  tuning,\n} from '../web-driver';\nimport {\n  createControls,\n  type Reconcile,\n  type ResetLayerUniforms,\n  type SetLayerUniforms,\n  type SetMask,\n} from './kaleidoscope/controls';\nimport { toEffectSpec } from './kaleidoscope/effect';\nimport type { EffectInput, EffectSpec } from './kaleidoscope/effect.types';\nimport type { KaleidoscopeBinding, KaleidoscopeBindOptions } from './kaleidoscope/types';\nimport type { KaleidoscopePresetBook } from './kaleidoscope.preset-book.types';\n\n// The tuning channel (tuning.*) is internal: the mask edge flows from the mask()\n// verb (see bindKaleidoscope). Per-layer uniform tuning flows from the\n// kaleidoscope verb's patch path into the composite compositor's live channel. The\n// old global set* exports are gone; effects are driven by kaleidoscope /\n// transform / mask, not loose setters.\n\nexport type { CatalogImageId } from '../catalog/images';\nexport type {\n  AnamorphicLensFlareUniforms,\n  BlurUniforms,\n  CloudsUniforms,\n  CorporateBlobsUniforms,\n  FirefliesUniforms,\n  GodraysUniforms,\n  LayerShaderName,\n  LayerShaderOptions,\n  LightBeamsAndMotesUniforms,\n  NebulaUniforms,\n  PatchableShaderName,\n  PlasmaUniforms,\n  ShaderUniformsMap,\n  SimianlightsUniforms,\n  UniformControl,\n} from '../catalog/shaders';\nexport {\n  ANAMORPHIC_LENSFLARE_CONTROLS,\n  BLUR_CONTROLS,\n  CLOUDS_CONTROLS,\n  CORPORATE_BLOBS_CONTROLS,\n  defaultUniforms,\n  FIREFLIES_CONTROLS,\n  GODRAYS_CONTROLS,\n  LIGHT_BEAMS_AND_MOTES_CONTROLS,\n  NEBULA_CONTROLS,\n  PLASMA_CONTROLS,\n  SIMIANLIGHTS_CONTROLS,\n} from '../catalog/shaders';\nexport type {\n  CompositeSpec,\n  EffectInput,\n  EffectName,\n  EffectSpec,\n  TransformName,\n  TransformSpec,\n} from './kaleidoscope/effect.types';\nexport type {\n  KaleidoscopeBinding,\n  KaleidoscopeBindOptions,\n  MaskInput,\n  PatchesFor,\n  PatchFor,\n  TransformInput,\n} from './kaleidoscope/types';\nexport type {\n  KaleidoscopeBlendMode,\n  KaleidoscopeControls,\n  KaleidoscopeLayer,\n  KaleidoscopeLayerTarget,\n  KaleidoscopePreset,\n  KaleidoscopePresetBook,\n  KaleidoscopePresetEntry,\n  KaleidoscopeTaxonomy,\n} from './kaleidoscope.preset-book.types';\nexport type { RGB } from './lib/primitives.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 'composite':\n      // The layer stack runs as a single compositor stage (painter's order,\n      // per-layer blend), not a serial chain of replace-stages. Blur, image, and\n      // generative layers all live inside it.\n      return makeComposite(spec.layers);\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\n/**\n * Bind a track and a preset book; get the three verbs back\n * (`{ kaleidoscope, transform, mask }`). Presets live in the consumer's\n * project; these verbs drive them. On web each `kaleidoscope` preset switch and\n * each `transform` command rebuilds the Insertable-Streams pipeline and yields a\n * new output track, so read the live track from `onTrack` (or `controls.track`);\n * the prior pipeline is disposed each command and on `dispose()`. A `kaleidoscope`\n * patch of the active preset and `mask` both update what the running pipeline\n * reads per frame (no rebuild).\n */\nexport const bindKaleidoscope = <P extends KaleidoscopePresetBook>(\n  track: MediaStreamTrack,\n  options: KaleidoscopeBindOptions<P>,\n): KaleidoscopeBinding<P> => {\n  let prevDispose = (): void => {};\n  const reconcile: Reconcile = {\n    apply: (specs) => {\n      // Rebuild the whole pipeline from the base track each command, disposing\n      // the previous one (generators/pipes) so stages don't leak.\n      prevDispose();\n      const { track: out, dispose } = applyVideoEffectsDisposable(track, specs);\n      prevDispose = dispose;\n      return out;\n    },\n    dispose: () => prevDispose(),\n  };\n  const setMask: SetMask = (hardness, threshold) => {\n    tuning.setMaskHardness(hardness);\n    tuning.setMaskThreshold(threshold);\n  };\n  // Live per-layer uniform channel: a patch of the active preset writes here\n  // (keyed by layer id) and the running compositor merges it each frame.\n  const setLayerUniforms: SetLayerUniforms = (id, uniforms) => {\n    setCompositeLayerUniforms(id, uniforms);\n  };\n  // A preset switch drops every live override so reused layer ids revert to the\n  // new preset's baked uniforms (see createControls).\n  const resetLayerUniforms: ResetLayerUniforms = () => {\n    resetCompositeLayerUniforms();\n  };\n  return createControls(track, options, reconcile, setMask, setLayerUniforms, resetLayerUniforms);\n};\n"]}

package/dist/src/index.web.js

@@ -0,0 +1,119 @@
+"use strict";
+// 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.
+//
+// Every visual effect is one composite (a layer stack) or one transform. A
+// composite wires an Insertable-Streams stage that runs the whole layer stack
+// through the compositor and returns a new MediaStreamTrack carrying the
+// transformed frames. Pass the returned track to a `<video>` element or to
+// `RTCRtpSender.replaceTrack(...)`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindKaleidoscope = exports.applyVideoEffectsDisposable = exports.SIMIANLIGHTS_CONTROLS = exports.PLASMA_CONTROLS = exports.NEBULA_CONTROLS = exports.LIGHT_BEAMS_AND_MOTES_CONTROLS = exports.GODRAYS_CONTROLS = exports.FIREFLIES_CONTROLS = exports.defaultUniforms = exports.CORPORATE_BLOBS_CONTROLS = exports.CLOUDS_CONTROLS = exports.BLUR_CONTROLS = exports.ANAMORPHIC_LENSFLARE_CONTROLS = void 0;
+const web_driver_1 = require("../web-driver");
+const controls_1 = require("./kaleidoscope/controls");
+const effect_1 = require("./kaleidoscope/effect");
+var shaders_1 = require("../catalog/shaders");
+Object.defineProperty(exports, "ANAMORPHIC_LENSFLARE_CONTROLS", { enumerable: true, get: function () { return shaders_1.ANAMORPHIC_LENSFLARE_CONTROLS; } });
+Object.defineProperty(exports, "BLUR_CONTROLS", { enumerable: true, get: function () { return shaders_1.BLUR_CONTROLS; } });
+Object.defineProperty(exports, "CLOUDS_CONTROLS", { enumerable: true, get: function () { return shaders_1.CLOUDS_CONTROLS; } });
+Object.defineProperty(exports, "CORPORATE_BLOBS_CONTROLS", { enumerable: true, get: function () { return shaders_1.CORPORATE_BLOBS_CONTROLS; } });
+Object.defineProperty(exports, "defaultUniforms", { enumerable: true, get: function () { return shaders_1.defaultUniforms; } });
+Object.defineProperty(exports, "FIREFLIES_CONTROLS", { enumerable: true, get: function () { return shaders_1.FIREFLIES_CONTROLS; } });
+Object.defineProperty(exports, "GODRAYS_CONTROLS", { enumerable: true, get: function () { return shaders_1.GODRAYS_CONTROLS; } });
+Object.defineProperty(exports, "LIGHT_BEAMS_AND_MOTES_CONTROLS", { enumerable: true, get: function () { return shaders_1.LIGHT_BEAMS_AND_MOTES_CONTROLS; } });
+Object.defineProperty(exports, "NEBULA_CONTROLS", { enumerable: true, get: function () { return shaders_1.NEBULA_CONTROLS; } });
+Object.defineProperty(exports, "PLASMA_CONTROLS", { enumerable: true, get: function () { return shaders_1.PLASMA_CONTROLS; } });
+Object.defineProperty(exports, "SIMIANLIGHTS_CONTROLS", { enumerable: true, get: function () { return shaders_1.SIMIANLIGHTS_CONTROLS; } });
+const specToTransform = (spec) => {
+    switch (spec.name) {
+        case 'flip-x':
+        case 'flip-y':
+        case 'rotate-cw':
+        case 'rotate-ccw':
+            return (0, web_driver_1.makeTransform)(spec.name);
+        case 'composite':
+            // The layer stack runs as a single compositor stage (painter's order,
+            // per-layer blend), not a serial chain of replace-stages. Blur, image, and
+            // generative layers all live inside it.
+            return (0, web_driver_1.makeComposite)(spec.layers);
+    }
+};
+/**
+ * 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.
+ */
+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 = (0, effect_1.toEffectSpec)(input);
+        const transform = specToTransform(spec);
+        const stage = (0, web_driver_1.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();
+            }
+        },
+    };
+};
+exports.applyVideoEffectsDisposable = applyVideoEffectsDisposable;
+/**
+ * Bind a track and a preset book; get the three verbs back
+ * (`{ kaleidoscope, transform, mask }`). Presets live in the consumer's
+ * project; these verbs drive them. On web each `kaleidoscope` preset switch and
+ * each `transform` command rebuilds the Insertable-Streams pipeline and yields a
+ * new output track, so read the live track from `onTrack` (or `controls.track`);
+ * the prior pipeline is disposed each command and on `dispose()`. A `kaleidoscope`
+ * patch of the active preset and `mask` both update what the running pipeline
+ * reads per frame (no rebuild).
+ */
+const bindKaleidoscope = (track, options) => {
+    let prevDispose = () => { };
+    const reconcile = {
+        apply: (specs) => {
+            // Rebuild the whole pipeline from the base track each command, disposing
+            // the previous one (generators/pipes) so stages don't leak.
+            prevDispose();
+            const { track: out, dispose } = (0, exports.applyVideoEffectsDisposable)(track, specs);
+            prevDispose = dispose;
+            return out;
+        },
+        dispose: () => prevDispose(),
+    };
+    const setMask = (hardness, threshold) => {
+        web_driver_1.tuning.setMaskHardness(hardness);
+        web_driver_1.tuning.setMaskThreshold(threshold);
+    };
+    // Live per-layer uniform channel: a patch of the active preset writes here
+    // (keyed by layer id) and the running compositor merges it each frame.
+    const setLayerUniforms = (id, uniforms) => {
+        (0, web_driver_1.setLayerUniforms)(id, uniforms);
+    };
+    // A preset switch drops every live override so reused layer ids revert to the
+    // new preset's baked uniforms (see createControls).
+    const resetLayerUniforms = () => {
+        (0, web_driver_1.resetLayerUniforms)();
+    };
+    return (0, controls_1.createControls)(track, options, reconcile, setMask, setLayerUniforms, resetLayerUniforms);
+};
+exports.bindKaleidoscope = bindKaleidoscope;
+//# sourceMappingURL=index.web.js.map

package/dist/src/index.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.web.js","sourceRoot":"","sources":["../../src/index.web.ts"],"names":[],"mappings":"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","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// Every visual effect is one composite (a layer stack) or one transform. A\n// composite wires an Insertable-Streams stage that runs the whole layer stack\n// through the compositor and returns a new MediaStreamTrack carrying the\n// transformed frames. Pass the returned track to a `<video>` element or to\n// `RTCRtpSender.replaceTrack(...)`.\n\nimport {\n  applyEffectToTrack,\n  type DisposablePipeline,\n  type FrameTransform,\n  makeComposite,\n  makeTransform,\n  resetLayerUniforms as resetCompositeLayerUniforms,\n  setLayerUniforms as setCompositeLayerUniforms,\n  tuning,\n} from '../web-driver';\nimport {\n  createControls,\n  type Reconcile,\n  type ResetLayerUniforms,\n  type SetLayerUniforms,\n  type SetMask,\n} from './kaleidoscope/controls';\nimport { toEffectSpec } from './kaleidoscope/effect';\nimport type { EffectInput, EffectSpec } from './kaleidoscope/effect.types';\nimport type { KaleidoscopeBinding, KaleidoscopeBindOptions } from './kaleidoscope/types';\nimport type { KaleidoscopePresetBook } from './kaleidoscope.preset-book.types';\n\n// The tuning channel (tuning.*) is internal: the mask edge flows from the mask()\n// verb (see bindKaleidoscope). Per-layer uniform tuning flows from the\n// kaleidoscope verb's patch path into the composite compositor's live channel. The\n// old global set* exports are gone; effects are driven by kaleidoscope /\n// transform / mask, not loose setters.\n\nexport type { CatalogImageId } from '../catalog/images';\nexport type {\n  AnamorphicLensFlareUniforms,\n  BlurUniforms,\n  CloudsUniforms,\n  CorporateBlobsUniforms,\n  FirefliesUniforms,\n  GodraysUniforms,\n  LayerShaderName,\n  LayerShaderOptions,\n  LightBeamsAndMotesUniforms,\n  NebulaUniforms,\n  PatchableShaderName,\n  PlasmaUniforms,\n  ShaderUniformsMap,\n  SimianlightsUniforms,\n  UniformControl,\n} from '../catalog/shaders';\nexport {\n  ANAMORPHIC_LENSFLARE_CONTROLS,\n  BLUR_CONTROLS,\n  CLOUDS_CONTROLS,\n  CORPORATE_BLOBS_CONTROLS,\n  defaultUniforms,\n  FIREFLIES_CONTROLS,\n  GODRAYS_CONTROLS,\n  LIGHT_BEAMS_AND_MOTES_CONTROLS,\n  NEBULA_CONTROLS,\n  PLASMA_CONTROLS,\n  SIMIANLIGHTS_CONTROLS,\n} from '../catalog/shaders';\nexport type {\n  CompositeSpec,\n  EffectInput,\n  EffectName,\n  EffectSpec,\n  TransformName,\n  TransformSpec,\n} from './kaleidoscope/effect.types';\nexport type {\n  KaleidoscopeBinding,\n  KaleidoscopeBindOptions,\n  MaskInput,\n  PatchesFor,\n  PatchFor,\n  TransformInput,\n} from './kaleidoscope/types';\nexport type {\n  KaleidoscopeBlendMode,\n  KaleidoscopeControls,\n  KaleidoscopeLayer,\n  KaleidoscopeLayerTarget,\n  KaleidoscopePreset,\n  KaleidoscopePresetBook,\n  KaleidoscopePresetEntry,\n  KaleidoscopeTaxonomy,\n} from './kaleidoscope.preset-book.types';\nexport type { RGB } from './lib/primitives.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 'composite':\n      // The layer stack runs as a single compositor stage (painter's order,\n      // per-layer blend), not a serial chain of replace-stages. Blur, image, and\n      // generative layers all live inside it.\n      return makeComposite(spec.layers);\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\n/**\n * Bind a track and a preset book; get the three verbs back\n * (`{ kaleidoscope, transform, mask }`). Presets live in the consumer's\n * project; these verbs drive them. On web each `kaleidoscope` preset switch and\n * each `transform` command rebuilds the Insertable-Streams pipeline and yields a\n * new output track, so read the live track from `onTrack` (or `controls.track`);\n * the prior pipeline is disposed each command and on `dispose()`. A `kaleidoscope`\n * patch of the active preset and `mask` both update what the running pipeline\n * reads per frame (no rebuild).\n */\nexport const bindKaleidoscope = <P extends KaleidoscopePresetBook>(\n  track: MediaStreamTrack,\n  options: KaleidoscopeBindOptions<P>,\n): KaleidoscopeBinding<P> => {\n  let prevDispose = (): void => {};\n  const reconcile: Reconcile = {\n    apply: (specs) => {\n      // Rebuild the whole pipeline from the base track each command, disposing\n      // the previous one (generators/pipes) so stages don't leak.\n      prevDispose();\n      const { track: out, dispose } = applyVideoEffectsDisposable(track, specs);\n      prevDispose = dispose;\n      return out;\n    },\n    dispose: () => prevDispose(),\n  };\n  const setMask: SetMask = (hardness, threshold) => {\n    tuning.setMaskHardness(hardness);\n    tuning.setMaskThreshold(threshold);\n  };\n  // Live per-layer uniform channel: a patch of the active preset writes here\n  // (keyed by layer id) and the running compositor merges it each frame.\n  const setLayerUniforms: SetLayerUniforms = (id, uniforms) => {\n    setCompositeLayerUniforms(id, uniforms);\n  };\n  // A preset switch drops every live override so reused layer ids revert to the\n  // new preset's baked uniforms (see createControls).\n  const resetLayerUniforms: ResetLayerUniforms = () => {\n    resetCompositeLayerUniforms();\n  };\n  return createControls(track, options, reconcile, setMask, setLayerUniforms, resetLayerUniforms);\n};\n"]}

package/dist/src/kaleidoscope/controls.d.ts

@@ -0,0 +1,24 @@
+import type { KaleidoscopePresetBook } from '../kaleidoscope.preset-book.types';
+import type { EffectSpec } from './effect.types';
+import type { KaleidoscopeBinding, KaleidoscopeBindOptions } from './types';
+/** Apply the ordered specs to the base track and return the output. */
+export type Reconcile = {
+    apply: (specs: ReadonlyArray<EffectSpec>) => MediaStreamTrack;
+    dispose: () => void;
+};
+/** Write the segmentation mask edge (platform tuning channel). */
+export type SetMask = (hardness: number, threshold: number) => void;
+/**
+ * Write a live per-layer uniform override (platform tuning channel), keyed by
+ * layer id. The running composite merges these over the layer's baked uniforms
+ * each frame, with no rebuild. Mirrors `setMask`.
+ */
+export type SetLayerUniforms = (id: string, uniforms: Readonly<Record<string, number | readonly number[]>>) => void;
+/**
+ * Drop every live per-layer override (platform tuning channel). A preset switch
+ * calls this so a reused layer id reverts to the new preset's baked uniforms
+ * rather than inheriting a stale override from the prior preset.
+ */
+export type ResetLayerUniforms = () => void;
+export declare const createControls: <P extends KaleidoscopePresetBook>(baseTrack: MediaStreamTrack, { presets, onTrack }: KaleidoscopeBindOptions<P>, reconcile: Reconcile, setMask: SetMask, setLayerUniforms: SetLayerUniforms, resetLayerUniforms: ResetLayerUniforms) => KaleidoscopeBinding<P>;
+//# sourceMappingURL=controls.d.ts.map

package/dist/src/kaleidoscope/controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controls.d.ts","sourceRoot":"","sources":["../../../src/kaleidoscope/controls.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAsB,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AACpG,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAkB,MAAM,SAAS,CAAC;AAE5F,uEAAuE;AACvE,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,KAAK,gBAAgB,CAAC;IAC9D,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,kEAAkE;AAClE,MAAM,MAAM,OAAO,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC,CAAC,KAC3D,IAAI,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC;AAiB5C,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,sBAAsB,aAClD,gBAAgB,wBACL,uBAAuB,CAAC,CAAC,CAAC,aACrC,SAAS,WACX,OAAO,oBACE,gBAAgB,sBACd,kBAAkB,KACrC,mBAAmB,CAAC,CAAC,CA0DvB,CAAC","sourcesContent":["// The three-verb controls: shared composite-state machine, platform-agnostic.\n//\n// Holds the art effect (one composite) and the transform op list, reconciles\n// them into an ordered EffectSpec array (art FIRST so segmentation sees the\n// upright frame, transform LAST so it reorients the finished composite), and\n// applies them through an injected platform `reconcile`. Web rebuilds the\n// pipeline and yields a new track (disposing the prior one); native mutates in\n// place. `mask` writes the segmentation edge through an injected `setMask`; the\n// running composite reads it per frame, so it needs no rebuild.\n//\n// The art verb is rebuild-aware: switching to a different preset rebuilds, but\n// patching the currently-active preset routes through an injected live\n// layer-uniform channel (`setLayerUniforms`, keyed by layer id) so a slider drag\n// updates the running composite without a rebuild.\n\nimport type { KaleidoscopePreset, KaleidoscopePresetBook } from '../kaleidoscope.preset-book.types';\nimport type { EffectSpec, TransformName } from './effect.types';\nimport { compositeToEffectSpec } from './shader-to-spec';\nimport type { KaleidoscopeBinding, KaleidoscopeBindOptions, TransformInput } from './types';\n\n/** Apply the ordered specs to the base track and return the output. */\nexport type Reconcile = {\n  apply: (specs: ReadonlyArray<EffectSpec>) => MediaStreamTrack;\n  dispose: () => void;\n};\n\n/** Write the segmentation mask edge (platform tuning channel). */\nexport type SetMask = (hardness: number, threshold: number) => void;\n\n/**\n * Write a live per-layer uniform override (platform tuning channel), keyed by\n * layer id. The running composite merges these over the layer's baked uniforms\n * each frame, with no rebuild. Mirrors `setMask`.\n */\nexport type SetLayerUniforms = (\n  id: string,\n  uniforms: Readonly<Record<string, number | readonly number[]>>,\n) => void;\n\n/**\n * Drop every live per-layer override (platform tuning channel). A preset switch\n * calls this so a reused layer id reverts to the new preset's baked uniforms\n * rather than inheriting a stale override from the prior preset.\n */\nexport type ResetLayerUniforms = () => void;\n\n// Decompose an absolute transform into the discrete ops the pipeline already\n// runs (reused on web and native). Flips first, then rotation; rotation snaps to\n// the nearest 90°. 180° is two CW steps; 270° is one CCW step.\nconst decomposeTransform = (t?: TransformInput): EffectSpec[] => {\n  if (!t) return [];\n  const names: TransformName[] = [];\n  if (t.flip?.x) names.push('flip-x');\n  if (t.flip?.y) names.push('flip-y');\n  const deg = (((Math.round((t.rotate ?? 0) / 90) * 90) % 360) + 360) % 360;\n  if (deg === 90) names.push('rotate-cw');\n  else if (deg === 180) names.push('rotate-cw', 'rotate-cw');\n  else if (deg === 270) names.push('rotate-ccw');\n  return names.map((name) => ({ name }));\n};\n\nexport const createControls = <P extends KaleidoscopePresetBook>(\n  baseTrack: MediaStreamTrack,\n  { presets, onTrack }: KaleidoscopeBindOptions<P>,\n  reconcile: Reconcile,\n  setMask: SetMask,\n  setLayerUniforms: SetLayerUniforms,\n  resetLayerUniforms: ResetLayerUniforms,\n): KaleidoscopeBinding<P> => {\n  let art: EffectSpec | null = null;\n  let transformOps: EffectSpec[] = [];\n  let current = baseTrack;\n  // The id of the active preset (null when cleared). A patch of THIS id routes\n  // through the live channel; any other cmd rebuilds.\n  let activeId: keyof P | null = null;\n\n  const apply = (): void => {\n    const specs: EffectSpec[] = [];\n    if (art) specs.push(art);\n    specs.push(...transformOps);\n    current = reconcile.apply(specs);\n    onTrack?.(current);\n  };\n\n  return {\n    kaleidoscope: (\n      cmd: keyof P | null,\n      patches?: ReadonlyArray<{\n        readonly id: string;\n        readonly uniforms: Readonly<Record<string, number | readonly number[]>>;\n      }>,\n    ) => {\n      // Patch the currently-active preset: route through the live no-rebuild\n      // channel, keyed by layer id. The `shader` field on a patch is only for\n      // narrowing; the channel resolves by `id`.\n      if (cmd != null && cmd === activeId && patches && patches.length > 0) {\n        for (const patch of patches) {\n          setLayerUniforms(patch.id, patch.uniforms);\n        }\n        return;\n      }\n      // Switch the preset (or clear): rebuild. Drop every live override first so\n      // a reused layer id (e.g. 'blur', shared by the low/medium/high blur\n      // presets) takes the new preset's baked uniforms instead of carrying a\n      // stale slider override across. A transform rebuild does NOT pass through\n      // here, so slider tweaks survive flips/rotations of the active preset.\n      activeId = cmd;\n      art = cmd == null ? null : compositeToEffectSpec(presets[cmd] as KaleidoscopePreset);\n      resetLayerUniforms();\n      apply();\n    },\n    transform: (t) => {\n      transformOps = decomposeTransform(t);\n      apply();\n    },\n    mask: (m) => {\n      // Updates the edge the per-frame composite reads; no pipeline rebuild.\n      setMask(m.hardness, m.threshold);\n    },\n    get track() {\n      return current;\n    },\n    dispose: () => {\n      reconcile.dispose();\n    },\n  };\n};\n"]}

package/dist/src/kaleidoscope/controls.js

@@ -0,0 +1,92 @@
+"use strict";
+// The three-verb controls: shared composite-state machine, platform-agnostic.
+//
+// Holds the art effect (one composite) and the transform op list, reconciles
+// them into an ordered EffectSpec array (art FIRST so segmentation sees the
+// upright frame, transform LAST so it reorients the finished composite), and
+// applies them through an injected platform `reconcile`. Web rebuilds the
+// pipeline and yields a new track (disposing the prior one); native mutates in
+// place. `mask` writes the segmentation edge through an injected `setMask`; the
+// running composite reads it per frame, so it needs no rebuild.
+//
+// The art verb is rebuild-aware: switching to a different preset rebuilds, but
+// patching the currently-active preset routes through an injected live
+// layer-uniform channel (`setLayerUniforms`, keyed by layer id) so a slider drag
+// updates the running composite without a rebuild.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createControls = void 0;
+const shader_to_spec_1 = require("./shader-to-spec");
+// Decompose an absolute transform into the discrete ops the pipeline already
+// runs (reused on web and native). Flips first, then rotation; rotation snaps to
+// the nearest 90°. 180° is two CW steps; 270° is one CCW step.
+const decomposeTransform = (t) => {
+    if (!t)
+        return [];
+    const names = [];
+    if (t.flip?.x)
+        names.push('flip-x');
+    if (t.flip?.y)
+        names.push('flip-y');
+    const deg = (((Math.round((t.rotate ?? 0) / 90) * 90) % 360) + 360) % 360;
+    if (deg === 90)
+        names.push('rotate-cw');
+    else if (deg === 180)
+        names.push('rotate-cw', 'rotate-cw');
+    else if (deg === 270)
+        names.push('rotate-ccw');
+    return names.map((name) => ({ name }));
+};
+const createControls = (baseTrack, { presets, onTrack }, reconcile, setMask, setLayerUniforms, resetLayerUniforms) => {
+    let art = null;
+    let transformOps = [];
+    let current = baseTrack;
+    // The id of the active preset (null when cleared). A patch of THIS id routes
+    // through the live channel; any other cmd rebuilds.
+    let activeId = null;
+    const apply = () => {
+        const specs = [];
+        if (art)
+            specs.push(art);
+        specs.push(...transformOps);
+        current = reconcile.apply(specs);
+        onTrack?.(current);
+    };
+    return {
+        kaleidoscope: (cmd, patches) => {
+            // Patch the currently-active preset: route through the live no-rebuild
+            // channel, keyed by layer id. The `shader` field on a patch is only for
+            // narrowing; the channel resolves by `id`.
+            if (cmd != null && cmd === activeId && patches && patches.length > 0) {
+                for (const patch of patches) {
+                    setLayerUniforms(patch.id, patch.uniforms);
+                }
+                return;
+            }
+            // Switch the preset (or clear): rebuild. Drop every live override first so
+            // a reused layer id (e.g. 'blur', shared by the low/medium/high blur
+            // presets) takes the new preset's baked uniforms instead of carrying a
+            // stale slider override across. A transform rebuild does NOT pass through
+            // here, so slider tweaks survive flips/rotations of the active preset.
+            activeId = cmd;
+            art = cmd == null ? null : (0, shader_to_spec_1.compositeToEffectSpec)(presets[cmd]);
+            resetLayerUniforms();
+            apply();
+        },
+        transform: (t) => {
+            transformOps = decomposeTransform(t);
+            apply();
+        },
+        mask: (m) => {
+            // Updates the edge the per-frame composite reads; no pipeline rebuild.
+            setMask(m.hardness, m.threshold);
+        },
+        get track() {
+            return current;
+        },
+        dispose: () => {
+            reconcile.dispose();
+        },
+    };
+};
+exports.createControls = createControls;
+//# sourceMappingURL=controls.js.map

package/dist/src/kaleidoscope/controls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controls.js","sourceRoot":"","sources":["../../../src/kaleidoscope/controls.ts"],"names":[],"mappings":"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","sourcesContent":["// The three-verb controls: shared composite-state machine, platform-agnostic.\n//\n// Holds the art effect (one composite) and the transform op list, reconciles\n// them into an ordered EffectSpec array (art FIRST so segmentation sees the\n// upright frame, transform LAST so it reorients the finished composite), and\n// applies them through an injected platform `reconcile`. Web rebuilds the\n// pipeline and yields a new track (disposing the prior one); native mutates in\n// place. `mask` writes the segmentation edge through an injected `setMask`; the\n// running composite reads it per frame, so it needs no rebuild.\n//\n// The art verb is rebuild-aware: switching to a different preset rebuilds, but\n// patching the currently-active preset routes through an injected live\n// layer-uniform channel (`setLayerUniforms`, keyed by layer id) so a slider drag\n// updates the running composite without a rebuild.\n\nimport type { KaleidoscopePreset, KaleidoscopePresetBook } from '../kaleidoscope.preset-book.types';\nimport type { EffectSpec, TransformName } from './effect.types';\nimport { compositeToEffectSpec } from './shader-to-spec';\nimport type { KaleidoscopeBinding, KaleidoscopeBindOptions, TransformInput } from './types';\n\n/** Apply the ordered specs to the base track and return the output. */\nexport type Reconcile = {\n  apply: (specs: ReadonlyArray<EffectSpec>) => MediaStreamTrack;\n  dispose: () => void;\n};\n\n/** Write the segmentation mask edge (platform tuning channel). */\nexport type SetMask = (hardness: number, threshold: number) => void;\n\n/**\n * Write a live per-layer uniform override (platform tuning channel), keyed by\n * layer id. The running composite merges these over the layer's baked uniforms\n * each frame, with no rebuild. Mirrors `setMask`.\n */\nexport type SetLayerUniforms = (\n  id: string,\n  uniforms: Readonly<Record<string, number | readonly number[]>>,\n) => void;\n\n/**\n * Drop every live per-layer override (platform tuning channel). A preset switch\n * calls this so a reused layer id reverts to the new preset's baked uniforms\n * rather than inheriting a stale override from the prior preset.\n */\nexport type ResetLayerUniforms = () => void;\n\n// Decompose an absolute transform into the discrete ops the pipeline already\n// runs (reused on web and native). Flips first, then rotation; rotation snaps to\n// the nearest 90°. 180° is two CW steps; 270° is one CCW step.\nconst decomposeTransform = (t?: TransformInput): EffectSpec[] => {\n  if (!t) return [];\n  const names: TransformName[] = [];\n  if (t.flip?.x) names.push('flip-x');\n  if (t.flip?.y) names.push('flip-y');\n  const deg = (((Math.round((t.rotate ?? 0) / 90) * 90) % 360) + 360) % 360;\n  if (deg === 90) names.push('rotate-cw');\n  else if (deg === 180) names.push('rotate-cw', 'rotate-cw');\n  else if (deg === 270) names.push('rotate-ccw');\n  return names.map((name) => ({ name }));\n};\n\nexport const createControls = <P extends KaleidoscopePresetBook>(\n  baseTrack: MediaStreamTrack,\n  { presets, onTrack }: KaleidoscopeBindOptions<P>,\n  reconcile: Reconcile,\n  setMask: SetMask,\n  setLayerUniforms: SetLayerUniforms,\n  resetLayerUniforms: ResetLayerUniforms,\n): KaleidoscopeBinding<P> => {\n  let art: EffectSpec | null = null;\n  let transformOps: EffectSpec[] = [];\n  let current = baseTrack;\n  // The id of the active preset (null when cleared). A patch of THIS id routes\n  // through the live channel; any other cmd rebuilds.\n  let activeId: keyof P | null = null;\n\n  const apply = (): void => {\n    const specs: EffectSpec[] = [];\n    if (art) specs.push(art);\n    specs.push(...transformOps);\n    current = reconcile.apply(specs);\n    onTrack?.(current);\n  };\n\n  return {\n    kaleidoscope: (\n      cmd: keyof P | null,\n      patches?: ReadonlyArray<{\n        readonly id: string;\n        readonly uniforms: Readonly<Record<string, number | readonly number[]>>;\n      }>,\n    ) => {\n      // Patch the currently-active preset: route through the live no-rebuild\n      // channel, keyed by layer id. The `shader` field on a patch is only for\n      // narrowing; the channel resolves by `id`.\n      if (cmd != null && cmd === activeId && patches && patches.length > 0) {\n        for (const patch of patches) {\n          setLayerUniforms(patch.id, patch.uniforms);\n        }\n        return;\n      }\n      // Switch the preset (or clear): rebuild. Drop every live override first so\n      // a reused layer id (e.g. 'blur', shared by the low/medium/high blur\n      // presets) takes the new preset's baked uniforms instead of carrying a\n      // stale slider override across. A transform rebuild does NOT pass through\n      // here, so slider tweaks survive flips/rotations of the active preset.\n      activeId = cmd;\n      art = cmd == null ? null : compositeToEffectSpec(presets[cmd] as KaleidoscopePreset);\n      resetLayerUniforms();\n      apply();\n    },\n    transform: (t) => {\n      transformOps = decomposeTransform(t);\n      apply();\n    },\n    mask: (m) => {\n      // Updates the edge the per-frame composite reads; no pipeline rebuild.\n      setMask(m.hardness, m.threshold);\n    },\n    get track() {\n      return current;\n    },\n    dispose: () => {\n      reconcile.dispose();\n    },\n  };\n};\n"]}

package/dist/src/kaleidoscope/effect.d.ts

@@ -0,0 +1,4 @@
+import type { EffectInput, EffectSpec } from './effect.types';
+/** Normalize an `EffectInput` (bare name or spec) into an `EffectSpec`. */
+export declare const toEffectSpec: (input: EffectInput) => EffectSpec;
+//# sourceMappingURL=effect.d.ts.map

package/dist/src/kaleidoscope/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../../src/kaleidoscope/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE9D,2EAA2E;AAC3E,eAAO,MAAM,YAAY,UAAW,WAAW,KAAG,UACmB,CAAC","sourcesContent":["import type { EffectInput, EffectSpec } from './effect.types';\n\n/** Normalize an `EffectInput` (bare name or spec) into an `EffectSpec`. */\nexport const toEffectSpec = (input: EffectInput): EffectSpec =>\n  typeof input === 'string' ? ({ name: input } as EffectSpec) : input;\n"]}

package/dist/src/kaleidoscope/effect.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEffectSpec = void 0;
+/** Normalize an `EffectInput` (bare name or spec) into an `EffectSpec`. */
+const toEffectSpec = (input) => typeof input === 'string' ? { name: input } : input;
+exports.toEffectSpec = toEffectSpec;
+//# sourceMappingURL=effect.js.map

package/dist/src/kaleidoscope/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","sourceRoot":"","sources":["../../../src/kaleidoscope/effect.ts"],"names":[],"mappings":";;;AAEA,2EAA2E;AACpE,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;AADzD,QAAA,YAAY,GAAZ,YAAY,CAC6C","sourcesContent":["import type { EffectInput, EffectSpec } from './effect.types';\n\n/** Normalize an `EffectInput` (bare name or spec) into an `EffectSpec`. */\nexport const toEffectSpec = (input: EffectInput): EffectSpec =>\n  typeof input === 'string' ? ({ name: input } as EffectSpec) : input;\n"]}

package/dist/src/kaleidoscope/effect.types.d.ts

@@ -0,0 +1,47 @@
+import type { KaleidoscopeLayer } from '../kaleidoscope.preset-book.types';
+/**
+ * Geometric reorientation of the frame: an axis flip or a 90-degree rotation.
+ * The operation IS the effect name (parameterless), compatible with the
+ * bare-string input form and the flat-string native registry. On web these run
+ * in display space; native pipelines correct for the camera buffer's rotation.
+ */
+export type TransformName = 'flip-x' | 'flip-y' | 'rotate-cw' | 'rotate-ccw';
+export type TransformSpec = {
+    readonly name: TransformName;
+};
+/**
+ * A composed effect: an ordered painter's stack of layers, run by the one
+ * compositor as a single stage. Layer 0 is the base; later layers blend over it.
+ * Every former singleton (blur, image, generative shader) is a layer inside it.
+ */
+export type CompositeSpec = {
+    readonly name: 'composite';
+    readonly layers: ReadonlyArray<KaleidoscopeLayer>;
+};
+export type EffectSpec = CompositeSpec | TransformSpec;
+/**
+ * The discriminant. Useful for typed switch statements and the bare-string call
+ * shape for the parameterless transforms (`applyVideoEffects(track, ['flip-x'])`).
+ */
+export type EffectName = EffectSpec['name'];
+/**
+ * `applyVideoEffects` accepts either a bare transform name (the parameterless
+ * transforms) or a full `EffectSpec` object (a composite or a transform). The
+ * bare-string form is `TransformName`, NOT `EffectName`: a bare `'composite'`
+ * would normalize to a layerless spec and crash the compositor, so the type
+ * rejects it. A composite must always arrive as a full `CompositeSpec`.
+ */
+export type EffectInput = EffectSpec | TransformName;
+/**
+ * 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.
+ * - Web: builds an Insertable-Streams pipeline and returns a NEW track carrying
+ *   the transformed frames.
+ *
+ * Throws on remote tracks, unknown effect names, missing platform capabilities,
+ * or non-video tracks.
+ */
+export type ApplyVideoEffects = (track: MediaStreamTrack, effects: ReadonlyArray<EffectInput>) => MediaStreamTrack;
+//# sourceMappingURL=effect.types.d.ts.map

package/dist/src/kaleidoscope/effect.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.types.d.ts","sourceRoot":"","sources":["../../../src/kaleidoscope/effect.types.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E;;;;;GAKG;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;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,aAAa,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,aAAa,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,KAChC,gBAAgB,CAAC","sourcesContent":["// The runtime effect contract: the lower-level spec the drivers consume.\n//\n// A consumer never writes these; they sit below the preset-book vocabulary. A\n// `KaleidoscopePreset` projects into a `CompositeSpec` (see shader-to-spec), the\n// transform verb produces `TransformSpec`s, and `applyVideoEffects` takes the\n// union. Each driver (android / ios / web-driver) renders this same spec.\n\nimport type { KaleidoscopeLayer } from '../kaleidoscope.preset-book.types';\n\n/**\n * Geometric reorientation of the frame: an axis flip or a 90-degree rotation.\n * The operation IS the effect name (parameterless), compatible with the\n * bare-string input form and the flat-string native registry. On web these run\n * in display space; native pipelines correct for the camera buffer's rotation.\n */\nexport type TransformName = 'flip-x' | 'flip-y' | 'rotate-cw' | 'rotate-ccw';\n\nexport type TransformSpec = {\n  readonly name: TransformName;\n};\n\n/**\n * A composed effect: an ordered painter's stack of layers, run by the one\n * compositor as a single stage. Layer 0 is the base; later layers blend over it.\n * Every former singleton (blur, image, generative shader) is a layer inside it.\n */\nexport type CompositeSpec = {\n  readonly name: 'composite';\n  readonly layers: ReadonlyArray<KaleidoscopeLayer>;\n};\n\nexport type EffectSpec = CompositeSpec | TransformSpec;\n\n/**\n * The discriminant. Useful for typed switch statements and the bare-string call\n * shape for the parameterless transforms (`applyVideoEffects(track, ['flip-x'])`).\n */\nexport type EffectName = EffectSpec['name'];\n\n/**\n * `applyVideoEffects` accepts either a bare transform name (the parameterless\n * transforms) or a full `EffectSpec` object (a composite or a transform). The\n * bare-string form is `TransformName`, NOT `EffectName`: a bare `'composite'`\n * would normalize to a layerless spec and crash the compositor, so the type\n * rejects it. A composite must always arrive as a full `CompositeSpec`.\n */\nexport type EffectInput = EffectSpec | TransformName;\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 * - Web: builds an Insertable-Streams pipeline and returns a NEW track carrying\n *   the transformed frames.\n *\n * Throws on remote tracks, unknown effect names, missing platform capabilities,\n * or non-video tracks.\n */\nexport type ApplyVideoEffects = (\n  track: MediaStreamTrack,\n  effects: ReadonlyArray<EffectInput>,\n) => MediaStreamTrack;\n"]}

package/dist/src/kaleidoscope/effect.types.js

@@ -0,0 +1,9 @@
+"use strict";
+// The runtime effect contract: the lower-level spec the drivers consume.
+//
+// A consumer never writes these; they sit below the preset-book vocabulary. A
+// `KaleidoscopePreset` projects into a `CompositeSpec` (see shader-to-spec), the
+// transform verb produces `TransformSpec`s, and `applyVideoEffects` takes the
+// union. Each driver (android / ios / web-driver) renders this same spec.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=effect.types.js.map

package/dist/src/kaleidoscope/effect.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.types.js","sourceRoot":"","sources":["../../../src/kaleidoscope/effect.types.ts"],"names":[],"mappings":";AAAA,yEAAyE;AACzE,EAAE;AACF,8EAA8E;AAC9E,iFAAiF;AACjF,8EAA8E;AAC9E,0EAA0E","sourcesContent":["// The runtime effect contract: the lower-level spec the drivers consume.\n//\n// A consumer never writes these; they sit below the preset-book vocabulary. A\n// `KaleidoscopePreset` projects into a `CompositeSpec` (see shader-to-spec), the\n// transform verb produces `TransformSpec`s, and `applyVideoEffects` takes the\n// union. Each driver (android / ios / web-driver) renders this same spec.\n\nimport type { KaleidoscopeLayer } from '../kaleidoscope.preset-book.types';\n\n/**\n * Geometric reorientation of the frame: an axis flip or a 90-degree rotation.\n * The operation IS the effect name (parameterless), compatible with the\n * bare-string input form and the flat-string native registry. On web these run\n * in display space; native pipelines correct for the camera buffer's rotation.\n */\nexport type TransformName = 'flip-x' | 'flip-y' | 'rotate-cw' | 'rotate-ccw';\n\nexport type TransformSpec = {\n  readonly name: TransformName;\n};\n\n/**\n * A composed effect: an ordered painter's stack of layers, run by the one\n * compositor as a single stage. Layer 0 is the base; later layers blend over it.\n * Every former singleton (blur, image, generative shader) is a layer inside it.\n */\nexport type CompositeSpec = {\n  readonly name: 'composite';\n  readonly layers: ReadonlyArray<KaleidoscopeLayer>;\n};\n\nexport type EffectSpec = CompositeSpec | TransformSpec;\n\n/**\n * The discriminant. Useful for typed switch statements and the bare-string call\n * shape for the parameterless transforms (`applyVideoEffects(track, ['flip-x'])`).\n */\nexport type EffectName = EffectSpec['name'];\n\n/**\n * `applyVideoEffects` accepts either a bare transform name (the parameterless\n * transforms) or a full `EffectSpec` object (a composite or a transform). The\n * bare-string form is `TransformName`, NOT `EffectName`: a bare `'composite'`\n * would normalize to a layerless spec and crash the compositor, so the type\n * rejects it. A composite must always arrive as a full `CompositeSpec`.\n */\nexport type EffectInput = EffectSpec | TransformName;\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 * - Web: builds an Insertable-Streams pipeline and returns a NEW track carrying\n *   the transformed frames.\n *\n * Throws on remote tracks, unknown effect names, missing platform capabilities,\n * or non-video tracks.\n */\nexport type ApplyVideoEffects = (\n  track: MediaStreamTrack,\n  effects: ReadonlyArray<EffectInput>,\n) => MediaStreamTrack;\n"]}

package/dist/src/kaleidoscope/shader-to-spec.d.ts

@@ -0,0 +1,4 @@
+import type { KaleidoscopePreset } from '../kaleidoscope.preset-book.types';
+import type { EffectSpec } from './effect.types';
+export declare const compositeToEffectSpec: (composite: KaleidoscopePreset) => EffectSpec;
+//# sourceMappingURL=shader-to-spec.d.ts.map

package/dist/src/kaleidoscope/shader-to-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-to-spec.d.ts","sourceRoot":"","sources":["../../../src/kaleidoscope/shader-to-spec.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,eAAO,MAAM,qBAAqB,cAAe,kBAAkB,KAAG,UAGpE,CAAC","sourcesContent":["// Translate a book composite into the lower-level EffectSpec the primitive\n// `applyVideoEffects` consumes. This is the seam between the book vocabulary the\n// consumer sees and the effect the pipeline runs; the controls own the active\n// composite and reconcile through here.\n//\n// Every book entry is a composite (an ordered layer stack), so this is a thin\n// projection: the layers already carry their own ids, sources, uniforms, and\n// blend. Transforms are not book entries; the transform verb handles them.\n\nimport type { KaleidoscopePreset } from '../kaleidoscope.preset-book.types';\nimport type { EffectSpec } from './effect.types';\n\nexport const compositeToEffectSpec = (composite: KaleidoscopePreset): EffectSpec => ({\n  name: 'composite',\n  layers: composite.layers,\n});\n"]}

package/dist/src/kaleidoscope/shader-to-spec.js

@@ -0,0 +1,17 @@
+"use strict";
+// Translate a book composite into the lower-level EffectSpec the primitive
+// `applyVideoEffects` consumes. This is the seam between the book vocabulary the
+// consumer sees and the effect the pipeline runs; the controls own the active
+// composite and reconcile through here.
+//
+// Every book entry is a composite (an ordered layer stack), so this is a thin
+// projection: the layers already carry their own ids, sources, uniforms, and
+// blend. Transforms are not book entries; the transform verb handles them.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositeToEffectSpec = void 0;
+const compositeToEffectSpec = (composite) => ({
+    name: 'composite',
+    layers: composite.layers,
+});
+exports.compositeToEffectSpec = compositeToEffectSpec;
+//# sourceMappingURL=shader-to-spec.js.map

package/dist/src/kaleidoscope/shader-to-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-to-spec.js","sourceRoot":"","sources":["../../../src/kaleidoscope/shader-to-spec.ts"],"names":[],"mappings":";AAAA,2EAA2E;AAC3E,iFAAiF;AACjF,8EAA8E;AAC9E,wCAAwC;AACxC,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,2EAA2E;;;AAKpE,MAAM,qBAAqB,GAAG,CAAC,SAA6B,EAAc,EAAE,CAAC,CAAC;IACnF,IAAI,EAAE,WAAW;IACjB,MAAM,EAAE,SAAS,CAAC,MAAM;CACzB,CAAC,CAAC;AAHU,QAAA,qBAAqB,GAArB,qBAAqB,CAG/B","sourcesContent":["// Translate a book composite into the lower-level EffectSpec the primitive\n// `applyVideoEffects` consumes. This is the seam between the book vocabulary the\n// consumer sees and the effect the pipeline runs; the controls own the active\n// composite and reconcile through here.\n//\n// Every book entry is a composite (an ordered layer stack), so this is a thin\n// projection: the layers already carry their own ids, sources, uniforms, and\n// blend. Transforms are not book entries; the transform verb handles them.\n\nimport type { KaleidoscopePreset } from '../kaleidoscope.preset-book.types';\nimport type { EffectSpec } from './effect.types';\n\nexport const compositeToEffectSpec = (composite: KaleidoscopePreset): EffectSpec => ({\n  name: 'composite',\n  layers: composite.layers,\n});\n"]}

package/dist/src/kaleidoscope/types.d.ts

@@ -0,0 +1,79 @@
+import type { PatchableShaderName, ShaderUniformsMap } from '../../catalog/shaders';
+import type { KaleidoscopePresetBook } from '../kaleidoscope.preset-book.types';
+/**
+ * A live per-layer uniform override for ONE layer, derived from the layer's own
+ * type: `id` is the layer's id, `uniforms` is `Partial` of the shader's uniform
+ * type (re-indexed from `ShaderUniformsMap` by the layer's literal `shader`).
+ * Non-tunable layers (`image`, `direct`) distribute to `never`, so they cannot be
+ * patched. The runtime resolves by `id`; the shader is never sent on the wire.
+ */
+export type PatchFor<L> = L extends {
+    readonly id: infer I extends string;
+    readonly shader: infer S extends PatchableShaderName;
+} ? {
+    readonly id: I;
+    readonly uniforms: Partial<ShaderUniformsMap[S]>;
+} : never;
+/**
+ * The patches `kaleidoscope` accepts for preset `K` in book `P`: per-layer
+ * overrides, each addressed by one of that preset's tunable layer ids and typed
+ * by that layer's shader. At a literal `cmd` call site this narrows to the
+ * preset's ids/uniforms; with a variable `cmd` it widens to the book-wide union
+ * and is runtime-checked by id.
+ */
+export type PatchesFor<P extends KaleidoscopePresetBook, K extends keyof P> = ReadonlyArray<PatchFor<P[K]['layers'][number]>>;
+/**
+ * Absolute, stateless geometric transform. Every call is the full desired state
+ * from the identity orientation: re-passing is the caller's responsibility, and
+ * `transform()` (or `transform({})`) resets to identity. Rotation snaps to the
+ * nearest 90°; arbitrary angles and offset are a later step.
+ */
+export type TransformInput = {
+    /** Mirror flips about each axis. */
+    readonly flip?: {
+        readonly x?: boolean;
+        readonly y?: boolean;
+    };
+    /** Clockwise rotation in degrees; snapped to the nearest 90 (0/90/180/270). */
+    readonly rotate?: number;
+};
+/** The segmentation mask edge, shared by every art effect (not transforms). */
+export type MaskInput = {
+    /** Edge hardness, 0..1. 0 = soft halo, 1 = near-step. */
+    readonly hardness: number;
+    /** Edge threshold, 0..1. Higher rejects low-confidence (chair-edge) pixels. */
+    readonly threshold: number;
+};
+export type KaleidoscopeBindOptions<P extends KaleidoscopePresetBook> = {
+    /** The consumer's preset book. Declare it `as const satisfies KaleidoscopePresetBook`. */
+    readonly presets: P;
+    /**
+     * Called with the live output track after every art/transform command. On web
+     * each command yields a NEW MediaStreamTrack (the pipeline is rebuilt); on
+     * native the same track is mutated in place and passed back.
+     */
+    readonly onTrack?: (track: MediaStreamTrack) => void;
+};
+/**
+ * The art verb: select a composite by id (rebuilding the pipeline), or clear it
+ * with `null`. When `cmd` is the currently-active preset id and `patches` is
+ * given, the patches merge through the live no-rebuild uniform channel (keyed by
+ * layer id) instead of rebuilding, so a slider drag stays smooth.
+ */
+type KaleidoscopeCommand<P extends KaleidoscopePresetBook> = <K extends keyof P>(cmd: K | null, patches?: PatchesFor<P, K>) => void;
+/**
+ * The three verbs for one bound track and book, plus the live track and a
+ * teardown. `kaleidoscope` (preset switch) and `transform` rebuild the composite
+ * (web yields a new track via onTrack); a `kaleidoscope` patch of the active
+ * preset and `mask` both update what the running composite reads each frame, so
+ * they need no rebuild.
+ */
+export interface KaleidoscopeBinding<P extends KaleidoscopePresetBook> {
+    readonly kaleidoscope: KaleidoscopeCommand<P>;
+    readonly transform: (t?: TransformInput) => void;
+    readonly mask: (m: MaskInput) => void;
+    readonly track: MediaStreamTrack;
+    readonly dispose: () => void;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/kaleidoscope/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/kaleidoscope/types.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACpF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAEhF;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,SAAS,mBAAmB,CAAC;CACtD,GACG;IAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAA;CAAE,GACpE,KAAK,CAAC;AAEV;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,sBAAsB,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,aAAa,CACzF,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CACjC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC/D,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,SAAS,GAAG;IACtB,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,sBAAsB,IAAI;IACtE,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF;;;;;GAKG;AACH,KAAK,mBAAmB,CAAC,CAAC,SAAS,sBAAsB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,EAC7E,GAAG,EAAE,CAAC,GAAG,IAAI,EACb,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KACvB,IAAI,CAAC;AAEV;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,sBAAsB;IACnE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B","sourcesContent":["// The three-verb surface: types.\n//\n// Bind a track and a preset book once; get three typed verbs back:\n//   - kaleidoscope(cmd, patches?)  the art axis: which composite (layer stack)\n//     fills the frame. cmd is a preset id from the book (narrowed), or null to\n//     clear. patches optionally merge per-layer uniform overrides (addressed by\n//     layer id); patching the currently-active preset routes through the live\n//     no-rebuild channel, so sliders stay smooth.\n//   - transform(t?)             the geometry axis: absolute flips + 90° rotation.\n//   - mask(m)                   the segmentation edge shared by every art effect.\n//\n// Shaders live in the library; consumers add presets (composites) over them,\n// never new shaders. Per shader-world convention, numeric uniforms are\n// normalized 0..1 where practical; ranges are documented in JSDoc as hints for\n// IntelliSense and tooling, not enforced at runtime (validation is userland).\n\nimport type { PatchableShaderName, ShaderUniformsMap } from '../../catalog/shaders';\nimport type { KaleidoscopePresetBook } from '../kaleidoscope.preset-book.types';\n\n/**\n * A live per-layer uniform override for ONE layer, derived from the layer's own\n * type: `id` is the layer's id, `uniforms` is `Partial` of the shader's uniform\n * type (re-indexed from `ShaderUniformsMap` by the layer's literal `shader`).\n * Non-tunable layers (`image`, `direct`) distribute to `never`, so they cannot be\n * patched. The runtime resolves by `id`; the shader is never sent on the wire.\n */\nexport type PatchFor<L> = L extends {\n  readonly id: infer I extends string;\n  readonly shader: infer S extends PatchableShaderName;\n}\n  ? { readonly id: I; readonly uniforms: Partial<ShaderUniformsMap[S]> }\n  : never;\n\n/**\n * The patches `kaleidoscope` accepts for preset `K` in book `P`: per-layer\n * overrides, each addressed by one of that preset's tunable layer ids and typed\n * by that layer's shader. At a literal `cmd` call site this narrows to the\n * preset's ids/uniforms; with a variable `cmd` it widens to the book-wide union\n * and is runtime-checked by id.\n */\nexport type PatchesFor<P extends KaleidoscopePresetBook, K extends keyof P> = ReadonlyArray<\n  PatchFor<P[K]['layers'][number]>\n>;\n\n/**\n * Absolute, stateless geometric transform. Every call is the full desired state\n * from the identity orientation: re-passing is the caller's responsibility, and\n * `transform()` (or `transform({})`) resets to identity. Rotation snaps to the\n * nearest 90°; arbitrary angles and offset are a later step.\n */\nexport type TransformInput = {\n  /** Mirror flips about each axis. */\n  readonly flip?: { readonly x?: boolean; readonly y?: boolean };\n  /** Clockwise rotation in degrees; snapped to the nearest 90 (0/90/180/270). */\n  readonly rotate?: number;\n};\n\n/** The segmentation mask edge, shared by every art effect (not transforms). */\nexport type MaskInput = {\n  /** Edge hardness, 0..1. 0 = soft halo, 1 = near-step. */\n  readonly hardness: number;\n  /** Edge threshold, 0..1. Higher rejects low-confidence (chair-edge) pixels. */\n  readonly threshold: number;\n};\n\nexport type KaleidoscopeBindOptions<P extends KaleidoscopePresetBook> = {\n  /** The consumer's preset book. Declare it `as const satisfies KaleidoscopePresetBook`. */\n  readonly presets: P;\n  /**\n   * Called with the live output track after every art/transform command. On web\n   * each command yields a NEW MediaStreamTrack (the pipeline is rebuilt); on\n   * native the same track is mutated in place and passed back.\n   */\n  readonly onTrack?: (track: MediaStreamTrack) => void;\n};\n\n/**\n * The art verb: select a composite by id (rebuilding the pipeline), or clear it\n * with `null`. When `cmd` is the currently-active preset id and `patches` is\n * given, the patches merge through the live no-rebuild uniform channel (keyed by\n * layer id) instead of rebuilding, so a slider drag stays smooth.\n */\ntype KaleidoscopeCommand<P extends KaleidoscopePresetBook> = <K extends keyof P>(\n  cmd: K | null,\n  patches?: PatchesFor<P, K>,\n) => void;\n\n/**\n * The three verbs for one bound track and book, plus the live track and a\n * teardown. `kaleidoscope` (preset switch) and `transform` rebuild the composite\n * (web yields a new track via onTrack); a `kaleidoscope` patch of the active\n * preset and `mask` both update what the running composite reads each frame, so\n * they need no rebuild.\n */\nexport interface KaleidoscopeBinding<P extends KaleidoscopePresetBook> {\n  readonly kaleidoscope: KaleidoscopeCommand<P>;\n  readonly transform: (t?: TransformInput) => void;\n  readonly mask: (m: MaskInput) => void;\n  readonly track: MediaStreamTrack;\n  readonly dispose: () => void;\n}\n"]}

package/dist/src/kaleidoscope/types.js

@@ -0,0 +1,18 @@
+"use strict";
+// The three-verb surface: types.
+//
+// Bind a track and a preset book once; get three typed verbs back:
+//   - kaleidoscope(cmd, patches?)  the art axis: which composite (layer stack)
+//     fills the frame. cmd is a preset id from the book (narrowed), or null to
+//     clear. patches optionally merge per-layer uniform overrides (addressed by
+//     layer id); patching the currently-active preset routes through the live
+//     no-rebuild channel, so sliders stay smooth.
+//   - transform(t?)             the geometry axis: absolute flips + 90° rotation.
+//   - mask(m)                   the segmentation edge shared by every art effect.
+//
+// Shaders live in the library; consumers add presets (composites) over them,
+// never new shaders. Per shader-world convention, numeric uniforms are
+// normalized 0..1 where practical; ranges are documented in JSDoc as hints for
+// IntelliSense and tooling, not enforced at runtime (validation is userland).
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map