framefields 2.12.0 → 2.13.1

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

@@ -1,5 +1,5 @@
-import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-W71TSjRM.mjs";
-import { $t as limitGradientStops, Et as emojiPresentation, Ht as gradientStopsToOklab, Xt as isSignal, Zt as isValueSignal, dn as parseCssGradient, un as parseCssColor } from "./dist-Bf2_efYP.mjs";
+import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-DOL2i2sR.mjs";
+import { $t as limitGradientStops, Et as emojiPresentation, Ht as gradientStopsToOklab, Xt as isSignal, Zt as isValueSignal, dn as parseCssGradient, un as parseCssColor } from "./dist-C8XSqfTx.mjs";
 import { ALL_FORMATS, AudioBufferSink, CanvasSink, FilePathSource, Input, UrlSource, VideoSampleSink } from "mediabunny";
 import fs from "node:fs";
 import path from "node:path";
@@ -1537,15 +1537,15 @@ var SignalRegistry = class {
 		res.lastProcessedFrame = cacheFrame;
 		res.lastFingerprint = fingerprint;
 		if (isSamplesArray(rawSamples) && rawSamples.length > 0) {
-			const flat = new Float32Array(numSamples);
+			const flat$1 = new Float32Array(numSamples);
 			const total = rawSamples.length;
 			const srcFps = Number(normalizedSd?.fps) || 24;
 			for (let i = 0; i < numSamples; i++) {
 				const t = elapsedTime + i / sampleRate;
 				const sIdx = Math.min(total - 1, Math.max(0, Math.round(t * srcFps)));
-				flat[i] = Number(rawSamples[sIdx]) || 0;
+				flat$1[i] = Number(rawSamples[sIdx]) || 0;
 			}
-			device.queue.writeBuffer(res.buffer, 0, flat);
+			device.queue.writeBuffer(res.buffer, 0, flat$1);
 		} else if (normalizedSd?.type === "generator" && (normalizedSd.customWGSL || normalizedSd.fnBody)) {
 			const signalEncoder = device.createCommandEncoder({ label: `signal_1d_encoder_${nodeId}` });
 			this.dispatch1DGenerator(device, signalEncoder, res, elapsedTime, duration$2, normalizedSd, numSamples, sampleRate, frame, fps);
@@ -1560,8 +1560,8 @@ var SignalRegistry = class {
 				device.queue.submit([signalEncoder.finish()]);
 			} else {
 				const val = Number(normalizedSd?.offset ?? 0);
-				const flat = new Float32Array(numSamples).fill(val);
-				device.queue.writeBuffer(res.buffer, 0, flat);
+				const flat$1 = new Float32Array(numSamples).fill(val);
+				device.queue.writeBuffer(res.buffer, 0, flat$1);
 			}
 		} else if (normalizedSd?.type === "signal_math") {
 			const sigAId = normalizedSd.signalA?.nodeId ?? `${nodeId}_a`;
@@ -1582,8 +1582,8 @@ var SignalRegistry = class {
 			device.queue.submit([signalEncoder.finish()]);
 		} else {
 			const val = Number(normalizedSd?.offset ?? 0);
-			const flat = new Float32Array(numSamples).fill(val);
-			device.queue.writeBuffer(res.buffer, 0, flat);
+			const flat$1 = new Float32Array(numSamples).fill(val);
+			device.queue.writeBuffer(res.buffer, 0, flat$1);
 		}
 		return res.buffer;
 	}
@@ -1649,7 +1649,7 @@ var SignalRegistry = class {
 			device.queue.submit([signalEncoder.finish()]);
 			return res.textureView;
 		} else if (isSamplesArray(rawSamples) && rawSamples.length > 0) {
-			const flat = new Float32Array(targetWidth * targetHeight * 4);
+			const flat$1 = new Float32Array(targetWidth * targetHeight * 4);
 			const total = rawSamples.length;
 			const baseTime = frame !== void 0 && fps !== void 0 && fps > 0 ? frame / fps : elapsedTime;
 			for (let i = 0; i < targetWidth; i++) {
@@ -1659,13 +1659,13 @@ var SignalRegistry = class {
 				const val = Number(rawSamples[sIdx]) || 0;
 				for (let row = 0; row < targetHeight; row++) {
 					const idx = (row * targetWidth + i) * 4;
-					flat[idx] = val;
-					flat[idx + 1] = val;
-					flat[idx + 2] = val;
-					flat[idx + 3] = val;
+					flat$1[idx] = val;
+					flat$1[idx + 1] = val;
+					flat$1[idx + 2] = val;
+					flat$1[idx + 3] = val;
 				}
 			}
-			const halfFlat = encodeFloat32ToFloat16(flat);
+			const halfFlat = encodeFloat32ToFloat16(flat$1);
 			device.queue.writeTexture({ texture: res.texture }, halfFlat, {
 				bytesPerRow: targetWidth * 8,
 				rowsPerImage: targetHeight
@@ -1691,14 +1691,14 @@ var SignalRegistry = class {
 			device.queue.submit([signalEncoder.finish()]);
 		} else {
 			const val = Number(normalizedSd?.offset ?? 0);
-			const flat = new Float32Array(targetWidth * targetHeight * 4);
+			const flat$1 = new Float32Array(targetWidth * targetHeight * 4);
 			for (let i = 0; i < targetWidth * targetHeight; i++) {
-				flat[i * 4] = val;
-				flat[i * 4 + 1] = val;
-				flat[i * 4 + 2] = val;
-				flat[i * 4 + 3] = 1;
+				flat$1[i * 4] = val;
+				flat$1[i * 4 + 1] = val;
+				flat$1[i * 4 + 2] = val;
+				flat$1[i * 4 + 3] = 1;
 			}
-			const halfFlat = encodeFloat32ToFloat16(flat);
+			const halfFlat = encodeFloat32ToFloat16(flat$1);
 			device.queue.writeTexture({ texture: res.texture }, halfFlat, {
 				bytesPerRow: targetWidth * 8,
 				rowsPerImage: targetHeight
@@ -16210,6 +16210,20 @@ var WebGPUAudioProcessor = class WebGPUAudioProcessor$1 {
 		const cacheKey = `${renderId ?? "global"}_${nodeId}_${activeSignalsKey}_${stateFloatCount}`;
 		return WebGPUAudioProcessor$1.devicePipelineCache.get(device)?.get(cacheKey);
 	}
+	/**
+	* Zeroes the state every effect keeps for `renderId` (delay lines,
+	* envelopes, reverb tails), as on its first use. Pipelines and buffers
+	* stay, so a mix that starts again doesn't compile them again.
+	*/
+	static resetState(renderId, device) {
+		const cache = WebGPUAudioProcessor$1.devicePipelineCache.get(device);
+		if (!cache) return;
+		const prefix = `${renderId}_`;
+		for (const [key, cached$1] of cache.entries()) {
+			if (!key.startsWith(prefix)) continue;
+			device.queue.writeBuffer(cached$1.stateBuffer, 0, new Float32Array(cached$1.stateBuffer.size / 4));
+		}
+	}
 	static clearCache(renderId, device) {
 		if (!device) return;
 		const cache = WebGPUAudioProcessor$1.devicePipelineCache.get(device);
@@ -17106,10 +17120,13 @@ async function toLocalPath(src) {
 );
 	return resolve$1$1(src);
 }
-/** In the browser, local paths are served through the dev server's `/@fs`. */
+/**
+* In the browser (a page or a worker), local paths are served through the
+* dev server's `/@fs`.
+*/
 function resolveInputUrl(url, isNode) {
 	let resolvedUrl = url;
-	if (!isNode && typeof window !== "undefined") {
+	if (!isNode && typeof location !== "undefined") {
 		if (resolvedUrl.startsWith("file://")) resolvedUrl = resolvedUrl.slice(7);
 		if (resolvedUrl.startsWith("/") && !resolvedUrl.startsWith("/@fs/") && !resolvedUrl.startsWith("/api/")) resolvedUrl = "/@fs" + resolvedUrl;
 	}
@@ -17138,6 +17155,15 @@ async function assertReadableFile(filePath, url) {
 }
 var InputStore = class {
 	store = /* @__PURE__ */ new Map();
+	resolveMissing;
+	/**
+	* Reads local files that are missing from disk from the URL `resolver`
+	* gives, with HTTP range requests, so a clip pinned on a bucket plays
+	* without being downloaded. Unset with no argument.
+	*/
+	setMissingMediaResolver(resolver) {
+		this.resolveMissing = resolver;
+	}
 	async acquire(url) {
 		if (!url) throw new Error("Cannot acquire Input for empty URL");
 		const resolvedUrl = resolveInputUrl(url, isNodeRuntime());
@@ -17146,10 +17172,8 @@ var InputStore = class {
 			const promise = (async () => {
 				const filePath = await toLocalPath(resolvedUrl.startsWith("file:") ? resolvedUrl : safeDecode(resolvedUrl));
 				let source;
-				if (filePath !== null) {
-					await assertReadableFile(filePath, url);
-					source = new FilePathSource(filePath);
-				} else source = new UrlSource(resolvedUrl);
+				if (filePath !== null) source = await this.localSource(filePath, url);
+				else source = new UrlSource(resolvedUrl);
 				return new Input({
 					source,
 					formats: ALL_FORMATS
@@ -17180,6 +17204,16 @@ var InputStore = class {
 			} catch (_) {}
 		}, () => {});
 	}
+	async localSource(filePath, url) {
+		try {
+			await assertReadableFile(filePath, url);
+			return new FilePathSource(filePath);
+		} catch (err) {
+			const remote = await this.resolveMissing?.(filePath);
+			if (remote) return new UrlSource(remote);
+			throw err;
+		}
+	}
 	release(url) {
 		if (!url) return;
 		const resolvedUrl = resolveInputUrl(url, isNodeRuntime());
@@ -27956,6 +27990,118 @@ var ClipStack = class {
 	}
 };
 /**
+* Filling compound paths: every subpath is a contour, contours nest, and a
+* region is filled by SVG's nonzero rule (the windings of the contours
+* around it, summed, are not zero). Each filled contour is triangulated with
+* its direct children as holes, so a map's coastlines and islands, a
+* letter's counter or a ring fill as drawn instead of being bridged into
+* one polygon.
+*
+* Contours are taken not to cross each other (each pair is nested or
+* apart), which holds for maps, glyphs and icons; a contour that crosses
+* itself is still triangulated as well as earcut can.
+*/
+function signedArea(points) {
+	let area = 0;
+	for (let i = 0; i < points.length; i++) {
+		const a = points[i];
+		const b = points[(i + 1) % points.length];
+		area += a.x * b.y - b.x * a.y;
+	}
+	return area / 2;
+}
+function flat(points) {
+	const out = [];
+	for (const p of points) out.push(p.x, p.y);
+	return out;
+}
+function boxOf(points) {
+	const box = {
+		x0: Infinity,
+		y0: Infinity,
+		x1: -Infinity,
+		y1: -Infinity
+	};
+	for (const p of points) {
+		box.x0 = Math.min(box.x0, p.x);
+		box.y0 = Math.min(box.y0, p.y);
+		box.x1 = Math.max(box.x1, p.x);
+		box.y1 = Math.max(box.y1, p.y);
+	}
+	return box;
+}
+/** The centroid of the contour's largest triangle: inside it, away from its edges. */
+function insidePoint(points) {
+	const coords = flat(points);
+	const tris = earcut(coords);
+	const at = (k) => ({
+		x: coords[k * 2],
+		y: coords[k * 2 + 1]
+	});
+	let best = -1;
+	let inside = points[0];
+	for (let i = 0; i < tris.length; i += 3) {
+		const a = at(tris[i]);
+		const b = at(tris[i + 1]);
+		const c = at(tris[i + 2]);
+		const size = Math.abs((b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y));
+		if (size > best) {
+			best = size;
+			inside = {
+				x: (a.x + b.x + c.x) / 3,
+				y: (a.y + b.y + c.y) / 3
+			};
+		}
+	}
+	return inside;
+}
+function contains(points, p) {
+	let inside = false;
+	for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+		const a = points[i];
+		const b = points[j];
+		if (a.y > p.y !== b.y > p.y && p.x < (b.x - a.x) * (p.y - a.y) / (b.y - a.y) + a.x) inside = !inside;
+	}
+	return inside;
+}
+const encloses = (p, c) => p.box.x0 <= c.box.x0 && p.box.y0 <= c.box.y0 && p.box.x1 >= c.box.x1 && p.box.y1 >= c.box.y1 && contains(p.points, c.inside);
+/** Triangles filling closed `contours` by the nonzero rule, as flat [x, y, …] vertices. */
+function fillContours(contours) {
+	const all = contours.map((points) => ({
+		points,
+		area: signedArea(points),
+		box: boxOf(points),
+		inside: insidePoint(points),
+		parent: -1,
+		winding: 0
+	}));
+	const order = all.map((_, i) => i).sort((a, b) => Math.abs(all[b].area) - Math.abs(all[a].area));
+	order.forEach((ci, rank) => {
+		const c = all[ci];
+		for (let r = rank - 1; r >= 0; r--) {
+			const pi = order[r];
+			if (encloses(all[pi], c)) {
+				c.parent = pi;
+				break;
+			}
+		}
+		c.winding = (c.parent >= 0 ? all[c.parent].winding : 0) + Math.sign(c.area);
+	});
+	const out = [];
+	all.forEach((c, ci) => {
+		if (c.winding === 0) return;
+		const coords = flat(c.points);
+		const holeStarts = [];
+		for (const h of all) {
+			if (h.parent !== ci) continue;
+			holeStarts.push(coords.length / 2);
+			for (const p of h.points) coords.push(p.x, p.y);
+		}
+		for (const k of earcut(coords, holeStarts)) out.push(coords[k * 2], coords[k * 2 + 1]);
+	});
+	return new Float32Array(out);
+}
+/**
 * Sample a cubic bezier curve into linear segments.
 */
 function sampleCubicBezier(p0, p1, p2, p3, steps = 24) {
@@ -28063,8 +28209,26 @@ function sampleSvgArc(p0, rxIn, ryIn, rotationDeg, largeArc, sweep, p1) {
 * Parse an SVG path string (M, L, H, V, C, S, Q, T, A, Z) into line segments.
 */
 function parseSvgPathToSegments(d) {
+	return parseSvgPath(d).segments;
+}
+/**
+* The path's segments, and for each the subpath it belongs to (every M
+* starts one): fills need to know where each subpath begins.
+*/
+function parseSvgPath(d) {
 	const segments = [];
-	if (!d || typeof d !== "string") return segments;
+	const subpaths = [];
+	if (!d || typeof d !== "string") return {
+		segments,
+		subpaths
+	};
+	let subpath = -1;
+	const emit = (...added) => {
+		for (const seg of added) {
+			segments.push(seg);
+			subpaths.push(subpath);
+		}
+	};
 	const tokens = [];
 	const regex = /([a-df-z])|([-+]?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?)/gi;
 	let match;
@@ -28110,9 +28274,10 @@ function parseSvgPathToSegments(d) {
 							x,
 							y
 						};
+						subpath++;
 						first = false;
 					} else {
-						segments.push({
+						emit({
 							p0: current,
 							p1: {
 								x,
@@ -28137,7 +28302,7 @@ function parseSvgPathToSegments(d) {
 						x += current.x;
 						y += current.y;
 					}
-					segments.push({
+					emit({
 						p0: current,
 						p1: {
 							x,
@@ -28160,7 +28325,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y: current.y
 					};
-					segments.push({
+					emit({
 						p0: current,
 						p1: next
 					});
@@ -28177,7 +28342,7 @@ function parseSvgPathToSegments(d) {
 						x: current.x,
 						y
 					};
-					segments.push({
+					emit({
 						p0: current,
 						p1: next
 					});
@@ -28214,7 +28379,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleCubicBezier(current, p1, p2, end));
+					emit(...sampleCubicBezier(current, p1, p2, end));
 					current = end;
 					lastCubicControl = p2;
 				}
@@ -28249,7 +28414,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleCubicBezier(current, p1, p2, end));
+					emit(...sampleCubicBezier(current, p1, p2, end));
 					current = end;
 					lastCubicControl = p2;
 				}
@@ -28275,7 +28440,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleQuadraticBezier(current, p1, end));
+					emit(...sampleQuadraticBezier(current, p1, end));
 					current = end;
 					lastQuadControl = p1;
 				}
@@ -28302,7 +28467,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleQuadraticBezier(current, p1, end));
+					emit(...sampleQuadraticBezier(current, p1, end));
 					current = end;
 					lastQuadControl = p1;
 				}
@@ -28325,14 +28490,14 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleSvgArc(current, rx, ry, rotation, largeArc, sweep, end));
+					emit(...sampleSvgArc(current, rx, ry, rotation, largeArc, sweep, end));
 					current = end;
 				}
 				lastCubicControl = null;
 				lastQuadControl = null;
 				break;
 			case "Z":
-				if (Math.hypot(current.x - subpathStart.x, current.y - subpathStart.y) > 1e-5) segments.push({
+				if (Math.hypot(current.x - subpathStart.x, current.y - subpathStart.y) > 1e-5) emit({
 					p0: current,
 					p1: subpathStart
 				});
@@ -28343,7 +28508,10 @@ function parseSvgPathToSegments(d) {
 			default: break;
 		}
 	}
-	return segments;
+	return {
+		segments,
+		subpaths
+	};
 }
 /**
 * Trim linear path segments using arc-length parameterization.
@@ -28404,6 +28572,19 @@ function trimPathSegments(segments, trimStart, trimEnd, trimOffset = 0) {
 	}
 }
 /**
+* A dash pattern as SVG's `stroke-dasharray` writes it ("16 12", "4,8") or as
+* numbers, ready for {@link dashPathSegments}. Following SVG, an odd list is
+* repeated to make it even, and a negative or unreadable entry, or a pattern
+* of zero length, means a solid stroke (`undefined`).
+*/
+function parseDashArray(value) {
+	if (value === void 0) return void 0;
+	const parts = typeof value === "string" ? value.trim().split(/[\s,]+/).filter(Boolean).map(Number) : [...value];
+	if (parts.length === 0 || parts.some((n) => !Number.isFinite(n) || n < 0)) return void 0;
+	if (parts.reduce((sum, n) => sum + n, 0) <= 0) return void 0;
+	return parts.length % 2 === 1 ? [...parts, ...parts] : parts;
+}
+/**
 * Apply dash patterns along linear path segments.
 */
 function dashPathSegments(segments, dashArray, dashOffset = 0) {
@@ -28615,6 +28796,44 @@ function triangulatePolygon(contour) {
 	if (rem.length === 3) triangles.push(rem[0], rem[1], rem[2]);
 	return triangles;
 }
+/** A path's subpaths as closed point lists, degenerate ones dropped. */
+function pathContours(d) {
+	const bySubpath = /* @__PURE__ */ new Map();
+	const { segments, subpaths } = parseSvgPath(d);
+	segments.forEach((seg, i) => {
+		const id = subpaths[i] ?? 0;
+		let points = bySubpath.get(id);
+		if (!points) {
+			points = [seg.p0];
+			bySubpath.set(id, points);
+		}
+		points.push(seg.p1);
+	});
+	const contours = [];
+	for (const points of bySubpath.values()) {
+		const first = points[0];
+		const last = points[points.length - 1];
+		if (Math.hypot(last.x - first.x, last.y - first.y) < 1e-5) points.pop();
+		if (points.length >= 3 && Math.abs(signedArea(points)) > 1e-6) contours.push(points);
+	}
+	return contours;
+}
+/** Path fills are redrawn every frame from the same data: keep the last few. */
+const PATH_FILL_CACHE = 64;
+const pathFills = /* @__PURE__ */ new Map();
+/** Triangles filling path `d` by the nonzero rule (see {@link fillContours}). */
+function cachedPathFill(d) {
+	const hit = pathFills.get(d);
+	if (hit) {
+		pathFills.delete(d);
+		pathFills.set(d, hit);
+		return hit;
+	}
+	const tris = fillContours(pathContours(d));
+	pathFills.set(d, tris);
+	if (pathFills.size > PATH_FILL_CACHE) pathFills.delete(pathFills.keys().next().value);
+	return tris;
+}
 /**
 * Triangulate a shape geometry into a flat Float32Array of 2D vertex pairs [x, y, x, y, ...].
 */
@@ -28739,19 +28958,16 @@ function triangulateShape(config$1) {
 			yBotHead
 		]);
 	}
-	if (shapeType === "path" && config$1.path) {
-		const segments = parseSvgPathToSegments(config$1.path);
-		if (segments.length === 0) return new Float32Array(0);
-		const tris = triangulatePolygon(segments.map((s) => s.p0));
-		const out = new Float32Array(tris.length * 2);
-		for (let i = 0; i < tris.length; i++) {
-			out[i * 2] = tris[i].x;
-			out[i * 2 + 1] = tris[i].y;
-		}
-		return out;
-	}
+	if (shapeType === "path" && config$1.path) return cachedPathFill(config$1.path);
 	return new Float32Array(0);
 }
+/**
+* Strokes a path in one instanced draw: each instance is one straight
+* segment (p0, p1), expanded by the vertex shader into a quad that covers it
+* plus half the stroke width and 2 px of antialiasing; the fragment shader
+* shades the segment's capped distance field. Everything shared by the
+* path (transform, colour, width, cap) is in the uniforms.
+*/
 const pathWgsl = `
 struct Uniforms {
     transformCol0 : vec4<f32>,
@@ -28760,8 +28976,6 @@ struct Uniforms {
     params        : vec4<f32>, // x = opacity, y = surfaceWidth, z = surfaceHeight, w = strokeWidth
     color         : vec4<f32>,
     style         : vec4<f32>, // x = capType (0 = round, 1 = butt, 2 = square)
-    p0            : vec2<f32>,
-    p1            : vec2<f32>,
 };
 
 @group(0) @binding(0) var<uniform> u : Uniforms;
@@ -28769,17 +28983,30 @@ struct Uniforms {
 struct VSOut {
     @builtin(position) pos : vec4<f32>,
     @location(0) localPos  : vec2<f32>,
+    @location(1) @interpolate(flat) p0 : vec2<f32>,
+    @location(2) @interpolate(flat) p1 : vec2<f32>,
 };
 
-@vertex fn vs(@location(0) xy : vec2<f32>) -> VSOut {
+@vertex fn vs(@builtin(vertex_index) corner : u32, @location(0) seg : vec4<f32>) -> VSOut {
+    let p0 = seg.xy;
+    let p1 = seg.zw;
+    let d = p1 - p0;
+    let len = max(length(d), 1e-6);
+    let padding = u.params.w * 0.5 + 2.0;
+    let along = (d / len) * padding;
+    let across = vec2<f32>(-along.y, along.x);
+    // Triangle strip: p0 −along ∓across, then p1 +along ∓across.
+    let atEnd = corner >= 2u;
+    let side = select(-1.0, 1.0, (corner & 1u) == 1u);
+    let xy = select(p0 - along, p1 + along, atEnd) + across * side;
+
     let transform = mat3x3<f32>(u.transformCol0.xyz, u.transformCol1.xyz, u.transformCol2.xyz);
     let p = transform * vec3<f32>(xy, 1.0);
-    
     let surfaceSize = u.params.yz;
     let clipX = (p.x / surfaceSize.x) * 2.0 - 1.0;
     let clipY = 1.0 - (p.y / surfaceSize.y) * 2.0;
 
-    return VSOut(vec4<f32>(clipX, clipY, 0.0, 1.0), xy);
+    return VSOut(vec4<f32>(clipX, clipY, 0.0, 1.0), xy, p0, p1);
 }
 
 fn sdSegmentWithCap(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>, radius: f32, capType: f32) -> f32 {
@@ -28791,10 +29018,10 @@ fn sdSegmentWithCap(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>, radius: f32, capTy
     let dir = ba / len;
     let normal = vec2<f32>(-dir.y, dir.x);
     let pa = p - a;
-    
+
     let proj = dot(pa, dir);
     let perp = abs(dot(pa, normal));
-    
+
     if (capType > 0.5 && capType < 1.5) {
         // Butt cap: terminates strictly at endpoints a and b
         let dx = max(-proj, proj - len);
@@ -28818,15 +29045,15 @@ fn sdSegmentWithCap(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>, radius: f32, capTy
 
 @fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
     let radius = u.params.w * 0.5;
-    let d = sdSegmentWithCap(in.localPos, u.p0, u.p1, radius, u.style.x);
-    
+    let d = sdSegmentWithCap(in.localPos, in.p0, in.p1, radius, u.style.x);
+
     let fw = max(fwidth(d), 1e-5);
     let edgeAlpha = clamp(0.5 - d / fw, 0.0, 1.0);
     let alpha = u.color.a * u.params.x * edgeAlpha;
     if (alpha <= 0.0) {
         discard;
     }
-    
+
     return vec4<f32>(u.color.rgb * alpha, alpha);
 }
 `;
@@ -28883,127 +29110,111 @@ function createVec2Pipeline(device, options) {
 		primitive: { topology: options.topology }
 	});
 }
+/** A straight segment's two ends, the instance the stroke shader expands into a quad. */
+const SEGMENT_FLOATS = 4;
 var PathPipeline = class {
 	device;
 	pipeline;
 	maxPipeline;
 	uniformLayout;
 	uniformPool;
-	vertexPool;
+	segmentPool;
 	uniformBindGroupCache = new UniformBindGroupCache();
-	scratchData = new Float32Array(28);
+	scratchData = new Float32Array(24);
 	constructor(device, format) {
 		this.device = device;
 		this.uniformPool = new BufferPool(4096, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
-		this.vertexPool = new BufferPool(4096, GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST);
+		this.segmentPool = new BufferPool(4096, GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST);
 		const module$1 = device.createShaderModule({
 			label: "path.wgsl",
 			code: pathWgsl
 		});
 		this.uniformLayout = createUniformLayout(device);
-		this.pipeline = createVec2Pipeline(device, {
-			label: "PathPipeline",
-			module: module$1,
-			uniformLayout: this.uniformLayout,
-			format,
-			topology: "triangle-strip"
+		const create = (label, blend) => device.createRenderPipeline({
+			label,
+			layout: device.createPipelineLayout({ bindGroupLayouts: [this.uniformLayout] }),
+			vertex: {
+				module: module$1,
+				entryPoint: "vs",
+				buffers: [{
+					arrayStride: SEGMENT_FLOATS * 4,
+					stepMode: "instance",
+					attributes: [{
+						shaderLocation: 0,
+						offset: 0,
+						format: "float32x4"
+					}]
+				}]
+			},
+			fragment: {
+				module: module$1,
+				entryPoint: "fs",
+				targets: [{
+					format,
+					blend
+				}]
+			},
+			primitive: { topology: "triangle-strip" }
 		});
-		this.maxPipeline = createVec2Pipeline(device, {
-			label: "PathPipeline.max",
-			module: module$1,
-			uniformLayout: this.uniformLayout,
-			format,
-			topology: "triangle-strip",
-			blend: {
-				color: {
-					srcFactor: "one",
-					dstFactor: "one",
-					operation: "max"
-				},
-				alpha: {
-					srcFactor: "one",
-					dstFactor: "one",
-					operation: "max"
-				}
+		this.pipeline = create("PathPipeline", PREMULTIPLIED_OVER);
+		this.maxPipeline = create("PathPipeline.max", {
+			color: {
+				srcFactor: "one",
+				dstFactor: "one",
+				operation: "max"
+			},
+			alpha: {
+				srcFactor: "one",
+				dstFactor: "one",
+				operation: "max"
 			}
 		});
 	}
 	resetPools() {
 		this.uniformPool.reset();
-		this.vertexPool.reset();
+		this.segmentPool.reset();
 	}
 	drawPath(pass, transformStack, pathStr, color, strokeWidth, surfaceWidth, surfaceHeight, opts) {
-		let segments = parseSvgPathToSegments(pathStr);
-		if (segments.length === 0) return;
-		if (opts?.trimStart !== void 0 || opts?.trimEnd !== void 0 || opts?.trimOffset !== void 0) segments = trimPathSegments(segments, opts.trimStart ?? 0, opts.trimEnd ?? 1, opts.trimOffset ?? 0);
-		if (opts?.strokeDashArray && opts.strokeDashArray.length > 0) segments = dashPathSegments(segments, opts.strokeDashArray, opts.strokeDashOffset ?? 0);
-		if (segments.length === 0) return;
-		const c = parseColor(color);
-		const opacity = opts?.opacity ?? 1;
-		let capType = 0;
-		if (opts?.strokeLineCap === "butt") capType = 1;
-		else if (opts?.strokeLineCap === "square") capType = 2;
-		for (const segment of segments) this.drawSegment(pass, transformStack, segment.p0, segment.p1, c, strokeWidth, capType, surfaceWidth, surfaceHeight, opacity, opts);
+		this.drawSegments(pass, transformStack, parseSvgPathToSegments(pathStr), color, strokeWidth, surfaceWidth, surfaceHeight, opts);
 	}
 	drawSegments(pass, transformStack, segments, color, strokeWidth, surfaceWidth, surfaceHeight, opts) {
 		let activeSegments = segments;
 		if (opts?.trimStart !== void 0 || opts?.trimEnd !== void 0 || opts?.trimOffset !== void 0) activeSegments = trimPathSegments(activeSegments, opts.trimStart ?? 0, opts.trimEnd ?? 1, opts.trimOffset ?? 0);
 		if (opts?.strokeDashArray && opts.strokeDashArray.length > 0) activeSegments = dashPathSegments(activeSegments, opts.strokeDashArray, opts.strokeDashOffset ?? 0);
-		if (activeSegments.length === 0) return;
+		const ends = new Float32Array(activeSegments.length * SEGMENT_FLOATS);
+		let count = 0;
+		for (const { p0, p1 } of activeSegments) {
+			if (Math.hypot(p1.x - p0.x, p1.y - p0.y) < 1e-6) continue;
+			const at = count++ * SEGMENT_FLOATS;
+			ends[at] = p0.x;
+			ends[at + 1] = p0.y;
+			ends[at + 2] = p1.x;
+			ends[at + 3] = p1.y;
+		}
+		if (count === 0) return;
 		const c = parseColor(color);
-		const opacity = opts?.opacity ?? 1;
-		let capType = 0;
-		if (opts?.strokeLineCap === "butt") capType = 1;
-		else if (opts?.strokeLineCap === "square") capType = 2;
-		for (const segment of activeSegments) this.drawSegment(pass, transformStack, segment.p0, segment.p1, c, strokeWidth, capType, surfaceWidth, surfaceHeight, opacity, opts);
-	}
-	drawSegment(pass, transformStack, p0, p1, color, strokeWidth, capType, surfaceWidth, surfaceHeight, opacity, opts) {
 		const data = this.scratchData;
-		transformStack.packIntoBuffer(data, opacity, surfaceWidth, surfaceHeight, opts?.transform);
+		transformStack.packIntoBuffer(data, opts?.opacity ?? 1, surfaceWidth, surfaceHeight, opts?.transform);
 		data[15] = strokeWidth;
-		data[16] = color.r;
-		data[17] = color.g;
-		data[18] = color.b;
-		data[19] = color.a;
-		data[20] = capType;
+		data[16] = c.r;
+		data[17] = c.g;
+		data[18] = c.b;
+		data[19] = c.a;
+		data[20] = opts?.strokeLineCap === "butt" ? 1 : opts?.strokeLineCap === "square" ? 2 : 0;
 		data[21] = 0;
 		data[22] = 0;
 		data[23] = 0;
-		data[24] = p0.x;
-		data[25] = p0.y;
-		data[26] = p1.x;
-		data[27] = p1.y;
 		const uniformBuffer = this.uniformPool.getBuffer(this.device, data);
-		const dx = p1.x - p0.x;
-		const dy = p1.y - p0.y;
-		const len = Math.sqrt(dx * dx + dy * dy);
-		if (len < 1e-6) return;
-		const padding = strokeWidth * .5 + 2;
-		const nx = dx / len * padding;
-		const ny = dy / len * padding;
-		const px = -ny;
-		const py = nx;
-		const vertexData = new Float32Array([
-			p0.x - nx - px,
-			p0.y - ny - py,
-			p0.x - nx + px,
-			p0.y - ny + py,
-			p1.x + nx - px,
-			p1.y + ny - py,
-			p1.x + nx + px,
-			p1.y + ny + py
-		]);
-		const vertexBuffer = this.vertexPool.getBuffer(this.device, vertexData);
-		const pipeline = opts?.blendMode === "max" ? this.maxPipeline : this.pipeline;
-		pass.setPipeline(pipeline);
-		const uniformBindGroup = this.uniformBindGroupCache.getBindGroup(this.device, this.uniformLayout, uniformBuffer);
-		pass.setBindGroup(0, uniformBindGroup);
-		pass.setVertexBuffer(0, vertexBuffer);
-		pass.draw(4);
+		const segmentBuffer = this.segmentPool.getBuffer(this.device, ends.subarray(0, count * SEGMENT_FLOATS));
+		const useMax = opts?.blendMode === "max";
+		pass.setPipeline(useMax ? this.maxPipeline : this.pipeline);
+		pass.setBindGroup(0, this.uniformBindGroupCache.getBindGroup(this.device, this.uniformLayout, uniformBuffer));
+		pass.setVertexBuffer(0, segmentBuffer);
+		pass.draw(4, count);
 	}
 	destroy() {
 		this.uniformPool.destroy();
-		this.vertexPool.destroy();
+		this.segmentPool.destroy();
 		this.uniformBindGroupCache.destroy();
 	}
 };
@@ -41574,5 +41785,5 @@ var NodeSurfaceProvider = class {
 if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThis.__GATEWAI_DELAYS__ || /* @__PURE__ */ new Set();
 
 //#endregion
-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
+export { poseNodes as $, TextAnchorConfigSchema as $t, emojiGraphemes as A, evaluateSkewMatrix as An, AnimatableGlyphPropsSchema as At, jointMatrices as B, sampleCurveGeometry as Bn, GlyphAnchorPointSchema as Bt, drawGifNode as C, distanceToCurveParameter as Cn, parseColorToRgb as Ct, drawSignalNode as D, evaluateExpressionSelector as Dn, AdvancedTextAnimatorSchema as Dt, drawParagraphNode as E, evaluateCubicBezierDerivative as En, AdvancedTextAnimatorBuilder as Et, getPrimitiveGeometry as F, generatePathSegments as Fn, DynamicStrokePropertiesSchema as Ft, measureMaxCaptionHeight as G, SelectorBasedOnSchema as Gt, loadModel3D as H, signalRegistry as Hn, LineSpacingDynamicsSchema as Ht, getRegisteredFontSource as I, getScramblePool as In, EnhancedTextNodeSchema as It, parseDashArray as J, SelectorUnitsSchema as Jt, mediaDecoderCache as K, SelectorModeSchema as Kt, getRenderer2D as L, getShuffledOrder as Ln, ExpressionSelectorSchema as Lt, fitSpansToText as M, evaluateTypewriterState as Mn, AudioSpectrumTypographySchema as Mt, generateExtrudedTextGeometry as N, evaluateVolumetricFormation as Nn, ChromaticGlitchConfigSchema as Nt, drawSvgNode as O, evaluateMarqueeOffset as On, AnchorGroupingSchema as Ot, getHeadlessFontPath as P, generateArcLengthLUT as Pn, CubicBezierSegmentSchema as Pt, parseSvgPathToSegments as Q, SpringPhysicsSchema as Qt, initHeadlessWebGPU as R, parseSvgPathToCubicBeziers as Rn, ExtendedGlyphPropertiesSchema as Rt, drawCaptionNode as S, deterministicWigglyNoise as Sn, linearRgb as St, drawLottieNode as T, evaluateCubicBezier as Tn, AETextAnimatorSchema as Tt, loadOBJ as U, waveToCubicBeziers as Un, LongShadowConfigSchema as Ut, loadFBX as V, samplePathChainGeometry as Vn, KineticMarqueeConfigSchema as Vt, lutStore as W, ParticleDissolveConfigSchema as Wt, parseMTL as X, SkewPropertiesSchema as Xt, parseFBX as Y, SignalRegistry as Yt, parseOBJ as Z, Spatial3DPropertiesSchema as Zt, buildShapeSvgPath as _, buildPathLUT as _n, Light3D as _t, GlassPipeline as a, TextPathSourceSchema as an, setRegisteredFontSource as at, colorMatrixWgsl as b, computeLineLeadingDisplacement as bn, Path3D as bt, Renderer2D as c, TextSelectorSchema as cn, srtLoader as ct, ScreenSpaceRelightPipeline as d, TypewriterAnimatorSchema as dn, transformScale as dt, TextAnimatorBuilder as en, probeVideoSize as et, ShadowPipeline as f, TypingCadenceSchema as fn, GetFontAssetUrl as ft, WebGPUAudioProcessor as g, VolumetricFormationModeSchema as gn, LIGHT_UNIFORM_SIZE_BYTES as gt, SlugPipeline as h, VolumetricFormationConfigSchema as hn, ENVIRONMENT_PRESETS as ht, EffectPipeline as i, TextPathOptionsSchema as in, sampleMorphWeights as it, ensureDevice as j, evaluateSpringProgress as jn, AudioSignalComputePipeline as jt, drawVideoNode as k, evaluateSelectorCombination as kn, AnchorPresetSchema as kt, Renderer3D as l, TextSignalSelectorSchema as ln, textureCache as lt, SlugGeometry as m, Vec2Schema as mn, Camera3D as mt, AudioLatentTrackCache as n, TextCursorStyleSchema as nn, resolveInputUrl as nt, MotionBlurPipeline as o, TextRangeSelectorSchema as on, shaderStore as ot, SlugFontCache as p, VariableFontAxesSchema as pn, resolveMediaSourceUrl as pt, parseColor as q, SelectorShapeSchema as qt, AudioMeshDeformPipeline as r, TextPathBuilder as rn, resolveTextSpans as rt, NodeSurfaceProvider as s, TextScrambleConfigSchema as sn, spansText as st, AudioLatentEngine as t, TextCursorConfigSchema as tn, registerHeadlessFont as tt, SSAOPipeline as u, TextWigglySelectorSchema as un, trackAudioPitch as ut, clearAllVideoCache as v, buildWGSLSignalFn as vn, MAX_LIGHTS as vt, drawImageNode as w, ellipseToCubicBeziers as wn, resolveEnvironment as wt, describeGpu as x, computeRangeSelectorWeight as xn, Vector3Math as xt, clearHeadlessFonts as y, computeAnchorPivotOffset as yn, Matrix4Math as yt, inputStore as z, sampleAudioSpectrumScale as zn, GlyphAnchorGroupingSchema as zt };
+//# sourceMappingURL=dist-DtPPPsZV.mjs.map