gitframes 1.3.0 → 1.3.1

package/dist/{dist-C37594c6.mjs → dist-8vbhZYqX.mjs}

@@ -5234,6 +5234,8 @@ var SlugGenerator = class {
 		return buffer;
 	}
 };
+/** Per-font load timings are debug output: shown only with LOG_LEVEL=debug or trace. */
+const VERBOSE_FONT_LOGS = typeof process !== "undefined" && /^(debug|trace)$/i.test(process.env?.LOG_LEVEL ?? "");
 function parseFontWeight(fontWeight) {
 	if (!fontWeight) return 400;
 	if (fontWeight === "bold") return 700;
@@ -5307,6 +5309,10 @@ var SlugFontCache = class SlugFontCache$1 {
 	static get parsedFontCache() {
 		return g[GLOBAL_PARSED_KEY];
 	}
+	/** Register an already parsed font (e.g. by FontManager) under a family name. */
+	static setParsed(fontFamily, font) {
+		SlugFontCache$1.parsedFontCache.set(fontFamily, font);
+	}
 	static getParsed(fontFamily) {
 		return SlugFontCache$1.parsedFontCache.get(fontFamily) || null;
 	}
@@ -5693,7 +5699,7 @@ var SlugFontCache = class SlugFontCache$1 {
 								whitelist: whitelist || null
 							}).generate(device, font);
 							const generateTime = performance.now();
-							console.log(`[SlugFontCache] Preloaded and parsed font "${fontFamily}":\n  - fontkit parse: ${(parseTime - startTime).toFixed(2)}ms\n  - slug generation: ${(generateTime - parseTime).toFixed(2)}ms\n  - total: ${(generateTime - startTime).toFixed(2)}ms`);
+							if (VERBOSE_FONT_LOGS) console.log(`[SlugFontCache] Preloaded and parsed font "${fontFamily}":\n  - fontkit parse: ${(parseTime - startTime).toFixed(2)}ms\n  - slug generation: ${(generateTime - parseTime).toFixed(2)}ms\n  - total: ${(generateTime - startTime).toFixed(2)}ms`);
 							generated.fontFamily = fontFamily;
 							SlugFontCache$1.cache.set(fontFamily, generated);
 							SlugFontCache$1.listeners.forEach((l) => {
@@ -6622,10 +6628,11 @@ function getKernOffset(font, a, b) {
 	let v = 0;
 	if (src) try {
 		const s = String.fromCodePoint(a) + String.fromCodePoint(b);
-		const laid = src.layout(s);
+		const laid = src.layout?.(s);
+		if (!laid) throw new Error("font cannot shape text");
 		const total = laid.positions.reduce((acc, p) => acc + p.xAdvance, 0);
-		const advA = src.glyphForCodePoint(a)?.advanceWidth ?? 0;
-		const advB = src.glyphForCodePoint(b)?.advanceWidth ?? 0;
+		const advA = src.glyphForCodePoint?.(a)?.advanceWidth ?? 0;
+		const advB = src.glyphForCodePoint?.(b)?.advanceWidth ?? 0;
 		v = laid.glyphs.length === 2 ? total - (advA + advB) : 0;
 	} catch {
 		v = 0;
@@ -11448,6 +11455,7 @@ const ExtendedGlyphPropertiesSchema = object({
 	rotationX: number().optional(),
 	rotationY: number().optional(),
 	rotationZ: number().optional(),
+	formation: VolumetricFormationConfigSchema.optional(),
 	skew: number().optional(),
 	skewAxis: number().optional(),
 	tracking: number().optional(),
@@ -12723,7 +12731,7 @@ function drawParagraphNode(ctx, pass, props) {
 	if (slugFont && hasStroke && ctx.device) {
 		const alignMultiplier = props.strokeAlign === "outside" ? 2 : 1;
 		const strokeWidthInFontUnits = (props.strokeWidth ?? 0) * alignMultiplier * (slugFont.unitsPerEm / fontSize);
-		strokeFont = SlugFontCache.getFont(fontFamily, props.fontWeight, ctx.device, strokeWidthInFontUnits, fontSize, props.variableAxes);
+		strokeFont = SlugFontCache.getFont(fontFamily, props.fontWeight, ctx.device, strokeWidthInFontUnits, fontSize, props.variableAxes) ?? null;
 	}
 	if (!slugFont?.curvesTex || hasStroke && !strokeFont?.curvesTex) {
 		const fontUrl = GetFontAssetUrl(fontFamily);
@@ -12762,6 +12770,12 @@ function drawParagraphNode(ctx, pass, props) {
 	const alignWidth = props.isCaption ? props.dstRect.width : maxWidth;
 	const animApplyBy = props.animation?.applyBy ?? "word";
 	const layout = align === "left" && (alignWidth === void 0 || alignWidth === maxWidth) && !pathOptions && animApplyBy === "word" && Boolean(measured?.layout) && measured.layout ? measured.layout : SlugGeometry.layout(textToRender, slugFont, fontSize, letterSpacing, lineHeight, maxWidth, align, animApplyBy, alignWidth, pathOptions, props.spans);
+	const vAlign = props.verticalAlign ?? "top";
+	const slack = props.height != null && !pathOptions && !props.isCaption ? props.height - (measured.height + padding * 2) : 0;
+	const textRect = {
+		...props.dstRect,
+		y: props.dstRect.y + (vAlign === "middle" ? slack / 2 : vAlign === "bottom" ? slack : 0)
+	};
 	const anim = props.animation;
 	const isBold = props.fontWeight === "bold" || typeof props.fontWeight === "number" && props.fontWeight >= 600 || typeof props.fontWeight === "string" && parseInt(props.fontWeight, 10) >= 600;
 	const hasTrueWeight = "hasTrueWeight" in slugFont && Boolean(slugFont.hasTrueWeight);
@@ -12829,7 +12843,7 @@ function drawParagraphNode(ctx, pass, props) {
 		ctx.renderer.drawRRect(pass, {
 			rect: {
 				x: props.dstRect.x + padding + m.x,
-				y: props.dstRect.y + padding + m.y,
+				y: textRect.y + padding + m.y,
 				width: m.width,
 				height: m.height
 			},
@@ -13001,10 +13015,10 @@ function drawParagraphNode(ctx, pass, props) {
 					const rotatedR0x = r0x * cosT - r0y * sinT;
 					const rotatedR0y = r0x * sinT + r0y * cosT;
 					biasX = glyphX + rotatedR0x + props.dstRect.x + padding + offsetX + boldShift;
-					biasY = glyph.y + rotatedR0y + props.dstRect.y + padding + offsetY;
+					biasY = glyph.y + rotatedR0y + textRect.y + padding + offsetY;
 				} else {
 					biasX = glyphX + cp.bearingX * fontScale + scaleX + props.dstRect.x + padding + offsetX + boldShift;
-					biasY = glyph.y - cp.bearingY * fontScale + scaleY + props.dstRect.y + padding + offsetY;
+					biasY = glyph.y - cp.bearingY * fontScale + scaleY + textRect.y + padding + offsetY;
 				}
 				if (anchorConfig) {
 					const pivot = computeAnchorPivotOffset({
@@ -13210,7 +13224,7 @@ function drawParagraphNode(ctx, pass, props) {
 		const offsetAdjustment = (localEmojiSize - emoji$1.size) / 2;
 		const emojiDstRect = {
 			x: props.dstRect.x + emoji$1.x + padding - offsetAdjustment,
-			y: props.dstRect.y + emoji$1.y + padding - offsetAdjustment,
+			y: textRect.y + emoji$1.y + padding - offsetAdjustment,
 			width: localEmojiSize,
 			height: localEmojiSize
 		};
@@ -13239,13 +13253,13 @@ function drawParagraphNode(ctx, pass, props) {
 		const cursorWidth = cursorCfg.width ?? 2.5;
 		const cursorSpacing = cursorCfg.spacing ?? 3;
 		let cursorX = props.dstRect.x + padding;
-		let cursorY = props.dstRect.y + padding;
+		let cursorY = textRect.y + padding;
 		if (layout.glyphs.length > 0) {
 			const lastG = layout.glyphs[layout.glyphs.length - 1];
 			const fontScale = fontSize / slugFont.unitsPerEm;
 			const adv = (lastG.cp?.advanceWidth || 0) * fontScale;
 			cursorX = lastG.x + props.dstRect.x + padding + adv + cursorSpacing;
-			cursorY = lastG.y + props.dstRect.y + padding;
+			cursorY = lastG.y + textRect.y + padding;
 		}
 		if (cursorCfg.style === "underscore") ctx.renderer.drawRect(pass, {
 			x: cursorX,
@@ -15339,6 +15353,15 @@ const clearVideoNodeState = (nodeId, device) => {
 		lastSourceUrl.delete(key);
 	}
 };
+const clearAllVideoCache = (device) => {
+	for (const key of lastGoodFrameKey.values()) {
+		textureCache.evict(key, device);
+		textureCache.activeKeys.delete(key);
+	}
+	lastGoodFrameKey.clear();
+	lastSourceUrl.clear();
+	pendingDecodes.clear();
+};
 var BufferPool = class {
 	buffers = [];
 	index = 0;
@@ -19963,7 +19986,7 @@ var Path3D = class Path3D$1 {
 	/**
 	* Extracts pitch, yaw, roll Euler angles in degrees from the orthonormal frame.
 	*/
-	eulerFromFrame(tangent, normal, binormal) {
+	eulerFromFrame(tangent, normal, _binormal) {
 		return [
 			Math.asin(Math.max(-1, Math.min(1, -tangent[1]))) * (180 / Math.PI),
 			Math.atan2(tangent[0], tangent[2]) * (180 / Math.PI),
@@ -20908,14 +20931,12 @@ var FbxLoader = class FbxLoader$1 {
 				if (offset + 25 > u8.byteLength) return null;
 				endOffset = Number(view.getBigUint64(offset, true));
 				numProperties = Number(view.getBigUint64(offset + 8, true));
-				Number(view.getBigUint64(offset + 16, true));
 				nameLen = view.getUint8(offset + 24);
 				offset += 25;
 			} else {
 				if (offset + 13 > u8.byteLength) return null;
 				endOffset = view.getUint32(offset, true);
 				numProperties = view.getUint32(offset + 4, true);
-				view.getUint32(offset + 8, true);
 				nameLen = view.getUint8(offset + 12);
 				offset += 13;
 			}
@@ -21125,7 +21146,6 @@ var FbxLoader = class FbxLoader$1 {
 			const indicesNode = geomNode.children.find((c) => c.name === "PolygonVertexIndex");
 			const normalLayer = geomNode.children.find((c) => c.name === "LayerElementNormal");
 			const uvLayer = geomNode.children.find((c) => c.name === "LayerElementUV");
-			geomNode.children.find((c) => c.name === "LayerElementMaterial");
 			if (!verticesNode || !indicesNode) continue;
 			const rawVerts = extractArrayProp(verticesNode);
 			const rawPolyIndices = extractArrayProp(indicesNode);
@@ -21242,7 +21262,6 @@ var FbxLoader = class FbxLoader$1 {
 						const cIndexes = extractArrayProp(indexesNode);
 						const cWeights = extractArrayProp(weightsNode);
 						for (let k = 0; k < cIndexes.length; k++) {
-							cIndexes[k];
 							const weight = cWeights[k] ?? 0;
 							for (let v = 0; v < numVerts; v++) for (let slot = 0; slot < 4; slot++) if (jointWeights[v * 4 + slot] === 0) {
 								jointIndices[v * 4 + slot] = boneIdx;
@@ -21266,7 +21285,7 @@ var FbxLoader = class FbxLoader$1 {
 				materialName: entry.name
 			});
 		}
-		for (const [id, entry] of objects) if (entry.node.name === "Material") {
+		for (const [, entry] of objects) if (entry.node.name === "Material") {
 			const props70 = entry.node.children.find((c) => c.name === "Properties70");
 			let diffuseColor = [
 				1,
@@ -21306,37 +21325,48 @@ var FbxLoader = class FbxLoader$1 {
 			const layerConn = connections.find((c) => c.parentId === id && objects.get(c.childId)?.node.name === "AnimationLayer");
 			if (layerConn) {
 				const curveNodeConns = connections.filter((c) => c.parentId === layerConn.childId && objects.get(c.childId)?.node.name === "AnimationCurveNode");
+				const groups = /* @__PURE__ */ new Map();
 				for (const cnc of curveNodeConns) {
 					const curveNodeObj = objects.get(cnc.childId);
 					if (!curveNodeObj) continue;
 					const modelConn = connections.find((c) => c.childId === curveNodeObj.id && objects.get(c.parentId)?.node.name === "Model");
-					const nodeName = (modelConn ? objects.get(modelConn.parentId) : null)?.name ?? curveNodeObj.name;
-					const propType = (modelConn?.property ?? curveNodeObj.name).toLowerCase();
-					const animCurves = connections.filter((c) => c.parentId === curveNodeObj.id && objects.get(c.childId)?.node.name === "AnimationCurve");
-					for (const ac of animCurves) {
-						const curveObj = objects.get(ac.childId)?.node;
-						const keyTimeNode = curveObj?.children.find((c) => c.name === "KeyTime");
-						const keyValueNode = curveObj?.children.find((c) => c.name === "KeyValueFloat");
-						if (keyTimeNode && keyValueNode) {
-							const rawTimes = extractArrayProp(keyTimeNode);
-							const rawValues = extractArrayProp(keyValueNode);
-							const times = new Float32Array(rawTimes.length);
-							const values = new Float32Array(rawValues.length);
-							for (let k = 0; k < rawTimes.length; k++) {
-								times[k] = (rawTimes[k] ?? 0) / FbxLoader$1.FBX_KTIME;
-								values[k] = rawValues[k] ?? 0;
-							}
-							const isRotation = propType.includes("rot") || propType.includes("r");
-							const isScaling = propType.includes("sc") || propType.includes("s");
-							tracks.push({
-								nodeName,
-								times,
-								translations: !isRotation && !isScaling ? values : void 0,
-								rotations: isRotation ? values : void 0,
-								scalings: isScaling ? values : void 0
-							});
-						}
+					const targetModel = modelConn ? objects.get(modelConn.parentId) : void 0;
+					const kind = transformKindFromProperty(modelConn?.propName) ?? transformKindFromProperty(curveNodeObj.name);
+					if (!kind) continue;
+					const key = `${targetModel?.id ?? curveNodeObj.id}|${kind}`;
+					let group = groups.get(key);
+					if (!group) {
+						const model = targetModel?.node;
+						group = {
+							nodeName: targetModel?.name ?? curveNodeObj.name,
+							model,
+							kind,
+							defaults: staticTransform(model, curveNodeObj.node, kind),
+							channels: [
+								void 0,
+								void 0,
+								void 0
+							]
+						};
+						groups.set(key, group);
 					}
+					connections.filter((c) => c.parentId === curveNodeObj.id && objects.get(c.childId)?.node.name === "AnimationCurve").forEach((cc, order) => {
+						const axis = axisFromProperty(cc.propName) ?? order;
+						if (axis > 2) return;
+						const curveObj = objects.get(cc.childId)?.node;
+						const times = extractArrayProp(curveObj?.children.find((c) => c.name === "KeyTime"));
+						const values = extractArrayProp(curveObj?.children.find((c) => c.name === "KeyValueFloat"));
+						const n = Math.min(times.length, values.length);
+						if (n === 0) return;
+						group.channels[axis] = {
+							times: Array.from(times.slice(0, n), (t) => Number(t)),
+							values: Array.from(values.slice(0, n), (v) => Number(v))
+						};
+					});
+				}
+				for (const group of groups.values()) {
+					const track = buildTransformTrack(group);
+					if (track) tracks.push(track);
 				}
 			}
 			let maxDuration = 1;
@@ -21413,6 +21443,151 @@ var FbxLoader = class FbxLoader$1 {
 		};
 	}
 };
+/**
+* Classifies a curve node from its OP connection property ("Lcl Translation",
+* "Lcl Rotation", "Lcl Scaling") or, failing that, its short name ("T", "R", "S").
+*/
+function transformKindFromProperty(name) {
+	switch (name) {
+		case "Lcl Translation":
+		case "T": return "T";
+		case "Lcl Rotation":
+		case "R": return "R";
+		case "Lcl Scaling":
+		case "S": return "S";
+		default: return;
+	}
+}
+/** Channel index of a curve from its curve-node connection property ("d|X" → 0). */
+function axisFromProperty(name) {
+	switch (name) {
+		case "d|X": return 0;
+		case "d|Y": return 1;
+		case "d|Z": return 2;
+		default: return;
+	}
+}
+/** Numeric values of a Properties70 `P` entry (they start at props[4]). */
+function readProperty70(node, name) {
+	const p = (node?.children.find((c) => c.name === "Properties70"))?.children.find((c) => c.name === "P" && c.props[0] === name);
+	if (!p) return void 0;
+	return p.props.slice(4).map((v) => Number(v));
+}
+/** A model's rest value for one transform, used where a channel has no curve. */
+function staticTransform(model, curveNode, kind) {
+	const fallback = kind === "S" ? 1 : 0;
+	const modelProp = readProperty70(model, kind === "T" ? "Lcl Translation" : kind === "R" ? "Lcl Rotation" : "Lcl Scaling");
+	const out = [
+		fallback,
+		fallback,
+		fallback
+	];
+	for (let axis = 0; axis < 3; axis++) {
+		const fromModel = modelProp?.[axis];
+		const fromCurveNode = readProperty70(curveNode, `d|${"XYZ"[axis]}`)?.[0];
+		const value = fromModel ?? fromCurveNode;
+		if (value !== void 0 && Number.isFinite(value)) out[axis] = value;
+	}
+	return out;
+}
+/** FBX EOrder enum (Model "RotationOrder"): axes in the order they are applied. */
+const FBX_ROTATION_ORDERS = [
+	"XYZ",
+	"XZY",
+	"YZX",
+	"YXZ",
+	"ZXY",
+	"ZYX"
+];
+function rotationOrder(model) {
+	return FBX_ROTATION_ORDERS[readProperty70(model, "RotationOrder")?.[0] ?? 0] ?? "XYZ";
+}
+/**
+* Euler degrees → [x, y, z, w] quaternion. FBX applies the axes in `order`
+* (XYZ: X first, so R = Rz·Ry·Rx).
+*/
+function fbxEulerToQuat(degrees, order = "XYZ") {
+	let q = [
+		0,
+		0,
+		0,
+		1
+	];
+	for (const axisName of order) {
+		const axis = "XYZ".indexOf(axisName);
+		const half = (degrees[axis] ?? 0) * Math.PI / 360;
+		const s = Math.sin(half);
+		const a = [
+			0,
+			0,
+			0,
+			Math.cos(half)
+		];
+		a[axis] = s;
+		q = [
+			a[3] * q[0] + a[0] * q[3] + a[1] * q[2] - a[2] * q[1],
+			a[3] * q[1] - a[0] * q[2] + a[1] * q[3] + a[2] * q[0],
+			a[3] * q[2] + a[0] * q[1] - a[1] * q[0] + a[2] * q[3],
+			a[3] * q[3] - a[0] * q[0] - a[1] * q[1] - a[2] * q[2]
+		];
+	}
+	return q;
+}
+/** Linear sample of a curve at `t` (KTime ticks), clamped to its ends. */
+function sampleCurve(curve, t) {
+	const { times, values } = curve;
+	const last = times.length - 1;
+	if (t <= times[0]) return values[0];
+	if (t >= times[last]) return values[last];
+	let k = 0;
+	while (k < last - 1 && times[k + 1] <= t) k++;
+	const t0 = times[k];
+	const t1 = times[k + 1];
+	const u = t1 > t0 ? (t - t0) / (t1 - t0) : 0;
+	return values[k] + (values[k + 1] - values[k]) * u;
+}
+/**
+* Merges a transform's X/Y/Z curves onto one sorted key set: channels without
+* a key at some time are interpolated, channels without a curve keep the
+* static value. Rotations become quaternions in the model's RotationOrder.
+*/
+function buildTransformTrack(group) {
+	const keySet = /* @__PURE__ */ new Set();
+	for (const channel of group.channels) for (const t of channel?.times ?? []) keySet.add(t);
+	if (keySet.size === 0) return void 0;
+	const keys = [...keySet].sort((a, b) => a - b);
+	const times = new Float32Array(keys.length);
+	const isRotation = group.kind === "R";
+	const values = new Float32Array(keys.length * (isRotation ? 4 : 3));
+	const order = isRotation ? rotationOrder(group.model) : "XYZ";
+	let prev;
+	keys.forEach((key, k) => {
+		times[k] = key / FbxLoader.FBX_KTIME;
+		const v = [
+			0,
+			1,
+			2
+		].map((axis) => {
+			const channel = group.channels[axis];
+			return channel ? sampleCurve(channel, key) : group.defaults[axis];
+		});
+		if (!isRotation) {
+			values.set(v, k * 3);
+			return;
+		}
+		const q = fbxEulerToQuat(v, order);
+		if (prev && prev[0] * q[0] + prev[1] * q[1] + prev[2] * q[2] + prev[3] * q[3] < 0) for (let i = 0; i < 4; i++) q[i] = -q[i];
+		prev = q;
+		values.set(q, k * 4);
+	});
+	return {
+		nodeName: group.nodeName,
+		times,
+		translations: group.kind === "T" ? values : void 0,
+		rotations: isRotation ? values : void 0,
+		scales: group.kind === "S" ? values : void 0
+	};
+}
 function parseFBX(bufferOrText, options = {}) {
 	return FbxLoader.parse(bufferOrText, options);
 }
@@ -22365,7 +22540,6 @@ var GltfLoader = class GltfLoader$1 {
 	static unpackGlb(bytes) {
 		const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 		const magic = view.getUint32(0, true);
-		view.getUint32(4, true);
 		const totalLength = view.getUint32(8, true);
 		if (magic !== GLB_MAGIC) throw new Error("Invalid GLB header: magic mismatch");
 		let offset = 12;
@@ -22747,6 +22921,9 @@ var GltfLoader = class GltfLoader$1 {
 function loadGLTF(srcOrData, options = {}) {
 	return GltfLoader.load(srcOrData, options);
 }
+function loadGLB(srcOrData, options = {}) {
+	return GltfLoader.load(srcOrData, options);
+}
 const DEFAULT_PALETTE = [[
 	0,
 	0,
@@ -22784,7 +22961,6 @@ var VoxLoader = class VoxLoader$1 {
 		while (offset + 12 <= bytes.byteLength) {
 			const chunkId = new TextDecoder("ascii").decode(bytes.subarray(offset, offset + 4));
 			const contentSize = view.getUint32(offset + 4, true);
-			view.getUint32(offset + 8, true);
 			offset += 12;
 			const chunkDataOffset = offset;
 			if (chunkId === "SIZE") {
@@ -22827,7 +23003,7 @@ var VoxLoader = class VoxLoader$1 {
 		}
 		return VoxLoader$1.buildModel(voxels, palette, sizeX, sizeY, sizeZ, options);
 	}
-	static buildModel(voxels, palette, sizeX, sizeY, sizeZ, options) {
+	static buildModel(voxels, palette, _sizeX, _sizeY, _sizeZ, options) {
 		const voxelSet = /* @__PURE__ */ new Set();
 		voxels.forEach((v) => voxelSet.add(`${v.x},${v.y},${v.z}`));
 		const rawPositions = [];
@@ -23177,7 +23353,7 @@ var ThreeDSLoader = class ThreeDSLoader$1 {
 			offset = nextChunkOffset;
 		}
 	}
-	static readTriMesh(view, startOffset, endOffset, mesh, materials) {
+	static readTriMesh(view, startOffset, endOffset, mesh, _materials) {
 		let offset = startOffset;
 		while (offset + 6 <= endOffset) {
 			const chunkId = view.getUint16(offset, true);
@@ -24359,7 +24535,7 @@ var Mesh3DPipeline = class {
 	defaultWhiteTexture;
 	defaultSkinningBuffer;
 	modelData = new Float32Array(48);
-	constructor(device, format, depthFormat = "depth24plus", cameraLayout, lightsLayout) {
+	constructor(device, format, depthFormat = "depth24plus", cameraLayout, lightsLayout, sampleCount = 1) {
 		this.device = device;
 		this.modelPool = new BufferPool(192, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
 		this.skinningPool = new BufferPool(8192, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
@@ -24478,7 +24654,8 @@ var Mesh3DPipeline = class {
 			primitive: {
 				topology: "triangle-list",
 				cullMode: "none"
-			}
+			},
+			multisample: { count: sampleCount }
 		});
 		this.pipelineMrt = device.createRenderPipeline({
 			label: "Mesh3DPipelineMrt",
@@ -24511,7 +24688,8 @@ var Mesh3DPipeline = class {
 			primitive: {
 				topology: "triangle-list",
 				cullMode: "none"
-			}
+			},
+			multisample: { count: sampleCount }
 		});
 		this.defaultWhiteTexture = device.createTexture({
 			label: "Mesh3DDefaultWhiteTexture",
@@ -25146,7 +25324,7 @@ var Quad3DPipeline = class {
 	vertexBuffer;
 	indexBuffer;
 	modelData = new Float32Array(52);
-	constructor(device, format, depthFormat = "depth24plus") {
+	constructor(device, format, depthFormat = "depth24plus", sampleCount = 1) {
 		this.device = device;
 		this.modelPool = new BufferPool(208, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
 		const module = device.createShaderModule({
@@ -25250,7 +25428,8 @@ var Quad3DPipeline = class {
 			primitive: {
 				topology: "triangle-list",
 				cullMode: "none"
-			}
+			},
+			multisample: { count: sampleCount }
 		});
 		this.pipelineMrt = device.createRenderPipeline({
 			label: "Quad3DPipelineMrt",
@@ -25283,7 +25462,8 @@ var Quad3DPipeline = class {
 			primitive: {
 				topology: "triangle-list",
 				cullMode: "none"
-			}
+			},
+			multisample: { count: sampleCount }
 		});
 		const vertices = new Float32Array([
 			-.5,
@@ -25688,7 +25868,7 @@ var Slug3DPipeline = class {
 	instancePool;
 	fontBindGroups = /* @__PURE__ */ new WeakMap();
 	modelData = new Float32Array(40);
-	constructor(device, format, depthFormat, cameraLayout, lightsLayout) {
+	constructor(device, format, depthFormat, cameraLayout, lightsLayout, sampleCount = 1) {
 		this.device = device;
 		this.modelPool = new BufferPool(160, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
 		this.instancePool = new BufferPool(65536, GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST);
@@ -25783,6 +25963,7 @@ var Slug3DPipeline = class {
 			topology: "triangle-list",
 			cullMode: "none"
 		};
+		const multisample = { count: sampleCount };
 		this.pipelineSingle = device.createRenderPipeline({
 			label: "Slug3DPipelineSingle",
 			layout,
@@ -25796,7 +25977,8 @@ var Slug3DPipeline = class {
 				}]
 			},
 			depthStencil,
-			primitive
+			primitive,
+			multisample
 		});
 		this.pipelineMrt = device.createRenderPipeline({
 			label: "Slug3DPipelineMrt",
@@ -25811,7 +25993,8 @@ var Slug3DPipeline = class {
 				}, { format: "rgba16float" }]
 			},
 			depthStencil,
-			primitive
+			primitive,
+			multisample
 		});
 	}
 	resetPools() {
@@ -25894,6 +26077,8 @@ var Renderer3D = class {
 	samplerCache = new SamplerCache();
 	depthTexture = null;
 	linearDepthTexture = null;
+	msaaColorTexture = null;
+	msaaLinearDepthTexture = null;
 	cameraUniformData = new Float32Array(80);
 	meshBuffersCache = /* @__PURE__ */ new WeakMap();
 	materialTextures = /* @__PURE__ */ new WeakMap();
@@ -25901,12 +26086,19 @@ var Renderer3D = class {
 	modelCache = /* @__PURE__ */ new Map();
 	lastCameraPose = null;
 	lastCameraBuffer = null;
-	constructor(device, format) {
+	/**
+	* Samples per pixel in the 3D pass. Mesh silhouettes (extruded text,
+	* models) are rasterized triangles: without MSAA every edge is a hard
+	* stair-step. 4 is the count every WebGPU device supports; 1 turns it off.
+	*/
+	sampleCount;
+	constructor(device, format, sampleCount = 4) {
 		this.device = device;
 		this.format = format;
-		this.quad3dPipeline = new Quad3DPipeline(device, format);
-		this.slug3dPipeline = new Slug3DPipeline(device, format, "depth24plus", this.quad3dPipeline.cameraLayout, this.quad3dPipeline.lightsLayout);
-		this.mesh3dPipeline = new Mesh3DPipeline(device, format, "depth24plus", this.quad3dPipeline.cameraLayout, this.quad3dPipeline.lightsLayout);
+		this.sampleCount = sampleCount;
+		this.quad3dPipeline = new Quad3DPipeline(device, format, "depth24plus", sampleCount);
+		this.slug3dPipeline = new Slug3DPipeline(device, format, "depth24plus", this.quad3dPipeline.cameraLayout, this.quad3dPipeline.lightsLayout, sampleCount);
+		this.mesh3dPipeline = new Mesh3DPipeline(device, format, "depth24plus", this.quad3dPipeline.cameraLayout, this.quad3dPipeline.lightsLayout, sampleCount);
 		this.audioMeshDeformPipeline = new AudioMeshDeformPipeline(device);
 		this.cameraPool = new BufferPool(320, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
 		this.lightsPool = new BufferPool(LIGHT_UNIFORM_SIZE_BYTES, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
@@ -25972,11 +26164,26 @@ var Renderer3D = class {
 					height
 				},
 				format: "depth24plus",
+				sampleCount: this.sampleCount,
 				usage: GPUTextureUsage.RENDER_ATTACHMENT
 			});
 		}
 		return this.depthTexture;
 	}
+	getOrCreateMsaaTexture(current, label, format, width, height) {
+		if (current && current.width === width && current.height === height) return current;
+		current?.destroy();
+		return this.device.createTexture({
+			label,
+			size: {
+				width,
+				height
+			},
+			format,
+			sampleCount: this.sampleCount,
+			usage: GPUTextureUsage.RENDER_ATTACHMENT
+		});
+	}
 	getOrCreateLinearDepthTexture(width, height) {
 		if (!this.linearDepthTexture || this.linearDepthTexture.width !== width || this.linearDepthTexture.height !== height) {
 			this.linearDepthTexture?.destroy();
@@ -26042,23 +26249,31 @@ var Renderer3D = class {
 		const cameraBindGroup = this.createCameraBindGroup(cameraBuffer);
 		const lightsBuffer = this.getOrCreateLightsBuffer(lights);
 		const lightsBindGroup = this.lightsUniformBindGroupCache.getBindGroup(this.device, this.quad3dPipeline.lightsLayout, lightsBuffer);
-		const colorAttachments = [{
-			view: colorTargetView,
-			loadOp,
-			storeOp: "store",
-			clearValue: clearColor
-		}];
-		if (linearDepthTargetView) colorAttachments.push({
-			view: linearDepthTargetView,
+		const msaa = this.sampleCount > 1;
+		if (msaa && loadOp === "load") throw new Error("Renderer3D.beginPass: loadOp 'load' needs a Renderer3D built with sampleCount 1");
+		const attach = (view, msaaTex, clearValue, attachmentLoadOp) => msaaTex ? {
+			view: msaaTex.createView(),
+			resolveTarget: view,
 			loadOp: "clear",
+			storeOp: "discard",
+			clearValue
+		} : {
+			view,
+			loadOp: attachmentLoadOp,
 			storeOp: "store",
-			clearValue: {
+			clearValue
+		};
+		if (msaa) this.msaaColorTexture = this.getOrCreateMsaaTexture(this.msaaColorTexture, "Renderer3DMsaaColor", this.format, surfaceWidth, surfaceHeight);
+		const colorAttachments = [attach(colorTargetView, msaa ? this.msaaColorTexture : null, clearColor, loadOp)];
+		if (linearDepthTargetView) {
+			if (msaa) this.msaaLinearDepthTexture = this.getOrCreateMsaaTexture(this.msaaLinearDepthTexture, "Renderer3DMsaaLinearDepth", "rgba16float", surfaceWidth, surfaceHeight);
+			colorAttachments.push(attach(linearDepthTargetView, msaa ? this.msaaLinearDepthTexture : null, {
 				r: camera.far,
 				g: 0,
 				b: 0,
 				a: 1
-			}
-		});
+			}, "clear"));
+		}
 		return {
 			pass: encoder.beginRenderPass({
 				colorAttachments,
@@ -26066,7 +26281,7 @@ var Renderer3D = class {
 					view: depthTex.createView(),
 					depthClearValue: 1,
 					depthLoadOp: "clear",
-					depthStoreOp: "store"
+					depthStoreOp: msaa ? "discard" : "store"
 				}
 			}),
 			cameraBindGroup,
@@ -26438,6 +26653,8 @@ var Renderer3D = class {
 	destroy() {
 		this.depthTexture?.destroy();
 		this.linearDepthTexture?.destroy();
+		this.msaaColorTexture?.destroy();
+		this.msaaLinearDepthTexture?.destroy();
 		this.quad3dPipeline.destroy();
 		this.slug3dPipeline.destroy();
 		this.mesh3dPipeline.destroy();
@@ -26489,13 +26706,11 @@ function loadModel3D(srcOrData, format = "auto", options = {}) {
 * Directional and Point Light Shadow Map Generator with Percentage Closer Filtering (PCF).
 */
 var ShadowPipeline = class {
-	device;
 	shadowDepthTexture;
 	shadowDepthView;
 	shadowComparisonSampler;
 	lightViewProjMatrix;
 	constructor(device, resolution = 2048) {
-		this.device = device;
 		this.lightViewProjMatrix = Matrix4Math.identity();
 		this.shadowDepthTexture = device.createTexture({
 			label: "shadow-depth-map",
@@ -26522,7 +26737,7 @@ var ShadowPipeline = class {
 			0
 		]);
 		const half = orthoSize * .5;
-		const projMatrix = Matrix4Math.ortho(-half, half, -half, half, near, far);
+		const projMatrix = Matrix4Math.orthographic(-half, half, -half, half, near, far);
 		this.lightViewProjMatrix = Matrix4Math.multiply(projMatrix, viewMatrix);
 		return this.lightViewProjMatrix;
 	}
@@ -26703,7 +26918,7 @@ var SSAOPipeline = class {
 		});
 	}
 	render(commandEncoder, depthView, normalView, rawAOView, finalAOView, options) {
-		const invProj = options.invProjMatrix ?? Matrix4Math.invert(options.projMatrix);
+		const invProj = options.invProjMatrix ?? Matrix4Math.invert(options.projMatrix) ?? Matrix4Math.identity();
 		const uBuf = new Float32Array(64);
 		uBuf.set(options.projMatrix, 0);
 		uBuf.set(invProj, 16);
@@ -26878,7 +27093,19 @@ function isPointInsidePolygon(p, poly) {
 	}
 	return inside;
 }
-function processCurveQuadratic(p0, cp, end, segments, out) {
+const DEFAULT_CURVE_TOLERANCE = .1;
+const MAX_CURVE_SEGMENTS = 64;
+/**
+* Segments needed for a polyline through n uniform steps of a curve to stay
+* within `tolerance`: the chord error is at most max|B''| / (8 n^2).
+*/
+function curveSegmentCount(maxSecondDerivative, flattening) {
+	if (flattening.segments !== void 0) return flattening.segments;
+	const n = Math.ceil(Math.sqrt(maxSecondDerivative / (8 * flattening.tolerance)));
+	return Math.min(MAX_CURVE_SEGMENTS, Math.max(1, n));
+}
+function processCurveQuadratic(p0, cp, end, flattening, out) {
+	const segments = curveSegmentCount(2 * Math.hypot(p0.x - 2 * cp.x + end.x, p0.y - 2 * cp.y + end.y), flattening);
 	for (let s = 1; s <= segments; s++) {
 		const t = s / segments;
 		const mt = 1 - t;
@@ -26888,7 +27115,8 @@ function processCurveQuadratic(p0, cp, end, segments, out) {
 		});
 	}
 }
-function processCurveCubic(p0, cp1, cp2, end, segments, out) {
+function processCurveCubic(p0, cp1, cp2, end, flattening, out) {
+	const segments = curveSegmentCount(6 * Math.max(Math.hypot(p0.x - 2 * cp1.x + cp2.x, p0.y - 2 * cp1.y + cp2.y), Math.hypot(cp1.x - 2 * cp2.x + end.x, cp1.y - 2 * cp2.y + end.y)), flattening);
 	for (let s = 1; s <= segments; s++) {
 		const t = s / segments;
 		const mt = 1 - t;
@@ -26898,7 +27126,7 @@ function processCurveCubic(p0, cp1, cp2, end, segments, out) {
 		});
 	}
 }
-function extractGlyphContours(glyph, glyphX, glyphY, scale, curveSegments) {
+function extractGlyphContours(glyph, glyphX, glyphY, scale, flattening) {
 	const svg = glyph.path?.toSVG();
 	if (!svg) return [];
 	let edges;
@@ -26947,7 +27175,7 @@ function extractGlyphContours(glyph, glyphX, glyphY, scale, curveSegments) {
 				x: (glyphX + args[2]) * scale,
 				y: -(glyphY + args[3]) * scale
 			};
-			processCurveQuadratic(curr, cp, end, curveSegments, current);
+			processCurveQuadratic(curr, cp, end, flattening, current);
 			curr = end;
 		} else if (name === "bezierCurveTo") {
 			const cp1 = {
@@ -26962,45 +27190,90 @@ function extractGlyphContours(glyph, glyphX, glyphY, scale, curveSegments) {
 				x: (glyphX + args[4]) * scale,
 				y: -(glyphY + args[5]) * scale
 			};
-			processCurveCubic(curr, cp1, cp2, end, curveSegments, current);
+			processCurveCubic(curr, cp1, cp2, end, flattening, current);
 			curr = end;
 		} else if (name === "closePath") finishCurrent();
 	}
 	finishCurrent();
 	return contours;
 }
+/** Side-wall segments meeting at more than this angle (30°) keep a hard edge. */
+const SIDE_CREASE_COS = Math.cos(30 * Math.PI / 180);
+/**
+* Group a glyph's contours into filled outlines and their holes by nesting
+* depth: a contour inside an even number of others is an outline (the ring
+* of "O", or the "R" sitting in the counter of "®"), one inside an odd number
+* is a hole of the smallest outline around it.
+*/
 function organizeGlyphPolygons(glyphContours) {
-	if (glyphContours.length === 0) return [];
-	const sorted = [...glyphContours].sort((a, b) => Math.abs(computeContourSignedArea(b)) - Math.abs(computeContourSignedArea(a)));
-	const outers = [];
-	for (const contour of sorted) {
-		const area = Math.abs(computeContourSignedArea(contour));
-		let parent = null;
-		for (const out of outers) if (area < Math.abs(computeContourSignedArea(out.outer))) {
-			const sample = contour[0];
-			const mid = {
-				x: (contour[0].x + contour[Math.floor(contour.length / 2)].x) / 2,
-				y: (contour[0].y + contour[Math.floor(contour.length / 2)].y) / 2
-			};
-			if (isPointInsidePolygon(sample, out.outer) || isPointInsidePolygon(mid, out.outer)) {
-				parent = out;
-				break;
-			}
+	const contours = glyphContours.map((contour) => ({
+		contour,
+		area: Math.abs(computeContourSignedArea(contour))
+	}));
+	contours.sort((a, b) => b.area - a.area);
+	const containers = contours.map(() => []);
+	for (let i = 0; i < contours.length; i++) {
+		const inner = contours[i].contour;
+		const mid = inner[Math.floor(inner.length / 2)];
+		for (let j = 0; j < i; j++) {
+			if (contours[j].area <= contours[i].area) continue;
+			const outer = contours[j].contour;
+			if (isPointInsidePolygon(inner[0], outer) || isPointInsidePolygon(mid, outer)) containers[i].push(j);
 		}
-		if (parent) parent.holes.push(contour);
-		else outers.push({
-			outer: contour,
-			holes: []
-		});
 	}
-	return outers;
+	const polygons = [];
+	const polygonOf = /* @__PURE__ */ new Map();
+	for (let i = 0; i < contours.length; i++) {
+		const around = containers[i];
+		if (around.length % 2 === 0) {
+			const poly = {
+				outer: contours[i].contour,
+				holes: []
+			};
+			polygons.push(poly);
+			polygonOf.set(i, poly);
+		} else polygonOf.get(around[around.length - 1])?.holes.push(contours[i].contour);
+	}
+	return polygons;
+}
+/**
+* A glyph's outlines are flattened and sorted into outlines and holes once per
+* font, size and flattening, at the glyph origin; each use gets a translated
+* copy (callers reorder and move the points they are given).
+*/
+const glyphOutlineCache = /* @__PURE__ */ new WeakMap();
+function glyphPolygonsAt(font, glyph, glyphX, glyphY, scale, flattening) {
+	let byGlyph = glyphOutlineCache.get(font);
+	if (!byGlyph) {
+		byGlyph = /* @__PURE__ */ new Map();
+		glyphOutlineCache.set(font, byGlyph);
+	}
+	const key = `${glyph.id}|${scale}|${flattening.segments ?? ""}|${flattening.tolerance}`;
+	let atOrigin = byGlyph.get(key);
+	if (!atOrigin) {
+		atOrigin = organizeGlyphPolygons(extractGlyphContours(glyph, 0, 0, scale, flattening));
+		byGlyph.set(key, atOrigin);
+	}
+	const dx = glyphX * scale;
+	const dy = -glyphY * scale;
+	const moved = (c) => c.map((p) => ({
+		x: p.x + dx,
+		y: p.y + dy
+	}));
+	return atOrigin.map((poly) => ({
+		outer: moved(poly.outer),
+		holes: poly.holes.map(moved)
+	}));
 }
 function generateExtrudedTextGeometry(options) {
 	const font = options.font;
 	const fontSize = options.fontSize ?? 48;
 	const depth = options.depth ?? 20;
 	const halfDepth = depth / 2;
-	const curveSegments = Math.max(2, options.curveSegments ?? 5);
+	const flattening = {
+		segments: options.curveSegments !== void 0 ? Math.max(2, options.curveSegments) : void 0,
+		tolerance: Math.max(.001, options.curveTolerance ?? DEFAULT_CURVE_TOLERANCE)
+	};
 	const scale = fontSize / (font.unitsPerEm || 1e3);
 	const run = font.layout(options.text);
 	let cursorX = 0;
@@ -27008,7 +27281,7 @@ function generateExtrudedTextGeometry(options) {
 	for (let i = 0; i < run.glyphs.length; i++) {
 		const glyph = run.glyphs[i];
 		const pos = run.positions[i];
-		const glyphPolys = organizeGlyphPolygons(extractGlyphContours(glyph, cursorX + (pos.xOffset ?? 0), pos.yOffset ?? 0, scale, curveSegments));
+		const glyphPolys = glyphPolygonsAt(font, glyph, cursorX + (pos.xOffset ?? 0), pos.yOffset ?? 0, scale, flattening);
 		for (const gp of glyphPolys) polygons.push(gp);
 		cursorX += (pos.xAdvance ?? glyph.advanceWidth ?? 0) + (options.letterSpacing ? options.letterSpacing / scale : 0);
 	}
@@ -27039,8 +27312,8 @@ function generateExtrudedTextGeometry(options) {
 	const w = maxX - minX;
 	const h = maxY - minY;
 	let alignOffsetX = (minX + maxX) / 2;
-	if (options.align === "left") alignOffsetX = minX;
-	if (options.align === "right") alignOffsetX = maxX;
+	if (options.align === "left" || options.align === "start") alignOffsetX = minX;
+	if (options.align === "right" || options.align === "end") alignOffsetX = maxX;
 	let alignOffsetY = (minY + maxY) / 2;
 	if (options.verticalAlign === "top") alignOffsetY = minY;
 	if (options.verticalAlign === "bottom") alignOffsetY = maxY;
@@ -27054,6 +27327,10 @@ function generateExtrudedTextGeometry(options) {
 			p.y -= alignOffsetY;
 		}
 	}
+	minX -= alignOffsetX;
+	maxX -= alignOffsetX;
+	minY -= alignOffsetY;
+	maxY -= alignOffsetY;
 	const frontPositions = [];
 	const frontNormals = [];
 	const frontUvs = [];
@@ -27062,28 +27339,57 @@ function generateExtrudedTextGeometry(options) {
 	const sideNormals = [];
 	const sideUvs = [];
 	const sideIndices = [];
-	const addSideQuad = (p0, p1) => {
-		const dx = p1.x - p0.x;
-		const dy = p1.y - p0.y;
-		const len = Math.hypot(dx, dy);
-		if (len < 1e-6) return;
-		const nx = dy / len;
-		const ny = -dx / len;
-		const baseIdx = sidePositions.length / 3;
-		sidePositions.push(p0.x, p0.y, halfDepth);
-		sideNormals.push(nx, ny, 0);
-		sideUvs.push(0, 0);
-		sidePositions.push(p1.x, p1.y, halfDepth);
-		sideNormals.push(nx, ny, 0);
-		sideUvs.push(1, 0);
-		sidePositions.push(p1.x, p1.y, -halfDepth);
-		sideNormals.push(nx, ny, 0);
-		sideUvs.push(1, 1);
-		sidePositions.push(p0.x, p0.y, -halfDepth);
-		sideNormals.push(nx, ny, 0);
-		sideUvs.push(0, 1);
-		sideIndices.push(baseIdx, baseIdx + 2, baseIdx + 1);
-		sideIndices.push(baseIdx, baseIdx + 3, baseIdx + 2);
+	const addColumn = (p, n, u) => {
+		const index = sidePositions.length / 3;
+		sidePositions.push(p.x, p.y, halfDepth, p.x, p.y, -halfDepth);
+		sideNormals.push(n.x, n.y, 0, n.x, n.y, 0);
+		sideUvs.push(u, 0, u, 1);
+		return index;
+	};
+	const addSideWall = (contour) => {
+		const pts = contour.filter((p, k) => {
+			const next = contour[(k + 1) % contour.length];
+			return Math.hypot(next.x - p.x, next.y - p.y) >= 1e-6;
+		});
+		const count = pts.length;
+		if (count < 2) return;
+		const edgeLengths = [];
+		const faceNormals = pts.map((p, k) => {
+			const next = pts[(k + 1) % count];
+			const len = Math.hypot(next.x - p.x, next.y - p.y);
+			edgeLengths.push(len);
+			return {
+				x: (next.y - p.y) / len,
+				y: -(next.x - p.x) / len
+			};
+		});
+		const perimeter = edgeLengths.reduce((a, b) => a + b, 0);
+		const startColumn = [];
+		const endColumn = [];
+		let along = 0;
+		for (let k = 0; k < count; k++) {
+			const incoming = faceNormals[(k - 1 + count) % count];
+			const outgoing = faceNormals[k];
+			const u = along / perimeter;
+			const sx = incoming.x + outgoing.x;
+			const sy = incoming.y + outgoing.y;
+			const averaged = incoming.x * outgoing.x + incoming.y * outgoing.y >= SIDE_CREASE_COS ? {
+				x: sx / Math.hypot(sx, sy),
+				y: sy / Math.hypot(sx, sy)
+			} : null;
+			if (averaged && k > 0) startColumn[k] = endColumn[k] = addColumn(pts[k], averaged, u);
+			else {
+				endColumn[k] = addColumn(pts[k], averaged ?? incoming, k === 0 ? 1 : u);
+				startColumn[k] = addColumn(pts[k], averaged ?? outgoing, u);
+			}
+			along += edgeLengths[k];
+		}
+		for (let k = 0; k < count; k++) {
+			const a = startColumn[k];
+			const b = endColumn[(k + 1) % count];
+			sideIndices.push(a, b + 1, b);
+			sideIndices.push(a, a + 1, b + 1);
+		}
 	};
 	for (const poly of polygons) {
 		const outer = poly.outer;
@@ -27102,28 +27408,22 @@ function generateExtrudedTextGeometry(options) {
 		for (let v = 0; v < vertCount; v++) {
 			const vx = earcutCoords[v * 2];
 			const vy = earcutCoords[v * 2 + 1];
-			frontPositions.push(vx, vy, halfDepth);
-			frontNormals.push(0, 0, 1);
+			frontPositions.push(vx, vy, -halfDepth);
+			frontNormals.push(0, 0, -1);
 			frontUvs.push((vx - minX) / (w || 1), (vy - minY) / (h || 1));
 		}
-		for (let t = 0; t < triangles.length; t += 3) frontIndices.push(frontBaseIdx + triangles[t], frontBaseIdx + triangles[t + 1], frontBaseIdx + triangles[t + 2]);
-		const backBaseIdx = sidePositions.length / 3;
+		for (let t = 0; t < triangles.length; t += 3) frontIndices.push(frontBaseIdx + triangles[t], frontBaseIdx + triangles[t + 2], frontBaseIdx + triangles[t + 1]);
+		const backBaseIdx = frontPositions.length / 3;
 		for (let v = 0; v < vertCount; v++) {
 			const vx = earcutCoords[v * 2];
 			const vy = earcutCoords[v * 2 + 1];
-			sidePositions.push(vx, vy, -halfDepth);
-			sideNormals.push(0, 0, -1);
-			sideUvs.push((vx - minX) / (w || 1), (vy - minY) / (h || 1));
-		}
-		for (let t = 0; t < triangles.length; t += 3) sideIndices.push(backBaseIdx + triangles[t], backBaseIdx + triangles[t + 2], backBaseIdx + triangles[t + 1]);
-		for (let k = 0; k < outer.length; k++) {
-			const next = (k + 1) % outer.length;
-			addSideQuad(outer[k], outer[next]);
-		}
-		for (const hole of poly.holes) for (let k = 0; k < hole.length; k++) {
-			const next = (k + 1) % hole.length;
-			addSideQuad(hole[k], hole[next]);
+			frontPositions.push(vx, vy, halfDepth);
+			frontNormals.push(0, 0, 1);
+			frontUvs.push((vx - minX) / (w || 1), (vy - minY) / (h || 1));
 		}
+		for (let t = 0; t < triangles.length; t += 3) frontIndices.push(backBaseIdx + triangles[t], backBaseIdx + triangles[t + 1], backBaseIdx + triangles[t + 2]);
+		addSideWall(outer);
+		for (const hole of poly.holes) addSideWall(hole);
 	}
 	const frontColor = parseHexOrRgbColor(options.fill ?? "#ffffff");
 	const sideColor = parseHexOrRgbColor(options.bevelColor ?? options.fill ?? "#ffffff");
@@ -27133,8 +27433,6 @@ function generateExtrudedTextGeometry(options) {
 		shading: options.material ?? "lit",
 		shininess: options.shininess ?? 32,
 		roughness: options.roughness,
-		specularIntensity: options.specularIntensity ?? .8,
-		ambientIntensity: options.ambientIntensity ?? 1,
 		metallic: options.metallic,
 		twoSided: true
 	};
@@ -27144,8 +27442,6 @@ function generateExtrudedTextGeometry(options) {
 		shading: options.material ?? "lit",
 		shininess: options.shininess ?? 32,
 		roughness: options.roughness,
-		specularIntensity: options.specularIntensity ?? .8,
-		ambientIntensity: options.ambientIntensity ?? 1,
 		metallic: options.metallic,
 		twoSided: true
 	};
@@ -27176,7 +27472,30 @@ function generateExtrudedTextGeometry(options) {
 				"front-material": frontMaterial,
 				"side-material": sideMaterial
 			},
-			animations: []
+			animations: [],
+			bounds: {
+				min: [
+					minX,
+					minY,
+					-halfDepth
+				],
+				max: [
+					maxX,
+					maxY,
+					halfDepth
+				],
+				center: [
+					(minX + maxX) / 2,
+					(minY + maxY) / 2,
+					0
+				],
+				size: [
+					w,
+					h,
+					depth
+				],
+				boundingSphereRadius: Math.hypot(w, h, depth) / 2
+			}
 		},
 		bounds: {
 			minX,
@@ -27191,5 +27510,5 @@ function generateExtrudedTextGeometry(options) {
 }
 
 //#endregion
-export { parseOBJ as $, drawCaptionNode as A, generateExtrudedTextGeometry as B, SlugGeometry as C, chartBridgeCache as D, buildWGSLSignalFn as E, drawParagraphNode as F, loadFBX as G, getRenderer2D as H, drawSignalNode as I, lutStore as J, loadModel3D as K, drawSvgNode as L, drawGifNode as M, drawImageNode as N, clearVideoNodeState as O, drawLottieNode as P, parseMTL as Q, drawVideoNode as R, SlugFontCache as S, WebGPUAudioProcessor as T, initHeadlessWebGPU as U, getHeadlessFontPath as V, inputStore as W, parseColor as X, mediaDecoderCache as Y, parseFBX as Z, Renderer2D as _, Camera3D as a, GetFontAssetUrl as at, ShadowPipeline as b, GlassPipeline as c, resolveMediaSourceUrl as ct, HeadlessGPUCanvasContextMock as d, registerHeadlessFont as et, Light3D as f, RenderProvider as g, Path3D as h, AudioSignalComputePipeline as i, useRenderContext as it, drawChartNode as j, colorMatrixWgsl as k, HeadlessChartCanvasElementMock as l, NodeSurfaceProvider as m, AudioLatentTrackCache as n, signalRegistry as nt, ChartGPUEngineBridge as o, R2_CUSTOM_DOMAIN as ot, MotionBlurPipeline as p, loadOBJ as q, AudioMeshDeformPipeline as r, textureCache as rt, EffectPipeline as s, getEnv as st, AudioLatentEngine as t, shaderStore as tt, HeadlessChartContainerMock as u, Renderer3D as v, SlugPipeline as w, SignalRegistry as x, SSAOPipeline as y, ensureDevice as z };
-//# sourceMappingURL=dist-C37594c6.mjs.map
+export { parseMTL as $, colorMatrixWgsl as A, ensureDevice as B, SlugGeometry as C, chartBridgeCache as D, buildWGSLSignalFn as E, drawLottieNode as F, inputStore as G, getHeadlessFontPath as H, drawParagraphNode as I, loadOBJ as J, loadFBX as K, drawSignalNode as L, drawChartNode as M, drawGifNode as N, clearAllVideoCache as O, drawImageNode as P, parseFBX as Q, drawSvgNode as R, SlugFontCache as S, WebGPUAudioProcessor as T, getRenderer2D as U, generateExtrudedTextGeometry as V, initHeadlessWebGPU as W, mediaDecoderCache as X, lutStore as Y, parseColor as Z, Renderer2D as _, Camera3D as a, useRenderContext as at, ShadowPipeline as b, GlassPipeline as c, getEnv as ct, HeadlessGPUCanvasContextMock as d, parseOBJ as et, Light3D as f, RenderProvider as g, Path3D as h, AudioSignalComputePipeline as i, textureCache as it, drawCaptionNode as j, clearVideoNodeState as k, HeadlessChartCanvasElementMock as l, resolveMediaSourceUrl as lt, NodeSurfaceProvider as m, AudioLatentTrackCache as n, shaderStore as nt, ChartGPUEngineBridge as o, GetFontAssetUrl as ot, MotionBlurPipeline as p, loadModel3D as q, AudioMeshDeformPipeline as r, signalRegistry as rt, EffectPipeline as s, R2_CUSTOM_DOMAIN as st, AudioLatentEngine as t, registerHeadlessFont as tt, HeadlessChartContainerMock as u, Renderer3D as v, SlugPipeline as w, SignalRegistry as x, SSAOPipeline as y, drawVideoNode as z };
+//# sourceMappingURL=dist-8vbhZYqX.mjs.map