framefields 2.8.0 → 2.9.0

package/dist/{dist-CnFcSau0.mjs → dist-C1cCW7Bt.mjs}

@@ -10052,6 +10052,7 @@ function resolveEnvironment(opts) {
 * normal matrix computation for non-uniform surface scaling,
 * and binary uniform buffer packing for WGSL shaders.
 */
+/** Slots retained in the legacy uniform prefix; actual direct lights use storage. */
 const MAX_LIGHTS = 8;
 /**
 * 16 (ambient) + 16 (params) + 8 * 64 (lights), then the physical-shading
@@ -10255,7 +10256,7 @@ const Light3D = {
 			ambientR += col[0] * int$1;
 			ambientG += col[1] * int$1;
 			ambientB += col[2] * int$1;
-		} else if (directLights.length < MAX_LIGHTS) directLights.push(Light3D.processLight(l));
+		} else directLights.push(Light3D.processLight(l));
 		buffer[0] = ambientR;
 		buffer[1] = ambientG;
 		buffer[2] = ambientB;
@@ -10287,12 +10288,42 @@ const Light3D = {
 		}
 		return buffer;
 	},
+	packDirectLights(lights, shadows = []) {
+		const direct = lights.filter((light) => (light.lightType ?? light.type) !== "ambient");
+		const data = new Float32Array(Math.max(1, direct.length) * 40);
+		const shadowLayers = new Map(shadows.map((shadow, layer) => [shadow.lightIndex, layer]));
+		for (const [i, light] of direct.entries()) {
+			const packed = Light3D.processLight(light);
+			const offset = i * 40;
+			data.set(packed.posType, offset);
+			data.set(packed.dirRadius, offset + 4);
+			data.set(packed.colorIntensity, offset + 8);
+			data.set(packed.spotParams, offset + 12);
+			const layer = shadowLayers.get(i);
+			const shadow = layer === void 0 ? void 0 : shadows[layer];
+			if (shadow && layer !== void 0) {
+				for (let j = 0; j < 16; j++) data[offset + 16 + j] = shadow.matrix[j] ?? 0;
+				data.set([
+					shadow.softness,
+					shadow.mapSize,
+					layer,
+					1
+				], offset + 32);
+				data.set([
+					shadow.bias,
+					shadow.normalOffset,
+					shadow.darkness,
+					0
+				], offset + 36);
+			}
+		}
+		return data;
+	},
 	shadowCasterIndex(lights) {
 		let index = 0;
 		for (const l of lights) {
 			const kind = l.lightType ?? l.type;
 			if (kind === "ambient") continue;
-			if (index >= MAX_LIGHTS) break;
 			if (l.castShadow && (kind === "directional" || kind === "spot")) return index;
 			index++;
 		}
@@ -10400,7 +10431,7 @@ var Path3D = class Path3D$1 {
 			0,
 			0
 		];
-		let b0 = Vector3Math.normalize(Vector3Math.cross(t0, n0));
+		const b0 = Vector3Math.normalize(Vector3Math.cross(t0, n0));
 		this.frames[0] = {
 			normal: n0,
 			binormal: b0,
@@ -10443,6 +10474,21 @@ var Path3D = class Path3D$1 {
 		];
 	}
 	/**
+	* Returns a copy of the discrete samples `[position, tangent, distance]` along this path.
+	*/
+	getSamples() {
+		return this.samples;
+	}
+	/**
+	* Evaluates `count` evenly arc-length-spaced 3D positions along the path.
+	*/
+	getPoints(count = 64) {
+		const n = Math.max(2, Math.round(count));
+		const pts = [];
+		for (let i = 0; i < n; i++) pts.push(this.getPointAt(i / (n - 1)).position);
+		return pts;
+	}
+	/**
 	* Evaluates point, tangent, normal, binormal, and rotation at normalized progress u in [0, 1].
 	* Progression moves with constant velocity along the arc length of the path.
 	*/
@@ -17784,8 +17830,6 @@ function transformModelBounds(bounds, { offset, scale }) {
 * hierarchy into model-space matrices, and turns a skin's joints into the
 * joint matrices the mesh shader blends (joint world × inverse bind).
 */
-/** Joints per skin the mesh shader holds (mesh3d.wgsl jointMatrices). */
-const MAX_JOINTS = 128;
 /** Column-major translate · rotate(quaternion) · scale. */
 function trsMatrix(t, q, s) {
 	const [x, y, z, w] = q;
@@ -17927,12 +17971,12 @@ function poseNodes(model, clip, time$2) {
 	};
 	return nodes.map((_, i) => resolve$1$1(i));
 }
-/** The joint matrices of one skin for a posed scene graph, padded with identity to MAX_JOINTS. */
+/** The joint matrices of one skin for a posed scene graph. */
 function jointMatrices(model, skinIndex, world) {
 	const skin = model.skins?.[skinIndex];
 	if (!skin) throw new Error(`model has no skin ${skinIndex}`);
-	const out = new Float32Array(MAX_JOINTS * 16);
-	for (let j = 0; j < MAX_JOINTS; j++) {
+	const out = new Float32Array(Math.max(1, skin.joints.length) * 16);
+	for (let j = 0; j < Math.max(1, skin.joints.length); j++) {
 		const node = skin.joints[j];
 		if (node === void 0) {
 			out.set(Matrix4Math.identity(), j * 16);
@@ -18354,7 +18398,6 @@ var FbxLoader = class FbxLoader$1 {
 						influences.set(cp, list);
 					}
 				}
-				if (joints.length > MAX_JOINTS) throw new Error(`FBX skin has ${joints.length} bones; the mesh shader holds ${MAX_JOINTS}`);
 				if (joints.length > 0) {
 					skinIndex = skins.length;
 					skins.push({
@@ -20054,7 +20097,6 @@ var GltfLoader = class GltfLoader$1 {
 				});
 			});
 		}
-		for (const skin of skins) if (skin.joints.length > MAX_JOINTS) throw new Error(`glTF skin has ${skin.joints.length} joints; the mesh shader holds ${MAX_JOINTS}`);
 		if (!Number.isFinite(minX)) {
 			minX = minY = minZ = 0;
 			maxX = maxY = maxZ = 0;
@@ -25798,6 +25840,13 @@ var VideoDecoder = class extends BaseMediaDecoder {
 	*/
 	decodeBuffer = null;
 	nextRequest = null;
+	/** Precise video-track duration, independent of a potentially longer audio track. */
+	async durationSec() {
+		await this.init();
+		const track = await this.input?.getPrimaryVideoTrack();
+		if (!track) throw new Error(`No video track in ${this.url}`);
+		return track.computeDuration();
+	}
 	pushHeadlessQueue(sample) {
 		const index = this.headlessQueue.findIndex((s) => s.timestamp > sample.timestamp);
 		if (index === -1) this.headlessQueue.push(sample);
@@ -30950,6 +30999,16 @@ struct GPULight {
     spotParams     : vec4<f32>, // x = cos(outer), y = cos(inner), z = decay, w = unused
 };
 
+struct DirectLight {
+    posType : vec4<f32>,
+    dirRadius : vec4<f32>,
+    colorIntensity : vec4<f32>,
+    spotParams : vec4<f32>,
+    shadowMatrix : mat4x4<f32>,
+    shadowParams : vec4<f32>,
+    shadowBias : vec4<f32>,
+};
+
 struct LightsUniforms {
     ambientColor  : vec4<f32>, // rgb = ambient color * intensity (sRGB), w = unused
     params        : vec4<f32>, // x = numLights, y = hasLights, z = physical (1), w = tone mapping (0 none, 1 ACES, 2 AgX, 3 PBR Neutral)
@@ -31132,25 +31191,26 @@ var<private> POISSON : array<vec2<f32>, 12> = array<vec2<f32>, 12>(
 
 /// 1 = fully lit, 0 = fully shadowed, for light index i.
 fn shadowFactor(worldPos: vec3<f32>, N: vec3<f32>, i: i32) -> f32 {
-    if (lights.shadowParams.x < 0.5 || i32(lights.shadowParams.y) != i) {
+    let shadow = directLights[i];
+    if (shadow.shadowParams.w < 0.5) {
         return 1.0;
     }
-    let p = worldPos + N * lights.shadowBias.y;
-    let lp = lights.shadowMatrix * vec4<f32>(p, 1.0);
+    let p = worldPos + N * shadow.shadowBias.y;
+    let lp = shadow.shadowMatrix * vec4<f32>(p, 1.0);
     let ndc = lp.xyz / lp.w;
     let uv = vec2<f32>(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
     if (lp.w <= 0.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0 || ndc.z > 1.0) {
         return 1.0;
     }
-    let texel = 1.0 / max(lights.shadowParams.w, 1.0);
-    let radius = lights.shadowParams.z * texel;
-    let depthRef = ndc.z - lights.shadowBias.x;
+    let texel = 1.0 / max(shadow.shadowParams.y, 1.0);
+    let radius = shadow.shadowParams.x * texel;
+    let depthRef = ndc.z - shadow.shadowBias.x;
     var lit = 0.0;
     for (var k = 0; k < 12; k++) {
-        lit += textureSampleCompareLevel(shadowMap, shadowSampler, uv + POISSON[k] * radius, depthRef);
+        lit += textureSampleCompareLevel(shadowMap, shadowSampler, uv + POISSON[k] * radius, i32(shadow.shadowParams.z), depthRef);
     }
     lit = lit / 12.0;
-    return mix(1.0, lit, lights.shadowBias.z);
+    return mix(1.0, lit, shadow.shadowBias.z);
 }
 
 // ── Lights ────────────────────────────────────────────────────────────
@@ -31163,7 +31223,7 @@ struct LightSample {
 
 fn sampleLight(i: i32, worldPos: vec3<f32>) -> LightSample {
     var out = LightSample(vec3<f32>(0.0, 0.0, 1.0), 1.0, false);
-    let light = lights.lights[i];
+    let light = directLights[i];
     let lightType = light.posType.w;
     if (lightType > 0.5 && lightType < 1.5) {
         out.L = normalize(-light.dirRadius.xyz);
@@ -31212,15 +31272,12 @@ fn applyLighting3D(worldPos: vec3<f32>, worldNormal: vec3<f32>, baseColor: vec3<
 
     var totalIllumination = baseColor * (lights.ambientColor.rgb * ambientInt);
     let numLights = i32(lights.params.x);
-    for (var i = 0; i < 8; i++) {
-        if (i >= numLights) {
-            break;
-        }
+    for (var i = 0; i < numLights; i++) {
         let ls = sampleLight(i, worldPos);
         if (!ls.valid) {
             continue;
         }
-        let light = lights.lights[i];
+        let light = directLights[i];
         let lightColor = light.colorIntensity.rgb;
         let intensity = light.colorIntensity.w;
         let NdotL = max(dot(N, ls.L), 0.0);
@@ -31253,15 +31310,12 @@ fn shadePhysical(worldPos: vec3<f32>, worldNormal: vec3<f32>, albedo: vec3<f32>,
 
     var lo = vec3<f32>(0.0);
     let numLights = i32(lights.params.x);
-    for (var i = 0; i < 8; i++) {
-        if (i >= numLights) {
-            break;
-        }
+    for (var i = 0; i < numLights; i++) {
         let ls = sampleLight(i, worldPos);
         if (!ls.valid) {
             continue;
         }
-        let light = lights.lights[i];
+        let light = directLights[i];
         let nDotL = max(dot(N, ls.L), 0.0);
         if (nDotL <= 0.0) {
             continue;
@@ -31358,8 +31412,9 @@ fn shadeSurface(worldPos: vec3<f32>, worldNormal: vec3<f32>, baseColor: vec3<f32
 /** Group-3 bindings every lit 3D shader declares. */
 const lightsBindingsWgsl = `
 @group(3) @binding(0) var<uniform> lights : LightsUniforms;
-@group(3) @binding(1) var shadowMap : texture_depth_2d;
+@group(3) @binding(1) var shadowMap : texture_depth_2d_array;
 @group(3) @binding(2) var shadowSampler : sampler_comparison;
+@group(3) @binding(3) var<storage, read> directLights : array<DirectLight>;
 `;
 /**
 * The 3D pipelines draw into one of four target sets: color; color + linear
@@ -32385,7 +32440,7 @@ fn matteCoverage(fragPos : vec2<f32>) -> f32 {
 }
 /**
 * WebGPU WGSL shaders for 3D static and skinned meshes.
-* Supports GPU Linear Blend Skinning (up to 128 bones),
+* Supports GPU Linear Blend Skinning,
 * the shared 3D surface shading (Blinn-Phong, or physical GGX + image-based light
 * in scenes with an environment) or toon shading, shadow maps, emissive,
 * alpha-cutoff (glTF MASK) materials,
@@ -32398,7 +32453,7 @@ struct ModelUniforms {
     modelMatrix    : mat4x4<f32>,
     normalMatrix   : mat4x4<f32>,
     colorTint      : vec4<f32>,
-    params         : vec4<f32>, // x = opacity, y = twoSided, z = isSkinned, w = flags (bit 0 instanced, bit 1 map UVs)
+    params         : vec4<f32>, // x = opacity, y = twoSided, z = isSkinned, w = flags (bit 0 instanced, bit 1 map UVs, bit 2 matrix instances)
     materialParams : vec4<f32>, // x = shininess, y = specularIntensity, z = ambientIntensity, w = materialMode (0=unlit, 1=lit, 2=toon)
     shade          : vec4<f32>, // rgb = toon shadow-side color multiplier, a = alpha cutoff (0 = none)
     pbr            : vec4<f32>, // x = roughness (<0 = default), y = metallic
@@ -32407,7 +32462,7 @@ struct ModelUniforms {
 };
 
 struct SkinningUniforms {
-    jointMatrices : array<mat4x4<f32>, 128>,
+    jointMatrices : array<mat4x4<f32>>,
 };
 
 struct InstanceData {
@@ -32419,7 +32474,7 @@ struct InstanceData {
 
 @group(0) @binding(0) var<uniform> cam      : CameraUniforms;
 @group(1) @binding(0) var<uniform> model    : ModelUniforms;
-@group(1) @binding(1) var<uniform> skinning : SkinningUniforms;
+@group(1) @binding(1) var<storage, read> skinning : SkinningUniforms;
 ${matte3dWgsl(1, 2)}@group(1) @binding(3) var backdropTex : texture_2d<f32>;
 @group(1) @binding(4) var<storage, read> instances : array<InstanceData>;
 @group(2) @binding(0) var texSampler        : sampler;
@@ -32505,7 +32560,14 @@ fn vs_main(
     var instColor = vec4<f32>(1.0);
     var instEmissive = vec4<f32>(0.0);
 
-    if ((u32(model.params.w) & 1u) != 0u) {
+    if ((u32(model.params.w) & 4u) != 0u) {
+        let a = instances[instanceIndex * 2u];
+        let b = instances[instanceIndex * 2u + 1u];
+        let instanceModel = mat4x4<f32>(a.posScale, a.quat, a.color, a.emissive);
+        let instanceNormal = mat4x4<f32>(b.posScale, b.quat, b.color, b.emissive);
+        localPos = (instanceModel * vec4<f32>(localPos, 1.0)).xyz;
+        localNorm = (instanceNormal * vec4<f32>(localNorm, 0.0)).xyz;
+    } else if ((u32(model.params.w) & 1u) != 0u) {
         let inst = instances[instanceIndex];
         let scaledPos = localPos * inst.posScale.w;
         localPos = rotateVecByQuat(scaledPos, inst.quat) + inst.posScale.xyz;
@@ -33057,12 +33119,20 @@ function createLightsLayout(device, label = "Lights3DLayout") {
 			{
 				binding: 1,
 				visibility: GPUShaderStage.FRAGMENT,
-				texture: { sampleType: "depth" }
+				texture: {
+					sampleType: "depth",
+					viewDimension: "2d-array"
+				}
 			},
 			{
 				binding: 2,
 				visibility: GPUShaderStage.FRAGMENT,
 				sampler: { type: "comparison" }
+			},
+			{
+				binding: 3,
+				visibility: GPUShaderStage.FRAGMENT,
+				buffer: { type: "read-only-storage" }
 			}
 		]
 	});
@@ -33367,7 +33437,7 @@ var Mesh3DPipeline = class {
 	constructor(device, format, depthFormat = "depth24plus", cameraLayout, lightsLayout, sampleCount = 1) {
 		this.device = device;
 		this.modelPool = new BufferPool((52 + SURFACE_PARAMS_FLOATS) * 4, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
-		this.skinningPool = new BufferPool(8192, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
+		this.skinningPool = new BufferPool(64, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
 		const module$1 = device.createShaderModule({
 			label: "mesh3d.wgsl",
 			code: mesh3dWgsl
@@ -33391,7 +33461,7 @@ var Mesh3DPipeline = class {
 				{
 					binding: 1,
 					visibility: GPUShaderStage.VERTEX,
-					buffer: { type: "uniform" }
+					buffer: { type: "read-only-storage" }
 				},
 				matteLayoutEntry(2),
 				matteLayoutEntry(3),
@@ -33642,16 +33712,11 @@ var Mesh3DPipeline = class {
 			width: 1,
 			height: 1
 		});
-		const idMatrices = new Float32Array(2048);
-		for (let b = 0; b < 128; b++) {
-			idMatrices[b * 16] = 1;
-			idMatrices[b * 16 + 5] = 1;
-			idMatrices[b * 16 + 10] = 1;
-			idMatrices[b * 16 + 15] = 1;
-		}
+		const idMatrices = new Float32Array(16);
+		idMatrices[0] = idMatrices[5] = idMatrices[10] = idMatrices[15] = 1;
 		this.defaultSkinningBuffer = device.createBuffer({
-			size: 8192,
-			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+			size: 64,
+			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
 			mappedAtCreation: true
 		});
 		new Float32Array(this.defaultSkinningBuffer.getMappedRange()).set(idMatrices);
@@ -33690,7 +33755,7 @@ var Mesh3DPipeline = class {
 		this.modelData[36] = data.opacity ?? 1;
 		this.modelData[37] = data.twoSided ? 1 : 0;
 		this.modelData[38] = data.isSkinned ? 1 : 0;
-		this.modelData[39] = (data.isInstanced || data.instanceBuffer ? 1 : 0) + (data.hasMapUvs ? 2 : 0);
+		this.modelData[39] = (data.isInstanced || data.instanceBuffer ? 1 : 0) + (data.hasMapUvs ? 2 : 0) + (data.matrixInstances ? 4 : 0);
 		const shininess = data.roughness !== void 0 ? Math.max(1, (1 - data.roughness) * 128) : data.shininess ?? 32;
 		const specInt = data.metallic !== void 0 ? data.metallic : data.specularIntensity ?? .5;
 		const ambientInt = data.ambientIntensity ?? 1;
@@ -33723,6 +33788,7 @@ var Mesh3DPipeline = class {
 			this.modelData[51] = glass.ior;
 		}
 		const modelBuffer = this.modelPool.getBuffer(this.device, this.modelData);
+		if (data.skinningMatrices && data.skinningMatrices.byteLength > this.device.limits.maxStorageBufferBindingSize) throw new Error(`Skinning data requires ${data.skinningMatrices.byteLength} bytes, exceeding the device storage binding limit of ${this.device.limits.maxStorageBufferBindingSize} bytes`);
 		const skinningBuffer = data.isSkinned && data.skinningMatrices ? this.skinningPool.getBuffer(this.device, data.skinningMatrices) : this.defaultSkinningBuffer;
 		return this.device.createBindGroup({
 			layout: this.modelLayout,
@@ -34119,37 +34185,13 @@ var MotionBlurPipeline = class {
 	}
 };
 function parseHexOrRgbColor(colorStr) {
-	const c = colorStr.trim();
-	if (c.startsWith("#")) {
-		const hex = c.slice(1);
-		if (hex.length === 3) return [
-			Number.parseInt(hex[0] + hex[0], 16) / 255,
-			Number.parseInt(hex[1] + hex[1], 16) / 255,
-			Number.parseInt(hex[2] + hex[2], 16) / 255,
-			1
-		];
-		if (hex.length === 6) return [
-			Number.parseInt(hex.slice(0, 2), 16) / 255,
-			Number.parseInt(hex.slice(2, 4), 16) / 255,
-			Number.parseInt(hex.slice(4, 6), 16) / 255,
-			1
-		];
-		if (hex.length === 8) return [
-			Number.parseInt(hex.slice(0, 2), 16) / 255,
-			Number.parseInt(hex.slice(2, 4), 16) / 255,
-			Number.parseInt(hex.slice(4, 6), 16) / 255,
-			Number.parseInt(hex.slice(6, 8), 16) / 255
-		];
-	}
-	if (c.startsWith("rgb")) {
-		const parts = c.replace(/rgba?\(/, "").replace(/\)/, "").split(",").map((p) => Number.parseFloat(p.trim()));
-		return [
-			(parts[0] ?? 0) / 255,
-			(parts[1] ?? 0) / 255,
-			(parts[2] ?? 0) / 255,
-			parts[3] !== void 0 ? parts[3] : 1
-		];
-	}
+	const c = parseColor(colorStr);
+	if (c.a > 0 || colorStr.trim().toLowerCase() === "transparent") return [
+		c.r,
+		c.g,
+		c.b,
+		c.a
+	];
 	return [
 		1,
 		1,
@@ -34298,7 +34340,7 @@ function extractGlyphContours(glyph, glyphX, glyphY, scale, flattening) {
 	};
 }
 /** Side-wall segments meeting at more than this angle (30°) keep a hard edge. */
-const SIDE_CREASE_COS = Math.cos(30 * Math.PI / 180);
+const SIDE_CREASE_COS$1 = 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
@@ -34597,7 +34639,7 @@ function generateExtrudedTextGeometry(options) {
 			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 ? {
+			const averaged = incoming.x * outgoing.x + incoming.y * outgoing.y >= SIDE_CREASE_COS$1 ? {
 				x: sx / Math.hypot(sx, sy),
 				y: sy / Math.hypot(sx, sy)
 			} : null;
@@ -34736,11 +34778,14 @@ var MeshBuilder = class {
 	positions = [];
 	normals = [];
 	uvs = [];
+	colors = [];
 	indices = [];
-	vertex(p, n, uv) {
+	topology;
+	vertex(p, n, uv, color) {
 		this.positions.push(p[0], p[1], p[2]);
 		this.normals.push(n[0], n[1], n[2]);
 		this.uvs.push(uv[0], uv[1]);
+		if (color) this.colors.push(color[0], color[1], color[2], color[3]);
 		return this.positions.length / 3 - 1;
 	}
 	/**
@@ -34760,7 +34805,7 @@ var MeshBuilder = class {
 	}
 	build(name) {
 		const count = this.positions.length / 3;
-		return {
+		const mesh = {
 			id: `${name}-mesh`,
 			name,
 			positions: new Float32Array(this.positions),
@@ -34769,6 +34814,9 @@ var MeshBuilder = class {
 			indices: count > 65535 ? new Uint32Array(this.indices) : new Uint16Array(this.indices),
 			materialName: `${name}-material`
 		};
+		if (this.topology) mesh.topology = this.topology;
+		if (this.colors.length === count * 4 && this.colors.length > 0) mesh.colors = new Float32Array(this.colors);
+		return mesh;
 	}
 };
 function normalize(v) {
@@ -34783,6 +34831,23 @@ function normalize(v) {
 		0
 	];
 }
+function sub3(a, b) {
+	return [
+		a[0] - b[0],
+		a[1] - b[1],
+		a[2] - b[2]
+	];
+}
+function dot3(a, b) {
+	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross3(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
 /**
 * 1D samples across a side of half-extent `e` whose ends round off with
 * radius `r`: arc-spaced through each rounded zone, nothing in between, so
@@ -34943,29 +35008,87 @@ function sphere(o, mb) {
 }
 function cylinder(o, mb) {
 	const seg = Math.max(3, Math.round(o.segments ?? 32));
-	const rTop = o.radiusTop ?? o.radius ?? 50;
-	const rBottom = o.radiusBottom ?? o.radius ?? 50;
+	const rTop = Math.max(0, o.radiusTop ?? o.radius ?? 50);
+	const rBottom = Math.max(0, o.radiusBottom ?? o.radius ?? 50);
 	const hy = o.height / 2;
-	const lean = o.height > 0 ? (rBottom - rTop) / o.height : 0;
-	for (let j = 0; j <= 1; j++) {
-		const rr = j === 0 ? rTop : rBottom;
-		const y = j === 0 ? -hy : hy;
-		for (let i = 0; i <= seg; i++) {
-			const theta = i / seg * Math.PI * 2;
-			const c = Math.cos(theta);
-			const s = Math.sin(theta);
-			mb.vertex([
-				c * rr,
-				y,
-				s * rr
-			], normalize([
-				c,
-				-lean,
-				s
-			]), [i / seg, j]);
+	if (o.flatShaded) for (let i = 0; i < seg; i++) {
+		const theta0 = i / seg * Math.PI * 2;
+		const theta1 = (i + 1) / seg * Math.PI * 2;
+		const c0 = Math.cos(theta0);
+		const s0 = Math.sin(theta0);
+		const c1 = Math.cos(theta1);
+		const s1 = Math.sin(theta1);
+		const t0 = [
+			c0 * rTop,
+			-hy,
+			s0 * rTop
+		];
+		const t1 = [
+			c1 * rTop,
+			-hy,
+			s1 * rTop
+		];
+		const b0 = [
+			c0 * rBottom,
+			hy,
+			s0 * rBottom
+		];
+		const b1 = [
+			c1 * rBottom,
+			hy,
+			s1 * rBottom
+		];
+		const fn = normalize(cross3(sub3(b0, t0), rBottom >= rTop ? sub3(b1, b0) : sub3(t1, t0)));
+		const u0 = i / seg;
+		const u1 = (i + 1) / seg;
+		if (rTop <= 1e-6) {
+			const apex = mb.vertex([
+				0,
+				-hy,
+				0
+			], fn, [(u0 + u1) / 2, 0]);
+			const vB0 = mb.vertex(b0, fn, [u0, 1]);
+			const vB1 = mb.vertex(b1, fn, [u1, 1]);
+			mb.indices.push(apex, vB0, vB1);
+		} else if (rBottom <= 1e-6) {
+			const vT0 = mb.vertex(t0, fn, [u0, 0]);
+			const vT1 = mb.vertex(t1, fn, [u1, 0]);
+			const apex = mb.vertex([
+				0,
+				hy,
+				0
+			], fn, [(u0 + u1) / 2, 1]);
+			mb.indices.push(vT0, apex, vT1);
+		} else {
+			const base = mb.vertex(t0, fn, [u0, 0]);
+			mb.vertex(t1, fn, [u1, 0]);
+			mb.vertex(b0, fn, [u0, 1]);
+			mb.vertex(b1, fn, [u1, 1]);
+			mb.indices.push(base, base + 2, base + 1, base + 1, base + 2, base + 3);
+		}
+	}
+	else {
+		const lean = o.height > 0 ? (rBottom - rTop) / o.height : 0;
+		for (let j = 0; j <= 1; j++) {
+			const rr = j === 0 ? rTop : rBottom;
+			const y = j === 0 ? -hy : hy;
+			for (let i = 0; i <= seg; i++) {
+				const theta = i / seg * Math.PI * 2;
+				const c = Math.cos(theta);
+				const s = Math.sin(theta);
+				mb.vertex([
+					c * rr,
+					y,
+					s * rr
+				], normalize([
+					c,
+					-lean,
+					s
+				]), [i / seg, j]);
+			}
 		}
+		mb.grid(0, seg, 1);
 	}
-	mb.grid(0, seg, 1);
 	if (o.openEnded) return;
 	for (const [y, rr, ny] of [[
 		-hy,
@@ -34976,7 +35099,7 @@ function cylinder(o, mb) {
 		rBottom,
 		1
 	]]) {
-		if (rr <= 0) continue;
+		if (rr <= 1e-6) continue;
 		const center = mb.vertex([
 			0,
 			y,
@@ -34986,7 +35109,7 @@ function cylinder(o, mb) {
 			ny,
 			0
 		], [.5, .5]);
-		const ring = mb.positions.length / 3;
+		const ring$1 = mb.positions.length / 3;
 		for (let i = 0; i <= seg; i++) {
 			const theta = i / seg * Math.PI * 2;
 			const c = Math.cos(theta);
@@ -35001,98 +35124,2015 @@ function cylinder(o, mb) {
 				0
 			], [(c + 1) / 2, (s + 1) / 2]);
 		}
-		for (let i = 0; i < seg; i++) if (ny < 0) mb.indices.push(center, ring + i, ring + i + 1);
-		else mb.indices.push(center, ring + i + 1, ring + i);
+		for (let i = 0; i < seg; i++) if (ny < 0) mb.indices.push(center, ring$1 + i, ring$1 + i + 1);
+		else mb.indices.push(center, ring$1 + i + 1, ring$1 + i);
 	}
 }
-function shard(o, mb) {
-	const r = o.radius ?? 50;
-	const hx = (o.size ? o.size[0] : r) || 50;
-	const hy = (o.size ? o.size[1] : r) || 50;
-	const hz = (o.size ? o.size[2] : r) || 50;
-	const maxR = Math.max(hx, hy, hz);
-	const facets = Math.max(4, Math.min(64, Math.round(o.facets ?? 14)));
-	const seed = Math.round(o.seed ?? 1) >>> 0;
-	const irregularity = Math.max(0, Math.min(.85, o.irregularity ?? .35));
-	let state = BigInt(seed) * 6364136223846793005n + 1442695040888963407n;
-	const rnd = () => {
-		state = state * 6364136223846793005n + 1442695040888963407n;
-		const xorshifted = Number((state >> 18n ^ state) >> 27n) >>> 0;
-		const rot = Number(state >> 59n) >>> 0;
-		return ((xorshifted >>> rot | xorshifted << (32 - rot & 31)) >>> 0) / 4294967296;
-	};
-	const sub3 = (a, b) => [
-		a[0] - b[0],
-		a[1] - b[1],
-		a[2] - b[2]
-	];
-	const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-	const cross3 = (a, b) => [
-		a[1] * b[2] - a[2] * b[1],
-		a[2] * b[0] - a[0] * b[2],
-		a[0] * b[1] - a[1] * b[0]
-	];
-	let faces = [
-		[
-			[
-				-hx,
-				-hy,
+/**
+* Torus centered at origin lying in the XY plane (so its hole faces a default
+* camera looking along +Z), with major radius `radius` and tube radius `tube`.
+*/
+function torus(o, mb) {
+	const R = Math.max(.001, o.radius ?? 60);
+	const r = Math.max(.001, o.tube ?? 20);
+	const radialSegments = Math.max(3, Math.round(o.radialSegments ?? 24));
+	const tubularSegments = Math.max(3, Math.round(o.tubularSegments ?? 48));
+	const arcRad = (o.arc ?? 360) * Math.PI / 180;
+	const base = mb.positions.length / 3;
+	for (let j = 0; j <= radialSegments; j++) {
+		const v = j / radialSegments * Math.PI * 2;
+		const cv = Math.cos(v);
+		const sv = Math.sin(v);
+		for (let i = 0; i <= tubularSegments; i++) {
+			const u = i / tubularSegments * arcRad;
+			const cu = Math.cos(u);
+			const su = Math.sin(u);
+			const x = (R + r * cv) * cu;
+			const y = (R + r * cv) * su;
+			const z = r * sv;
+			const nx = cv * cu;
+			const ny = cv * su;
+			const nz = sv;
+			mb.vertex([
+				x,
+				y,
+				z
+			], normalize([
+				nx,
+				ny,
+				nz
+			]), [i / tubularSegments, j / radialSegments]);
+		}
+	}
+	mb.grid(base, tubularSegments, radialSegments, true);
+	if (Math.abs(arcRad) < Math.PI * 2 - 1e-4) for (const [u, sign] of [[0, -1], [arcRad, 1]]) {
+		const cu = Math.cos(u);
+		const su = Math.sin(u);
+		const capN = [
+			-su * sign,
+			cu * sign,
+			0
+		];
+		const center = mb.vertex([
+			R * cu,
+			R * su,
+			0
+		], capN, [.5, .5]);
+		const ring$1 = mb.positions.length / 3;
+		for (let j = 0; j <= radialSegments; j++) {
+			const v = j / radialSegments * Math.PI * 2;
+			const cv = Math.cos(v);
+			const sv = Math.sin(v);
+			mb.vertex([
+				(R + r * cv) * cu,
+				(R + r * cv) * su,
+				r * sv
+			], capN, [(cv + 1) / 2, (sv + 1) / 2]);
+		}
+		for (let j = 0; j < radialSegments; j++) if (sign < 0) mb.indices.push(center, ring$1 + j, ring$1 + j + 1);
+		else mb.indices.push(center, ring$1 + j + 1, ring$1 + j);
+	}
+}
+/**
+* Capsule aligned along the Y axis: a cylinder of height `length` and radius `radius`
+* capped by top (-y) and bottom (+y) hemispheres of radius `radius`.
+*/
+function capsule(o, mb) {
+	const r = Math.max(.001, o.radius ?? 30);
+	const length = Math.max(0, o.length ?? 60);
+	const hy = length / 2;
+	const capSeg = Math.max(2, Math.round(o.capSegments ?? 12));
+	const radSeg = Math.max(3, Math.round(o.radialSegments ?? 32));
+	const rings = [];
+	const totalArc = Math.PI * r + length;
+	for (let j = 0; j <= capSeg; j++) {
+		const phi = j / capSeg * Math.PI / 2;
+		const s = Math.sin(phi);
+		const c = Math.cos(phi);
+		rings.push({
+			y: -hy - r * c,
+			rRing: r * s,
+			ny: -c,
+			nr: s,
+			v: phi * r / (totalArc || 1)
+		});
+	}
+	for (let j = 0; j <= capSeg; j++) {
+		if (j === 0 && length <= 1e-6) continue;
+		const phi = Math.PI / 2 + j / capSeg * Math.PI / 2;
+		const s = Math.sin(phi);
+		const c = Math.cos(phi);
+		rings.push({
+			y: hy - r * c,
+			rRing: r * s,
+			ny: -c,
+			nr: s,
+			v: (Math.PI / 2 * r + length + (phi - Math.PI / 2) * r) / (totalArc || 1)
+		});
+	}
+	const base = mb.positions.length / 3;
+	for (const ring$1 of rings) for (let i = 0; i <= radSeg; i++) {
+		const theta = i / radSeg * Math.PI * 2;
+		const ct = Math.cos(theta);
+		const st = Math.sin(theta);
+		const n = normalize([
+			ring$1.nr * ct,
+			ring$1.ny,
+			ring$1.nr * st
+		]);
+		mb.vertex([
+			ring$1.rRing * ct,
+			ring$1.y,
+			ring$1.rRing * st
+		], n, [i / radSeg, ring$1.v]);
+	}
+	mb.grid(base, radSeg, rings.length - 1, false);
+}
+/**
+* Flat or thick-walled annulus (ring) in the XY plane facing -Z (front) and +Z (back).
+* Always builds a closed two-sided or solid manifold so it works with single-sided culling.
+*/
+function ring(o, mb) {
+	const rInner = Math.max(0, o.innerRadius ?? 30);
+	const rOuter = Math.max(rInner + .001, o.outerRadius ?? 60);
+	const hz = Math.max(0, o.depth ?? 0) / 2;
+	const thetaSeg = Math.max(3, Math.round(o.thetaSegments ?? 48));
+	const phiSeg = Math.max(1, Math.round(o.phiSegments ?? 1));
+	const thetaStart = (o.thetaStart ?? 0) * Math.PI / 180;
+	const thetaLength = (o.thetaLength ?? 360) * Math.PI / 180;
+	for (const [z, nz, flip] of [[
+		-hz,
+		-1,
+		false
+	], [
+		hz,
+		1,
+		true
+	]]) {
+		const base = mb.positions.length / 3;
+		for (let j = 0; j <= phiSeg; j++) {
+			const radius = rInner + (rOuter - rInner) * j / phiSeg;
+			for (let i = 0; i <= thetaSeg; i++) {
+				const theta = thetaStart + i / thetaSeg * thetaLength;
+				const c = Math.cos(theta);
+				const s = Math.sin(theta);
+				const x = radius * c;
+				const y = radius * s;
+				mb.vertex([
+					x,
+					y,
+					z
+				], [
+					0,
+					0,
+					nz
+				], [(x / rOuter + 1) / 2, (y / rOuter + 1) / 2]);
+			}
+		}
+		mb.grid(base, thetaSeg, phiSeg, !flip);
+	}
+	if (hz > 0) {
+		const outerBase = mb.positions.length / 3;
+		for (const [z, v] of [[-hz, 0], [hz, 1]]) for (let i = 0; i <= thetaSeg; i++) {
+			const theta = thetaStart + i / thetaSeg * thetaLength;
+			const c = Math.cos(theta);
+			const s = Math.sin(theta);
+			mb.vertex([
+				rOuter * c,
+				rOuter * s,
+				z
+			], [
+				c,
+				s,
+				0
+			], [i / thetaSeg, v]);
+		}
+		mb.grid(outerBase, thetaSeg, 1, true);
+		if (rInner > 1e-6) {
+			const innerBase = mb.positions.length / 3;
+			for (const [z, v] of [[-hz, 0], [hz, 1]]) for (let i = 0; i <= thetaSeg; i++) {
+				const theta = thetaStart + i / thetaSeg * thetaLength;
+				const c = Math.cos(theta);
+				const s = Math.sin(theta);
+				mb.vertex([
+					rInner * c,
+					rInner * s,
+					z
+				], [
+					-c,
+					-s,
+					0
+				], [i / thetaSeg, v]);
+			}
+			mb.grid(innerBase, thetaSeg, 1, false);
+		}
+		if (Math.abs(thetaLength) < Math.PI * 2 - 1e-4) for (const [theta, sign] of [[thetaStart, -1], [thetaStart + thetaLength, 1]]) {
+			const c = Math.cos(theta);
+			const s = Math.sin(theta);
+			const capN = [
+				-s * sign,
+				c * sign,
+				0
+			];
+			const p0 = mb.vertex([
+				rInner * c,
+				rInner * s,
+				-hz
+			], capN, [0, 0]);
+			const p1 = mb.vertex([
+				rOuter * c,
+				rOuter * s,
 				-hz
+			], capN, [1, 0]);
+			const p2 = mb.vertex([
+				rInner * c,
+				rInner * s,
+				hz
+			], capN, [0, 1]);
+			const p3 = mb.vertex([
+				rOuter * c,
+				rOuter * s,
+				hz
+			], capN, [1, 1]);
+			if (sign > 0) mb.indices.push(p0, p2, p1, p1, p2, p3);
+			else mb.indices.push(p0, p1, p2, p1, p3, p2);
+		}
+	}
+}
+/**
+* Platonic solids (tetrahedron, octahedron, dodecahedron, icosahedron) and
+* geodesic icosphere with configurable subdivision `detail`.
+*/
+function polyhedron(o, mb) {
+	const shape = o.shape ?? "icosahedron";
+	const radius = Math.max(.001, o.radius ?? 50);
+	const detail = Math.max(0, Math.min(5, Math.round(o.detail ?? (shape === "icosphere" ? 2 : 0))));
+	const flatShaded = o.flatShaded ?? shape !== "icosphere";
+	let baseVerts = [];
+	let baseFaces = [];
+	if (shape === "tetrahedron") {
+		baseVerts = [
+			[
+				1,
+				1,
+				1
 			],
 			[
-				hx,
-				-hy,
-				-hz
+				-1,
+				-1,
+				1
 			],
 			[
-				hx,
-				hy,
-				-hz
+				-1,
+				1,
+				-1
 			],
 			[
-				-hx,
-				hy,
-				-hz
+				1,
+				-1,
+				-1
 			]
-		],
-		[
+		];
+		baseFaces = [
 			[
-				hx,
-				-hy,
-				hz
+				2,
+				1,
+				0
 			],
 			[
-				-hx,
-				-hy,
-				hz
+				0,
+				3,
+				2
 			],
 			[
-				-hx,
-				hy,
-				hz
+				1,
+				3,
+				0
 			],
 			[
-				hx,
-				hy,
-				hz
+				2,
+				3,
+				1
 			]
-		],
-		[
+		];
+	} else if (shape === "octahedron") {
+		baseVerts = [
 			[
-				-hx,
-				-hy,
-				hz
+				1,
+				0,
+				0
 			],
 			[
-				-hx,
-				-hy,
-				-hz
+				-1,
+				0,
+				0
 			],
 			[
-				-hx,
-				hy,
-				-hz
-			],
+				0,
+				1,
+				0
+			],
+			[
+				0,
+				-1,
+				0
+			],
+			[
+				0,
+				0,
+				1
+			],
+			[
+				0,
+				0,
+				-1
+			]
+		];
+		baseFaces = [
+			[
+				0,
+				2,
+				4
+			],
+			[
+				0,
+				4,
+				3
+			],
+			[
+				0,
+				3,
+				5
+			],
+			[
+				0,
+				5,
+				2
+			],
+			[
+				1,
+				2,
+				5
+			],
+			[
+				1,
+				5,
+				3
+			],
+			[
+				1,
+				3,
+				4
+			],
+			[
+				1,
+				4,
+				2
+			]
+		];
+	} else if (shape === "dodecahedron") {
+		const t = (1 + Math.sqrt(5)) / 2;
+		const r = 1 / t;
+		baseVerts = [
+			[
+				-1,
+				-1,
+				-1
+			],
+			[
+				-1,
+				-1,
+				1
+			],
+			[
+				-1,
+				1,
+				-1
+			],
+			[
+				-1,
+				1,
+				1
+			],
+			[
+				1,
+				-1,
+				-1
+			],
+			[
+				1,
+				-1,
+				1
+			],
+			[
+				1,
+				1,
+				-1
+			],
+			[
+				1,
+				1,
+				1
+			],
+			[
+				0,
+				-r,
+				-t
+			],
+			[
+				0,
+				-r,
+				t
+			],
+			[
+				0,
+				r,
+				-t
+			],
+			[
+				0,
+				r,
+				t
+			],
+			[
+				-r,
+				-t,
+				0
+			],
+			[
+				-r,
+				t,
+				0
+			],
+			[
+				r,
+				-t,
+				0
+			],
+			[
+				r,
+				t,
+				0
+			],
+			[
+				-t,
+				0,
+				-r
+			],
+			[
+				t,
+				0,
+				-r
+			],
+			[
+				-t,
+				0,
+				r
+			],
+			[
+				t,
+				0,
+				r
+			]
+		];
+		const pentagons = [
+			[
+				3,
+				11,
+				7,
+				15,
+				13
+			],
+			[
+				7,
+				19,
+				17,
+				6,
+				15
+			],
+			[
+				17,
+				4,
+				8,
+				10,
+				6
+			],
+			[
+				8,
+				0,
+				16,
+				2,
+				10
+			],
+			[
+				0,
+				12,
+				1,
+				18,
+				16
+			],
+			[
+				6,
+				10,
+				2,
+				13,
+				15
+			],
+			[
+				2,
+				16,
+				18,
+				3,
+				13
+			],
+			[
+				18,
+				1,
+				9,
+				11,
+				3
+			],
+			[
+				4,
+				14,
+				12,
+				0,
+				8
+			],
+			[
+				11,
+				9,
+				5,
+				19,
+				7
+			],
+			[
+				19,
+				5,
+				14,
+				4,
+				17
+			],
+			[
+				1,
+				12,
+				14,
+				5,
+				9
+			]
+		];
+		if (detail === 0 && flatShaded) {
+			const unitVerts = baseVerts.map((v) => normalize(v));
+			for (const pent of pentagons) {
+				const pts = pent.map((idx) => unitVerts[idx]);
+				const center = [
+					pts.reduce((s, p) => s + p[0], 0) / 5,
+					pts.reduce((s, p) => s + p[1], 0) / 5,
+					pts.reduce((s, p) => s + p[2], 0) / 5
+				];
+				let fn = normalize(cross3(sub3(pts[1], pts[0]), sub3(pts[2], pts[0])));
+				if (dot3(fn, center) < 0) {
+					pts.reverse();
+					fn = [
+						-fn[0],
+						-fn[1],
+						-fn[2]
+					];
+				}
+				const base = mb.positions.length / 3;
+				for (const p of pts) {
+					const u = .5 + Math.atan2(p[2], p[0]) / (2 * Math.PI);
+					const v = Math.acos(Math.max(-1, Math.min(1, -p[1]))) / Math.PI;
+					mb.vertex([
+						p[0] * radius,
+						p[1] * radius,
+						p[2] * radius
+					], fn, [u, v]);
+				}
+				for (let k = 1; k < pts.length - 1; k++) mb.indices.push(base, base + k, base + k + 1);
+			}
+			return;
+		}
+		for (const p of pentagons) baseFaces.push([
+			p[0],
+			p[1],
+			p[2]
+		], [
+			p[0],
+			p[2],
+			p[3]
+		], [
+			p[0],
+			p[3],
+			p[4]
+		]);
+	} else {
+		const t = (1 + Math.sqrt(5)) / 2;
+		baseVerts = [
+			[
+				-1,
+				t,
+				0
+			],
+			[
+				1,
+				t,
+				0
+			],
+			[
+				-1,
+				-t,
+				0
+			],
+			[
+				1,
+				-t,
+				0
+			],
+			[
+				0,
+				-1,
+				t
+			],
+			[
+				0,
+				1,
+				t
+			],
+			[
+				0,
+				-1,
+				-t
+			],
+			[
+				0,
+				1,
+				-t
+			],
+			[
+				t,
+				0,
+				-1
+			],
+			[
+				t,
+				0,
+				1
+			],
+			[
+				-t,
+				0,
+				-1
+			],
+			[
+				-t,
+				0,
+				1
+			]
+		];
+		baseFaces = [
+			[
+				0,
+				11,
+				5
+			],
+			[
+				0,
+				5,
+				1
+			],
+			[
+				0,
+				1,
+				7
+			],
+			[
+				0,
+				7,
+				10
+			],
+			[
+				0,
+				10,
+				11
+			],
+			[
+				1,
+				5,
+				9
+			],
+			[
+				5,
+				11,
+				4
+			],
+			[
+				11,
+				10,
+				2
+			],
+			[
+				10,
+				7,
+				6
+			],
+			[
+				7,
+				1,
+				8
+			],
+			[
+				3,
+				9,
+				4
+			],
+			[
+				3,
+				4,
+				2
+			],
+			[
+				3,
+				2,
+				6
+			],
+			[
+				3,
+				6,
+				8
+			],
+			[
+				3,
+				8,
+				9
+			],
+			[
+				4,
+				9,
+				5
+			],
+			[
+				2,
+				4,
+				11
+			],
+			[
+				6,
+				2,
+				10
+			],
+			[
+				8,
+				6,
+				7
+			],
+			[
+				9,
+				8,
+				1
+			]
+		];
+	}
+	const verts = baseVerts.map((v) => normalize(v));
+	let tris = baseFaces.map((f) => [
+		f[0],
+		f[1],
+		f[2]
+	]);
+	for (let d = 0; d < detail; d++) {
+		const midCache = /* @__PURE__ */ new Map();
+		const midpoint = (a, b) => {
+			const key = a < b ? `${a}_${b}` : `${b}_${a}`;
+			const existing = midCache.get(key);
+			if (existing !== void 0) return existing;
+			const va = verts[a];
+			const vb = verts[b];
+			const idx = verts.length;
+			verts.push(normalize([
+				va[0] + vb[0],
+				va[1] + vb[1],
+				va[2] + vb[2]
+			]));
+			midCache.set(key, idx);
+			return idx;
+		};
+		const nextTris = [];
+		for (const [i0, i1, i2] of tris) {
+			const m01 = midpoint(i0, i1);
+			const m12 = midpoint(i1, i2);
+			const m20 = midpoint(i2, i0);
+			nextTris.push([
+				i0,
+				m01,
+				m20
+			], [
+				i1,
+				m12,
+				m01
+			], [
+				i2,
+				m20,
+				m12
+			], [
+				m01,
+				m12,
+				m20
+			]);
+		}
+		tris = nextTris;
+	}
+	const uvOf = (n) => [.5 + Math.atan2(n[2], n[0]) / (2 * Math.PI), Math.acos(Math.max(-1, Math.min(1, -n[1]))) / Math.PI];
+	if (flatShaded) for (const [i0, i1, i2] of tris) {
+		const a = verts[i0];
+		let b = verts[i1];
+		let c = verts[i2];
+		const centroid = [
+			(a[0] + b[0] + c[0]) / 3,
+			(a[1] + b[1] + c[1]) / 3,
+			(a[2] + b[2] + c[2]) / 3
+		];
+		let fn = normalize(cross3(sub3(b, a), sub3(c, a)));
+		if (dot3(fn, centroid) < 0) {
+			const tmp = b;
+			b = c;
+			c = tmp;
+			fn = [
+				-fn[0],
+				-fn[1],
+				-fn[2]
+			];
+		}
+		const base = mb.positions.length / 3;
+		mb.vertex([
+			a[0] * radius,
+			a[1] * radius,
+			a[2] * radius
+		], fn, uvOf(a));
+		mb.vertex([
+			b[0] * radius,
+			b[1] * radius,
+			b[2] * radius
+		], fn, uvOf(b));
+		mb.vertex([
+			c[0] * radius,
+			c[1] * radius,
+			c[2] * radius
+		], fn, uvOf(c));
+		mb.indices.push(base, base + 1, base + 2);
+	}
+	else {
+		const base = mb.positions.length / 3;
+		for (const n of verts) mb.vertex([
+			n[0] * radius,
+			n[1] * radius,
+			n[2] * radius
+		], n, uvOf(n));
+		for (const [i0, i1, i2] of tris) {
+			const a = verts[i0];
+			const b = verts[i1];
+			const c = verts[i2];
+			const centroid = [
+				(a[0] + b[0] + c[0]) / 3,
+				(a[1] + b[1] + c[1]) / 3,
+				(a[2] + b[2] + c[2]) / 3
+			];
+			if (dot3(cross3(sub3(b, a), sub3(c, a)), centroid) < 0) mb.indices.push(base + i0, base + i2, base + i1);
+			else mb.indices.push(base + i0, base + i1, base + i2);
+		}
+	}
+}
+/**
+* Parses an SVG path string (supporting M, L, H, V, C, S, Q, T, A, Z and multiple subpaths)
+* into closed 2D contours with adaptive or fixed curve flattening.
+*/
+function parseSvgPathToContours(d, flattening) {
+	const contours = [];
+	if (!d || typeof d !== "string") return contours;
+	const tokens = [];
+	const regex = /([a-df-z])|([-+]?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?)/gi;
+	let match = regex.exec(d);
+	while (match !== null) {
+		if (match[1]) tokens.push(match[1]);
+		else if (match[2]) tokens.push(Number.parseFloat(match[2]));
+		match = regex.exec(d);
+	}
+	let cursor = 0;
+	let current = {
+		x: 0,
+		y: 0
+	};
+	let subpathStart = {
+		x: 0,
+		y: 0
+	};
+	let lastCubicControl = null;
+	let lastQuadControl = null;
+	let contour = [];
+	const finishContour = () => {
+		if (contour.length >= 2) {
+			const first = contour[0];
+			const last = contour[contour.length - 1];
+			if (Math.hypot(last.x - first.x, last.y - first.y) < 1e-4) contour.pop();
+			if (contour.length >= 2) contours.push(contour);
+		}
+		contour = [];
+	};
+	const segCount = (maxSecondDeriv) => {
+		if (flattening.segments !== void 0) return Math.max(1, flattening.segments);
+		const n = Math.ceil(Math.sqrt(maxSecondDeriv / (8 * Math.max(.001, flattening.tolerance))));
+		return Math.min(64, Math.max(1, n));
+	};
+	const addQuad = (p0, cp, end) => {
+		const n = segCount(2 * Math.hypot(p0.x - 2 * cp.x + end.x, p0.y - 2 * cp.y + end.y));
+		for (let s = 1; s <= n; s++) {
+			const t = s / n;
+			const mt = 1 - t;
+			contour.push({
+				x: mt * mt * p0.x + 2 * mt * t * cp.x + t * t * end.x,
+				y: mt * mt * p0.y + 2 * mt * t * cp.y + t * t * end.y
+			});
+		}
+	};
+	const addCubic = (p0, cp1, cp2, end) => {
+		const n = segCount(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)));
+		for (let s = 1; s <= n; s++) {
+			const t = s / n;
+			const mt = 1 - t;
+			contour.push({
+				x: mt * mt * mt * p0.x + 3 * mt * mt * t * cp1.x + 3 * mt * t * t * cp2.x + t * t * t * end.x,
+				y: mt * mt * mt * p0.y + 3 * mt * mt * t * cp1.y + 3 * mt * t * t * cp2.y + t * t * t * end.y
+			});
+		}
+	};
+	const getNum = () => cursor < tokens.length && typeof tokens[cursor] === "number" ? tokens[cursor++] : 0;
+	while (cursor < tokens.length) {
+		const cmdToken = tokens[cursor++];
+		if (typeof cmdToken !== "string") continue;
+		const isRel = cmdToken === cmdToken.toLowerCase();
+		switch (cmdToken.toUpperCase()) {
+			case "M": {
+				finishContour();
+				let first = true;
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					let x = getNum();
+					let y = getNum();
+					if (isRel) {
+						x += current.x;
+						y += current.y;
+					}
+					current = {
+						x,
+						y
+					};
+					if (first) {
+						subpathStart = current;
+						contour = [current];
+						first = false;
+					} else contour.push(current);
+				}
+				lastCubicControl = null;
+				lastQuadControl = null;
+				break;
+			}
+			case "L":
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					let x = getNum();
+					let y = getNum();
+					if (isRel) {
+						x += current.x;
+						y += current.y;
+					}
+					current = {
+						x,
+						y
+					};
+					contour.push(current);
+				}
+				lastCubicControl = null;
+				lastQuadControl = null;
+				break;
+			case "H":
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					let x = getNum();
+					if (isRel) x += current.x;
+					current = {
+						x,
+						y: current.y
+					};
+					contour.push(current);
+				}
+				lastCubicControl = null;
+				lastQuadControl = null;
+				break;
+			case "V":
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					let y = getNum();
+					if (isRel) y += current.y;
+					current = {
+						x: current.x,
+						y
+					};
+					contour.push(current);
+				}
+				lastCubicControl = null;
+				lastQuadControl = null;
+				break;
+			case "C":
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					let x1 = getNum();
+					let y1 = getNum();
+					let x2 = getNum();
+					let y2 = getNum();
+					let x = getNum();
+					let y = getNum();
+					if (isRel) {
+						x1 += current.x;
+						y1 += current.y;
+						x2 += current.x;
+						y2 += current.y;
+						x += current.x;
+						y += current.y;
+					}
+					const cp1 = {
+						x: x1,
+						y: y1
+					};
+					const cp2 = {
+						x: x2,
+						y: y2
+					};
+					const end = {
+						x,
+						y
+					};
+					addCubic(current, cp1, cp2, end);
+					current = end;
+					lastCubicControl = cp2;
+				}
+				lastQuadControl = null;
+				break;
+			case "S":
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					let x2 = getNum();
+					let y2 = getNum();
+					let x = getNum();
+					let y = getNum();
+					if (isRel) {
+						x2 += current.x;
+						y2 += current.y;
+						x += current.x;
+						y += current.y;
+					}
+					const cp1 = lastCubicControl ? {
+						x: 2 * current.x - lastCubicControl.x,
+						y: 2 * current.y - lastCubicControl.y
+					} : current;
+					const cp2 = {
+						x: x2,
+						y: y2
+					};
+					const end = {
+						x,
+						y
+					};
+					addCubic(current, cp1, cp2, end);
+					current = end;
+					lastCubicControl = cp2;
+				}
+				lastQuadControl = null;
+				break;
+			case "Q":
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					let x1 = getNum();
+					let y1 = getNum();
+					let x = getNum();
+					let y = getNum();
+					if (isRel) {
+						x1 += current.x;
+						y1 += current.y;
+						x += current.x;
+						y += current.y;
+					}
+					const cp = {
+						x: x1,
+						y: y1
+					};
+					const end = {
+						x,
+						y
+					};
+					addQuad(current, cp, end);
+					current = end;
+					lastQuadControl = cp;
+				}
+				lastCubicControl = null;
+				break;
+			case "T":
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					let x = getNum();
+					let y = getNum();
+					if (isRel) {
+						x += current.x;
+						y += current.y;
+					}
+					const cp = lastQuadControl ? {
+						x: 2 * current.x - lastQuadControl.x,
+						y: 2 * current.y - lastQuadControl.y
+					} : current;
+					const end = {
+						x,
+						y
+					};
+					addQuad(current, cp, end);
+					current = end;
+					lastQuadControl = cp;
+				}
+				lastCubicControl = null;
+				break;
+			case "A":
+				while (cursor < tokens.length && typeof tokens[cursor] === "number") {
+					const rx = getNum();
+					const ry = getNum();
+					const rot = getNum();
+					const largeArc = getNum() !== 0;
+					const sweep = getNum() !== 0;
+					let x = getNum();
+					let y = getNum();
+					if (isRel) {
+						x += current.x;
+						y += current.y;
+					}
+					const end = {
+						x,
+						y
+					};
+					const segs = sampleSvgArc(current, rx, ry, rot, largeArc, sweep, end);
+					for (const s of segs) contour.push(s.p1);
+					current = end;
+				}
+				lastCubicControl = null;
+				lastQuadControl = null;
+				break;
+			case "Z":
+				finishContour();
+				current = subpathStart;
+				lastCubicControl = null;
+				lastQuadControl = null;
+				break;
+		}
+	}
+	finishContour();
+	return contours;
+}
+function toPoint2D(p) {
+	return Array.isArray(p) ? {
+		x: p[0],
+		y: p[1]
+	} : {
+		x: p.x,
+		y: p.y
+	};
+}
+function normalizeContoursInput(o, flattening) {
+	const raw = o.shape ?? o.d ?? o.contour;
+	let contours = [];
+	if (typeof raw === "string") contours = parseSvgPathToContours(raw, flattening).filter((c) => c.length >= 3);
+	else if (Array.isArray(raw) && raw.length > 0) {
+		const first = raw[0];
+		if (Array.isArray(first) && first.length > 0 && (Array.isArray(first[0]) || typeof first[0] === "object" && first[0] !== null && "x" in first[0])) contours = raw.map((c) => c.map(toPoint2D)).filter((c) => c.length >= 3);
+		else {
+			const single = raw.map(toPoint2D);
+			if (single.length >= 3) contours = [single];
+		}
+	}
+	if (Array.isArray(o.holes)) for (const hole of o.holes) {
+		const mapped = hole.map(toPoint2D);
+		if (mapped.length >= 3) contours.push(mapped);
+	}
+	return contours;
+}
+/** Side-wall segments meeting at more than 30° keep a crisp hard edge. */
+const SIDE_CREASE_COS = Math.cos(30 * Math.PI / 180);
+/**
+* Extrudes any 2D outline (SVG path string with subpaths/holes, or polygon contour arrays)
+* into a 3D solid mesh with optional front/back bevels and crease-aware smooth/hard side normals.
+*/
+function buildExtrudedShapeModel(o) {
+	const halfDepth = Math.max(.001, o.depth ?? 20) / 2;
+	const bevelThickness = Math.max(0, Math.min(halfDepth * .49, o.bevelThickness ?? 0));
+	const bevelSize = Math.max(0, o.bevelSize ?? bevelThickness);
+	const bevelSegments = bevelThickness > 0 || bevelSize > 0 ? Math.max(1, Math.round(o.bevelSegments ?? 2)) : 0;
+	const polygons = organizeGlyphPolygons({
+		contours: normalizeContoursInput(o, {
+			segments: o.curveSegments,
+			tolerance: Math.max(.001, o.curveTolerance ?? .25)
+		}),
+		simplified: false
+	});
+	let minX = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const poly of polygons) {
+		for (const p of poly.outer) {
+			if (p.x < minX) minX = p.x;
+			if (p.x > maxX) maxX = p.x;
+			if (p.y < minY) minY = p.y;
+			if (p.y > maxY) maxY = p.y;
+		}
+		for (const hole of poly.holes) for (const p of hole) {
+			if (p.x < minX) minX = p.x;
+			if (p.x > maxX) maxX = p.x;
+			if (p.y < minY) minY = p.y;
+			if (p.y > maxY) maxY = p.y;
+		}
+	}
+	if (!Number.isFinite(minX)) minX = maxX = minY = maxY = 0;
+	if (o.center ?? true) {
+		const cx = (minX + maxX) / 2;
+		const cy = (minY + maxY) / 2;
+		for (const poly of polygons) {
+			for (const p of poly.outer) {
+				p.x -= cx;
+				p.y -= cy;
+			}
+			for (const hole of poly.holes) for (const p of hole) {
+				p.x -= cx;
+				p.y -= cy;
+			}
+		}
+		minX -= cx;
+		maxX -= cx;
+		minY -= cy;
+		maxY -= cy;
+	}
+	const w = maxX - minX;
+	const h = maxY - minY;
+	const frontMb = new MeshBuilder();
+	const sideMb = new MeshBuilder();
+	const useSeparateSideMaterial = o.bevelColor !== void 0 && o.bevelColor !== o.color;
+	const wallMb = useSeparateSideMaterial ? sideMb : frontMb;
+	const cleanContour = (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-5;
+		});
+		const count = pts.length;
+		if (count < 3) return null;
+		const edgeLengths = [];
+		const edgeNormals = 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
+			};
+		});
+		return {
+			pts,
+			edgeLengths,
+			edgeNormals,
+			miterNormals: pts.map((_, k) => {
+				const nPrev = edgeNormals[(k - 1 + count) % count];
+				const nNext = edgeNormals[k];
+				const sx = nPrev.x + nNext.x;
+				const sy = nPrev.y + nNext.y;
+				const len = Math.hypot(sx, sy);
+				if (len < 1e-6) return nNext;
+				const dot = sx / len * nNext.x + sy / len * nNext.y;
+				const scale = Math.min(2, 1 / Math.max(.35, dot));
+				return {
+					x: sx / len * scale,
+					y: sy / len * scale
+				};
+			})
+		};
+	};
+	const addSideWallWithProfile = (contour) => {
+		const info = cleanContour(contour);
+		if (!info) return;
+		const { pts, edgeLengths, edgeNormals, miterNormals } = info;
+		const count = pts.length;
+		const perimeter = edgeLengths.reduce((a, b) => a + b, 0) || 1;
+		const slices = [];
+		if (bevelSegments <= 0) slices.push({
+			z: -halfDepth,
+			inset: 0,
+			nr: 1,
+			nz: 0,
+			v: 0
+		}, {
+			z: halfDepth,
+			inset: 0,
+			nr: 1,
+			nz: 0,
+			v: 1
+		});
+		else {
+			const totalRows = bevelSegments * 2 + 1;
+			let row = 0;
+			for (let b = 0; b <= bevelSegments; b++) {
+				const a = b / bevelSegments * Math.PI / 2;
+				slices.push({
+					z: -halfDepth + bevelThickness * (1 - Math.cos(a)),
+					inset: -bevelSize * (1 - Math.sin(a)),
+					nr: Math.sin(a),
+					nz: -Math.cos(a),
+					v: row++ / totalRows
+				});
+			}
+			for (let b = 0; b <= bevelSegments; b++) {
+				const a = b / bevelSegments * Math.PI / 2;
+				slices.push({
+					z: halfDepth - bevelThickness * (1 - Math.sin(a)),
+					inset: -bevelSize * (1 - Math.cos(a)),
+					nr: Math.cos(a),
+					nz: Math.sin(a),
+					v: row++ / totalRows
+				});
+			}
+		}
+		const numSlices = slices.length;
+		const addColumn = (p, miter, n2d, u) => {
+			const base = wallMb.positions.length / 3;
+			for (const s of slices) {
+				const px = p.x + miter.x * s.inset;
+				const py = p.y + miter.y * s.inset;
+				const n3 = normalize([
+					n2d.x * s.nr,
+					n2d.y * s.nr,
+					s.nz
+				]);
+				wallMb.vertex([
+					px,
+					py,
+					s.z
+				], n3, [u, s.v]);
+			}
+			return base;
+		};
+		const startColumn = [];
+		const endColumn = [];
+		let along = 0;
+		for (let k = 0; k < count; k++) {
+			const incoming = edgeNormals[(k - 1 + count) % count];
+			const outgoing = edgeNormals[k];
+			const miter = miterNormals[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], miter, averaged, u);
+			else {
+				endColumn[k] = addColumn(pts[k], miter, averaged ?? incoming, k === 0 ? 1 : u);
+				startColumn[k] = addColumn(pts[k], miter, averaged ?? outgoing, u);
+			}
+			along += edgeLengths[k];
+		}
+		for (let k = 0; k < count; k++) {
+			const colA = startColumn[k];
+			const colB = endColumn[(k + 1) % count];
+			for (let s = 0; s < numSlices - 1; s++) {
+				const a0 = colA + s;
+				const a1 = colA + s + 1;
+				const b0 = colB + s;
+				const b1 = colB + s + 1;
+				wallMb.indices.push(a0, b0, a1, b0, b1, a1);
+			}
+		}
+	};
+	for (const poly of polygons) {
+		const outer = poly.outer;
+		if (computeContourSignedArea(outer) < 0) outer.reverse();
+		for (const hole of poly.holes) if (computeContourSignedArea(hole) > 0) hole.reverse();
+		const outerInfo = cleanContour(outer);
+		if (!outerInfo) continue;
+		const holeInfos = poly.holes.map(cleanContour).filter((x) => x !== null);
+		const capInset = -bevelSize;
+		const earcutCoords = [];
+		const holeIndices = [];
+		for (let k = 0; k < outerInfo.pts.length; k++) {
+			const p = outerInfo.pts[k];
+			const m = outerInfo.miterNormals[k];
+			earcutCoords.push(p.x + m.x * capInset, p.y + m.y * capInset);
+		}
+		for (const hInfo of holeInfos) {
+			holeIndices.push(earcutCoords.length / 2);
+			for (let k = 0; k < hInfo.pts.length; k++) {
+				const p = hInfo.pts[k];
+				const m = hInfo.miterNormals[k];
+				earcutCoords.push(p.x + m.x * capInset, p.y + m.y * capInset);
+			}
+		}
+		const triangles = earcut(earcutCoords, holeIndices, 2);
+		const vertCount = earcutCoords.length / 2;
+		const frontBase = frontMb.positions.length / 3;
+		for (let v = 0; v < vertCount; v++) {
+			const vx = earcutCoords[v * 2];
+			const vy = earcutCoords[v * 2 + 1];
+			frontMb.vertex([
+				vx,
+				vy,
+				-halfDepth
+			], [
+				0,
+				0,
+				-1
+			], [(vx - minX) / (w || 1), (vy - minY) / (h || 1)]);
+		}
+		for (let t = 0; t < triangles.length; t += 3) frontMb.indices.push(frontBase + triangles[t], frontBase + triangles[t + 2], frontBase + triangles[t + 1]);
+		const backBase = frontMb.positions.length / 3;
+		for (let v = 0; v < vertCount; v++) {
+			const vx = earcutCoords[v * 2];
+			const vy = earcutCoords[v * 2 + 1];
+			frontMb.vertex([
+				vx,
+				vy,
+				halfDepth
+			], [
+				0,
+				0,
+				1
+			], [(vx - minX) / (w || 1), (vy - minY) / (h || 1)]);
+		}
+		for (let t = 0; t < triangles.length; t += 3) frontMb.indices.push(backBase + triangles[t], backBase + triangles[t + 1], backBase + triangles[t + 2]);
+		addSideWallWithProfile(outer);
+		for (const hole of poly.holes) addSideWallWithProfile(hole);
+	}
+	const meshes = [];
+	const materials = {};
+	const frontMesh = frontMb.build("extrude-front");
+	frontMesh.materialName = "extrude-front-material";
+	meshes.push(frontMesh);
+	materials["extrude-front-material"] = {
+		name: "extrude-front-material",
+		diffuseColor: parseHexOrRgbColor(o.color ?? "#ffffff"),
+		shading: o.material ?? "lit",
+		shininess: o.shininess ?? 32,
+		roughness: o.roughness,
+		metallic: o.metallic
+	};
+	if (useSeparateSideMaterial && sideMb.indices.length > 0) {
+		const sideMesh = sideMb.build("extrude-side");
+		sideMesh.materialName = "extrude-side-material";
+		meshes.push(sideMesh);
+		materials["extrude-side-material"] = {
+			name: "extrude-side-material",
+			diffuseColor: parseHexOrRgbColor(o.bevelColor ?? o.color ?? "#ffffff"),
+			shading: o.material ?? "lit",
+			shininess: o.shininess ?? 32,
+			roughness: o.roughness,
+			metallic: o.metallic
+		};
+	}
+	return finalizeModel3DData("extrude", meshes, materials);
+}
+/**
+* Revolves a 2D profile `(r, y)` around the Y axis (`x = r cos φ, y = y, z = r sin φ`).
+*/
+function lathe(o, mb) {
+	const rawPoints = typeof o.points === "string" ? parseSvgPathToContours(o.points, { tolerance: .25 })[0] ?? [] : o.points.map(toPoint2D);
+	if (rawPoints.length < 2) return;
+	const pts = rawPoints.map((p) => ({
+		x: Math.max(0, p.x),
+		y: p.y
+	}));
+	const isClosedLoop = pts.length >= 3 && Math.hypot(pts[pts.length - 1].x - pts[0].x, pts[pts.length - 1].y - pts[0].y) < 1e-4;
+	if (isClosedLoop) {
+		if (computeContourSignedArea(pts) < 0) pts.reverse();
+	} else if (pts[0].y > pts[pts.length - 1].y) pts.reverse();
+	const seg = Math.max(3, Math.round(o.segments ?? 32));
+	const phiStart = (o.phiStart ?? 0) * Math.PI / 180;
+	const phiLength = (o.phiLength ?? 360) * Math.PI / 180;
+	const count = pts.length;
+	const segLens = [];
+	const segNormals = [];
+	let totalLen = 0;
+	for (let j = 0; j < count - 1; j++) {
+		const a = pts[j];
+		const b = pts[j + 1];
+		const dr = b.x - a.x;
+		const dy = b.y - a.y;
+		const len = Math.hypot(dr, dy);
+		segLens.push(len);
+		totalLen += len;
+		segNormals.push(len > 1e-8 ? {
+			x: dy / len,
+			y: -dr / len
+		} : {
+			x: 1,
+			y: 0
+		});
+	}
+	const vCoords = [0];
+	let acc = 0;
+	for (const len of segLens) {
+		acc += len;
+		vCoords.push(totalLen > 0 ? acc / totalLen : 0);
+	}
+	if (o.flatShaded) for (let j = 0; j < count - 1; j++) {
+		const pA = pts[j];
+		const pB = pts[j + 1];
+		const n2 = segNormals[j];
+		for (let i = 0; i < seg; i++) {
+			const phi0 = phiStart + i / seg * phiLength;
+			const phi1 = phiStart + (i + 1) / seg * phiLength;
+			const phiMid = (phi0 + phi1) / 2;
+			const fn = normalize([
+				n2.x * Math.cos(phiMid),
+				n2.y,
+				n2.x * Math.sin(phiMid)
+			]);
+			const c0 = Math.cos(phi0);
+			const s0 = Math.sin(phi0);
+			const c1 = Math.cos(phi1);
+			const s1 = Math.sin(phi1);
+			const base = mb.positions.length / 3;
+			mb.vertex([
+				pA.x * c0,
+				pA.y,
+				pA.x * s0
+			], fn, [i / seg, vCoords[j]]);
+			mb.vertex([
+				pA.x * c1,
+				pA.y,
+				pA.x * s1
+			], fn, [(i + 1) / seg, vCoords[j]]);
+			mb.vertex([
+				pB.x * c0,
+				pB.y,
+				pB.x * s0
+			], fn, [i / seg, vCoords[j + 1]]);
+			mb.vertex([
+				pB.x * c1,
+				pB.y,
+				pB.x * s1
+			], fn, [(i + 1) / seg, vCoords[j + 1]]);
+			mb.indices.push(base, base + 2, base + 1, base + 1, base + 2, base + 3);
+		}
+	}
+	else {
+		const smoothOrCrease = (nSeg, nAdj) => {
+			if (nSeg.x * nAdj.x + nSeg.y * nAdj.y < SIDE_CREASE_COS) return nSeg;
+			const nx = nSeg.x + nAdj.x;
+			const ny = nSeg.y + nAdj.y;
+			const nLen = Math.hypot(nx, ny);
+			return nLen > 1e-8 ? {
+				x: nx / nLen,
+				y: ny / nLen
+			} : nSeg;
+		};
+		const emitRing = (p, n2, v) => {
+			for (let i = 0; i <= seg; i++) {
+				const phi = phiStart + i / seg * phiLength;
+				const c = Math.cos(phi);
+				const s = Math.sin(phi);
+				const vNorm = p.x <= 1e-5 && Math.abs(n2.y) > 1e-5 ? [
+					0,
+					n2.y < 0 ? -1 : 1,
+					0
+				] : normalize([
+					n2.x * c,
+					n2.y,
+					n2.x * s
+				]);
+				mb.vertex([
+					p.x * c,
+					p.y,
+					p.x * s
+				], vNorm, [i / seg, v]);
+			}
+		};
+		for (let j = 0; j < count - 1; j++) {
+			const pA = pts[j];
+			const pB = pts[j + 1];
+			const nSeg = segNormals[j];
+			const nPrevA = j > 0 ? segNormals[j - 1] : isClosedLoop ? segNormals[count - 2] : nSeg;
+			const nNextB = j + 1 < count - 1 ? segNormals[j + 1] : isClosedLoop ? segNormals[0] : nSeg;
+			const nA = smoothOrCrease(nSeg, nPrevA);
+			const nB = smoothOrCrease(nSeg, nNextB);
+			const base = mb.positions.length / 3;
+			emitRing(pA, nA, vCoords[j]);
+			emitRing(pB, nB, vCoords[j + 1]);
+			mb.grid(base, seg, 1, false);
+		}
+	}
+	if ((o.capped ?? o.closed) && !isClosedLoop) {
+		const first = pts[0];
+		const last = pts[count - 1];
+		for (const [pt, ny] of [[first, -1], [last, 1]]) {
+			if (pt.x <= 1e-5) continue;
+			const center = mb.vertex([
+				0,
+				pt.y,
+				0
+			], [
+				0,
+				ny,
+				0
+			], [.5, .5]);
+			const ring$1 = mb.positions.length / 3;
+			for (let i = 0; i <= seg; i++) {
+				const phi = phiStart + i / seg * phiLength;
+				const c = Math.cos(phi);
+				const s = Math.sin(phi);
+				mb.vertex([
+					pt.x * c,
+					pt.y,
+					pt.x * s
+				], [
+					0,
+					ny,
+					0
+				], [(c + 1) / 2, (s + 1) / 2]);
+			}
+			for (let i = 0; i < seg; i++) if (ny < 0) mb.indices.push(center, ring$1 + i, ring$1 + i + 1);
+			else mb.indices.push(center, ring$1 + i + 1, ring$1 + i);
+		}
+	}
+}
+function buildPath3DFromSpec(spec, closedDefault = false) {
+	if (Array.isArray(spec)) {
+		if (spec.length < 2) throw new Error("3D path requires at least 2 points");
+		return Path3D.catmullRom(spec, { closed: closedDefault });
+	}
+	if (spec.kind === "catmullRom") return Path3D.catmullRom(spec.points, {
+		tension: spec.tension,
+		closed: spec.closed ?? closedDefault,
+		samplesPerSegment: spec.samplesPerSegment
+	});
+	if (spec.kind === "bezier") return Path3D.bezier(spec.segments, spec.samplesPerSegment);
+	if (spec.kind === "helix") return Path3D.helix({
+		center: spec.center ?? [
+			0,
+			0,
+			0
+		],
+		radius: spec.radius,
+		pitch: spec.pitch,
+		turns: spec.turns,
+		axis: spec.axis,
+		samplesPerTurn: spec.samplesPerTurn
+	});
+	return Path3D.circle({
+		center: spec.center ?? [
+			0,
+			0,
+			0
+		],
+		radius: spec.radius,
+		startAngleDeg: spec.startAngleDeg,
+		endAngleDeg: spec.endAngleDeg,
+		samples: spec.samples
+	});
+}
+/**
+* Sweeps a circular (or thick-walled hollow pipe) cross-section along a 3D path
+* using Rotation-Minimizing Frames (RMF) so the tube never kinks or gimbal-flips.
+*/
+function tube(o, mb) {
+	const closed = o.closed ?? (!Array.isArray(o.path) && o.path.kind === "catmullRom" && Boolean(o.path.closed));
+	const path$1 = buildPath3DFromSpec(o.path, closed);
+	const tubSeg = Math.max(2, Math.round(o.tubularSegments ?? 64));
+	const radSeg = Math.max(3, Math.round(o.radialSegments ?? 16));
+	const rDefault = Math.max(.001, o.radius ?? 12);
+	const rStart = o.radiusTaper ? Math.max(0, o.radiusTaper[0]) : rDefault;
+	const rEnd = o.radiusTaper ? Math.max(0, o.radiusTaper[1]) : rDefault;
+	const rInnerBase = Math.max(0, Math.min(rDefault - .001, o.innerRadius ?? 0));
+	const capped = o.capped ?? true;
+	const frames = [];
+	for (let j = 0; j <= tubSeg; j++) frames.push(path$1.getPointAt(j / tubSeg));
+	const outerBase = mb.positions.length / 3;
+	for (let j = 0; j <= tubSeg; j++) {
+		const u = j / tubSeg;
+		const r = rStart + (rEnd - rStart) * u;
+		const f = frames[j];
+		const [px, py, pz] = f.position;
+		const [nx, ny, nz] = f.normal;
+		const [bx, by, bz] = f.binormal;
+		for (let i = 0; i <= radSeg; i++) {
+			const v = i / radSeg;
+			const theta = v * Math.PI * 2;
+			const c = Math.cos(theta);
+			const s = Math.sin(theta);
+			const dirX = c * nx + s * bx;
+			const dirY = c * ny + s * by;
+			const dirZ = c * nz + s * bz;
+			mb.vertex([
+				px + r * dirX,
+				py + r * dirY,
+				pz + r * dirZ
+			], normalize([
+				dirX,
+				dirY,
+				dirZ
+			]), [u, v]);
+		}
+	}
+	mb.grid(outerBase, radSeg, tubSeg, true);
+	if (rInnerBase > 1e-6) {
+		const innerRatio = rInnerBase / rDefault;
+		const innerBase = mb.positions.length / 3;
+		for (let j = 0; j <= tubSeg; j++) {
+			const u = j / tubSeg;
+			const r = (rStart + (rEnd - rStart) * u) * innerRatio;
+			const f = frames[j];
+			const [px, py, pz] = f.position;
+			const [nx, ny, nz] = f.normal;
+			const [bx, by, bz] = f.binormal;
+			for (let i = 0; i <= radSeg; i++) {
+				const v = i / radSeg;
+				const theta = v * Math.PI * 2;
+				const c = Math.cos(theta);
+				const s = Math.sin(theta);
+				const dirX = c * nx + s * bx;
+				const dirY = c * ny + s * by;
+				const dirZ = c * nz + s * bz;
+				mb.vertex([
+					px + r * dirX,
+					py + r * dirY,
+					pz + r * dirZ
+				], normalize([
+					-dirX,
+					-dirY,
+					-dirZ
+				]), [u, v]);
+			}
+		}
+		mb.grid(innerBase, radSeg, tubSeg, false);
+		if (!closed && capped) for (const [j, sign] of [[0, -1], [tubSeg, 1]]) {
+			const u = j / tubSeg;
+			const rOut = rStart + (rEnd - rStart) * u;
+			const rIn = rOut * innerRatio;
+			const f = frames[j];
+			const [px, py, pz] = f.position;
+			const [nx, ny, nz] = f.normal;
+			const [bx, by, bz] = f.binormal;
+			const capN = normalize([
+				f.tangent[0] * sign,
+				f.tangent[1] * sign,
+				f.tangent[2] * sign
+			]);
+			const base = mb.positions.length / 3;
+			for (const rr of [rIn, rOut]) for (let i = 0; i <= radSeg; i++) {
+				const theta = i / radSeg * Math.PI * 2;
+				const c = Math.cos(theta);
+				const s = Math.sin(theta);
+				const dirX = c * nx + s * bx;
+				const dirY = c * ny + s * by;
+				const dirZ = c * nz + s * bz;
+				mb.vertex([
+					px + rr * dirX,
+					py + rr * dirY,
+					pz + rr * dirZ
+				], capN, [(c * (rr / rOut) + 1) / 2, (s * (rr / rOut) + 1) / 2]);
+			}
+			mb.grid(base, radSeg, 1, sign < 0);
+		}
+	} else if (!closed && capped) for (const [j, sign] of [[0, -1], [tubSeg, 1]]) {
+		const u = j / tubSeg;
+		const r = rStart + (rEnd - rStart) * u;
+		if (r <= 1e-6) continue;
+		const f = frames[j];
+		const [px, py, pz] = f.position;
+		const [nx, ny, nz] = f.normal;
+		const [bx, by, bz] = f.binormal;
+		const capN = normalize([
+			f.tangent[0] * sign,
+			f.tangent[1] * sign,
+			f.tangent[2] * sign
+		]);
+		const center = mb.vertex([
+			px,
+			py,
+			pz
+		], capN, [.5, .5]);
+		const ring$1 = mb.positions.length / 3;
+		for (let i = 0; i <= radSeg; i++) {
+			const theta = i / radSeg * Math.PI * 2;
+			const c = Math.cos(theta);
+			const s = Math.sin(theta);
+			const dirX = c * nx + s * bx;
+			const dirY = c * ny + s * by;
+			const dirZ = c * nz + s * bz;
+			mb.vertex([
+				px + r * dirX,
+				py + r * dirY,
+				pz + r * dirZ
+			], capN, [(c + 1) / 2, (s + 1) / 2]);
+		}
+		for (let i = 0; i < radSeg; i++) if (sign > 0) mb.indices.push(center, ring$1 + i, ring$1 + i + 1);
+		else mb.indices.push(center, ring$1 + i + 1, ring$1 + i);
+	}
+}
+function resolvePointArray(spec) {
+	if (Array.isArray(spec)) return spec;
+	const path$1 = buildPath3DFromSpec(spec);
+	const count = 96;
+	const out = [];
+	for (let i = 0; i <= count; i++) out.push(path$1.getPointAt(i / count).position);
+	return out;
+}
+/**
+* Native 3D line geometry (`line-list` topology) with optional dashing and per-vertex colors.
+*/
+function line3d(o, mb) {
+	mb.topology = "line-list";
+	const pts = resolvePointArray(o.points);
+	if (pts.length < 2) return;
+	const parsedColors = o.colors?.map((c) => parseHexOrRgbColor(c));
+	const mode = o.mode ?? "strip";
+	if (o.dashSize && o.dashSize > 0 && mode === "strip") {
+		const dash = o.dashSize;
+		const cycle = dash + (o.gapSize ?? dash);
+		const workPts = o.closed ? [...pts, pts[0]] : pts;
+		let dist = 0;
+		for (let i = 0; i < workPts.length - 1; i++) {
+			const a = workPts[i];
+			const b = workPts[i + 1];
+			const segLen = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+			if (segLen < 1e-6) continue;
+			const dir = [
+				(b[0] - a[0]) / segLen,
+				(b[1] - a[1]) / segLen,
+				(b[2] - a[2]) / segLen
+			];
+			const colA = parsedColors?.[i % parsedColors.length];
+			let local = 0;
+			while (local < segLen) {
+				const phase = (dist + local) % cycle;
+				if (phase < dash) {
+					const step = Math.min(dash - phase, segLen - local);
+					const p0 = [
+						a[0] + dir[0] * local,
+						a[1] + dir[1] * local,
+						a[2] + dir[2] * local
+					];
+					const p1 = [
+						a[0] + dir[0] * (local + step),
+						a[1] + dir[1] * (local + step),
+						a[2] + dir[2] * (local + step)
+					];
+					const idx0 = mb.vertex(p0, [
+						0,
+						-1,
+						0
+					], [0, 0], colA);
+					const idx1 = mb.vertex(p1, [
+						0,
+						-1,
+						0
+					], [1, 0], colA);
+					mb.indices.push(idx0, idx1);
+					local += step;
+				} else local += cycle - phase;
+			}
+			dist += segLen;
+		}
+		return;
+	}
+	for (let i = 0; i < pts.length; i++) {
+		const u = pts.length > 1 ? i / (pts.length - 1) : 0;
+		mb.vertex(pts[i], [
+			0,
+			-1,
+			0
+		], [u, 0], parsedColors ? parsedColors[i % parsedColors.length] : void 0);
+	}
+	if (mode === "segments") for (let i = 0; i + 1 < pts.length; i += 2) mb.indices.push(i, i + 1);
+	else {
+		for (let i = 0; i < pts.length - 1; i++) mb.indices.push(i, i + 1);
+		if (o.closed && pts.length >= 3) mb.indices.push(pts.length - 1, 0);
+	}
+}
+/**
+* 3D point cloud geometry: either native GPU `point-list` topology (`pointSize <= 0` or omitted)
+* or icosahedral 3D dots of radius `pointSize` for diagram vertices that scale with perspective.
+*/
+function points3d(o, mb) {
+	const pts = resolvePointArray(o.points);
+	if (pts.length === 0) return;
+	const parsedColors = o.colors?.map((c) => parseHexOrRgbColor(c));
+	const pointSize = o.pointSize ?? 0;
+	if (pointSize > 0) {
+		const dotMb = new MeshBuilder();
+		polyhedron({
+			type: "polyhedron",
+			shape: "icosphere",
+			radius: pointSize,
+			detail: 1,
+			flatShaded: false
+		}, dotMb);
+		const dotVerts = dotMb.positions.length / 3;
+		for (let pIdx = 0; pIdx < pts.length; pIdx++) {
+			const [px, py, pz] = pts[pIdx];
+			const col = parsedColors ? parsedColors[pIdx % parsedColors.length] : void 0;
+			const base = mb.positions.length / 3;
+			for (let v = 0; v < dotVerts; v++) mb.vertex([
+				px + dotMb.positions[v * 3],
+				py + dotMb.positions[v * 3 + 1],
+				pz + dotMb.positions[v * 3 + 2]
+			], [
+				dotMb.normals[v * 3],
+				dotMb.normals[v * 3 + 1],
+				dotMb.normals[v * 3 + 2]
+			], [dotMb.uvs[v * 2], dotMb.uvs[v * 2 + 1]], col);
+			for (const idx of dotMb.indices) mb.indices.push(base + idx);
+		}
+		return;
+	}
+	mb.topology = "point-list";
+	for (let i = 0; i < pts.length; i++) {
+		const u = pts.length > 1 ? i / (pts.length - 1) : 0;
+		const idx = mb.vertex(pts[i], [
+			0,
+			-1,
+			0
+		], [u, 0], parsedColors ? parsedColors[i % parsedColors.length] : void 0);
+		mb.indices.push(idx);
+	}
+}
+function shard(o, mb) {
+	const r = o.radius ?? 50;
+	const hx = (o.size ? o.size[0] : r) || 50;
+	const hy = (o.size ? o.size[1] : r) || 50;
+	const hz = (o.size ? o.size[2] : r) || 50;
+	const maxR = Math.max(hx, hy, hz);
+	const facets = Math.max(4, Math.min(64, Math.round(o.facets ?? 14)));
+	const seed = Math.round(o.seed ?? 1) >>> 0;
+	const irregularity = Math.max(0, Math.min(.85, o.irregularity ?? .35));
+	let state = BigInt(seed) * 6364136223846793005n + 1442695040888963407n;
+	const rnd = () => {
+		state = state * 6364136223846793005n + 1442695040888963407n;
+		const xorshifted = Number((state >> 18n ^ state) >> 27n) >>> 0;
+		const rot = Number(state >> 59n) >>> 0;
+		return ((xorshifted >>> rot | xorshifted << (32 - rot & 31)) >>> 0) / 4294967296;
+	};
+	let faces = [
+		[
+			[
+				-hx,
+				-hy,
+				-hz
+			],
+			[
+				hx,
+				-hy,
+				-hz
+			],
+			[
+				hx,
+				hy,
+				-hz
+			],
+			[
+				-hx,
+				hy,
+				-hz
+			]
+		],
+		[
+			[
+				hx,
+				-hy,
+				hz
+			],
+			[
+				-hx,
+				-hy,
+				hz
+			],
+			[
+				-hx,
+				hy,
+				hz
+			],
+			[
+				hx,
+				hy,
+				hz
+			]
+		],
+		[
+			[
+				-hx,
+				-hy,
+				hz
+			],
+			[
+				-hx,
+				-hy,
+				-hz
+			],
+			[
+				-hx,
+				hy,
+				-hz
+			],
 			[
 				-hx,
 				hy,
@@ -35330,24 +37370,7 @@ function shard(o, mb) {
 		for (let j = 1; j < face.length - 1; j++) mb.indices.push(baseIdx, baseIdx + j, baseIdx + j + 1);
 	}
 }
-/** Builds a procedural solid as a single-mesh Model3DData. */
-function generatePrimitiveGeometry(options) {
-	const mb = new MeshBuilder();
-	if (options.type === "roundedBox") roundedBox(options, mb);
-	else if (options.type === "sphere") sphere(options, mb);
-	else if (options.type === "cylinder") cylinder(options, mb);
-	else if (options.type === "shard") shard(options, mb);
-	else throw new Error(`Unknown 3D primitive: ${options.type}`);
-	const name = options.type;
-	const mesh = mb.build(name);
-	const material = {
-		name: `${name}-material`,
-		diffuseColor: parseHexOrRgbColor(options.color ?? "#ffffff"),
-		shading: options.material ?? "lit",
-		shininess: options.shininess ?? 32,
-		roughness: options.roughness,
-		metallic: options.metallic
-	};
+function finalizeModel3DData(name, meshes, materials) {
 	const min = [
 		Number.POSITIVE_INFINITY,
 		Number.POSITIVE_INFINITY,
@@ -35358,11 +37381,17 @@ function generatePrimitiveGeometry(options) {
 		Number.NEGATIVE_INFINITY,
 		Number.NEGATIVE_INFINITY
 	];
-	const pos = mesh.positions;
-	for (let i = 0; i < pos.length; i += 3) for (let k = 0; k < 3; k++) {
-		const v = pos[i + k];
-		if (v < min[k]) min[k] = v;
-		if (v > max[k]) max[k] = v;
+	for (const mesh of meshes) {
+		const pos = mesh.positions;
+		for (let i = 0; i < pos.length; i += 3) for (let k = 0; k < 3; k++) {
+			const v = pos[i + k];
+			if (v < min[k]) min[k] = v;
+			if (v > max[k]) max[k] = v;
+		}
+	}
+	if (!Number.isFinite(min[0])) {
+		min[0] = min[1] = min[2] = 0;
+		max[0] = max[1] = max[2] = 0;
 	}
 	const size = [
 		max[0] - min[0],
@@ -35371,8 +37400,8 @@ function generatePrimitiveGeometry(options) {
 	];
 	return {
 		name: `primitive-${name}`,
-		meshes: [mesh],
-		materials: { [material.name]: material },
+		meshes,
+		materials,
 		animations: [],
 		bounds: {
 			min,
@@ -35387,6 +37416,36 @@ function generatePrimitiveGeometry(options) {
 		}
 	};
 }
+/** Builds a procedural solid as a Model3DData. */
+function generatePrimitiveGeometry(options) {
+	if (options.type === "extrude") return buildExtrudedShapeModel(options);
+	const mb = new MeshBuilder();
+	if (options.type === "roundedBox") roundedBox(options, mb);
+	else if (options.type === "sphere") sphere(options, mb);
+	else if (options.type === "cylinder") cylinder(options, mb);
+	else if (options.type === "torus") torus(options, mb);
+	else if (options.type === "capsule") capsule(options, mb);
+	else if (options.type === "ring") ring(options, mb);
+	else if (options.type === "polyhedron") polyhedron(options, mb);
+	else if (options.type === "lathe") lathe(options, mb);
+	else if (options.type === "tube") tube(options, mb);
+	else if (options.type === "line3d") line3d(options, mb);
+	else if (options.type === "points3d") points3d(options, mb);
+	else if (options.type === "shard") shard(options, mb);
+	else throw new Error(`Unknown 3D primitive: ${options.type}`);
+	const name = options.type;
+	const mesh = mb.build(name);
+	const defaultShading = options.type === "line3d" || options.type === "points3d" && (options.pointSize ?? 0) <= 0 ? "unlit" : "lit";
+	const material = {
+		name: `${name}-material`,
+		diffuseColor: parseHexOrRgbColor(options.color ?? "#ffffff"),
+		shading: options.material ?? defaultShading,
+		shininess: options.shininess ?? 32,
+		roughness: options.roughness,
+		metallic: options.metallic
+	};
+	return finalizeModel3DData(name, [mesh], { [material.name]: material });
+}
 const primitiveCache = /* @__PURE__ */ new Map();
 /**
 * Like generatePrimitiveGeometry, but identical options return the same
@@ -37084,6 +39143,7 @@ var Renderer3D = class {
 	dofBindGroupLayout;
 	cameraPool;
 	lightsPool;
+	directLightsPool;
 	instancePool;
 	cameraUniformBindGroupCache = new UniformBindGroupCache();
 	samplerCache = new SamplerCache();
@@ -37108,6 +39168,7 @@ var Renderer3D = class {
 	modelCache = /* @__PURE__ */ new Map();
 	lastCameraPose = null;
 	shadowTexture = null;
+	shadowTextures = /* @__PURE__ */ new Map();
 	placeholderShadowTexture = null;
 	shadowSampler = null;
 	meshBounds = /* @__PURE__ */ new WeakMap();
@@ -37132,6 +39193,7 @@ var Renderer3D = class {
 		this.floorReflectionPipeline = new FloorReflectionPipeline(device, format, sampleCount, this.quad3dPipeline.cameraLayout, this.quad3dPipeline.lightsLayout, "depth24plus");
 		this.cameraPool = new BufferPool(320, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
 		this.lightsPool = new BufferPool(LIGHT_UNIFORM_SIZE_BYTES, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
+		this.directLightsPool = new BufferPool(64, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
 		this.instancePool = new BufferPool(65536, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
 		const dofModule = device.createShaderModule({
 			label: "dof-bokeh.wgsl",
@@ -37183,6 +39245,7 @@ var Renderer3D = class {
 		this.lastCameraPose = null;
 		this.lastCameraBuffer = null;
 		this.lightsPool.reset();
+		this.directLightsPool.reset();
 		this.instancePool.reset();
 		this.quad3dPipeline.resetPools();
 		this.slug3dPipeline.resetPools();
@@ -37367,11 +39430,14 @@ var Renderer3D = class {
 		return this.cameraUniformBindGroupCache.getBindGroup(this.device, this.quad3dPipeline.cameraLayout, cameraBuffer);
 	}
 	getOrCreateLightsBuffer(lights, world) {
-		const lightsData = Light3D.packLightsUniforms(lights ?? [], world?.environment, world?.shadow);
+		const lightsData = Light3D.packLightsUniforms(lights ?? [], world?.environment, Array.isArray(world?.shadow) ? world.shadow[0] : world?.shadow);
 		return this.lightsPool.getBuffer(this.device, lightsData);
 	}
 	/** Lights uniform + shadow map + comparison sampler (group 3 of every lit shader). */
-	createLightsBindGroup(lightsBuffer, withShadow) {
+	createLightsBindGroup(lightsBuffer, withShadow, lights, shadows) {
+		const data = Light3D.packDirectLights(lights, shadows);
+		if (data.byteLength > this.device.limits.maxStorageBufferBindingSize) throw new Error(`Direct lights require ${data.byteLength} bytes, exceeding the device storage binding limit of ${this.device.limits.maxStorageBufferBindingSize} bytes`);
+		const directBuffer = this.directLightsPool.getBuffer(this.device, data);
 		this.shadowSampler ??= this.device.createSampler({
 			label: "ShadowComparisonSampler",
 			compare: "less-equal",
@@ -37400,11 +39466,15 @@ var Renderer3D = class {
 				},
 				{
 					binding: 1,
-					resource: map.createView()
+					resource: map.createView({ dimension: "2d-array" })
 				},
 				{
 					binding: 2,
 					resource: this.shadowSampler
+				},
+				{
+					binding: 3,
+					resource: { buffer: directBuffer }
 				}
 			]
 		});
@@ -37487,6 +39557,9 @@ var Renderer3D = class {
 			processed.dirRadius[2]
 		];
 		const mapSize = options.mapSize ?? 2048;
+		const layer = options.layer ?? 0;
+		const layerCount = options.layerCount ?? 1;
+		if (layerCount > this.device.limits.maxTextureArrayLayers) throw new Error(`Shadow maps require ${layerCount} texture layers, exceeding the device limit of ${this.device.limits.maxTextureArrayLayers}`);
 		const casterBounds = casters.map((c) => this.worldBounds(c));
 		const frustum = fitShadowFrustum({
 			type: kind,
@@ -37495,18 +39568,22 @@ var Renderer3D = class {
 			angle: light.angle
 		}, casterBounds, receivers, mapSize);
 		if (!frustum) return null;
-		if (!this.shadowTexture || this.shadowTexture.width !== mapSize) {
-			this.shadowTexture?.destroy();
-			this.shadowTexture = this.device.createTexture({
+		const key = `${mapSize}:${layerCount}`;
+		let texture = this.shadowTextures.get(key);
+		if (!texture) {
+			texture = this.device.createTexture({
 				label: "ShadowMap",
 				size: {
 					width: mapSize,
-					height: mapSize
+					height: mapSize,
+					depthOrArrayLayers: layerCount
 				},
 				format: SHADOW_DEPTH_FORMAT,
 				usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
 			});
+			this.shadowTextures.set(key, texture);
 		}
+		this.shadowTexture = texture;
 		const lightCam = new Float32Array(80);
 		lightCam.set(frustum.viewProj, 32);
 		lightCam.set(frustum.viewProj, 0);
@@ -37525,7 +39602,11 @@ var Renderer3D = class {
 			label: "ShadowMapPass",
 			colorAttachments: [],
 			depthStencilAttachment: {
-				view: this.shadowTexture.createView(),
+				view: this.shadowTexture.createView({
+					dimension: "2d",
+					baseArrayLayer: layer,
+					arrayLayerCount: 1
+				}),
 				depthClearValue: 1,
 				depthLoadOp: "clear",
 				depthStoreOp: "store"
@@ -37576,7 +39657,7 @@ var Renderer3D = class {
 		const cameraBuffer = this.packCameraUniforms(camera, surfaceWidth, surfaceHeight);
 		const cameraBindGroup = this.createCameraBindGroup(cameraBuffer);
 		const lightsBuffer = this.getOrCreateLightsBuffer(lights, world);
-		const lightsBindGroup = this.createLightsBindGroup(lightsBuffer, Boolean(world?.shadow));
+		const lightsBindGroup = this.createLightsBindGroup(lightsBuffer, Boolean(world?.shadow), lights ?? [], world?.shadow ? Array.isArray(world.shadow) ? world.shadow : [world.shadow] : []);
 		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 ? {
@@ -37636,9 +39717,9 @@ var Renderer3D = class {
 		const depthTex = this.getOrCreateReflectionDepthTexture(reflWidth, reflHeight);
 		const cameraBuffer = this.packCameraUniforms(camera, reflWidth, reflHeight);
 		const cameraBindGroup = this.createCameraBindGroup(cameraBuffer);
-		const lightsData = Light3D.packLightsUniforms(lights ?? [], world?.environment, world?.shadow, true);
+		const lightsData = Light3D.packLightsUniforms(lights ?? [], world?.environment, Array.isArray(world?.shadow) ? world.shadow[0] : world?.shadow, true);
 		const lightsBuffer = this.lightsPool.getBuffer(this.device, lightsData);
-		const lightsBindGroup = this.createLightsBindGroup(lightsBuffer, Boolean(world?.shadow));
+		const lightsBindGroup = this.createLightsBindGroup(lightsBuffer, Boolean(world?.shadow), lights ?? [], world?.shadow ? Array.isArray(world.shadow) ? world.shadow : [world.shadow] : []);
 		const msaa = this.sampleCount > 1;
 		const msaaTex = msaa ? this.getOrCreateReflectionMsaaTexture(reflWidth, reflHeight) : null;
 		const colorAttachments = [msaaTex ? {
@@ -38061,7 +40142,8 @@ var Renderer3D = class {
 			matte: opts.matte,
 			maps: opts.maps,
 			isInstanced: Boolean(opts.instanceBuffer || opts.instanceCount && opts.instanceCount > 1),
-			instanceBuffer: opts.instanceBuffer
+			instanceBuffer: opts.instanceBuffer,
+			matrixInstances: opts.matrixInstances
 		}, useMrt, this.passWritesHdr, opts.instanceCount ?? 1, opts.firstInstance ?? 0);
 	}
 	loadModel(srcOrData, format = "auto", options = {}) {
@@ -38265,7 +40347,8 @@ var Renderer3D = class {
 	destroy() {
 		this.bloomPipeline?.destroy();
 		this.depthTexture?.destroy();
-		this.shadowTexture?.destroy();
+		for (const texture of this.shadowTextures.values()) texture.destroy();
+		this.shadowTextures.clear();
 		this.placeholderShadowTexture?.destroy();
 		this.linearDepthTexture?.destroy();
 		this.msaaColorTexture?.destroy();
@@ -38284,6 +40367,7 @@ var Renderer3D = class {
 		this.reflectionBlurredTexture?.destroy();
 		this.cameraPool.destroy();
 		this.lightsPool.destroy();
+		this.directLightsPool.destroy();
 		this.instancePool.destroy();
 		this.cameraUniformBindGroupCache.destroy();
 	}
@@ -38934,4 +41018,4 @@ if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThi
 
 //#endregion
 export { probeVideoSize as $, TextPathBuilder as $t, emojiGraphemes as A, generateArcLengthLUT as An, CubicBezierSegmentSchema as At, jointMatrices as B, ParticleDissolveConfigSchema as Bt, drawGifNode as C, evaluateExpressionSelector as Cn, AdvancedTextAnimatorSchema as Ct, drawSignalNode as D, evaluateSpringProgress as Dn, AudioSignalComputePipeline as Dt, drawParagraphNode as E, evaluateSkewMatrix as En, AnimatableGlyphPropsSchema as Et, getPrimitiveGeometry as F, sampleAudioSpectrumScale as Fn, GlyphAnchorGroupingSchema as Ft, measureMaxCaptionHeight as G, SignalRegistry as Gt, loadModel3D as H, SelectorModeSchema as Ht, getRegisteredFontSource as I, sampleCurveGeometry as In, GlyphAnchorPointSchema as It, parseFBX as J, SpringPhysicsSchema as Jt, mediaDecoderCache as K, SkewPropertiesSchema as Kt, getRenderer2D as L, samplePathChainGeometry as Ln, KineticMarqueeConfigSchema as Lt, fitSpansToText as M, getScramblePool as Mn, EnhancedTextNodeSchema as Mt, generateExtrudedTextGeometry as N, getShuffledOrder as Nn, ExpressionSelectorSchema as Nt, drawSvgNode as O, evaluateTypewriterState as On, AudioSpectrumTypographySchema as Ot, getHeadlessFontPath as P, parseSvgPathToCubicBeziers as Pn, ExtendedGlyphPropertiesSchema as Pt, poseNodes as Q, TextCursorStyleSchema as Qt, initHeadlessWebGPU as R, signalRegistry as Rn, LineSpacingDynamicsSchema as Rt, drawCaptionNode as S, evaluateCubicBezierDerivative as Sn, AdvancedTextAnimatorBuilder as St, drawLottieNode as T, evaluateSelectorCombination as Tn, AnchorPresetSchema as Tt, loadOBJ as U, SelectorShapeSchema as Ut, loadFBX as V, SelectorBasedOnSchema as Vt, lutStore as W, SelectorUnitsSchema as Wt, parseOBJ as X, TextAnimatorBuilder as Xt, parseMTL as Y, TextAnchorConfigSchema as Yt, parseSvgPathToSegments as Z, TextCursorConfigSchema as Zt, buildShapeSvgPath as _, computeRangeSelectorWeight as _n, Vector3Math as _t, GlassPipeline as a, TextSignalSelectorSchema as an, spansText as at, colorMatrixWgsl as b, ellipseToCubicBeziers as bn, resolveEnvironment as bt, Renderer2D as c, TypingCadenceSchema as cn, GetFontAssetUrl as ct, ScreenSpaceRelightPipeline as d, VolumetricFormationConfigSchema as dn, ENVIRONMENT_PRESETS as dt, TextPathOptionsSchema as en, registerHeadlessFont as et, ShadowPipeline as f, VolumetricFormationModeSchema as fn, LIGHT_UNIFORM_SIZE_BYTES as ft, WebGPUAudioProcessor as g, computeLineLeadingDisplacement as gn, Path3D as gt, SlugPipeline as h, computeAnchorPivotOffset as hn, Matrix4Math as ht, EffectPipeline as i, TextSelectorSchema as in, shaderStore as it, ensureDevice as j, generatePathSegments as jn, DynamicStrokePropertiesSchema as jt, drawVideoNode as k, evaluateVolumetricFormation as kn, ChromaticGlitchConfigSchema as kt, Renderer3D as l, VariableFontAxesSchema as ln, resolveMediaSourceUrl as lt, SlugGeometry as m, buildWGSLSignalFn as mn, MAX_LIGHTS as mt, AudioLatentTrackCache as n, TextRangeSelectorSchema as nn, sampleMorphWeights as nt, MotionBlurPipeline as o, TextWigglySelectorSchema as on, srtLoader as ot, SlugFontCache as p, buildPathLUT as pn, Light3D as pt, parseColor as q, Spatial3DPropertiesSchema as qt, AudioMeshDeformPipeline as r, TextScrambleConfigSchema as rn, setRegisteredFontSource as rt, NodeSurfaceProvider as s, TypewriterAnimatorSchema as sn, textureCache as st, AudioLatentEngine as t, TextPathSourceSchema as tn, resolveTextSpans as tt, SSAOPipeline as u, Vec2Schema as un, Camera3D as ut, clearAllVideoCache as v, deterministicWigglyNoise as vn, linearRgb as vt, drawImageNode as w, evaluateMarqueeOffset as wn, AnchorGroupingSchema as wt, describeGpu as x, evaluateCubicBezier as xn, AETextAnimatorSchema as xt, clearHeadlessFonts as y, distanceToCurveParameter as yn, parseColorToRgb as yt, inputStore as z, waveToCubicBeziers as zn, LongShadowConfigSchema as zt };
-//# sourceMappingURL=dist-CnFcSau0.mjs.map
+//# sourceMappingURL=dist-C1cCW7Bt.mjs.map