framefields 2.10.0-canary.0 → 2.11.0

package/dist/{dist-C4Vxgm0Q.mjs → dist-CWLLnigL.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,
@@ -16642,10 +16643,6 @@ async function acquireDevice(opts) {
 	if (adapter.limits && Number.isInteger(adapter.limits.maxTextureDimension2D)) requiredLimits.maxTextureDimension2D = Math.min(8192, adapter.limits.maxTextureDimension2D);
 	if (adapter.limits && Number.isInteger(adapter.limits.maxStorageBuffersPerShaderStage)) requiredLimits.maxStorageBuffersPerShaderStage = Math.min(16, adapter.limits.maxStorageBuffersPerShaderStage);
 	if (adapter.limits && Number.isInteger(adapter.limits.maxStorageBuffersPerPipelineLayout)) requiredLimits.maxStorageBuffersPerPipelineLayout = Math.min(16, adapter.limits.maxStorageBuffersPerPipelineLayout);
-	for (const limit of ["maxStorageBufferBindingSize", "maxBufferSize"]) {
-		const max = adapter.limits?.[limit];
-		if (Number.isFinite(max)) requiredLimits[limit] = max;
-	}
 	return adapter.requestDevice({
 		requiredFeatures,
 		requiredLimits
@@ -26447,9 +26444,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 +26466,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) {
@@ -26514,50 +26511,6 @@ async function drawSignalNode(ctx, encoder, pass, props) {
 	pass.setBindGroup(1, bindGroup1);
 	pass.draw(4);
 }
-/**
-* Target pixels per local unit along the axis `m` stretches most: what a
-* raster drawn under `m` needs per unit to stay sharp, and what one target
-* pixel is in local units (its inverse).
-*/
-function transformScale(m) {
-	return Math.max(Math.hypot(m.a, m.b), Math.hypot(m.c, m.d));
-}
-var TransformStack = class {
-	stack = [new DOMMatrix()];
-	push(matrix) {
-		const next = this.stack[this.stack.length - 1].multiply(matrix);
-		this.stack.push(next);
-	}
-	pop() {
-		if (this.stack.length > 1) this.stack.pop();
-	}
-	getCurrent() {
-		return this.stack[this.stack.length - 1];
-	}
-	packIntoBuffer(bufferData, opacity, surfaceWidth, surfaceHeight, localOverride, customParam) {
-		let m = this.getCurrent();
-		if (localOverride) m = m.multiply(localOverride);
-		bufferData[0] = m.a;
-		bufferData[1] = m.b;
-		bufferData[2] = 0;
-		bufferData[3] = 0;
-		bufferData[4] = m.c;
-		bufferData[5] = m.d;
-		bufferData[6] = 0;
-		bufferData[7] = 0;
-		bufferData[8] = m.e;
-		bufferData[9] = m.f;
-		bufferData[10] = 1;
-		bufferData[11] = 0;
-		bufferData[12] = opacity;
-		bufferData[13] = surfaceWidth;
-		bufferData[14] = surfaceHeight;
-		bufferData[15] = customParam ?? 0;
-	}
-	destroy() {
-		this.stack = [new DOMMatrix()];
-	}
-};
 var SvgLoader = class {
 	cache = /* @__PURE__ */ new Map();
 	async load(src, width, height, isHeadless) {
@@ -26630,10 +26583,8 @@ var SvgLoader = class {
 };
 const svgLoader = new SvgLoader();
 async function drawSvgNode(ctx, pass, props) {
-	const m = ctx.renderer.getCurrentTransform();
-	const k = transformScale(props.matrix ? m.multiply(props.matrix) : m);
-	const resolvedWidth = Math.max(1, Math.ceil(props.dstRect.width * k));
-	const resolvedHeight = Math.max(1, Math.ceil(props.dstRect.height * k));
+	const resolvedWidth = Math.max(1, Math.ceil(props.dstRect.width));
+	const resolvedHeight = Math.max(1, Math.ceil(props.dstRect.height));
 	const cacheKey = `${props.src}-${resolvedWidth}-${resolvedHeight}`;
 	let tex = textureCache.acquire(cacheKey);
 	if (!tex) try {
@@ -27438,8 +27389,6 @@ fn sampleSlugCoverage(sampleUV: vec2<f32>, g: SlugGlyph, pixelsPerEm: vec2<f32>)
 // pixel footprint in glyph uv, |d/dx| + |d/dy| (fwidth): the caller takes it in
 // uniform control flow. On a turned or foreshortened glyph it is wider than one
 // pixel along an axis, so that axis gets the soft ramp a box filter gives.
-// A blur of blurAmount px averages coverage over a grid reaching 0.3 of it
-// each way, blurTaps taps per side past the centre.
 fn shadeSlugGlyph(
 	uv: vec2<f32>,
 	fw: vec2<f32>,
@@ -27448,7 +27397,6 @@ fn shadeSlugGlyph(
 	color: vec4<f32>,
 	opacity: f32,
 	blurAmount: f32,
-	blurTaps: f32,
 	chromaticShift: f32,
 	dissolveProgress: f32,
 ) -> vec4<f32> {
@@ -27481,15 +27429,14 @@ fn shadeSlugGlyph(
 
 	var slugAlpha = 0.0;
 	if (blurAmount > 0.01) {
-		let step = fw * blurAmount * 0.3 / blurTaps;
-		for (var y_offset = -blurTaps; y_offset <= blurTaps; y_offset = y_offset + 1.0) {
-			for (var x_offset = -blurTaps; x_offset <= blurTaps; x_offset = x_offset + 1.0) {
+		let step = fw * blurAmount * 0.3;
+		for (var y_offset = -1.0; y_offset <= 1.0; y_offset = y_offset + 1.0) {
+			for (var x_offset = -1.0; x_offset <= 1.0; x_offset = x_offset + 1.0) {
 				let offset = vec2<f32>(x_offset, y_offset) * step;
 				slugAlpha = slugAlpha + sampleSlugCoverage(uv + offset, g, pixelsPerEm);
 			}
 		}
-		let side = 2.0 * blurTaps + 1.0;
-		slugAlpha = slugAlpha / (side * side);
+		slugAlpha = slugAlpha / 9.0;
 	} else {
 		slugAlpha = sampleSlugCoverage(uv, g, pixelsPerEm);
 	}
@@ -27525,7 +27472,6 @@ struct VSOut {
 	@location(7) @interpolate(flat) chromaticShift : f32,
 	@location(8) @interpolate(flat) dissolveProgress : f32,
 	@location(9) @interpolate(flat) vfxParam : f32,
-	@location(10) @interpolate(flat) blurTaps : f32,
 };
 
 var<private> pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
@@ -27559,11 +27505,7 @@ var<private> pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
 	let transform2 = mat2x2<f32>(u.transformCol0.xy, u.transformCol1.xy);
 	let pixelsPerUnit = sqrt(max(abs(determinant(transform2)), 1e-8));
 	let halfSize = max(abs(aScaleBias.xy * scale_mult), vec2<f32>(1e-4));
-	// A blurred glyph keeps a unit around it however many pixels a unit
-	// spans: its blur spills that far at one pixel per unit.
-	let blurred = aExtraParams.x > 0.01;
-	let dilation = select(1.0, max(1.0, pixelsPerUnit), blurred) / pixelsPerUnit;
-	let grow = vec2<f32>(1.0) + dilation / halfSize;
+	let grow = vec2<f32>(1.0) + (1.0 / pixelsPerUnit) / halfSize;
 	let uv = vec2<f32>(
 		quad_pos.x * grow.x * 0.5 + 0.5,
 		1.0 - (quad_pos.y * grow.y * 0.5 + 0.5),
@@ -27597,11 +27539,7 @@ var<private> pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
 	out.bandMax = vec2<u32>(aBandMaxTexCoords.xy);
 	out.bandsTexCoords = vec2<u32>(aBandMaxTexCoords.zw);
 	out.color = aColor;
-	// Blur is in local units, like every other length here; the fragment
-	// stage spreads its taps in pixels, as far apart as at one pixel per
-	// unit (more of them as a unit spans more pixels, up to 4).
-	out.blurAmount = aExtraParams.x * pixelsPerUnit;
-	out.blurTaps = clamp(ceil(pixelsPerUnit - 1e-3), 1.0, 4.0);
+	out.blurAmount = aExtraParams.x;
 	out.chromaticShift = aExtraParams.y;
 	out.dissolveProgress = aExtraParams.z;
 	out.vfxParam = aExtraParams.w;
@@ -27620,7 +27558,6 @@ var<private> pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
 		in.color,
 		u.params.x,
 		in.blurAmount,
-		in.blurTaps,
 		in.chromaticShift,
 		in.dissolveProgress,
 	);
@@ -29673,6 +29610,42 @@ var SolidPipeline = class {
 		this.uniformBindGroupCache.destroy();
 	}
 };
+var TransformStack = class {
+	stack = [new DOMMatrix()];
+	push(matrix) {
+		const next = this.stack[this.stack.length - 1].multiply(matrix);
+		this.stack.push(next);
+	}
+	pop() {
+		if (this.stack.length > 1) this.stack.pop();
+	}
+	getCurrent() {
+		return this.stack[this.stack.length - 1];
+	}
+	packIntoBuffer(bufferData, opacity, surfaceWidth, surfaceHeight, localOverride, customParam) {
+		let m = this.getCurrent();
+		if (localOverride) m = m.multiply(localOverride);
+		bufferData[0] = m.a;
+		bufferData[1] = m.b;
+		bufferData[2] = 0;
+		bufferData[3] = 0;
+		bufferData[4] = m.c;
+		bufferData[5] = m.d;
+		bufferData[6] = 0;
+		bufferData[7] = 0;
+		bufferData[8] = m.e;
+		bufferData[9] = m.f;
+		bufferData[10] = 1;
+		bufferData[11] = 0;
+		bufferData[12] = opacity;
+		bufferData[13] = surfaceWidth;
+		bufferData[14] = surfaceHeight;
+		bufferData[15] = customParam ?? 0;
+	}
+	destroy() {
+		this.stack = [new DOMMatrix()];
+	}
+};
 function premultiplyClearColor(color) {
 	if (Array.isArray(color)) {
 		const a$1 = color[3] ?? 1;
@@ -29823,14 +29796,10 @@ var Renderer2D = class {
 				this.drawShapeFill(pass, tris, fill, bounds, opts);
 				if ((!stroke || !stroke.width || stroke.width <= 0) && (fill.type ?? "solid") === "solid" && fill.color) {
 					const svgPath = buildShapeSvgPath(config$1);
-					if (svgPath) {
-						const m = this.transformStack.getCurrent();
-						const hairline = 1 / transformScale(opts?.transform ? m.multiply(opts.transform) : m);
-						this.drawPath(pass, svgPath, fill.color, hairline, {
-							...opts,
-							strokeLineCap: "round"
-						});
-					}
+					if (svgPath) this.drawPath(pass, svgPath, fill.color, 1, {
+						...opts,
+						strokeLineCap: "round"
+					});
 				}
 			}
 		}
@@ -32879,9 +32848,6 @@ fn fs_mrt_bloom(in: VertexOutput, @builtin(front_facing) isFront: bool) -> MrtBl
 */
 const quad3dWgsl = `
 ${lighting3dWgsl}
-// Grid cells either side a relief's normals span.
-const RELIEF_NORMAL_CELLS : f32 = 4.0;
-
 struct ModelUniforms {
     modelMatrix    : mat4x4<f32>,
     normalMatrix   : mat4x4<f32>,
@@ -32892,15 +32858,11 @@ struct ModelUniforms {
     materialParams : vec4<f32>, // x = shininess, y = specularIntensity, z = ambientIntensity, w = materialMode (0=unlit, 1=lit)
     pbr            : vec4<f32>, // x = roughness (<0 = default), y = metallic
     emissive       : vec4<f32>, // rgb = sRGB emissive color, w = strength
-    relief         : vec4<f32>, // x = amount (px), y = on, w = grid cells per side
-    reliefRect     : vec4<f32>, // xy = where the layer's box starts in reliefTex (0..1), zw = its size
-    reliefEye      : vec4<f32>, // xyz = the eye the surface keeps its look from (the default camera)
 };
 
 @group(0) @binding(0) var<uniform> cam    : CameraUniforms;
 @group(1) @binding(0) var<uniform> model  : ModelUniforms;
-${matte3dWgsl(1, 1)}@group(1) @binding(2) var reliefTex : texture_2d<f32>;
-@group(2) @binding(0) var texSampler      : sampler;
+${matte3dWgsl(1, 1)}@group(2) @binding(0) var texSampler      : sampler;
 @group(2) @binding(1) var mainTex         : texture_2d<f32>;
 ${lightsBindingsWgsl}
 
@@ -32919,48 +32881,13 @@ struct VertexOutput {
     @location(4)       localPos    : vec2<f32>,
 };
 
-// Relief: the layer's plane pushed toward the eye by the brightness of a
-// second picture, so a flat quad becomes a surface (see DrawQuad3DOpts.relief).
-fn reliefAt(uv: vec2<f32>) -> f32 {
-    let dims = vec2<f32>(textureDimensions(reliefTex));
-    let p = (model.reliefRect.xy + clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0)) * model.reliefRect.zw) * dims - 0.5;
-    let i = floor(p);
-    let f = p - i;
-    // Texels of the layer's own box only: past its edge the relief was never drawn.
-    let lo = max(floor(model.reliefRect.xy * dims), vec2<f32>(0.0));
-    let hi = min(ceil((model.reliefRect.xy + model.reliefRect.zw) * dims) - 1.0, dims - 1.0);
-    let a = textureLoad(reliefTex, vec2<i32>(clamp(i, lo, hi)), 0).rgb;
-    let b = textureLoad(reliefTex, vec2<i32>(clamp(i + vec2<f32>(1.0, 0.0), lo, hi)), 0).rgb;
-    let c = textureLoad(reliefTex, vec2<i32>(clamp(i + vec2<f32>(0.0, 1.0), lo, hi)), 0).rgb;
-    let d = textureLoad(reliefTex, vec2<i32>(clamp(i + vec2<f32>(1.0, 1.0), lo, hi)), 0).rgb;
-    let rgb = mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
-    return dot(rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
-}
-
-// The plane's front: the side the default camera sees.
-fn reliefFront() -> vec3<f32> {
-    return normalize((model.normalMatrix * vec4<f32>(0.0, 0.0, -1.0, 0.0)).xyz);
-}
-
-// A point of the plane lifted by its relief along the ray to the eye, so from
-// the eye it lands on the same pixel as the flat picture.
-fn reliefPoint(local: vec2<f32>, uv: vec2<f32>) -> vec3<f32> {
-    let flat = (model.modelMatrix * vec4<f32>(local, 0.0, 1.0)).xyz;
-    let n = reliefFront();
-    let h = model.relief.x * reliefAt(uv);
-    let toEye = model.reliefEye.xyz - flat;
-    let along = dot(toEye, n);
-    return select(flat + n * h, flat + toEye * (h / along), along > 1.0);
-}
-
 @vertex
 fn vs_main(in: VertexInput) -> VertexOutput {
     var out: VertexOutput;
     
     let hasDimensions = model.dimensions.x > 0.0 && model.dimensions.y > 0.0;
-    let hasRelief = model.relief.y > 0.5;
     var pad = 0.0;
-    if (hasDimensions && !hasRelief) {
+    if (hasDimensions) {
         let viewPos = cam.viewMatrix * model.modelMatrix * vec4<f32>(0.0, 0.0, 0.0, 1.0);
         let viewDepth = max(abs(viewPos.z), 0.1);
         let projScale = max(cam.projMatrix[1][1], 0.001);
@@ -32970,28 +32897,12 @@ fn vs_main(in: VertexInput) -> VertexOutput {
     let scalePad = select(vec2<f32>(1.0), 1.0 + vec2<f32>(2.0 * pad) / model.dimensions.xy, hasDimensions);
     
     let paddedPos = vec3<f32>(in.position.xy * scalePad, in.position.z);
-    var worldPos4 = model.modelMatrix * vec4<f32>(paddedPos, 1.0);
+    let worldPos4 = model.modelMatrix * vec4<f32>(paddedPos, 1.0);
+    out.worldPos = worldPos4.xyz;
     
     // Normal transformed by 3x3 normal matrix
     let norm4 = model.normalMatrix * vec4<f32>(in.normal, 0.0);
     out.worldNormal = normalize(norm4.xyz);
-    if (hasRelief) {
-        let p = reliefPoint(in.position.xy, in.uv);
-        // Central differences a few cells wide: an 8-bit height map steps every
-        // level, and normals from adjacent cells would light those steps as rings.
-        let e = RELIEF_NORMAL_CELLS / max(model.relief.w, 1.0);
-        let dx = vec2<f32>(e, 0.0);
-        let dy = vec2<f32>(0.0, e);
-        let tx = reliefPoint(in.position.xy + dx, in.uv + dx) - reliefPoint(in.position.xy - dx, in.uv - dx);
-        let ty = reliefPoint(in.position.xy + dy, in.uv + dy) - reliefPoint(in.position.xy - dy, in.uv - dy);
-        var nrm = normalize(cross(tx, ty));
-        if (dot(nrm, reliefFront()) < 0.0) {
-            nrm = -nrm;
-        }
-        worldPos4 = vec4<f32>(p, 1.0);
-        out.worldNormal = nrm;
-    }
-    out.worldPos = worldPos4.xyz;
     
     out.clipPos = cam.viewProjMatrix * worldPos4;
     
@@ -33227,10 +33138,6 @@ function createLightsLayout(device, label = "Lights3DLayout") {
 		]
 	});
 }
-/** Grid cells per side of a relief surface. */
-const RELIEF_GRID = 512;
-/** Floats in the quad's model uniform: transform, colors, params, material, surface, then relief. */
-const MODEL_FLOATS = 52 + SURFACE_PARAMS_FLOATS + 12;
 /** [shininess, specularIntensity, ambientIntensity, materialMode] as the 3D shaders' lighting reads them. */
 function packMaterialParams(data) {
 	return [
@@ -33254,12 +33161,10 @@ var Quad3DPipeline = class {
 	modelPool;
 	vertexBuffer;
 	indexBuffer;
-	/** The relief grid, built on first use. */
-	reliefGrid;
-	modelData = new Float32Array(MODEL_FLOATS);
+	modelData = new Float32Array(52 + SURFACE_PARAMS_FLOATS);
 	constructor(device, format, depthFormat = "depth24plus", sampleCount = 1) {
 		this.device = device;
-		this.modelPool = new BufferPool(MODEL_FLOATS * 4, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
+		this.modelPool = new BufferPool((52 + SURFACE_PARAMS_FLOATS) * 4, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
 		const module$1 = device.createShaderModule({
 			label: "quad3d.wgsl",
 			code: quad3dWgsl
@@ -33274,19 +33179,11 @@ var Quad3DPipeline = class {
 		});
 		this.modelLayout = device.createBindGroupLayout({
 			label: "Quad3DModelLayout",
-			entries: [
-				{
-					binding: 0,
-					visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
-					buffer: { type: "uniform" }
-				},
-				matteLayoutEntry(1),
-				{
-					binding: 2,
-					visibility: GPUShaderStage.VERTEX,
-					texture: { sampleType: "float" }
-				}
-			]
+			entries: [{
+				binding: 0,
+				visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+				buffer: { type: "uniform" }
+			}, matteLayoutEntry(1)]
 		});
 		this.textureLayout = device.createBindGroupLayout({
 			label: "Quad3DTextureLayout",
@@ -33453,110 +33350,18 @@ var Quad3DPipeline = class {
 		this.modelData[47] = data.textureExtent?.[1] ?? 0;
 		this.modelData.set(packMaterialParams(data), 48);
 		packSurfaceParams(data, this.modelData, 52);
-		const relief = data.relief;
-		const r = 52 + SURFACE_PARAMS_FLOATS;
-		this.modelData.set(relief ? [
-			relief.amount,
-			1,
-			0,
-			RELIEF_GRID
-		] : [
-			0,
-			0,
-			0,
-			0
-		], r);
-		this.modelData.set(relief?.uvRect ?? [
-			0,
-			0,
-			1,
-			1
-		], r + 4);
-		this.modelData.set([...relief?.eye ?? [
-			0,
-			0,
-			0
-		], 0], r + 8);
 		const modelBuffer = this.modelPool.getBuffer(this.device, this.modelData);
 		return this.device.createBindGroup({
 			layout: this.modelLayout,
-			entries: [
-				{
-					binding: 0,
-					resource: { buffer: modelBuffer }
-				},
-				{
-					binding: 1,
-					resource: data.matte?.createView() ?? fullCoverageView(this.device)
-				},
-				{
-					binding: 2,
-					resource: data.relief?.texture.createView() ?? fullCoverageView(this.device)
-				}
-			]
+			entries: [{
+				binding: 0,
+				resource: { buffer: modelBuffer }
+			}, {
+				binding: 1,
+				resource: data.matte?.createView() ?? fullCoverageView(this.device)
+			}]
 		});
 	}
-	/** Binds the geometry for `data` and draws it: the quad, or the relief grid. */
-	drawGeometry(pass, data) {
-		if (!data.relief) {
-			pass.setVertexBuffer(0, this.vertexBuffer);
-			pass.setIndexBuffer(this.indexBuffer, "uint16");
-			pass.drawIndexed(6);
-			return;
-		}
-		this.reliefGrid ??= this.createReliefGrid();
-		pass.setVertexBuffer(0, this.reliefGrid.vertices);
-		pass.setIndexBuffer(this.reliefGrid.indices, "uint32");
-		pass.drawIndexed(this.reliefGrid.count);
-	}
-	/** A RELIEF_GRID² grid over the unit quad, laid out like the quad's vertices. */
-	createReliefGrid() {
-		const side = RELIEF_GRID + 1;
-		const vertices = new Float32Array(side * side * 8);
-		for (let j = 0; j < side; j++) for (let i = 0; i < side; i++) {
-			const u = i / RELIEF_GRID;
-			const v = j / RELIEF_GRID;
-			vertices.set([
-				u - .5,
-				v - .5,
-				0,
-				u,
-				v,
-				0,
-				0,
-				-1
-			], (j * side + i) * 8);
-		}
-		const indices = new Uint32Array(RELIEF_GRID * RELIEF_GRID * 6);
-		let k = 0;
-		for (let j = 0; j < RELIEF_GRID; j++) for (let i = 0; i < RELIEF_GRID; i++) {
-			const a = j * side + i;
-			indices.set([
-				a,
-				a + 1,
-				a + side + 1,
-				a,
-				a + side + 1,
-				a + side
-			], k);
-			k += 6;
-		}
-		const upload = (data, usage) => {
-			const buffer = this.device.createBuffer({
-				size: data.byteLength,
-				usage: usage | GPUBufferUsage.COPY_DST,
-				mappedAtCreation: true
-			});
-			new data.constructor(buffer.getMappedRange()).set(data);
-			buffer.unmap();
-			return buffer;
-		};
-		return {
-			vertices: upload(vertices, GPUBufferUsage.VERTEX),
-			indices: upload(indices, GPUBufferUsage.INDEX),
-			count: indices.length
-		};
-	}
 	textureBindGroup(texture, sampler) {
 		return this.device.createBindGroup({
 			layout: this.textureLayout,
@@ -33577,7 +33382,9 @@ var Quad3DPipeline = class {
 		pass.setBindGroup(1, modelBindGroup);
 		pass.setBindGroup(2, textureBindGroup);
 		pass.setBindGroup(3, lightsBindGroup);
-		this.drawGeometry(pass, data);
+		pass.setVertexBuffer(0, this.vertexBuffer);
+		pass.setIndexBuffer(this.indexBuffer, "uint16");
+		pass.drawIndexed(6);
 	}
 	/** Draws the quad into a shadow map (`lightCameraBindGroup` holds the light's view-projection). */
 	drawShadow(pass, lightCameraBindGroup, texture, sampler, data) {
@@ -33585,14 +33392,14 @@ var Quad3DPipeline = class {
 		pass.setBindGroup(0, lightCameraBindGroup);
 		pass.setBindGroup(1, this.packModel(data));
 		pass.setBindGroup(2, this.textureBindGroup(texture, sampler));
-		this.drawGeometry(pass, data);
+		pass.setVertexBuffer(0, this.vertexBuffer);
+		pass.setIndexBuffer(this.indexBuffer, "uint16");
+		pass.drawIndexed(6);
 	}
 	destroy() {
 		this.modelPool.destroy();
 		this.vertexBuffer.destroy();
 		this.indexBuffer.destroy();
-		this.reliefGrid?.vertices.destroy();
-		this.reliefGrid?.indices.destroy();
 	}
 };
 var Mesh3DPipeline = class {
@@ -38240,7 +38047,6 @@ fn shadeText(in : VSOut, fw : vec2<f32>) -> TextFragment {
 		in.color,
 		model.params.x,
 		in.fx.x,
-		1.0,
 		in.fx.y,
 		in.fx.z,
 	);
@@ -39828,8 +39634,7 @@ var Renderer3D = class {
 				height: c.opts.height,
 				textureExtent: c.opts.textureExtent,
 				opacity: c.opts.opacity,
-				colorTint: c.opts.colorTint,
-				relief: c.opts.relief
+				colorTint: c.opts.colorTint
 			});
 		}
 		pass.end();
@@ -40093,8 +39898,7 @@ var Renderer3D = class {
 			metallic,
 			emissive: opts.emissive,
 			emissiveIntensity: opts.emissiveIntensity,
-			matte: opts.matte,
-			relief: opts.relief
+			matte: opts.matte
 		}, useMrt, this.passWritesHdr);
 	}
 	/** T(pos) * Rz * Ry * Rx * S, or the draw's precomputed model matrix. */
@@ -41147,6 +40951,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 +41377,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 $, 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, trackAudioPitch 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-CWLLnigL.mjs.map