framefields 2.10.0-canary.0 → 2.12.0

package/dist/{dist-C4Vxgm0Q.mjs → dist-B-OPY7Cs.mjs}

@@ -10,7 +10,7 @@ import { DotLottie } from "@lottiefiles/dotlottie-web";
 import earcut from "earcut";
 import { Path2D } from "skia-canvas";
 
-//#region ../webgpu-renderers/dist/text-animations-CaYMwhsz.mjs
+//#region ../webgpu-renderers/dist/text-animations-COSsiLBc.mjs
 /**
 * 1. Biquad IIR Filter Bank Compute Shader
 * Applies resonant bandpass/lowpass/highpass filtering on PCM audio buffer.
@@ -293,6 +293,12 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     }
 }
 `;
+/** Averages every channel into one mono buffer for storage buffer upload. */
+function downmixToMono(channels) {
+	const mono = new Float32Array(channels[0]?.length ?? 0);
+	for (const ch of channels) for (let i = 0; i < mono.length; i++) mono[i] += ch[i] / channels.length;
+	return mono;
+}
 function calculateBiquadBandpassCoeffs(sampleRate, centerFreq, Q) {
 	const w0 = 2 * Math.PI * centerFreq / sampleRate;
 	const alpha = Math.sin(w0) / (2 * Q);
@@ -363,18 +369,13 @@ var AudioSignalComputePipeline = class AudioSignalComputePipeline$1 {
 	* Processes raw PCM audio channels on the GPU and outputs extracted feature buffers and textures.
 	*/
 	static async extractFeatures(device, audioChannels, sampleRate, fps, config$1 = {}, targetWidth = 512) {
-		const numChannels = audioChannels.length;
-		if (numChannels === 0 || audioChannels[0].length === 0) throw new Error("Empty audio buffer supplied to AudioSignalComputePipeline.");
+		if (audioChannels.length === 0 || audioChannels[0].length === 0) throw new Error("Empty audio buffer supplied to AudioSignalComputePipeline.");
 		const numAudioSamples = audioChannels[0].length;
 		const durationSec = numAudioSamples / sampleRate;
 		const numFrames = Math.max(1, Math.ceil(durationSec * fps));
 		const hopSize = Math.max(1, Math.round(sampleRate / fps));
 		const windowSize = Math.max(32, Math.round(hopSize * 2));
-		const monoPcm = new Float32Array(numAudioSamples);
-		for (let c = 0; c < numChannels; c++) {
-			const ch = audioChannels[c];
-			for (let i = 0; i < numAudioSamples; i++) monoPcm[i] += ch[i] / numChannels;
-		}
+		const monoPcm = downmixToMono(audioChannels);
 		const rawAudioBuffer = device.createBuffer({
 			size: numAudioSamples * 4,
 			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
@@ -26447,9 +26448,9 @@ async function drawSignalNode(ctx, encoder, pass, props) {
 	const elapsedTimeSec = elapsedMs / 1e3;
 	await signalRegistry.ensureAudioSourcesExtracted(ctx.device, config$1, fps, props.renderId);
 	const signalView = signalRegistry.getOrCreate2DTextureView(ctx.device, encoder, nodeId, elapsedTimeSec, durationSec, config$1, width, height, props.renderId, frame, fps);
-	const pipelines = getDevicePipelines(ctx.device);
+	const pipelines$1 = getDevicePipelines(ctx.device);
 	const cacheKey = `preview_${ctx.renderer.format}`;
-	let pipeline = pipelines.get(cacheKey);
+	let pipeline = pipelines$1.get(cacheKey);
 	if (!pipeline) {
 		const shaderModule = ctx.device.createShaderModule({
 			label: `signal_preview_static.wgsl`,
@@ -26469,7 +26470,7 @@ async function drawSignalNode(ctx, encoder, pass, props) {
 			},
 			primitive: { topology: "triangle-strip" }
 		});
-		pipelines.set(cacheKey, pipeline);
+		pipelines$1.set(cacheKey, pipeline);
 	}
 	let previewModeInt = 0;
 	if (!isMathNode && !isGateNode) {
@@ -41147,6 +41148,365 @@ struct VSOut {
 	return vec4<f32>(outRgb, outAlpha);
 }
 `;
+const MAX_PITCH_LAG = 2048;
+const PITCH_CANDIDATES = 8;
+const EMPTY_CANDIDATE = 2;
+/** Cost of switching between voiced and unvoiced from one frame to the next. */
+const VOICING_SWITCH_COST = .6;
+/** Extra cost of a dip that echoes a shorter candidate's period. */
+const SUBHARMONIC_COST = .5;
+/** How many times shallower the shorter dip may be and still explain a longer one. */
+const SUBHARMONIC_DEPTH_RATIO = 1.25;
+/** Relative lag error allowed when matching a period multiple. */
+const PERIOD_MULTIPLE_TOLERANCE = .03;
+/** Relative lag distance under which two local minima are one noisy dip. */
+const RIPPLE_MERGE = .03;
+const WORKGROUP_SIZE = 128;
+const MAX_GRID_X = 65535;
+const AUDIO_PITCH_CANDIDATES_SHADER = `
+struct PitchUniforms {
+    sampleRate : f32,
+    numSamples : u32,
+    numFrames  : u32,
+    windowSize : u32,
+    lagMin     : u32,
+    lagMax     : u32,
+    gridX      : u32,
+    fps        : f32,
+};
+
+const K : u32 = ${PITCH_CANDIDATES}u;
+const WG : u32 = ${WORKGROUP_SIZE}u;
+const EMPTY : f32 = ${EMPTY_CANDIDATE}.0f;
+const MERGE : f32 = ${RIPPLE_MERGE}f;
+
+@group(0) @binding(0) var<uniform> u : PitchUniforms;
+@group(0) @binding(1) var<storage, read> pcm : array<f32>;
+@group(0) @binding(2) var<storage, read_write> candidates : array<vec2f>;
+
+var<workgroup> yin : array<f32, ${MAX_PITCH_LAG + 1}>;
+
+fn sampleAt(i : u32) -> f32 {
+    if (i >= u.numSamples) { return 0.0f; }
+    return pcm[i];
+}
+
+// Keeps the K deepest dips sorted by value, shallowest last. A dip within
+// MERGE of an existing candidate's lag is the same broad dip: only the
+// deeper of the two survives.
+fn insertCandidate(lags : ptr<function, array<f32, K>>, vals : ptr<function, array<f32, K>>, lag : f32, val : f32) {
+    var slot = K - 1u;
+    for (var k = 0u; k < K; k = k + 1u) {
+        if ((*vals)[k] < EMPTY && abs((*lags)[k] - lag) <= MERGE * lag) {
+            if ((*vals)[k] <= val) { return; }
+            slot = k;
+            break;
+        }
+    }
+    if ((*vals)[slot] <= val) { return; }
+    var i = slot;
+    loop {
+        if (i == 0u || (*vals)[i - 1u] <= val) { break; }
+        (*vals)[i] = (*vals)[i - 1u];
+        (*lags)[i] = (*lags)[i - 1u];
+        i = i - 1u;
+    }
+    (*vals)[i] = val;
+    (*lags)[i] = lag;
+}
+
+@compute @workgroup_size(${WORKGROUP_SIZE})
+fn main(@builtin(workgroup_id) wid : vec3<u32>, @builtin(local_invocation_index) lid : u32) {
+    let frame = wid.x + wid.y * u.gridX;
+    if (frame >= u.numFrames) { return; }
+
+    // Center the analysed span (window + longest lag) on the frame time.
+    let span = u.windowSize + u.lagMax;
+    let center = i32(round(f32(frame) * u.sampleRate / u.fps));
+    let maxStart = max(i32(u.numSamples) - i32(span), 0);
+    let start = u32(clamp(center - i32(span / 2u), 0, maxStart));
+
+    // YIN difference function, one lag per invocation per stride.
+    for (var tau = lid; tau <= u.lagMax; tau = tau + WG) {
+        var acc = 0.0f;
+        for (var j = 0u; j < u.windowSize; j = j + 1u) {
+            let d = sampleAt(start + j) - sampleAt(start + j + tau);
+            acc = acc + d * d;
+        }
+        yin[tau] = acc;
+    }
+    workgroupBarrier();
+    if (lid != 0u) { return; }
+
+    // Cumulative mean normalized difference, in place.
+    var running = 0.0f;
+    yin[0] = 1.0f;
+    for (var tau = 1u; tau <= u.lagMax; tau = tau + 1u) {
+        running = running + yin[tau];
+        yin[tau] = select(1.0f, yin[tau] * f32(tau) / running, running > 0.0f);
+    }
+
+    var lags : array<f32, K>;
+    var vals : array<f32, K>;
+    for (var k = 0u; k < K; k = k + 1u) {
+        lags[k] = 0.0f;
+        vals[k] = EMPTY;
+    }
+    for (var tau = max(u.lagMin, 1u); tau < u.lagMax; tau = tau + 1u) {
+        let prev = yin[tau - 1u];
+        let cur = yin[tau];
+        let next = yin[tau + 1u];
+        if (cur < prev && cur <= next) {
+            // Parabolic interpolation of the dip for sub-sample period.
+            let den = prev - 2.0f * cur + next;
+            let offset = select(0.0f, 0.5f * (prev - next) / den, den > 0.0f);
+            insertCandidate(&lags, &vals, f32(tau) + offset, cur);
+        }
+    }
+
+    let base = frame * K;
+    for (var k = 0u; k < K; k = k + 1u) {
+        candidates[base + k] = vec2f(lags[k], vals[k]);
+    }
+}
+`;
+function resolvePitchConfig(sampleRate, config$1) {
+	const minHz = config$1.minHz ?? 50;
+	const maxHz = config$1.maxHz ?? 1e3;
+	if (!(minHz > 0 && maxHz > minHz)) throw new Error(`Pitch range needs 0 < minHz < maxHz (got ${minHz}..${maxHz}).`);
+	const lagMax = Math.ceil(sampleRate / minHz) + 1;
+	if (lagMax > MAX_PITCH_LAG) throw new Error(`minHz ${minHz} needs a ${lagMax}-sample period at ${sampleRate} Hz; the limit is ${MAX_PITCH_LAG} (minHz >= ${Math.ceil(sampleRate / (MAX_PITCH_LAG - 1))}).`);
+	const lagMin = Math.max(2, Math.floor(sampleRate / maxHz));
+	const windowMs = config$1.windowMs ?? 45;
+	return {
+		lagMin,
+		lagMax,
+		windowSize: Math.max(lagMax, Math.round(windowMs / 1e3 * sampleRate)),
+		voicingThreshold: config$1.voicingThreshold ?? .8,
+		octaveJumpCost: config$1.octaveJumpCost ?? 8
+	};
+}
+function transitionCost(prevLag, lag, octaveJumpCost) {
+	const prevVoiced = prevLag > 0;
+	const voiced = lag > 0;
+	if (prevVoiced !== voiced) return VOICING_SWITCH_COST;
+	if (!voiced) return 0;
+	return octaveJumpCost * Math.abs(Math.log2(lag / prevLag));
+}
+/**
+* True when `lag` is an integer multiple (2x, 3x, ...) of a shorter candidate
+* that is about as deep. YIN's normalized difference dips at every multiple
+* of the true period, often slightly deeper, so such a dip is an echo.
+*/
+function isPeriodMultiple(data, base, lag, depth) {
+	for (let j = 0; j < PITCH_CANDIDATES; j++) {
+		const shorter = data[(base + j) * 2];
+		const shorterDepth = data[(base + j) * 2 + 1];
+		if (shorterDepth >= EMPTY_CANDIDATE || shorter <= 0 || shorter >= lag) continue;
+		const m = Math.round(lag / shorter);
+		if (m >= 2 && Math.abs(lag - m * shorter) <= PERIOD_MULTIPLE_TOLERANCE * lag && shorterDepth <= depth * SUBHARMONIC_DEPTH_RATIO) return true;
+	}
+	return false;
+}
+/**
+* Writes each state's lag and emission cost for frame `f`. A candidate costs
+* its YIN dip depth, plus `SUBHARMONIC_COST` when it is a period multiple;
+* the unvoiced state (index K, lag 0) costs the voicing threshold.
+*/
+function observeFrame(data, f, voicingThreshold, lags, costs) {
+	const K = PITCH_CANDIDATES;
+	const base = f * K;
+	const row = f * (K + 1);
+	for (let k = 0; k < K; k++) {
+		const lag = data[(base + k) * 2];
+		const depth = data[(base + k) * 2 + 1];
+		const valid = depth < EMPTY_CANDIDATE && lag > 0;
+		lags[row + k] = valid ? lag : 0;
+		costs[row + k] = !valid ? Number.POSITIVE_INFINITY : depth + (isPeriodMultiple(data, base, lag, depth) ? SUBHARMONIC_COST : 0);
+	}
+	lags[row + K] = 0;
+	costs[row + K] = voicingThreshold;
+}
+/** Most likely state per frame given per-state lags and -log emission costs. */
+function viterbi(lags, costs, numFrames, octaveJumpCost) {
+	const S = PITCH_CANDIDATES + 1;
+	const back = new Uint8Array(numFrames * S);
+	let total = costs.slice(0, S);
+	for (let f = 1; f < numFrames; f++) {
+		const next = new Float64Array(S);
+		for (let s = 0; s < S; s++) {
+			let best = Number.POSITIVE_INFINITY;
+			for (let p = 0; p < S; p++) {
+				const c = total[p] + transitionCost(lags[(f - 1) * S + p], lags[f * S + s], octaveJumpCost);
+				if (c < best) {
+					best = c;
+					back[f * S + s] = p;
+				}
+			}
+			next[s] = best + costs[f * S + s];
+		}
+		total = next;
+	}
+	const path$1 = new Uint8Array(numFrames);
+	let state = total.indexOf(Math.min(...total));
+	for (let f = numFrames - 1; f >= 0; f--) {
+		path$1[f] = state;
+		state = back[f * S + state];
+	}
+	return path$1;
+}
+/**
+* Viterbi decode over each frame's period candidates plus one unvoiced state,
+* emissions from `observeFrame`, transitions costing `octaveJumpCost` per
+* octave and a fixed voicing switch.
+*/
+function decodePitchTrack(candidates, config$1) {
+	const { data, numFrames, sampleRate } = candidates;
+	const K = PITCH_CANDIDATES;
+	const S = K + 1;
+	const lags = new Float64Array(numFrames * S);
+	const costs = new Float64Array(numFrames * S);
+	for (let f = 0; f < numFrames; f++) observeFrame(data, f, config$1.voicingThreshold ?? .8, lags, costs);
+	const path$1 = viterbi(lags, costs, numFrames, config$1.octaveJumpCost ?? 8);
+	const hz = new Float32Array(numFrames);
+	const confidence = new Float32Array(numFrames);
+	const voiced = new Float32Array(numFrames);
+	for (let f = 0; f < numFrames; f++) {
+		const s = path$1[f];
+		if (lags[f * S + s] === 0) continue;
+		hz[f] = sampleRate / lags[f * S + s];
+		confidence[f] = Math.min(1, Math.max(0, 1 - data[(f * K + s) * 2 + 1]));
+		voiced[f] = 1;
+	}
+	fillUnvoiced(hz, voiced);
+	return {
+		hz,
+		confidence,
+		voiced,
+		numFrames
+	};
+}
+/** Linearly interpolates `hz` across unvoiced runs; holds the nearest voiced value at the ends. */
+function fillUnvoiced(hz, voiced) {
+	let prev = -1;
+	for (let f = 0; f <= hz.length; f++) {
+		if (f < hz.length && voiced[f] === 0) continue;
+		const from = prev >= 0 ? hz[prev] : f < hz.length ? hz[f] : 0;
+		const to = f < hz.length ? hz[f] : from;
+		for (let g$1 = prev + 1; g$1 < f; g$1++) {
+			const t = prev >= 0 && f < hz.length ? (g$1 - prev) / (f - prev) : 0;
+			hz[g$1] = from + (to - from) * t;
+		}
+		prev = f;
+	}
+}
+const pipelines = /* @__PURE__ */ new WeakMap();
+function getPipeline(device) {
+	let pipeline = pipelines.get(device);
+	if (!pipeline) {
+		pipeline = device.createComputePipeline({
+			label: "AudioPitchCandidatesPipeline",
+			layout: "auto",
+			compute: {
+				module: device.createShaderModule({
+					label: "AudioPitchCandidatesPipeline.wgsl",
+					code: AUDIO_PITCH_CANDIDATES_SHADER
+				}),
+				entryPoint: "main"
+			}
+		});
+		pipelines.set(device, pipeline);
+	}
+	return pipeline;
+}
+/** Runs the YIN candidate pass on the GPU: `PITCH_CANDIDATES` periods per frame. */
+async function extractPitchCandidates(device, audioChannels, sampleRate, fps, config$1 = {}) {
+	if (audioChannels.length === 0 || audioChannels[0].length === 0) throw new Error("Empty audio buffer supplied to the pitch tracker.");
+	const { lagMin, lagMax, windowSize } = resolvePitchConfig(sampleRate, config$1);
+	const mono = downmixToMono(audioChannels);
+	const numFrames = Math.max(1, Math.ceil(mono.length / sampleRate * fps));
+	const gridX = Math.min(numFrames, MAX_GRID_X);
+	const outBytes = numFrames * PITCH_CANDIDATES * 2 * 4;
+	const uniforms = /* @__PURE__ */ new ArrayBuffer(32);
+	const f32 = new Float32Array(uniforms);
+	const u32 = new Uint32Array(uniforms);
+	f32[0] = sampleRate;
+	u32[1] = mono.length;
+	u32[2] = numFrames;
+	u32[3] = windowSize;
+	u32[4] = lagMin;
+	u32[5] = lagMax;
+	u32[6] = gridX;
+	f32[7] = fps;
+	const uniformBuffer = device.createBuffer({
+		size: uniforms.byteLength,
+		usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+		label: "audio_pitch_uniforms"
+	});
+	device.queue.writeBuffer(uniformBuffer, 0, uniforms);
+	const pcmBuffer = device.createBuffer({
+		size: mono.byteLength,
+		usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+		label: "audio_pitch_pcm"
+	});
+	device.queue.writeBuffer(pcmBuffer, 0, mono);
+	const candidateBuffer = device.createBuffer({
+		size: outBytes,
+		usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+		label: "audio_pitch_candidates"
+	});
+	const readback = device.createBuffer({
+		size: outBytes,
+		usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+		label: "audio_pitch_candidates_readback"
+	});
+	const pipeline = getPipeline(device);
+	const encoder = device.createCommandEncoder({ label: "audio_pitch_encoder" });
+	const pass = encoder.beginComputePass({ label: "audio_pitch_candidates_pass" });
+	pass.setPipeline(pipeline);
+	pass.setBindGroup(0, device.createBindGroup({
+		layout: pipeline.getBindGroupLayout(0),
+		entries: [
+			{
+				binding: 0,
+				resource: { buffer: uniformBuffer }
+			},
+			{
+				binding: 1,
+				resource: { buffer: pcmBuffer }
+			},
+			{
+				binding: 2,
+				resource: { buffer: candidateBuffer }
+			}
+		]
+	}));
+	pass.dispatchWorkgroups(gridX, Math.ceil(numFrames / gridX));
+	pass.end();
+	encoder.copyBufferToBuffer(candidateBuffer, 0, readback, 0, outBytes);
+	device.queue.submit([encoder.finish()]);
+	await readback.mapAsync(GPUMapMode.READ);
+	const data = new Float32Array(readback.getMappedRange().slice(0));
+	readback.unmap();
+	for (const b of [
+		readback,
+		candidateBuffer,
+		pcmBuffer,
+		uniformBuffer
+	]) b.destroy();
+	return {
+		data,
+		numFrames,
+		sampleRate
+	};
+}
+/** Tracks the fundamental frequency of the downmixed channels at `fps` frames per second. */
+async function trackAudioPitch(device, audioChannels, sampleRate, fps, config$1 = {}) {
+	return {
+		...decodePitchTrack(await extractPitchCandidates(device, audioChannels, sampleRate, fps, config$1), config$1),
+		durationSec: audioChannels[0].length / sampleRate
+	};
+}
 const GLOBAL_WEBGPU_REGISTRY_KEY = Symbol.for("gatewai.webgpuRegistry");
 const GLOBAL_ANALYSIS_STORE_KEY = Symbol.for("gatewai.videoAnalysisStore");
 var NodeSurfaceProvider = class {
@@ -41214,5 +41574,5 @@ var NodeSurfaceProvider = class {
 if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThis.__GATEWAI_DELAYS__ || /* @__PURE__ */ new Set();
 
 //#endregion
-export { probeVideoSize as $, TextCursorStyleSchema as $t, emojiGraphemes as A, evaluateVolumetricFormation as An, ChromaticGlitchConfigSchema as At, jointMatrices as B, waveToCubicBeziers as Bn, LongShadowConfigSchema as Bt, drawGifNode as C, evaluateCubicBezierDerivative as Cn, AdvancedTextAnimatorBuilder as Ct, drawSignalNode as D, evaluateSkewMatrix as Dn, AnimatableGlyphPropsSchema as Dt, drawParagraphNode as E, evaluateSelectorCombination as En, AnchorPresetSchema as Et, getPrimitiveGeometry as F, parseSvgPathToCubicBeziers as Fn, ExtendedGlyphPropertiesSchema as Ft, measureMaxCaptionHeight as G, SelectorUnitsSchema as Gt, loadModel3D as H, SelectorBasedOnSchema as Ht, getRegisteredFontSource as I, sampleAudioSpectrumScale as In, GlyphAnchorGroupingSchema as It, parseFBX as J, Spatial3DPropertiesSchema as Jt, mediaDecoderCache as K, SignalRegistry as Kt, getRenderer2D as L, sampleCurveGeometry as Ln, GlyphAnchorPointSchema as Lt, fitSpansToText as M, generatePathSegments as Mn, DynamicStrokePropertiesSchema as Mt, generateExtrudedTextGeometry as N, getScramblePool as Nn, EnhancedTextNodeSchema as Nt, drawSvgNode as O, evaluateSpringProgress as On, AudioSignalComputePipeline as Ot, getHeadlessFontPath as P, getShuffledOrder as Pn, ExpressionSelectorSchema as Pt, poseNodes as Q, TextCursorConfigSchema as Qt, initHeadlessWebGPU as R, samplePathChainGeometry as Rn, KineticMarqueeConfigSchema as Rt, drawCaptionNode as S, evaluateCubicBezier as Sn, AETextAnimatorSchema as St, drawLottieNode as T, evaluateMarqueeOffset as Tn, AnchorGroupingSchema as Tt, loadOBJ as U, SelectorModeSchema as Ut, loadFBX as V, ParticleDissolveConfigSchema as Vt, lutStore as W, SelectorShapeSchema as Wt, parseOBJ as X, TextAnchorConfigSchema as Xt, parseMTL as Y, SpringPhysicsSchema as Yt, parseSvgPathToSegments as Z, TextAnimatorBuilder as Zt, buildShapeSvgPath as _, computeLineLeadingDisplacement as _n, Path3D as _t, GlassPipeline as a, TextSelectorSchema as an, spansText as at, colorMatrixWgsl as b, distanceToCurveParameter as bn, parseColorToRgb as bt, Renderer2D as c, TypewriterAnimatorSchema as cn, transformScale as ct, ScreenSpaceRelightPipeline as d, Vec2Schema as dn, Camera3D as dt, TextPathBuilder as en, registerHeadlessFont as et, ShadowPipeline as f, VolumetricFormationConfigSchema as fn, ENVIRONMENT_PRESETS as ft, WebGPUAudioProcessor as g, computeAnchorPivotOffset as gn, Matrix4Math as gt, SlugPipeline as h, buildWGSLSignalFn as hn, MAX_LIGHTS as ht, EffectPipeline as i, TextScrambleConfigSchema as in, shaderStore as it, ensureDevice as j, generateArcLengthLUT as jn, CubicBezierSegmentSchema as jt, drawVideoNode as k, evaluateTypewriterState as kn, AudioSpectrumTypographySchema as kt, Renderer3D as l, TypingCadenceSchema as ln, GetFontAssetUrl as lt, SlugGeometry as m, buildPathLUT as mn, Light3D as mt, AudioLatentTrackCache as n, TextPathSourceSchema as nn, sampleMorphWeights as nt, MotionBlurPipeline as o, TextSignalSelectorSchema as on, srtLoader as ot, SlugFontCache as p, VolumetricFormationModeSchema as pn, LIGHT_UNIFORM_SIZE_BYTES as pt, parseColor as q, SkewPropertiesSchema as qt, AudioMeshDeformPipeline as r, TextRangeSelectorSchema as rn, setRegisteredFontSource as rt, NodeSurfaceProvider as s, TextWigglySelectorSchema as sn, textureCache as st, AudioLatentEngine as t, TextPathOptionsSchema as tn, resolveTextSpans as tt, SSAOPipeline as u, VariableFontAxesSchema as un, resolveMediaSourceUrl as ut, clearAllVideoCache as v, computeRangeSelectorWeight as vn, Vector3Math as vt, drawImageNode as w, evaluateExpressionSelector as wn, AdvancedTextAnimatorSchema as wt, describeGpu as x, ellipseToCubicBeziers as xn, resolveEnvironment as xt, clearHeadlessFonts as y, deterministicWigglyNoise as yn, linearRgb as yt, inputStore as z, signalRegistry as zn, LineSpacingDynamicsSchema as zt };
-//# sourceMappingURL=dist-C4Vxgm0Q.mjs.map
+export { probeVideoSize as $, TextCursorConfigSchema as $t, emojiGraphemes as A, evaluateTypewriterState as An, AudioSpectrumTypographySchema as At, jointMatrices as B, signalRegistry as Bn, LineSpacingDynamicsSchema as Bt, drawGifNode as C, evaluateCubicBezier as Cn, AETextAnimatorSchema as Ct, drawSignalNode as D, evaluateSelectorCombination as Dn, AnchorPresetSchema as Dt, drawParagraphNode as E, evaluateMarqueeOffset as En, AnchorGroupingSchema as Et, getPrimitiveGeometry as F, getShuffledOrder as Fn, ExpressionSelectorSchema as Ft, measureMaxCaptionHeight as G, SelectorShapeSchema as Gt, loadModel3D as H, ParticleDissolveConfigSchema as Ht, getRegisteredFontSource as I, parseSvgPathToCubicBeziers as In, ExtendedGlyphPropertiesSchema as It, parseFBX as J, SkewPropertiesSchema as Jt, mediaDecoderCache as K, SelectorUnitsSchema as Kt, getRenderer2D as L, sampleAudioSpectrumScale as Ln, GlyphAnchorGroupingSchema as Lt, fitSpansToText as M, generateArcLengthLUT as Mn, CubicBezierSegmentSchema as Mt, generateExtrudedTextGeometry as N, generatePathSegments as Nn, DynamicStrokePropertiesSchema as Nt, drawSvgNode as O, evaluateSkewMatrix as On, AnimatableGlyphPropsSchema as Ot, getHeadlessFontPath as P, getScramblePool as Pn, EnhancedTextNodeSchema as Pt, poseNodes as Q, TextAnimatorBuilder as Qt, initHeadlessWebGPU as R, sampleCurveGeometry as Rn, GlyphAnchorPointSchema as Rt, drawCaptionNode as S, ellipseToCubicBeziers as Sn, resolveEnvironment as St, drawLottieNode as T, evaluateExpressionSelector as Tn, AdvancedTextAnimatorSchema as Tt, loadOBJ as U, SelectorBasedOnSchema as Ut, loadFBX as V, waveToCubicBeziers as Vn, LongShadowConfigSchema as Vt, lutStore as W, SelectorModeSchema as Wt, parseOBJ as X, SpringPhysicsSchema as Xt, parseMTL as Y, Spatial3DPropertiesSchema as Yt, parseSvgPathToSegments as Z, TextAnchorConfigSchema as Zt, buildShapeSvgPath as _, computeAnchorPivotOffset as _n, Matrix4Math as _t, GlassPipeline as a, TextScrambleConfigSchema as an, spansText as at, colorMatrixWgsl as b, deterministicWigglyNoise as bn, linearRgb as bt, Renderer2D as c, TextWigglySelectorSchema as cn, trackAudioPitch as ct, ScreenSpaceRelightPipeline as d, VariableFontAxesSchema as dn, resolveMediaSourceUrl as dt, TextCursorStyleSchema as en, registerHeadlessFont as et, ShadowPipeline as f, Vec2Schema as fn, Camera3D as ft, WebGPUAudioProcessor as g, buildWGSLSignalFn as gn, MAX_LIGHTS as gt, SlugPipeline as h, buildPathLUT as hn, Light3D as ht, EffectPipeline as i, TextRangeSelectorSchema as in, shaderStore as it, ensureDevice as j, evaluateVolumetricFormation as jn, ChromaticGlitchConfigSchema as jt, drawVideoNode as k, evaluateSpringProgress as kn, AudioSignalComputePipeline as kt, Renderer3D as l, TypewriterAnimatorSchema as ln, transformScale as lt, SlugGeometry as m, VolumetricFormationModeSchema as mn, LIGHT_UNIFORM_SIZE_BYTES as mt, AudioLatentTrackCache as n, TextPathOptionsSchema as nn, sampleMorphWeights as nt, MotionBlurPipeline as o, TextSelectorSchema as on, srtLoader as ot, SlugFontCache as p, VolumetricFormationConfigSchema as pn, ENVIRONMENT_PRESETS as pt, parseColor as q, SignalRegistry as qt, AudioMeshDeformPipeline as r, TextPathSourceSchema as rn, setRegisteredFontSource as rt, NodeSurfaceProvider as s, TextSignalSelectorSchema as sn, textureCache as st, AudioLatentEngine as t, TextPathBuilder as tn, resolveTextSpans as tt, SSAOPipeline as u, TypingCadenceSchema as un, GetFontAssetUrl as ut, clearAllVideoCache as v, computeLineLeadingDisplacement as vn, Path3D as vt, drawImageNode as w, evaluateCubicBezierDerivative as wn, AdvancedTextAnimatorBuilder as wt, describeGpu as x, distanceToCurveParameter as xn, parseColorToRgb as xt, clearHeadlessFonts as y, computeRangeSelectorWeight as yn, Vector3Math as yt, inputStore as z, samplePathChainGeometry as zn, KineticMarqueeConfigSchema as zt };
+//# sourceMappingURL=dist-B-OPY7Cs.mjs.map