framefields 2.0.5 → 2.0.6

package/dist/effects-l0T61DPU.mjs

@@ -0,0 +1,2086 @@
+import { Ot as isSignal, v as Effect } from "./dist-B9Afsv83.mjs";
+import { t as AudioSignal } from "./audio-D6enPyAG.mjs";
+
+//#region src/effects/with-defaults.ts
+function env(name) {
+	return typeof process !== "undefined" ? process.env?.[name] : void 0;
+}
+/** Throw instead of warn. Recommended for agent harnesses and CI. */
+function isStrict() {
+	const flag = env("FRAMEFIELDS_STRICT_PROPS");
+	return flag === "1" || flag === "true";
+}
+function checksEnabled() {
+	return isStrict() || env("NODE_ENV") !== "production";
+}
+const reported = /* @__PURE__ */ new Set();
+function report(message) {
+	if (isStrict()) throw new Error(message);
+	if (reported.has(message)) return;
+	reported.add(message);
+	console.warn(`[framefields] ${message}`);
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (Array.isArray(value) || isSignal(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/** Levenshtein distance, for "did you mean" suggestions on small key sets. */
+function distance(a, b) {
+	const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i++) {
+		let prev = row[0];
+		row[0] = i;
+		for (let j = 1; j <= b.length; j++) {
+			const current = row[j];
+			row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+			prev = current;
+		}
+	}
+	return row[b.length];
+}
+function suggest(key, known) {
+	let best;
+	let bestScore = Number.POSITIVE_INFINITY;
+	const lower = key.toLowerCase();
+	for (const candidate of known) {
+		const candidateLower = candidate.toLowerCase();
+		const score = candidateLower.includes(lower) || lower.includes(candidateLower) ? 1 : distance(lower, candidateLower);
+		if (score < bestScore) {
+			bestScore = score;
+			best = candidate;
+		}
+	}
+	return best && bestScore <= Math.max(2, Math.ceil(key.length / 2)) ? ` Did you mean "${best}"?` : ` Known props: ${known.join(", ")}.`;
+}
+function checkValue(path, value, meta) {
+	if (typeof value === "number") {
+		const { min, max } = meta;
+		if (min !== void 0 && value < min || max !== void 0 && value > max || Number.isNaN(value)) {
+			const range = min !== void 0 && max !== void 0 ? `${min} to ${max}` : min !== void 0 ? `≥ ${min}` : `≤ ${max}`;
+			report(Number.isNaN(value) ? `${path} is NaN` : `${path} = ${value} is outside ${range}`);
+		}
+		return;
+	}
+	if (meta.enum && (typeof value === "string" || typeof value === "boolean") && !meta.enum.includes(value)) report(`${path} = ${JSON.stringify(value)} is not one of ${meta.enum.map((v) => JSON.stringify(v)).join(", ")}`);
+}
+function checkProps(path, config, meta) {
+	const known = Object.keys(meta);
+	for (const [key, value] of Object.entries(config)) {
+		if (value === void 0) continue;
+		const propMeta = meta[key];
+		if (!propMeta) {
+			report(`${path}: unknown prop "${key}".${suggest(key, known)}`);
+			continue;
+		}
+		if (isSignal(value) || typeof value === "function") continue;
+		if (propMeta.props && isPlainObject(value)) checkProps(`${path}.${key}`, value, propMeta.props);
+		else checkValue(`${path}.${key}`, value, propMeta);
+	}
+}
+function cloneDefault(value) {
+	return typeof value === "object" && value !== null ? structuredClone(value) : value;
+}
+/**
+* Builds the initial config of a generated effect class.
+*
+* - `undefined` entries in `config` keep the default instead of overwriting it.
+* - When both the default and the supplied value are plain objects, they are
+*   merged one level deep, so `new ColorBalance({ shadows: { cyanRed: 10 } })`
+*   keeps the other two channels at their defaults.
+* - Object defaults are cloned per instance.
+* - Outside production, unknown props and out-of-range static values are
+*   reported: a `console.warn` once per message, or a thrown `Error` when
+*   `FRAMEFIELDS_STRICT_PROPS=1`. Unknown props are still passed through.
+*/
+function withDefaults(op, defaults, config, meta) {
+	const supplied = config;
+	if (checksEnabled()) checkProps(op, supplied, meta);
+	const result = {};
+	for (const [key, value] of Object.entries(defaults)) result[key] = cloneDefault(value);
+	for (const [key, value] of Object.entries(supplied)) {
+		if (value === void 0) continue;
+		const base = result[key];
+		result[key] = isPlainObject(base) && isPlainObject(value) ? {
+			...base,
+			...Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0))
+		} : value;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/effects/generated/meta.ts
+/** Ranges and allowed values per effect prop, used by `withDefaults()` checks. */
+const effectMeta = {
+	AudioCompressor: {
+		threshold: {
+			min: -60,
+			max: 0
+		},
+		ratio: {
+			min: 1,
+			max: 100
+		},
+		attack: {
+			min: 1e-4,
+			max: 1
+		},
+		release: {
+			min: .01,
+			max: 5
+		},
+		knee: {
+			min: 0,
+			max: 24
+		},
+		makeupGain: {
+			min: 0,
+			max: 24
+		}
+	},
+	AudioDelay: {
+		delayTime: {
+			min: .001,
+			max: 5
+		},
+		feedback: {
+			min: 0,
+			max: .95
+		},
+		wet: {
+			min: 0,
+			max: 1
+		},
+		dry: {
+			min: 0,
+			max: 1
+		},
+		pingPong: {}
+	},
+	AudioFade: {
+		fadeInDuration: {
+			min: 0,
+			max: 60
+		},
+		fadeOutDuration: {
+			min: 0,
+			max: 60
+		},
+		fadeInCurve: { enum: [
+			"linear",
+			"exponential",
+			"scurve"
+		] },
+		fadeOutCurve: { enum: [
+			"linear",
+			"exponential",
+			"scurve"
+		] }
+	},
+	AudioNoiseGate: {
+		threshold: {
+			min: -120,
+			max: 0
+		},
+		attack: {
+			min: 1e-4,
+			max: 1
+		},
+		hold: {
+			min: .001,
+			max: 5
+		},
+		release: {
+			min: .01,
+			max: 5
+		},
+		range: {
+			min: -120,
+			max: 0
+		}
+	},
+	AudioParametricEq: {
+		type: { enum: [
+			"lowShelf",
+			"highShelf",
+			"peak",
+			"lowPass",
+			"highPass",
+			"notch"
+		] },
+		frequency: {
+			min: 20,
+			max: 2e4
+		},
+		gain: {
+			min: -24,
+			max: 24
+		},
+		q: {
+			min: .01,
+			max: 10
+		}
+	},
+	AudioReverb: {
+		roomSize: {
+			min: 0,
+			max: .98
+		},
+		damping: {
+			min: 0,
+			max: 1
+		},
+		wet: {
+			min: 0,
+			max: 1
+		},
+		dry: {
+			min: 0,
+			max: 1
+		},
+		width: {
+			min: 0,
+			max: 1
+		}
+	},
+	Blur: {
+		blurType: { enum: [
+			"Gaussian",
+			"Box",
+			"Median",
+			"Motion",
+			"Bilateral",
+			"Edge-preserving",
+			"Radial",
+			"Zoom"
+		] },
+		strength: {
+			min: 0,
+			max: 100
+		},
+		angle: {
+			min: 0,
+			max: 360
+		},
+		sigmaColor: {
+			min: .01,
+			max: 1
+		},
+		centerX: {
+			min: 0,
+			max: 1
+		},
+		centerY: {
+			min: 0,
+			max: 1
+		},
+		partialBlur: {},
+		radius: {
+			min: .01,
+			max: 1
+		},
+		radiusY: {
+			min: 0,
+			max: 1
+		},
+		shape: { enum: [
+			"ellipse",
+			"circle",
+			"rect"
+		] }
+	},
+	CameraParallax3D: {
+		motionPreset: { enum: [
+			"Custom",
+			"DollyZoom",
+			"Orbit",
+			"FlyThrough",
+			"HandheldShake",
+			"RackFocus"
+		] },
+		panX: {
+			min: -1,
+			max: 1
+		},
+		panY: {
+			min: -1,
+			max: 1
+		},
+		dollyZ: {
+			min: -1,
+			max: 1
+		},
+		fov: {
+			min: 15,
+			max: 120
+		},
+		parallaxAmount: {
+			min: 0,
+			max: 2
+		},
+		dofAperture: {
+			min: 0,
+			max: 1
+		},
+		focusPlane: {
+			min: 0,
+			max: 1
+		},
+		edgeDilation: {
+			min: 0,
+			max: 1
+		},
+		depthInvert: {}
+	},
+	ChannelMerger: {
+		colorSpace: { enum: [
+			"RGBA",
+			"HSLA",
+			"CMYK",
+			"LAB"
+		] },
+		defaultChannel4: {
+			min: 0,
+			max: 1
+		}
+	},
+	ChannelSplitter: { colorSpace: { enum: [
+		"RGBA",
+		"HSLA",
+		"CMYK",
+		"LAB"
+	] } },
+	ColorBalance: {
+		shadows: { props: {
+			cyanRed: {
+				min: -100,
+				max: 100
+			},
+			magentaGreen: {
+				min: -100,
+				max: 100
+			},
+			yellowBlue: {
+				min: -100,
+				max: 100
+			}
+		} },
+		midtones: { props: {
+			cyanRed: {
+				min: -100,
+				max: 100
+			},
+			magentaGreen: {
+				min: -100,
+				max: 100
+			},
+			yellowBlue: {
+				min: -100,
+				max: 100
+			}
+		} },
+		highlights: { props: {
+			cyanRed: {
+				min: -100,
+				max: 100
+			},
+			magentaGreen: {
+				min: -100,
+				max: 100
+			},
+			yellowBlue: {
+				min: -100,
+				max: 100
+			}
+		} },
+		preserveLuminosity: {}
+	},
+	ColorKey: {
+		keyColor: {},
+		similarity: {
+			min: 0,
+			max: 1
+		},
+		smoothness: {
+			min: 0,
+			max: 1
+		},
+		spillSuppression: {
+			min: 0,
+			max: 1
+		},
+		colorSpace: { enum: ["YUV", "RGB"] },
+		spillSuppressionType: { enum: [
+			"Desaturate",
+			"Neutralize",
+			"None"
+		] }
+	},
+	CornerPin: { points: {} },
+	DisplacementMap: {
+		strengthX: {
+			min: 0,
+			max: 500
+		},
+		strengthY: {
+			min: 0,
+			max: 500
+		},
+		xChannel: { enum: [
+			"Red",
+			"Green",
+			"Blue",
+			"Alpha",
+			"Luminance"
+		] },
+		yChannel: { enum: [
+			"Red",
+			"Green",
+			"Blue",
+			"Alpha",
+			"Luminance"
+		] },
+		wrapMode: { enum: [
+			"Clamp",
+			"Repeat",
+			"Mirror"
+		] }
+	},
+	ExtractLUT: {
+		strategy: { enum: ["deterministic", "statistical"] },
+		samplePoints: {
+			min: 10,
+			max: 500
+		}
+	},
+	Flip: {
+		horizontal: {},
+		vertical: {},
+		diagonal: {},
+		mode: { enum: [
+			"horizontal",
+			"vertical",
+			"both",
+			"diagonal",
+			"antiDiagonal",
+			"custom"
+		] },
+		symmetry: { enum: [
+			"none",
+			"leftToRight",
+			"rightToLeft",
+			"topToBottom",
+			"bottomToTop",
+			"quadrant"
+		] }
+	},
+	KenBurns: {
+		keyframes: {},
+		motionBlurSize: {
+			min: 0,
+			max: 10
+		},
+		movementStyle: { enum: ["spline", "direct"] },
+		aspectRatio: { enum: [
+			"input",
+			"16:9",
+			"9:16",
+			"21:9",
+			"9:21",
+			"1:1",
+			"4:3",
+			"3:2",
+			"2:3",
+			"4:5",
+			"5:4"
+		] }
+	},
+	LayerStyle: {
+		dropShadow: { props: {
+			enabled: {},
+			color: {},
+			opacity: {
+				min: 0,
+				max: 1
+			},
+			angle: {
+				min: 0,
+				max: 360
+			},
+			distance: {
+				min: 0,
+				max: 500
+			},
+			spread: {
+				min: 0,
+				max: 100
+			},
+			size: {
+				min: 0,
+				max: 250
+			},
+			blendMode: {}
+		} },
+		innerShadow: { props: {
+			enabled: {},
+			color: {},
+			opacity: {
+				min: 0,
+				max: 1
+			},
+			angle: {
+				min: 0,
+				max: 360
+			},
+			distance: {
+				min: 0,
+				max: 500
+			},
+			choke: {
+				min: 0,
+				max: 100
+			},
+			size: {
+				min: 0,
+				max: 250
+			},
+			blendMode: {}
+		} },
+		outerGlow: { props: {
+			enabled: {},
+			color: {},
+			opacity: {
+				min: 0,
+				max: 1
+			},
+			size: {
+				min: 0,
+				max: 250
+			},
+			spread: {
+				min: 0,
+				max: 100
+			},
+			blendMode: {}
+		} },
+		innerGlow: { props: {
+			enabled: {},
+			color: {},
+			opacity: {
+				min: 0,
+				max: 1
+			},
+			size: {
+				min: 0,
+				max: 250
+			},
+			spread: {
+				min: 0,
+				max: 100
+			},
+			blendMode: {}
+		} },
+		stroke: { props: {
+			enabled: {},
+			size: {
+				min: 0,
+				max: 100
+			},
+			position: { enum: [
+				"inside",
+				"center",
+				"outside"
+			] },
+			color: {},
+			opacity: {
+				min: 0,
+				max: 1
+			},
+			blendMode: {}
+		} },
+		bevelEmboss: { props: {
+			enabled: {},
+			style: { enum: [
+				"InnerBevel",
+				"OuterBevel",
+				"Emboss",
+				"PillowEmboss"
+			] },
+			technique: { enum: [
+				"Smooth",
+				"ChiselHard",
+				"ChiselSoft"
+			] },
+			depth: {
+				min: 1,
+				max: 1e3
+			},
+			direction: { enum: ["Up", "Down"] },
+			size: {
+				min: 0,
+				max: 250
+			},
+			soften: {
+				min: 0,
+				max: 50
+			},
+			angle: {
+				min: 0,
+				max: 360
+			},
+			altitude: {
+				min: 0,
+				max: 90
+			},
+			highlightColor: {},
+			highlightOpacity: {
+				min: 0,
+				max: 1
+			},
+			shadowColor: {},
+			shadowOpacity: {
+				min: 0,
+				max: 1
+			}
+		} },
+		colorOverlay: { props: {
+			enabled: {},
+			color: {},
+			opacity: {
+				min: 0,
+				max: 1
+			},
+			blendMode: {}
+		} },
+		dropShadowAngleHandleId: {},
+		dropShadowDistanceHandleId: {},
+		dropShadowSpreadHandleId: {},
+		dropShadowSizeHandleId: {},
+		dropShadowOpacityHandleId: {},
+		innerShadowAngleHandleId: {},
+		innerShadowDistanceHandleId: {},
+		innerShadowChokeHandleId: {},
+		innerShadowSizeHandleId: {},
+		innerShadowOpacityHandleId: {},
+		outerGlowSizeHandleId: {},
+		outerGlowSpreadHandleId: {},
+		outerGlowOpacityHandleId: {},
+		innerGlowSizeHandleId: {},
+		innerGlowSpreadHandleId: {},
+		innerGlowOpacityHandleId: {},
+		strokeSizeHandleId: {},
+		strokeOpacityHandleId: {},
+		bevelEmbossDepthHandleId: {},
+		bevelEmbossSizeHandleId: {},
+		bevelEmbossSoftenHandleId: {},
+		bevelEmbossAngleHandleId: {},
+		bevelEmbossAltitudeHandleId: {},
+		bevelEmbossHighlightOpacityHandleId: {},
+		bevelEmbossShadowOpacityHandleId: {},
+		colorOverlayOpacityHandleId: {}
+	},
+	Liquify: { operations: {} },
+	MaskMath: {
+		operation: { enum: [
+			"Union",
+			"Intersect",
+			"Subtract",
+			"Difference",
+			"Invert",
+			"Dilate",
+			"Erode",
+			"Choke",
+			"Feather"
+		] },
+		radius: {
+			min: 0,
+			max: 200
+		},
+		threshold: {
+			min: 0,
+			max: 1
+		},
+		clampMin: {
+			min: 0,
+			max: 1
+		},
+		clampMax: {
+			min: 0,
+			max: 1
+		},
+		channelA: { enum: [
+			"Alpha",
+			"Luminance",
+			"Red",
+			"Green",
+			"Blue"
+		] },
+		channelB: { enum: [
+			"Alpha",
+			"Luminance",
+			"Red",
+			"Green",
+			"Blue"
+		] },
+		binarize: {},
+		invertResult: {},
+		outputFormat: { enum: [
+			"WhiteWithAlpha",
+			"GrayscaleRGB",
+			"AlphaOnly",
+			"PassthroughRGB"
+		] }
+	},
+	MeshWarp: {
+		cols: {
+			min: 2,
+			max: 12
+		},
+		rows: {
+			min: 2,
+			max: 12
+		},
+		points: {}
+	},
+	NoiseGenerator: {
+		noiseType: { enum: [
+			"Perlin",
+			"Simplex",
+			"Voronoi"
+		] },
+		outputType: { enum: ["Image", "Video"] },
+		width: {
+			min: 16,
+			max: 4096
+		},
+		height: {
+			min: 16,
+			max: 4096
+		},
+		scale: {
+			min: .1,
+			max: 100
+		},
+		octaves: {
+			min: 1,
+			max: 8
+		},
+		persistence: {
+			min: 0,
+			max: 1
+		},
+		lacunarity: {
+			min: 1,
+			max: 4
+		},
+		speed: {
+			min: 0,
+			max: 10
+		},
+		colorStart: {},
+		colorEnd: {},
+		durationMs: {
+			min: 1,
+			max: 6e4
+		},
+		fps: {
+			min: 1,
+			max: 120
+		}
+	},
+	Paint: {
+		width: {
+			min: 1,
+			max: 16384
+		},
+		height: {
+			min: 1,
+			max: 16384
+		},
+		maintainAspect: {},
+		aspectRatio: {},
+		backgroundColor: {},
+		strokes: {}
+	},
+	PatchHeal: {
+		patches: {},
+		centerX: {
+			min: 0,
+			max: 1
+		},
+		centerY: {
+			min: 0,
+			max: 1
+		},
+		offsetX: {
+			min: -4096,
+			max: 4096
+		},
+		offsetY: {
+			min: -4096,
+			max: 4096
+		},
+		radius: {
+			min: 1,
+			max: 500
+		},
+		sourceRadius: {
+			min: 1,
+			max: 500
+		},
+		feather: {
+			min: 0,
+			max: 100
+		},
+		opacity: {
+			min: 0,
+			max: 1
+		},
+		mode: { enum: [
+			"Clone",
+			"SeamlessHeal",
+			"TextureTransfer"
+		] }
+	},
+	ProceduralVFX: {
+		effectType: { enum: [
+			"Smoke",
+			"Fire",
+			"Rain",
+			"Sparks",
+			"Snow",
+			"Dust",
+			"Lightning",
+			"Magic",
+			"LensFlare",
+			"Embers",
+			"EnergyBeam"
+		] },
+		outputType: { enum: ["Image", "Video"] },
+		width: {
+			min: 16,
+			max: 4096
+		},
+		height: {
+			min: 16,
+			max: 4096
+		},
+		density: {
+			min: 0,
+			max: 1
+		},
+		scale: {
+			min: .001,
+			max: 10
+		},
+		speed: {
+			min: 0,
+			max: 10
+		},
+		intensity: {
+			min: 0,
+			max: 1
+		},
+		seed: {
+			min: 0,
+			max: 1e6
+		},
+		colorStart: {},
+		colorEnd: {},
+		durationMs: {
+			min: 100,
+			max: 1e5
+		},
+		fps: {
+			min: 1,
+			max: 120
+		}
+	},
+	RefineEdge: {
+		decontaminateAmount: {
+			min: 0,
+			max: 1
+		},
+		radius: {
+			min: .5,
+			max: 50
+		},
+		smooth: {
+			min: 0,
+			max: 100
+		},
+		feather: {
+			min: 0,
+			max: 50
+		},
+		shiftEdge: {
+			min: -100,
+			max: 100
+		},
+		matteChannel: { enum: [
+			"Alpha",
+			"Luminance",
+			"Red",
+			"Green",
+			"Blue"
+		] },
+		outputMode: { enum: [
+			"Composite",
+			"MatteOnly",
+			"DecontaminatedRGB"
+		] }
+	},
+	RefractionCaustics3D: {
+		ior: {
+			min: 1,
+			max: 2.5
+		},
+		dispersion: {
+			min: 0,
+			max: .2
+		},
+		refractionScale: {
+			min: 0,
+			max: 2
+		},
+		causticBrightness: {
+			min: 0,
+			max: 2
+		},
+		causticScale: {
+			min: .1,
+			max: 5
+		},
+		fluidRipples: {
+			min: 0,
+			max: 1
+		},
+		rippleSpeed: {
+			min: 0,
+			max: 5
+		},
+		roughness: {
+			min: 0,
+			max: 1
+		},
+		specularIntensity: {
+			min: 0,
+			max: 2
+		},
+		lightPosX: {
+			min: 0,
+			max: 1
+		},
+		lightPosY: {
+			min: 0,
+			max: 1
+		},
+		tintColor: {},
+		tintStrength: {
+			min: 0,
+			max: 1
+		},
+		depthInvert: {},
+		depthScale: {
+			min: .1,
+			max: 5
+		}
+	},
+	ResizerScaler: {
+		aspectRatioPreset: { enum: [
+			"9:16",
+			"16:9",
+			"1:1",
+			"4:5",
+			"21:9",
+			"custom"
+		] },
+		resolutionPreset: { enum: [
+			"4k",
+			"1080p",
+			"720p",
+			"480p",
+			"custom"
+		] },
+		targetWidth: {
+			min: 1,
+			max: 8192
+		},
+		targetHeight: {
+			min: 1,
+			max: 8192
+		},
+		fitMode: { enum: [
+			"cover",
+			"contain",
+			"stretch",
+			"manual"
+		] },
+		zoom: {
+			min: 1,
+			max: 1e3
+		},
+		offsetX: {
+			min: -8192,
+			max: 8192
+		},
+		offsetY: {
+			min: -8192,
+			max: 8192
+		},
+		backgroundMode: { enum: [
+			"solid",
+			"blurred",
+			"gradient",
+			"transparent"
+		] },
+		backgroundColor: {},
+		backgroundColor2: {},
+		blurRadius: {
+			min: 0,
+			max: 100
+		},
+		backgroundBrightness: {
+			min: 0,
+			max: 1
+		},
+		anchorX: { enum: [
+			"left",
+			"center",
+			"right"
+		] },
+		anchorY: { enum: [
+			"top",
+			"center",
+			"bottom"
+		] }
+	},
+	StereoPanning: { pan: {
+		min: -1,
+		max: 1
+	} },
+	Vignette: {
+		strength: {
+			min: 0,
+			max: 100
+		},
+		radius: {
+			min: .1,
+			max: 2
+		},
+		softness: {
+			min: 0,
+			max: 1
+		},
+		roundness: {
+			min: 0,
+			max: 1
+		},
+		centerX: {
+			min: 0,
+			max: 1
+		},
+		centerY: {
+			min: 0,
+			max: 1
+		}
+	}
+};
+
+//#endregion
+//#region src/effects/generated/classes.ts
+const audioCompressorDefaults = {
+	threshold: -24,
+	ratio: 4,
+	attack: .003,
+	release: .25,
+	knee: 6,
+	makeupGain: 0
+};
+var AudioCompressor = class extends Effect {
+	op = "AudioCompressor";
+	constructor(config = {}) {
+		super(withDefaults("AudioCompressor", audioCompressorDefaults, config, effectMeta.AudioCompressor));
+	}
+};
+const audioDelayDefaults = {
+	delayTime: .25,
+	feedback: .4,
+	wet: .3,
+	dry: 1,
+	pingPong: false
+};
+var AudioDelay = class extends Effect {
+	op = "AudioDelay";
+	constructor(config = {}) {
+		super(withDefaults("AudioDelay", audioDelayDefaults, config, effectMeta.AudioDelay));
+	}
+};
+const audioFadeDefaults = {
+	fadeInDuration: 0,
+	fadeOutDuration: 0,
+	fadeInCurve: "linear",
+	fadeOutCurve: "linear"
+};
+var AudioFade = class extends Effect {
+	op = "AudioFade";
+	constructor(config = {}) {
+		super(withDefaults("AudioFade", audioFadeDefaults, config, effectMeta.AudioFade));
+	}
+};
+const audioNoiseGateDefaults = {
+	threshold: -40,
+	attack: .005,
+	hold: .05,
+	release: .1,
+	range: -80
+};
+var AudioNoiseGate = class extends Effect {
+	op = "AudioNoiseGate";
+	constructor(config = {}) {
+		super(withDefaults("AudioNoiseGate", audioNoiseGateDefaults, config, effectMeta.AudioNoiseGate));
+	}
+};
+const audioParametricEqDefaults = {
+	type: "peak",
+	frequency: 1e3,
+	gain: 0,
+	q: 1
+};
+var AudioParametricEq = class extends Effect {
+	op = "AudioParametricEq";
+	constructor(config = {}) {
+		super(withDefaults("AudioParametricEq", audioParametricEqDefaults, config, effectMeta.AudioParametricEq));
+	}
+};
+const audioReverbDefaults = {
+	roomSize: .5,
+	damping: .5,
+	wet: .3,
+	dry: 1,
+	width: 1
+};
+var AudioReverb = class extends Effect {
+	op = "AudioReverb";
+	constructor(config = {}) {
+		super(withDefaults("AudioReverb", audioReverbDefaults, config, effectMeta.AudioReverb));
+	}
+};
+const blurDefaults = {
+	blurType: "Gaussian",
+	strength: 5,
+	angle: 0,
+	sigmaColor: .1,
+	centerX: .5,
+	centerY: .5,
+	partialBlur: false,
+	radius: .3,
+	radiusY: 0,
+	shape: "circle"
+};
+/** @internal Extended by `effects/custom/blur.ts`, which exports `Blur`. */
+var BlurBase = class extends Effect {
+	op = "Blur";
+	constructor(config = {}) {
+		super(withDefaults("Blur", blurDefaults, config, effectMeta.Blur));
+	}
+};
+const cameraParallax3DDefaults = {
+	motionPreset: "DollyZoom",
+	panX: 0,
+	panY: 0,
+	dollyZ: 0,
+	fov: 50,
+	parallaxAmount: .6,
+	dofAperture: .3,
+	focusPlane: .4,
+	edgeDilation: .5,
+	depthInvert: false
+};
+var CameraParallax3D = class extends Effect {
+	op = "CameraParallax3D";
+	constructor(config = {}) {
+		super(withDefaults("CameraParallax3D", cameraParallax3DDefaults, config, effectMeta.CameraParallax3D));
+	}
+};
+const channelMergerDefaults = {
+	colorSpace: "RGBA",
+	defaultChannel4: 1
+};
+var ChannelMerger = class extends Effect {
+	op = "ChannelMerger";
+	constructor(config = {}) {
+		super(withDefaults("ChannelMerger", channelMergerDefaults, config, effectMeta.ChannelMerger));
+	}
+};
+const channelSplitterDefaults = { colorSpace: "RGBA" };
+var ChannelSplitter = class extends Effect {
+	op = "ChannelSplitter";
+	constructor(config = {}) {
+		super(withDefaults("ChannelSplitter", channelSplitterDefaults, config, effectMeta.ChannelSplitter));
+	}
+};
+const colorBalanceDefaults = {
+	shadows: {
+		cyanRed: 0,
+		magentaGreen: 0,
+		yellowBlue: 0
+	},
+	midtones: {
+		cyanRed: 0,
+		magentaGreen: 0,
+		yellowBlue: 0
+	},
+	highlights: {
+		cyanRed: 0,
+		magentaGreen: 0,
+		yellowBlue: 0
+	},
+	preserveLuminosity: true
+};
+var ColorBalance = class extends Effect {
+	op = "ColorBalance";
+	constructor(config = {}) {
+		super(withDefaults("ColorBalance", colorBalanceDefaults, config, effectMeta.ColorBalance));
+	}
+};
+const colorKeyDefaults = {
+	keyColor: "#00ff00",
+	similarity: .4,
+	smoothness: .1,
+	spillSuppression: .2,
+	colorSpace: "YUV",
+	spillSuppressionType: "Desaturate"
+};
+var ColorKey = class extends Effect {
+	op = "ColorKey";
+	constructor(config = {}) {
+		super(withDefaults("ColorKey", colorKeyDefaults, config, effectMeta.ColorKey));
+	}
+};
+const cornerPinDefaults = {};
+var CornerPin = class extends Effect {
+	op = "CornerPin";
+	constructor(config = {}) {
+		super(withDefaults("CornerPin", cornerPinDefaults, config, effectMeta.CornerPin));
+	}
+};
+const displacementMapDefaults = {
+	strengthX: 50,
+	strengthY: 50,
+	xChannel: "Red",
+	yChannel: "Green",
+	wrapMode: "Clamp"
+};
+var DisplacementMap = class extends Effect {
+	op = "DisplacementMap";
+	constructor(config = {}) {
+		super(withDefaults("DisplacementMap", displacementMapDefaults, config, effectMeta.DisplacementMap));
+	}
+};
+const extractLUTDefaults = {
+	strategy: "deterministic",
+	samplePoints: 150
+};
+var ExtractLUT = class extends Effect {
+	op = "ExtractLUT";
+	constructor(config = {}) {
+		super(withDefaults("ExtractLUT", extractLUTDefaults, config, effectMeta.ExtractLUT));
+	}
+};
+const flipDefaults = {
+	horizontal: true,
+	vertical: false,
+	diagonal: false,
+	mode: "horizontal",
+	symmetry: "none"
+};
+var Flip = class extends Effect {
+	op = "Flip";
+	constructor(config = {}) {
+		super(withDefaults("Flip", flipDefaults, config, effectMeta.Flip));
+	}
+};
+const kenBurnsDefaults = {
+	keyframes: [],
+	motionBlurSize: 1.5,
+	movementStyle: "spline",
+	aspectRatio: "input"
+};
+var KenBurns = class extends Effect {
+	op = "KenBurns";
+	constructor(config = {}) {
+		super(withDefaults("KenBurns", kenBurnsDefaults, config, effectMeta.KenBurns));
+	}
+};
+const layerStyleDefaults = {
+	dropShadow: {
+		enabled: false,
+		color: "#000000",
+		opacity: .75,
+		angle: 120,
+		distance: 10,
+		spread: 0,
+		size: 10,
+		blendMode: "multiply"
+	},
+	innerShadow: {
+		enabled: false,
+		color: "#000000",
+		opacity: .75,
+		angle: 120,
+		distance: 5,
+		choke: 0,
+		size: 5,
+		blendMode: "multiply"
+	},
+	outerGlow: {
+		enabled: false,
+		color: "#ffffff",
+		opacity: .75,
+		size: 15,
+		spread: 0,
+		blendMode: "screen"
+	},
+	innerGlow: {
+		enabled: false,
+		color: "#ffffff",
+		opacity: .75,
+		size: 15,
+		spread: 0,
+		blendMode: "screen"
+	},
+	stroke: {
+		enabled: false,
+		size: 2,
+		position: "outside",
+		color: "#ffffff",
+		opacity: 1,
+		blendMode: "normal"
+	},
+	bevelEmboss: {
+		enabled: false,
+		style: "InnerBevel",
+		technique: "Smooth",
+		depth: 100,
+		direction: "Up",
+		size: 5,
+		soften: 0,
+		angle: 120,
+		altitude: 30,
+		highlightColor: "#ffffff",
+		highlightOpacity: .75,
+		shadowColor: "#000000",
+		shadowOpacity: .75
+	},
+	colorOverlay: {
+		enabled: false,
+		color: "#ff0000",
+		opacity: 1,
+		blendMode: "normal"
+	}
+};
+var LayerStyle = class extends Effect {
+	op = "LayerStyle";
+	constructor(config = {}) {
+		super(withDefaults("LayerStyle", layerStyleDefaults, config, effectMeta.LayerStyle));
+	}
+};
+const liquifyDefaults = { operations: [] };
+var Liquify = class extends Effect {
+	op = "Liquify";
+	constructor(config = {}) {
+		super(withDefaults("Liquify", liquifyDefaults, config, effectMeta.Liquify));
+	}
+};
+const maskMathDefaults = {
+	operation: "Union",
+	radius: 0,
+	threshold: .5,
+	clampMin: 0,
+	clampMax: 1,
+	channelA: "Alpha",
+	channelB: "Alpha",
+	binarize: false,
+	invertResult: false,
+	outputFormat: "WhiteWithAlpha"
+};
+var MaskMath = class extends Effect {
+	op = "MaskMath";
+	constructor(config = {}) {
+		super(withDefaults("MaskMath", maskMathDefaults, config, effectMeta.MaskMath));
+	}
+};
+const meshWarpDefaults = {
+	cols: 3,
+	rows: 3
+};
+var MeshWarp = class extends Effect {
+	op = "MeshWarp";
+	constructor(config = {}) {
+		super(withDefaults("MeshWarp", meshWarpDefaults, config, effectMeta.MeshWarp));
+	}
+};
+const noiseGeneratorDefaults = {
+	noiseType: "Perlin",
+	outputType: "Image",
+	width: 512,
+	height: 512,
+	scale: 10,
+	octaves: 4,
+	persistence: .5,
+	lacunarity: 2,
+	speed: 1,
+	colorStart: "#000000",
+	colorEnd: "#ffffff",
+	durationMs: 5e3,
+	fps: 30
+};
+var NoiseGenerator = class extends Effect {
+	op = "NoiseGenerator";
+	constructor(config = {}) {
+		super(withDefaults("NoiseGenerator", noiseGeneratorDefaults, config, effectMeta.NoiseGenerator));
+	}
+};
+const paintDefaults = {
+	width: 1080,
+	height: 1080,
+	maintainAspect: true,
+	backgroundColor: "#ffffff"
+};
+var Paint = class extends Effect {
+	op = "Paint";
+	constructor(config = {}) {
+		super(withDefaults("Paint", paintDefaults, config, effectMeta.Paint));
+	}
+};
+const patchHealDefaults = {
+	centerX: .5,
+	centerY: .5,
+	offsetX: 50,
+	offsetY: 0,
+	radius: 25,
+	sourceRadius: 25,
+	feather: 50,
+	opacity: 1,
+	mode: "SeamlessHeal"
+};
+var PatchHeal = class extends Effect {
+	op = "PatchHeal";
+	constructor(config = {}) {
+		super(withDefaults("PatchHeal", patchHealDefaults, config, effectMeta.PatchHeal));
+	}
+};
+const proceduralVFXDefaults = {
+	effectType: "Smoke",
+	outputType: "Video",
+	width: 1080,
+	height: 1080,
+	density: .6,
+	scale: .01,
+	speed: 1,
+	intensity: .8,
+	seed: 1234,
+	colorStart: "#ffffff",
+	colorEnd: "#ff5500",
+	durationMs: 5e3,
+	fps: 30
+};
+var ProceduralVFX = class extends Effect {
+	op = "ProceduralVFX";
+	constructor(config = {}) {
+		super(withDefaults("ProceduralVFX", proceduralVFXDefaults, config, effectMeta.ProceduralVFX));
+	}
+};
+const refineEdgeDefaults = {
+	decontaminateAmount: .7,
+	radius: 2,
+	smooth: 5,
+	feather: .5,
+	shiftEdge: 0,
+	matteChannel: "Alpha",
+	outputMode: "Composite"
+};
+var RefineEdge = class extends Effect {
+	op = "RefineEdge";
+	constructor(config = {}) {
+		super(withDefaults("RefineEdge", refineEdgeDefaults, config, effectMeta.RefineEdge));
+	}
+};
+const refractionCaustics3DDefaults = {
+	ior: 1.52,
+	dispersion: .04,
+	refractionScale: .5,
+	causticBrightness: .6,
+	causticScale: 1,
+	fluidRipples: 0,
+	rippleSpeed: 1,
+	roughness: 0,
+	specularIntensity: .8,
+	lightPosX: .5,
+	lightPosY: .2,
+	tintColor: "#ffffff",
+	tintStrength: 0,
+	depthInvert: false,
+	depthScale: 1
+};
+var RefractionCaustics3D = class extends Effect {
+	op = "RefractionCaustics3D";
+	constructor(config = {}) {
+		super(withDefaults("RefractionCaustics3D", refractionCaustics3DDefaults, config, effectMeta.RefractionCaustics3D));
+	}
+};
+const resizerScalerDefaults = {
+	aspectRatioPreset: "16:9",
+	resolutionPreset: "1080p",
+	targetWidth: 1920,
+	targetHeight: 1080,
+	fitMode: "contain",
+	zoom: 100,
+	offsetX: 0,
+	offsetY: 0,
+	backgroundMode: "solid",
+	backgroundColor: "#000000FF",
+	backgroundColor2: "#000000FF",
+	blurRadius: 40,
+	backgroundBrightness: .6,
+	anchorX: "center",
+	anchorY: "center"
+};
+var ResizerScaler = class extends Effect {
+	op = "ResizerScaler";
+	constructor(config = {}) {
+		super(withDefaults("ResizerScaler", resizerScalerDefaults, config, effectMeta.ResizerScaler));
+	}
+};
+const stereoPanningDefaults = { pan: 0 };
+var StereoPanning = class extends Effect {
+	op = "StereoPanning";
+	constructor(config = {}) {
+		super(withDefaults("StereoPanning", stereoPanningDefaults, config, effectMeta.StereoPanning));
+	}
+};
+const vignetteDefaults = {
+	strength: 50,
+	radius: 1,
+	softness: .5,
+	roundness: .5,
+	centerX: .5,
+	centerY: .5
+};
+var Vignette = class extends Effect {
+	op = "Vignette";
+	constructor(config = {}) {
+		super(withDefaults("Vignette", vignetteDefaults, config, effectMeta.Vignette));
+	}
+};
+
+//#endregion
+//#region src/effects/custom/blur.ts
+/** Props the track supplies when the caller does not. */
+function trackDefaults(track) {
+	return {
+		partialBlur: true,
+		centerX: track.center.x,
+		centerY: track.center.y,
+		radius: track.bounds.width.multiply(.55),
+		radiusY: track.bounds.height.multiply(.55),
+		shape: "ellipse",
+		strength: track.active.multiply(25)
+	};
+}
+/**
+* Blur effect. Props, defaults and ranges are generated from `node-blur`'s
+* schema ({@link BlurBase}); this subclass only adds `track`.
+*/
+var Blur = class extends BlurBase {
+	constructor(config = {}) {
+		const { track, ...rest } = config;
+		super(track ? {
+			...trackDefaults(track),
+			...definedOnly(rest)
+		} : rest);
+	}
+};
+function definedOnly(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
+
+//#endregion
+//#region src/effects/generated/registry.ts
+/** `Effect.<factory>(config)` helpers, one per generated effect class. */
+const effectFactories = {
+	audioCompressor: (config) => new AudioCompressor(config),
+	audioDelay: (config) => new AudioDelay(config),
+	audioFade: (config) => new AudioFade(config),
+	audioNoiseGate: (config) => new AudioNoiseGate(config),
+	audioParametricEq: (config) => new AudioParametricEq(config),
+	audioReverb: (config) => new AudioReverb(config),
+	blur: (config) => new Blur(config),
+	cameraParallax3D: (config) => new CameraParallax3D(config),
+	channelMerger: (config) => new ChannelMerger(config),
+	channelSplitter: (config) => new ChannelSplitter(config),
+	colorBalance: (config) => new ColorBalance(config),
+	colorKey: (config) => new ColorKey(config),
+	cornerPin: (config) => new CornerPin(config),
+	displacementMap: (config) => new DisplacementMap(config),
+	extractLUT: (config) => new ExtractLUT(config),
+	flip: (config) => new Flip(config),
+	kenBurns: (config) => new KenBurns(config),
+	layerStyle: (config) => new LayerStyle(config),
+	liquify: (config) => new Liquify(config),
+	maskMath: (config) => new MaskMath(config),
+	meshWarp: (config) => new MeshWarp(config),
+	noiseGenerator: (config) => new NoiseGenerator(config),
+	paint: (config) => new Paint(config),
+	patchHeal: (config) => new PatchHeal(config),
+	proceduralVFX: (config) => new ProceduralVFX(config),
+	refineEdge: (config) => new RefineEdge(config),
+	refractionCaustics3D: (config) => new RefractionCaustics3D(config),
+	resizerScaler: (config) => new ResizerScaler(config),
+	stereoPanning: (config) => new StereoPanning(config),
+	vignette: (config) => new Vignette(config)
+};
+
+//#endregion
+//#region src/effects/classes.ts
+var Levels = class extends Effect {
+	op = "Levels";
+	constructor(config = {}) {
+		const defaultChannel = {
+			inBlack: 0,
+			inWhite: 1,
+			outBlack: 0,
+			outWhite: 1
+		};
+		super({
+			master: config.master ?? { ...defaultChannel },
+			red: config.red ?? { ...defaultChannel },
+			green: config.green ?? { ...defaultChannel },
+			blue: config.blue ?? { ...defaultChannel },
+			...config
+		});
+	}
+};
+var FilmGrain = class extends Effect {
+	op = "FilmGrain";
+	constructor(config = {}) {
+		super({
+			strength: config.strength ?? 15,
+			size: config.size ?? 1.5,
+			monochrome: config.monochrome ?? true,
+			animated: config.animated ?? true,
+			speed: config.speed ?? 50,
+			shadows: config.shadows ?? .2,
+			midtones: config.midtones ?? 1,
+			highlights: config.highlights ?? .2,
+			...config
+		});
+	}
+};
+var CustomEffect = class extends Effect {
+	op;
+	constructor(opName, config = {}) {
+		super(config);
+		this.op = opName;
+	}
+};
+var AudioSignalExtractor = class extends Effect {
+	op = "AudioSignalExtractor";
+	constructor(config = {}) {
+		super({
+			extractionMode: config.extractionMode ?? "rms_envelope",
+			attackMs: config.attackMs ?? 10,
+			releaseMs: config.releaseMs ?? 120,
+			sensitivity: config.sensitivity ?? 1,
+			noiseFloorDb: config.noiseFloorDb ?? -48,
+			dynamicRangeDb: config.dynamicRangeDb ?? 48,
+			autoRange: config.autoRange ?? true,
+			smoothing: config.smoothing ?? .15,
+			curve: config.curve ?? "linear",
+			beatThreshold: config.beatThreshold ?? .08,
+			beatDecayMs: config.beatDecayMs ?? 80,
+			previewMode: config.previewMode ?? "envelope",
+			nodeId: config.nodeId ?? "audio_extractor",
+			...config
+		});
+	}
+	async extract(source, options = {}) {
+		return AudioSignal.extract(source, {
+			extractionMode: this.extractionMode,
+			attackMs: this.attackMs,
+			releaseMs: this.releaseMs,
+			sensitivity: this.sensitivity,
+			noiseFloorDb: this.noiseFloorDb,
+			dynamicRangeDb: this.dynamicRangeDb,
+			smoothing: this.smoothing,
+			curve: this.curve,
+			beatThreshold: this.beatThreshold,
+			beatDecayMs: this.beatDecayMs,
+			previewMode: this.previewMode,
+			...options
+		});
+	}
+};
+var Curves = class extends Effect {
+	op = "Curves";
+	constructor(config = {}) {
+		super({
+			...config,
+			curveType: config.curveType ?? "rgb",
+			master: config.master ?? [{
+				x: 0,
+				y: 0
+			}, {
+				x: 1,
+				y: 1
+			}],
+			red: config.red ?? [{
+				x: 0,
+				y: 0
+			}, {
+				x: 1,
+				y: 1
+			}],
+			green: config.green ?? [{
+				x: 0,
+				y: 0
+			}, {
+				x: 1,
+				y: 1
+			}],
+			blue: config.blue ?? [{
+				x: 0,
+				y: 0
+			}, {
+				x: 1,
+				y: 1
+			}],
+			hueVsHue: config.hueVsHue ?? [{
+				x: 0,
+				y: .5
+			}, {
+				x: 1,
+				y: .5
+			}],
+			hueVsSat: config.hueVsSat ?? [{
+				x: 0,
+				y: 1
+			}, {
+				x: 1,
+				y: 1
+			}],
+			lumVsSat: config.lumVsSat ?? [{
+				x: 0,
+				y: 1
+			}, {
+				x: 1,
+				y: 1
+			}],
+			satVsSat: config.satVsSat ?? [{
+				x: 0,
+				y: 1
+			}, {
+				x: 1,
+				y: 1
+			}]
+		});
+	}
+};
+var SelectiveColor = class extends Effect {
+	op = "SelectiveColor";
+	constructor(config = {}) {
+		const defaultAdj = {
+			cyan: 0,
+			magenta: 0,
+			yellow: 0,
+			black: 0
+		};
+		super({
+			...config,
+			method: config.method ?? "Relative",
+			reds: {
+				...defaultAdj,
+				...config.reds
+			},
+			yellows: {
+				...defaultAdj,
+				...config.yellows
+			},
+			greens: {
+				...defaultAdj,
+				...config.greens
+			},
+			cyans: {
+				...defaultAdj,
+				...config.cyans
+			},
+			blues: {
+				...defaultAdj,
+				...config.blues
+			},
+			magentas: {
+				...defaultAdj,
+				...config.magentas
+			},
+			whites: {
+				...defaultAdj,
+				...config.whites
+			},
+			neutrals: {
+				...defaultAdj,
+				...config.neutrals
+			},
+			blacks: {
+				...defaultAdj,
+				...config.blacks
+			}
+		});
+	}
+};
+var GradientMap = class extends Effect {
+	op = "GradientMap";
+	constructor(config = {}) {
+		const defaultStops = [{
+			position: 0,
+			color: "#000000"
+		}, {
+			position: 1,
+			color: "#ffffff"
+		}];
+		super({
+			...config,
+			stops: config.stops ?? defaultStops,
+			smooth: config.smooth ?? true,
+			dither: config.dither ?? true,
+			opacity: config.opacity ?? 1
+		});
+	}
+};
+var ShadowsHighlights = class extends Effect {
+	op = "ShadowsHighlights";
+	constructor(config = {}) {
+		super({
+			...config,
+			shadowAmount: config.shadowAmount ?? 0,
+			shadowTonalWidth: config.shadowTonalWidth ?? 50,
+			shadowRadius: config.shadowRadius ?? 30,
+			highlightAmount: config.highlightAmount ?? 0,
+			highlightTonalWidth: config.highlightTonalWidth ?? 50,
+			highlightRadius: config.highlightRadius ?? 30,
+			colorCorrection: config.colorCorrection ?? 0,
+			midtoneContrast: config.midtoneContrast ?? 0
+		});
+	}
+};
+var ApplyLUT = class extends Effect {
+	op = "ApplyLUT";
+	constructor(config = {}) {
+		super({
+			...config,
+			lutUrl: config.lutUrl ?? "",
+			intensity: config.intensity ?? 1
+		});
+	}
+};
+var UnsharpMask = class extends Effect {
+	op = "UnsharpMask";
+	constructor(config = {}) {
+		super({
+			...config,
+			amount: config.amount ?? 100,
+			radius: config.radius ?? 1.5,
+			threshold: config.threshold ?? 3
+		});
+	}
+};
+var HighPass = class extends Effect {
+	op = "HighPass";
+	constructor(config = {}) {
+		super({
+			...config,
+			radius: config.radius ?? 3,
+			contrastBoost: config.contrastBoost ?? 1,
+			monochrome: config.monochrome ?? true
+		});
+	}
+};
+var HalftoneScreen = class extends Effect {
+	op = "HalftoneScreen";
+	constructor(config = {}) {
+		super({
+			...config,
+			mode: config.mode ?? "Monochrome",
+			dotShape: config.dotShape ?? "Circle",
+			frequency: config.frequency ?? 30,
+			angle: config.angle ?? 45,
+			contrast: config.contrast ?? 1,
+			dotColor: config.dotColor ?? "#000000",
+			paperColor: config.paperColor ?? "#ffffff",
+			smooth: config.smooth ?? true,
+			invert: config.invert ?? false,
+			cyanAngle: config.cyanAngle ?? 15,
+			magentaAngle: config.magentaAngle ?? 75,
+			yellowAngle: config.yellowAngle ?? 0,
+			blackAngle: config.blackAngle ?? 45,
+			opacity: config.opacity ?? 1
+		});
+	}
+};
+var TileOffset = class extends Effect {
+	op = "TileOffset";
+	constructor(config = {}) {
+		super({
+			...config,
+			offsetX: config.offsetX ?? 0,
+			offsetY: config.offsetY ?? 0,
+			wrap: config.wrap ?? true,
+			edgeMode: config.edgeMode ?? "wrap"
+		});
+	}
+};
+var MotionBlur = class extends Effect {
+	op = "MotionBlur";
+	constructor(config = {}) {
+		super({
+			...config,
+			shutterAngle: config.shutterAngle ?? 180,
+			samples: config.samples ?? 16,
+			maxVelocity: config.maxVelocity ?? 64,
+			shutterCurve: config.shutterCurve ?? "gaussian",
+			depthAware: config.depthAware ?? true
+		});
+	}
+};
+var SSAO = class extends Effect {
+	op = "SSAO";
+	constructor(config = {}) {
+		super({
+			...config,
+			radius: config.radius ?? 45,
+			bias: config.bias ?? .025,
+			intensity: config.intensity ?? 1.5,
+			kernelSamples: config.kernelSamples ?? 16,
+			blurRadius: config.blurRadius ?? 4
+		});
+	}
+};
+var PBRGlass = class extends Effect {
+	op = "PBRGlass";
+	constructor(config = {}) {
+		super({
+			...config,
+			ior: config.ior ?? 1.49,
+			roughness: config.roughness ?? .15,
+			transmission: config.transmission ?? .92,
+			dispersion: config.dispersion ?? .015,
+			fresnelPower: config.fresnelPower ?? 5,
+			tintColor: config.tintColor ?? "#ffffff"
+		});
+	}
+};
+var DepthOfField = class extends Effect {
+	op = "DepthOfField";
+	constructor(config = {}) {
+		super({
+			...config,
+			focusDistance: config.focusDistance ?? 500,
+			focalLength: config.focalLength ?? 50,
+			aperture: config.aperture ?? 2.8,
+			maxBlur: config.maxBlur ?? 16,
+			quality: config.quality ?? "high"
+		});
+	}
+};
+var Crop = class extends Effect {
+	op = "Crop";
+	constructor(config = {}) {
+		super({
+			cropType: config.cropType ?? "rect",
+			leftPercentage: config.leftPercentage ?? 0,
+			topPercentage: config.topPercentage ?? 0,
+			widthPercentage: config.widthPercentage ?? 100,
+			heightPercentage: config.heightPercentage ?? 100,
+			roundness: config.roundness ?? 0,
+			...config
+		});
+	}
+};
+/**
+* On-device vision: tracks objects, segments instances, estimates pose and mattes people on
+* the rendered frame, feeding reactive signals. Models download lazily on first use.
+*/
+var Vision = class extends Effect {
+	op = "Vision";
+	constructor(config = {}) {
+		super({
+			enableDetection: config.enableDetection !== false,
+			enableSegmentation: config.enableSegmentation === true,
+			enablePose: config.enablePose === true,
+			enableMatte: config.enableMatte === true,
+			confidence: config.confidence ?? .3,
+			variant: config.variant ?? "s",
+			mode: config.mode ?? "passthrough",
+			matteSource: config.matteSource ?? "instance",
+			...config
+		});
+	}
+};
+var Relight3D = class extends Effect {
+	op = "Relight3D";
+	constructor(config = {}) {
+		super({
+			lightType: config.lightType ?? "Point",
+			intensity: config.intensity ?? 1,
+			lightPosX: config.lightPosX ?? .5,
+			lightPosY: config.lightPosY ?? .5,
+			lightPosZ: config.lightPosZ ?? .3,
+			lightRadius: config.lightRadius ?? .8,
+			spotConeAngle: config.spotConeAngle ?? 45,
+			specularRoughness: config.specularRoughness ?? .35,
+			specularStrength: config.specularStrength ?? .7,
+			metallic: config.metallic ?? 0,
+			ambientIntensity: config.ambientIntensity ?? .4,
+			volumetricDensity: config.volumetricDensity ?? .2,
+			depthScale: config.depthScale ?? 1,
+			depthInvert: config.depthInvert ?? false,
+			lightColor: config.lightColor ?? "#ffffff",
+			ambientColor: config.ambientColor ?? "#ffffff",
+			normalMap: config.normalMap,
+			...config
+		});
+	}
+};
+var TemporalDeflicker = class extends Effect {
+	op = "TemporalDeflicker";
+	constructor(config = {}) {
+		super({
+			blendWeight: config.blendWeight ?? .35,
+			disocclusionThreshold: config.disocclusionThreshold ?? .15,
+			maxMotionPixels: config.maxMotionPixels ?? 64,
+			scale: config.scale ?? .5,
+			windowSize: config.windowSize ?? 2,
+			...config
+		});
+	}
+};
+var Modulate = class extends Effect {
+	op = "Modulate";
+	constructor(config = {}) {
+		super({
+			hue: config.hue ?? 0,
+			brightness: config.brightness ?? 1,
+			contrast: config.contrast ?? 1,
+			exposure: config.exposure ?? 0,
+			saturation: config.saturation ?? 1,
+			sepia: config.sepia ?? 0,
+			...config
+		});
+	}
+};
+
+//#endregion
+export { Vignette as $, AudioReverb as A, KenBurns as B, effectFactories as C, AudioFade as D, AudioDelay as E, ColorKey as F, NoiseGenerator as G, Liquify as H, CornerPin as I, ProceduralVFX as J, Paint as K, DisplacementMap as L, ChannelMerger as M, ChannelSplitter as N, AudioNoiseGate as O, ColorBalance as P, StereoPanning as Q, ExtractLUT as R, Vision as S, AudioCompressor as T, MaskMath as U, LayerStyle as V, MeshWarp as W, RefractionCaustics3D as X, RefineEdge as Y, ResizerScaler as Z, SelectiveColor as _, CustomEffect as a, TileOffset as b, GradientMap as c, Levels as d, effectMeta as et, Modulate as f, SSAO as g, Relight3D as h, Curves as i, CameraParallax3D as j, AudioParametricEq as k, HalftoneScreen as l, PBRGlass as m, AudioSignalExtractor as n, DepthOfField as o, MotionBlur as p, PatchHeal as q, Crop as r, FilmGrain as s, ApplyLUT as t, HighPass as u, ShadowsHighlights as v, Blur as w, UnsharpMask as x, TemporalDeflicker as y, Flip as z };
+//# sourceMappingURL=effects-l0T61DPU.mjs.map