framefields 2.0.2

package/dist/effects-CHWORCYd.mjs

@@ -0,0 +1,811 @@
+import { Ot as isSignal, v as Effect } from "./dist-Bx6J0VcM.mjs";
+import { t as AudioSignal } from "./audio-x28ZgQBP.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 = {
+	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"
+		] }
+	},
+	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"
+		] }
+	},
+	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 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 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 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 = {
+	blur: (config) => new Blur(config),
+	colorBalance: (config) => new ColorBalance(config),
+	colorKey: (config) => new ColorKey(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 { effectFactories as C, Vignette as D, ColorKey as E, effectMeta as O, Vision as S, ColorBalance as T, SelectiveColor as _, CustomEffect as a, TileOffset as b, GradientMap as c, Levels as d, Modulate as f, SSAO as g, Relight3D as h, Curves as i, HalftoneScreen as l, PBRGlass as m, AudioSignalExtractor as n, DepthOfField as o, MotionBlur as p, Crop as r, FilmGrain as s, ApplyLUT as t, HighPass as u, ShadowsHighlights as v, Blur as w, UnsharpMask as x, TemporalDeflicker as y };
+//# sourceMappingURL=effects-CHWORCYd.mjs.map