insomni 0.2.0-alpha.0

package/dist/assemble-BT3CXbSx.mjs

@@ -0,0 +1,1574 @@
+import { A as DEPTH_FORMAT, _ as TAU, i as DEPTH_COMPARE, t as ALPHA_BLEND } from "./pipeline-BWCAZTKx.mjs";
+import { d } from "typegpu";
+import "earcut";
+//#region src/math/color.ts
+function rgba(r, g, b, a = 1) {
+	return {
+		r,
+		g,
+		b,
+		a
+	};
+}
+/** Parse a 24-bit hex color, e.g. hex(0xff6600). Alpha is always 1. */
+function hex(value) {
+	return {
+		r: (value >> 16 & 255) / 255,
+		g: (value >> 8 & 255) / 255,
+		b: (value & 255) / 255,
+		a: 1
+	};
+}
+/** Parse a CSS hex string, e.g. cssHex("#ff6600") or cssHex("#ff660080"). */
+function cssHex(value) {
+	const s = value.replace("#", "");
+	const n = parseInt(s, 16);
+	if (s.length === 6) return hex(n);
+	return {
+		r: (n >> 24 & 255) / 255,
+		g: (n >> 16 & 255) / 255,
+		b: (n >> 8 & 255) / 255,
+		a: (n & 255) / 255
+	};
+}
+/**
+* HSL → RGB. All inputs in `[0, 1]`. Hue wraps automatically.
+* `hsv` is the cousin of this for value-based color picking.
+*/
+function hsl(h, s, l, a = 1) {
+	const hh = (h % 1 + 1) % 1;
+	const k = (n) => (n + hh * 12) % 12;
+	const chroma = s * Math.min(l, 1 - l);
+	const f = (n) => l - chroma * Math.max(-1, Math.min(k(n) - 3, 9 - k(n), 1));
+	return {
+		r: f(0),
+		g: f(8),
+		b: f(4),
+		a
+	};
+}
+/** HSV → RGB. All inputs in `[0, 1]`. Hue wraps automatically. */
+function hsv(h, s, v, a = 1) {
+	const hh = (h % 1 + 1) % 1;
+	const k = (n) => (n + hh * 6) % 6;
+	const f = (n) => v - v * s * Math.max(0, Math.min(k(n), 4 - k(n), 1));
+	return {
+		r: f(5),
+		g: f(3),
+		b: f(1),
+		a
+	};
+}
+/** Alias of `hsl` for parity with code that explicitly calls out the conversion. */
+const hslToRgb = hsl;
+/** Alias of `hsl` — accepts the same `(h, s, l, a)` signature. */
+const hslToRgba = hsl;
+/** Linearly interpolate two colors channel-wise. */
+function lerpColor(a, b, t) {
+	return {
+		r: a.r + (b.r - a.r) * t,
+		g: a.g + (b.g - a.g) * t,
+		b: a.b + (b.b - a.b) * t,
+		a: a.a + (b.a - a.a) * t
+	};
+}
+/** Alias of `lerpColor` matching the `mix()` naming used in shaders. */
+const mixColor = lerpColor;
+/** Return a copy of `color` with the given alpha. */
+function withAlpha(color, alpha) {
+	return {
+		r: color.r,
+		g: color.g,
+		b: color.b,
+		a: alpha
+	};
+}
+/** Multiply alpha — useful for fading layered colors without losing the base value. */
+function fade(color, factor) {
+	return {
+		r: color.r,
+		g: color.g,
+		b: color.b,
+		a: color.a * factor
+	};
+}
+/** Mix `color` with white by `t` ∈ [0, 1]. */
+function lighten(color, t) {
+	return lerpColor(color, WHITE, t);
+}
+/** Mix `color` with black by `t` ∈ [0, 1]. */
+function darken(color, t) {
+	return lerpColor(color, BLACK, t);
+}
+const TRANSPARENT = {
+	r: 0,
+	g: 0,
+	b: 0,
+	a: 0
+};
+const BLACK = {
+	r: 0,
+	g: 0,
+	b: 0,
+	a: 1
+};
+const WHITE = {
+	r: 1,
+	g: 1,
+	b: 1,
+	a: 1
+};
+//#endregion
+//#region src/schema/instance.ts
+/**
+* Universal per-instance record: 16 floats / 64 bytes. Field order here IS the
+* GPU memory order; do not reorder without re-deriving every consumer.
+*
+* Depth is carried by the explicit `order` field (float-offset 10), never
+* derived from the instance index. Index-derived Z couples depth precision to
+* draw count and requires a per-draw uniform; the explicit field removes both.
+*
+* Layout (float offset / byte offset):
+*   geom0     @  0 /  0  vec4f  — geometry slot 0 (kind-specific)
+*   geom1     @  4 / 16  vec4f  — geometry slot 1 (kind-specific)
+*   colorBits @  8 / 32  u32    — packed unorm8x4 color
+*   typeFlag  @  9 / 36  u32    — shape-kind discriminant
+*   order     @ 10 / 40  f32    — EXPLICIT depth; never index-derived
+*   lane0     @ 11 / 44  u32    — kind-specific payload
+*   lane1     @ 12 / 48  u32
+*   lane2     @ 13 / 52  u32
+*   lane3     @ 14 / 56  u32
+*   lane4     @ 15 / 60  u32  — see emphasis note below
+*
+* `lane4` is dual-purpose, kind-by-kind. No *shape* kind (rect/circle/ellipse/
+* segment/curve/arc/triangle/polyline) reads it, so for shapes it carries the
+* **emphasis key** (Phase 4): the uber `transparent` / OIT-build fragments
+* compare it against the `Emphasis.focusedKey` uniform to dim non-focused
+* PARTICIPATING instances (`shader/assemble.ts`). EXEMPT-ZERO: `lane4 == 0u` —
+* the deterministic default `UberPack.append` writes — is the opt-out sentinel;
+* a key-0 shape is NEVER dimmed (instances opt INTO emphasis with a key ≥ 1), so
+* untagged shapes stay full-alpha during a mark emphasis. A shape's `lane4` is
+* never stale. The glyph pack (`glyph/glyph-pack.ts`) independently uses `lane4`
+* for the anchored-text world anchor Y — that is fine because glyphs render
+* through the dedicated glyph pipeline, which never reads the emphasis uniform.
+*/
+const INSTANCE_FIELDS = [
+	{
+		name: "geom0",
+		kind: "vec4f",
+		floats: 4
+	},
+	{
+		name: "geom1",
+		kind: "vec4f",
+		floats: 4
+	},
+	{
+		name: "colorBits",
+		kind: "u32",
+		floats: 1
+	},
+	{
+		name: "typeFlag",
+		kind: "u32",
+		floats: 1
+	},
+	{
+		name: "order",
+		kind: "f32",
+		floats: 1
+	},
+	{
+		name: "lane0",
+		kind: "u32",
+		floats: 1
+	},
+	{
+		name: "lane1",
+		kind: "u32",
+		floats: 1
+	},
+	{
+		name: "lane2",
+		kind: "u32",
+		floats: 1
+	},
+	{
+		name: "lane3",
+		kind: "u32",
+		floats: 1
+	},
+	{
+		name: "lane4",
+		kind: "u32",
+		floats: 1
+	}
+];
+/** Total floats per instance — derived from {@link INSTANCE_FIELDS}. */
+const INSTANCE_FLOATS = INSTANCE_FIELDS.reduce((sum, f) => sum + f.floats, 0);
+/** Total bytes per instance — derived from {@link INSTANCE_FLOATS}. */
+const INSTANCE_BYTES = INSTANCE_FLOATS * 4;
+if (INSTANCE_FLOATS !== 16) throw new Error(`v3 INSTANCE_FLOATS must be 16, got ${INSTANCE_FLOATS}`);
+if (INSTANCE_BYTES !== 64) throw new Error(`v3 INSTANCE_BYTES must be 64, got ${INSTANCE_BYTES}`);
+//#endregion
+//#region src/kinds/kind.ts
+/** Shape-kind discriminant written into `InstanceRecord.typeFlag`. */
+const TYPE_RECT = 0;
+const TYPE_CIRCLE = 1;
+const TYPE_ELLIPSE = 2;
+const TYPE_SEGMENT = 3;
+const TYPE_CURVE = 4;
+/**
+* Reserved for a future Phase-4 in-uber sprite kind (texture binding in the
+* uber-shader + `Layer.pushSprite`). In Phase 3, sprites render via the
+* {@link BufferLayer} + sibling pipeline path — see
+* `pipelines/sprite-pipelines.ts` (`createSpritePipelines`) and
+* `layers/buffer-layer.ts` (`BufferLayerSpritesOptions`). `TYPE_SPRITE` is
+* intentionally absent from `ORDERED_KINDS` in `kinds/index.ts`: the shader
+* assembler (`assembleShader`) does NOT emit a dispatch branch for it, and
+* there is no concrete sprite kind module under `kinds/`.
+*/
+const TYPE_SPRITE = 5;
+const TYPE_TRIANGLE = 6;
+const TYPE_ARC = 7;
+/**
+* Glyph quad packed by `GlyphPack`. One instance per visible glyph;
+* atlas UV, atlas glyph id, and per-string flags live in the lane slots.
+* The MSDF glyph pipeline (RTT bake) selects this kind at fragment time.
+*/
+const TYPE_GLYPH = 8;
+/**
+* Analytic SDF stroke-path (`kinds/stroke.ts`). Up to 4 points per instance; an
+* N-point stroke chains `ceil((M-1)/3)` instances. The min-of-segment SDF in
+* the fragment computes coverage analytically (no CPU triangulation) — the
+* opt-in alternative to the tessellated `pushPolyline` path for dense strokes.
+*/
+const TYPE_STROKE_PATH = 9;
+//#endregion
+//#region src/core/f16.ts
+/**
+* IEEE-754 half-precision (f16) packing helpers. Used to pack per-shape
+* scalars into the instance vertex buffer — see `pack/uber-pack.ts`.
+*
+* Not suitable for large-magnitude world coordinates: f16 has ±65504 range
+* and sub-pixel precision only up to ~1024.
+*/
+const _f32 = new Float32Array(1);
+const _u32 = new Uint32Array(_f32.buffer);
+const _f32_2 = new Float32Array(2);
+const _u32_2 = new Uint32Array(_f32_2.buffer);
+/**
+* Pack a 32-bit float into its 16-bit half-precision bit pattern.
+* Rounds ties to even. NaN → canonical quiet NaN. Out-of-range → ±Inf.
+*/
+function packF16(value) {
+	if (value === 0) return 1 / value === -Infinity ? 32768 : 0;
+	_f32[0] = value;
+	const bits = _u32[0];
+	const sign = bits >>> 16 & 32768;
+	const exp = bits >>> 23 & 255;
+	const mant = bits & 8388607;
+	if (exp > 112 && exp < 143) {
+		let m16 = mant >>> 13;
+		if ((mant & 4096) !== 0) {
+			m16 += 1;
+			if ((m16 & 1024) !== 0) return sign | exp - 111 << 10;
+		}
+		return sign | exp - 112 << 10 | m16;
+	}
+	if (exp === 255) return sign | 31744 | (mant !== 0 ? 512 : 0);
+	if (exp <= 112) {
+		const e = exp - 112;
+		if (e < -10) return sign;
+		let m = (mant | 8388608) >>> 1 - e;
+		if ((m & 4096) !== 0) m += 4096 + (m >>> 13 & 1);
+		return sign | m >>> 13;
+	}
+	return sign | 31744;
+}
+/** Pack (lo, hi) as a single little-endian u32 — `pack2x16float` equivalent. */
+function pack2xF16(lo, hi) {
+	if (lo === 0 && hi === 0) return ((1 / lo === -Infinity ? 32768 : 0) | (1 / hi === -Infinity ? 32768 : 0) << 16) >>> 0;
+	_f32_2[0] = lo;
+	_f32_2[1] = hi;
+	const bitsLo = _u32_2[0];
+	const bitsHi = _u32_2[1];
+	let f0 = 0;
+	if (lo === 0) f0 = 1 / lo === -Infinity ? 32768 : 0;
+	else {
+		const sign = bitsLo >>> 16 & 32768;
+		const exp = bitsLo >>> 23 & 255;
+		const mant = bitsLo & 8388607;
+		if (exp > 112 && exp < 143) {
+			let m16 = mant >>> 13;
+			if ((mant & 4096) !== 0) {
+				m16 += 1;
+				if ((m16 & 1024) !== 0) f0 = sign | exp - 111 << 10;
+				else f0 = sign | exp - 112 << 10 | m16;
+			} else f0 = sign | exp - 112 << 10 | m16;
+		} else if (exp === 255) f0 = sign | 31744 | (mant !== 0 ? 512 : 0);
+		else if (exp <= 112) {
+			const e = exp - 112;
+			if (e < -10) f0 = sign;
+			else {
+				let m = (mant | 8388608) >>> 1 - e;
+				if ((m & 4096) !== 0) m += 4096 + (m >>> 13 & 1);
+				f0 = sign | m >>> 13;
+			}
+		} else f0 = sign | 31744;
+	}
+	let f1 = 0;
+	if (hi === 0) f1 = 1 / hi === -Infinity ? 32768 : 0;
+	else {
+		const sign = bitsHi >>> 16 & 32768;
+		const exp = bitsHi >>> 23 & 255;
+		const mant = bitsHi & 8388607;
+		if (exp > 112 && exp < 143) {
+			let m16 = mant >>> 13;
+			if ((mant & 4096) !== 0) {
+				m16 += 1;
+				if ((m16 & 1024) !== 0) f1 = sign | exp - 111 << 10;
+				else f1 = sign | exp - 112 << 10 | m16;
+			} else f1 = sign | exp - 112 << 10 | m16;
+		} else if (exp === 255) f1 = sign | 31744 | (mant !== 0 ? 512 : 0);
+		else if (exp <= 112) {
+			const e = exp - 112;
+			if (e < -10) f1 = sign;
+			else {
+				let m = (mant | 8388608) >>> 1 - e;
+				if ((m & 4096) !== 0) m += 4096 + (m >>> 13 & 1);
+				f1 = sign | m >>> 13;
+			}
+		} else f1 = sign | 31744;
+	}
+	return (f0 | f1 << 16) >>> 0;
+}
+const _bcF32 = new Float32Array(1);
+const _bcU32 = new Uint32Array(_bcF32.buffer);
+/**
+* Reinterpret the bits of a 32-bit float as a u32 (IEEE-754 bitcast).
+* Equivalent to WGSL `bitcast<u32>(value)`. Used to store f32 scalars in
+* u32-typed instance slots (e.g. segment width, arc geometry params).
+*/
+function bitcastF32(value) {
+	_bcF32[0] = value;
+	return _bcU32[0];
+}
+/**
+* Pack four components clamped to [0,1] as a little-endian unorm8x4 u32.
+* Match to WGSL `unpack4x8unorm(value)` which yields `vec4f(r, g, b, a)` with
+* component 0 in the low byte.
+*/
+function packUnorm8x4(r, g, b, a) {
+	const r8 = r * 255 + .5 | 0;
+	const g8 = g * 255 + .5 | 0;
+	const b8 = b * 255 + .5 | 0;
+	const a8 = a * 255 + .5 | 0;
+	return ((r8 < 0 ? 0 : r8 > 255 ? 255 : r8) | (g8 < 0 ? 0 : g8 > 255 ? 255 : g8) << 8 | (b8 < 0 ? 0 : b8 > 255 ? 255 : b8) << 16 | (a8 < 0 ? 0 : a8 > 255 ? 255 : a8) << 24) >>> 0;
+}
+/** Unpack an IEEE-754 f16 bit pattern into a JS number. Inverse of `packF16`. */
+function unpackF16(bits) {
+	const sign = (bits & 32768) !== 0 ? -1 : 1;
+	const exp = bits >>> 10 & 31;
+	const mant = bits & 1023;
+	if (exp === 0) return sign * 2 ** -14 * (mant / 1024);
+	if (exp === 31) return mant === 0 ? sign * Infinity : NaN;
+	return sign * 2 ** (exp - 15) * (1 + mant / 1024);
+}
+//#endregion
+//#region src/schema/codegen.ts
+/** Map a {@link InstanceField} kind to its TypeGPU primitive schema. */
+function tgpuPrimitive(kind) {
+	switch (kind) {
+		case "vec4f": return d.vec4f;
+		case "u32": return d.u32;
+		case "f32": return d.f32;
+	}
+}
+/**
+* Derive the full instance layout from {@link INSTANCE_FIELDS}. Pure and
+* deterministic — calling it twice yields structurally identical layouts.
+*/
+function deriveLayout() {
+	let cursor = 0;
+	const offsets = {};
+	const shape = {};
+	for (const field of INSTANCE_FIELDS) {
+		offsets[field.name] = {
+			floatOffset: cursor,
+			byteOffset: cursor * 4
+		};
+		shape[field.name] = tgpuPrimitive(field.kind);
+		cursor += field.floats;
+	}
+	return {
+		byteStride: INSTANCE_BYTES,
+		floatStride: INSTANCE_FLOATS,
+		offsets,
+		tgpuStruct: d.struct(shape),
+		wgslAccessor: ""
+	};
+}
+/** Eagerly-derived canonical instance layout — the shared v3 contract. */
+const INSTANCE_LAYOUT = deriveLayout();
+//#endregion
+//#region src/kinds/polyline.ts
+function defaultEllipseSegments(rx, ry) {
+	return Math.max(16, Math.min(128, 16 + Math.ceil(Math.max(Math.abs(rx), Math.abs(ry)) * .5)));
+}
+/**
+* Generate a closed-loop polyline approximating an ellipse. Vertices are
+* spaced evenly in angle (not arc length) — for small markers this matches
+* SDF rendering to within a sub-pixel. Returns points in CCW math order (which
+* is CW in screen coords where y grows downward). The returned array does NOT
+* include a duplicate closing point — pass `closed: true` to `tessellatePolyline`.
+*/
+function polylineEllipseRing(opts) {
+	const { cx, cy, rx, ry, rotation = 0 } = opts;
+	const segments = opts.segments ?? defaultEllipseSegments(rx, ry);
+	if (segments < 3) throw new Error("polylineEllipseRing requires at least 3 segments.");
+	const cos = Math.cos(rotation);
+	const sin = Math.sin(rotation);
+	const out = Array.from({ length: segments });
+	for (let i = 0; i < segments; i++) {
+		const a = i / segments * TAU;
+		const px = Math.cos(a) * rx;
+		const py = Math.sin(a) * ry;
+		out[i] = {
+			x: cx + cos * px - sin * py,
+			y: cy + sin * px + cos * py
+		};
+	}
+	return out;
+}
+/**
+* Generate a closed-loop polyline for a rectangle outline. Sharp by default;
+* supply `cornerRadius` to get rounded corners via small arcs at each corner.
+* Like {@link polylineEllipseRing}, the returned array is unclosed — feed it
+* to `tessellatePolyline` with `closed: true`.
+*/
+function polylineRectRing(opts) {
+	const { x, y, width, height } = opts;
+	const cornerRadius = opts.cornerRadius ?? 0;
+	if (cornerRadius <= 0) return [
+		{
+			x,
+			y
+		},
+		{
+			x: x + width,
+			y
+		},
+		{
+			x: x + width,
+			y: y + height
+		},
+		{
+			x,
+			y: y + height
+		}
+	];
+	const r = Math.min(cornerRadius, width * .5, height * .5);
+	const cornerSegments = Math.max(2, opts.cornerSegments ?? 4);
+	const out = [];
+	const corners = [
+		{
+			cx: x + r,
+			cy: y + r,
+			a0: Math.PI,
+			a1: 1.5 * Math.PI
+		},
+		{
+			cx: x + width - r,
+			cy: y + r,
+			a0: 1.5 * Math.PI,
+			a1: 2 * Math.PI
+		},
+		{
+			cx: x + width - r,
+			cy: y + height - r,
+			a0: 0,
+			a1: .5 * Math.PI
+		},
+		{
+			cx: x + r,
+			cy: y + height - r,
+			a0: .5 * Math.PI,
+			a1: Math.PI
+		}
+	];
+	for (const c of corners) for (let i = 0; i <= cornerSegments; i++) {
+		const t = i / cornerSegments;
+		const a = c.a0 + (c.a1 - c.a0) * t;
+		out.push({
+			x: c.cx + Math.cos(a) * r,
+			y: c.cy + Math.sin(a) * r
+		});
+	}
+	return out;
+}
+/**
+* Tessellate a polyline into triangles for GPU rendering.
+* Returns an array of triangles representing the stroke geometry.
+*/
+function tessellatePolyline(shape) {
+	const width = shape.width ?? 1;
+	if (width <= 0 || shape.color.a <= 0) return [];
+	const points = shape.points;
+	if (points.length < 2) return [];
+	assertFinitePoints(points, "Polyline points");
+	const closed = shape.closed ?? false;
+	const cap = shape.cap ?? "butt";
+	const join = shape.join ?? "miter";
+	const miterLimit = shape.miterLimit ?? 4;
+	const halfWidth = width * .5;
+	const dashPattern = shape.dashPattern;
+	if (dashPattern && dashPattern.length > 0) return tessellateDashed(points, closed, cap, join, miterLimit, halfWidth, dashPattern, shape.dashOffset ?? 0);
+	return tessellateStroke(points, closed, cap, join, miterLimit, halfWidth);
+}
+function tessellateStroke(points, closed, cap, join, miterLimit, halfWidth) {
+	const out = [];
+	const pts = dedup(points);
+	if (pts.length < 2) return out;
+	const segCount = closed ? pts.length : pts.length - 1;
+	const normals = [];
+	for (let i = 0; i < segCount; i++) {
+		const next = (i + 1) % pts.length;
+		normals.push(segmentNormal(pts[i], pts[next]));
+	}
+	const entryLeft = [];
+	const entryRight = [];
+	const exitLeft = [];
+	const exitRight = [];
+	if (closed) {
+		for (let i = 0; i < pts.length; i++) {
+			const prevSeg = (i - 1 + segCount) % segCount;
+			const nextSeg = i % segCount;
+			const joinPts = computeJoin(pts[i], normals[prevSeg], normals[nextSeg], halfWidth, join, miterLimit);
+			entryLeft.push(joinPts.entryLeft);
+			entryRight.push(joinPts.entryRight);
+			exitLeft.push(joinPts.exitLeft);
+			exitRight.push(joinPts.exitRight);
+			if (joinPts.extraTriangles) for (const tri of joinPts.extraTriangles) out.push(tri);
+		}
+		for (let i = 0; i < segCount; i++) {
+			const next = (i + 1) % pts.length;
+			emitQuad(exitLeft[i], exitRight[i], entryLeft[next], entryRight[next], out);
+		}
+	} else {
+		const startCapTris = emitCap(pts[0], normals[0], halfWidth, cap, true);
+		for (const tri of startCapTris) out.push(tri);
+		const firstL = offset(pts[0], normals[0], halfWidth);
+		const firstR = offset(pts[0], normals[0], -halfWidth);
+		entryLeft.push(firstL);
+		entryRight.push(firstR);
+		exitLeft.push(firstL);
+		exitRight.push(firstR);
+		for (let i = 1; i < pts.length - 1; i++) {
+			const joinPts = computeJoin(pts[i], normals[i - 1], normals[i], halfWidth, join, miterLimit);
+			entryLeft.push(joinPts.entryLeft);
+			entryRight.push(joinPts.entryRight);
+			exitLeft.push(joinPts.exitLeft);
+			exitRight.push(joinPts.exitRight);
+			if (joinPts.extraTriangles) for (const tri of joinPts.extraTriangles) out.push(tri);
+		}
+		const last = pts.length - 1;
+		const lastL = offset(pts[last], normals[segCount - 1], halfWidth);
+		const lastR = offset(pts[last], normals[segCount - 1], -halfWidth);
+		entryLeft.push(lastL);
+		entryRight.push(lastR);
+		exitLeft.push(lastL);
+		exitRight.push(lastR);
+		const endCapTris = emitCap(pts[last], normals[segCount - 1], halfWidth, cap, false);
+		for (const tri of endCapTris) out.push(tri);
+		for (let i = 0; i < segCount; i++) emitQuad(exitLeft[i], exitRight[i], entryLeft[i + 1], entryRight[i + 1], out);
+	}
+	return out;
+}
+function tessellateDashed(points, closed, cap, join, miterLimit, halfWidth, dashPattern, dashOffset) {
+	const pts = dedup(points);
+	if (pts.length < 2) return [];
+	const segCount = closed ? pts.length : pts.length - 1;
+	const distances = [0];
+	for (let i = 0; i < segCount; i++) {
+		const next = (i + 1) % pts.length;
+		distances.push(distances[i] + dist(pts[i], pts[next]));
+	}
+	const totalLength = distances[distances.length - 1];
+	if (totalLength <= 0) return [];
+	let patternLength = 0;
+	for (const d of dashPattern) patternLength += Math.abs(d);
+	if (patternLength <= 0) return tessellateStroke(pts, closed, cap, join, miterLimit, halfWidth);
+	const out = [];
+	const patPos = (dashOffset % patternLength + patternLength) % patternLength;
+	let dashIdx = 0;
+	let consumed = 0;
+	for (let i = 0; i < dashPattern.length; i++) {
+		const dl = Math.abs(dashPattern[i]);
+		if (consumed + dl > patPos) {
+			dashIdx = i;
+			break;
+		}
+		consumed += dl;
+		if (i === dashPattern.length - 1) {
+			dashIdx = 0;
+			consumed = 0;
+		}
+	}
+	let remainInDash = Math.abs(dashPattern[dashIdx]) - (patPos - consumed);
+	let isDraw = dashIdx % 2 === 0;
+	let currentDash = [];
+	if (isDraw) currentDash.push(sampleAt(pts, distances, segCount, 0));
+	let walkDist = 0;
+	for (let seg = 0; seg < segCount; seg++) {
+		let segRemain = distances[seg + 1] - distances[seg];
+		while (segRemain > 0) {
+			const step = Math.min(remainInDash, segRemain);
+			walkDist += step;
+			segRemain -= step;
+			remainInDash -= step;
+			if (remainInDash <= 1e-6) {
+				if (isDraw) {
+					const t = Math.min(walkDist, totalLength);
+					currentDash.push(sampleAt(pts, distances, segCount, t));
+					if (currentDash.length >= 2) {
+						const tris = tessellateStroke(currentDash, false, cap, join, miterLimit, halfWidth);
+						for (const tri of tris) out.push(tri);
+					}
+					currentDash = [];
+				}
+				dashIdx = (dashIdx + 1) % dashPattern.length;
+				isDraw = dashIdx % 2 === 0;
+				remainInDash = Math.abs(dashPattern[dashIdx]);
+				if (isDraw) currentDash.push(sampleAt(pts, distances, segCount, Math.min(walkDist, totalLength)));
+			}
+		}
+	}
+	if (isDraw && currentDash.length >= 1) {
+		const endPt = closed ? pts[0] : pts[pts.length - 1];
+		if (currentDash.length === 1 && (currentDash[0].x !== endPt.x || currentDash[0].y !== endPt.y)) currentDash.push(endPt);
+		if (currentDash.length >= 2) {
+			const tris = tessellateStroke(currentDash, false, cap, join, miterLimit, halfWidth);
+			for (const tri of tris) out.push(tri);
+		}
+	}
+	return out;
+}
+function computeJoin(point, prevNormal, nextNormal, halfWidth, join, miterLimit) {
+	const mx = prevNormal.x + nextNormal.x;
+	const my = prevNormal.y + nextNormal.y;
+	const mLen = Math.sqrt(mx * mx + my * my);
+	if (mLen < 1e-6) {
+		const l = offset(point, prevNormal, halfWidth);
+		const r = offset(point, prevNormal, -halfWidth);
+		return {
+			entryLeft: l,
+			entryRight: r,
+			exitLeft: l,
+			exitRight: r
+		};
+	}
+	const miterX = mx / mLen;
+	const miterY = my / mLen;
+	const dotMN = miterX * prevNormal.x + miterY * prevNormal.y;
+	if (Math.abs(dotMN) < 1e-6) {
+		const l = offset(point, prevNormal, halfWidth);
+		const r = offset(point, prevNormal, -halfWidth);
+		return {
+			entryLeft: l,
+			entryRight: r,
+			exitLeft: l,
+			exitRight: r
+		};
+	}
+	const miterLen = halfWidth / dotMN;
+	const absMiterLen = Math.abs(miterLen);
+	const crossVal = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x;
+	if (join === "miter" && absMiterLen <= halfWidth * miterLimit) {
+		const l = {
+			x: point.x + miterX * miterLen,
+			y: point.y + miterY * miterLen
+		};
+		const r = {
+			x: point.x - miterX * miterLen,
+			y: point.y - miterY * miterLen
+		};
+		return {
+			entryLeft: l,
+			entryRight: r,
+			exitLeft: l,
+			exitRight: r
+		};
+	}
+	const prevLeft = offset(point, prevNormal, halfWidth);
+	const prevRight = offset(point, prevNormal, -halfWidth);
+	const nextLeft = offset(point, nextNormal, halfWidth);
+	const nextRight = offset(point, nextNormal, -halfWidth);
+	const extraTriangles = [];
+	if (crossVal > 0) {
+		const innerLeft = {
+			x: point.x + miterX * miterLen,
+			y: point.y + miterY * miterLen
+		};
+		if (join === "round") emitArc(innerLeft, point, prevRight, nextRight, halfWidth, extraTriangles);
+		else extraTriangles.push(tri(innerLeft, prevRight, nextRight));
+		return {
+			entryLeft: innerLeft,
+			entryRight: prevRight,
+			exitLeft: innerLeft,
+			exitRight: nextRight,
+			extraTriangles
+		};
+	} else {
+		const innerRight = {
+			x: point.x - miterX * miterLen,
+			y: point.y - miterY * miterLen
+		};
+		if (join === "round") emitArc(innerRight, point, prevLeft, nextLeft, halfWidth, extraTriangles);
+		else extraTriangles.push(tri(innerRight, prevLeft, nextLeft));
+		return {
+			entryLeft: prevLeft,
+			entryRight: innerRight,
+			exitLeft: nextLeft,
+			exitRight: innerRight,
+			extraTriangles
+		};
+	}
+}
+function emitCap(point, normal, halfWidth, cap, isStart) {
+	if (cap === "butt") return [];
+	const left = offset(point, normal, halfWidth);
+	const right = offset(point, normal, -halfWidth);
+	const dir = isStart ? {
+		x: -normal.y,
+		y: normal.x
+	} : {
+		x: normal.y,
+		y: -normal.x
+	};
+	if (cap === "square") {
+		const extLeft = {
+			x: left.x + dir.x * halfWidth,
+			y: left.y + dir.y * halfWidth
+		};
+		const extRight = {
+			x: right.x + dir.x * halfWidth,
+			y: right.y + dir.y * halfWidth
+		};
+		return [tri(left, extLeft, extRight), tri(left, extRight, right)];
+	}
+	const tris = [];
+	const segments = Math.max(8, Math.ceil(halfWidth));
+	const startAngle = Math.atan2(isStart ? left.y - point.y : right.y - point.y, isStart ? left.x - point.x : right.x - point.x);
+	for (let i = 0; i < segments; i++) {
+		const a1 = startAngle + Math.PI * i / segments;
+		const a2 = startAngle + Math.PI * (i + 1) / segments;
+		const p1 = {
+			x: point.x + Math.cos(a1) * halfWidth,
+			y: point.y + Math.sin(a1) * halfWidth
+		};
+		const p2 = {
+			x: point.x + Math.cos(a2) * halfWidth,
+			y: point.y + Math.sin(a2) * halfWidth
+		};
+		tris.push(tri(point, p1, p2));
+	}
+	return tris;
+}
+function emitArc(anchor, center, from, to, radius, out) {
+	const a1 = Math.atan2(from.y - center.y, from.x - center.x);
+	let sweep = Math.atan2(to.y - center.y, to.x - center.x) - a1;
+	if (sweep > Math.PI) sweep -= TAU;
+	if (sweep < -Math.PI) sweep += TAU;
+	const segments = Math.max(Math.ceil(Math.abs(sweep) / (Math.PI / 8)), 2);
+	for (let i = 0; i < segments; i++) {
+		const t1 = a1 + sweep * i / segments;
+		const t2 = a1 + sweep * (i + 1) / segments;
+		const p1 = {
+			x: center.x + Math.cos(t1) * radius,
+			y: center.y + Math.sin(t1) * radius
+		};
+		const p2 = {
+			x: center.x + Math.cos(t2) * radius,
+			y: center.y + Math.sin(t2) * radius
+		};
+		out.push(tri(anchor, p1, p2));
+	}
+}
+/**
+* Emit the two triangles for a single stroke segment given its start (left0,
+* right0) and end (left1, right1) offset corners.
+*/
+function emitQuad(left0, right0, left1, right1, out) {
+	out.push(tri(left0, right0, left1));
+	out.push(tri(left1, right0, right1));
+}
+function segmentNormal(a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const len = Math.sqrt(dx * dx + dy * dy);
+	if (len === 0) return {
+		x: 0,
+		y: -1
+	};
+	return {
+		x: -dy / len,
+		y: dx / len
+	};
+}
+function offset(point, normal, amount) {
+	return {
+		x: point.x + normal.x * amount,
+		y: point.y + normal.y * amount
+	};
+}
+function tri(a, b, c) {
+	return {
+		x1: a.x,
+		y1: a.y,
+		x2: b.x,
+		y2: b.y,
+		x3: c.x,
+		y3: c.y
+	};
+}
+function dist(a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	return Math.sqrt(dx * dx + dy * dy);
+}
+function dedup(points) {
+	if (points.length === 0) return [];
+	const out = [points[0]];
+	for (let i = 1; i < points.length; i++) {
+		const prev = out[out.length - 1];
+		if (Math.abs(points[i].x - prev.x) > 1e-6 || Math.abs(points[i].y - prev.y) > 1e-6) out.push(points[i]);
+	}
+	return out;
+}
+function assertFinitePoints(points, label) {
+	for (const point of points) if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) throw new Error(`${label} must contain only finite coordinates.`);
+}
+function sampleAt(pts, distances, segCount, t) {
+	if (t <= 0) return pts[0];
+	if (t >= distances[distances.length - 1]) return pts[segCount % pts.length === 0 && segCount > 0 ? 0 : pts.length - 1];
+	let lo = 0;
+	let hi = segCount;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		if (distances[mid + 1] < t) lo = mid + 1;
+		else hi = mid;
+	}
+	const segStart = distances[lo];
+	const segEnd = distances[lo + 1];
+	const frac = segEnd > segStart ? (t - segStart) / (segEnd - segStart) : 0;
+	const next = (lo + 1) % pts.length;
+	return {
+		x: pts[lo].x + (pts[next].x - pts[lo].x) * frac,
+		y: pts[lo].y + (pts[next].y - pts[lo].y) * frac
+	};
+}
+//#endregion
+//#region src/shared/pack.ts
+/**
+* Bytes per shape instance in the packed vertex buffer. Layout, little-endian:
+*   0:  float32 pos.x
+*   4:  float32 pos.y
+*   8:  float16 size.x
+*  10:  float16 size.y
+*  12:  u32     fill    (unorm8x4; R in low byte)
+*  16:  u32     stroke  (unorm8x4)
+*  20:  float16 rotation
+*  22:  float16 strokeWidth
+*  24:  float16 cornerRadius
+*  26:  u16     _pad (zero)
+*  28:  u32     shapeType
+*/
+const SHAPE_BYTES = 32;
+const TRIANGLE_FLOATS = 12;
+const SPRITE_FLOATS = 16;
+/**
+* Floats per segment instance in the packed segment buffer (24 B total).
+* Layout:
+*   float 0: start.x     (f32)
+*   float 1: start.y     (f32)
+*   float 2: end.x       (f32)
+*   float 3: end.y       (f32)
+*   float 4: colorBits   (u32 reinterpret; straight RGBA unorm8x4)
+*   float 5: width       (f32; layer-local units)
+*
+* Color is stored unpremultiplied (matching the shape pipeline); the shader
+* multiplies by alpha at output to produce premultiplied blended results.
+*/
+const SEGMENT_FLOATS = 6;
+/**
+* Floats per curve instance in the packed curve buffer (48 B total — a
+* multiple of 16 B for storage-buffer struct-array alignment). Layout:
+*   float  0..1: p0.xy         (f32)
+*   float  2..3: p1.xy         (f32)
+*   float  4..5: p2.xy         (f32)
+*   float  6..7: p3.xy         (f32)
+*   float  8:    colorBits     (u32 reinterpret; unorm8x4 RGBA, unpremultiplied)
+*   float  9:    widthPacked   (u32 reinterpret; pack2x16float(widthStart, widthEnd))
+*   float 10:    flagsBits     (u32 reinterpret; cap style in low 2 bits, rest reserved)
+*   float 11:    _pad          (zero)
+*
+* widthPacked carries two f16 widths from day one so curve taper can land
+* later without a schema migration. v1 callers pass the same width for both.
+* flagsBits reserves the remaining 30 bits for dash / phase / outline.
+*/
+const CURVE_FLOATS = 12;
+const CURVE_CAP_ROUND = 0;
+const CURVE_CAP_BUTT = 1;
+const CURVE_CAP_SQUARE = 2;
+/**
+* Floats per arc instance in the packed arc buffer (32 B total — multiple
+* of 16 B for storage-buffer struct-array alignment). Layout:
+*   float 0..1: center.xy   (f32)
+*   float 2:    radius      (f32)
+*   float 3:    theta0      (f32; radians)
+*   float 4:    theta1      (f32; radians)
+*   float 5:    width       (f32; layer-local units)
+*   float 6:    colorBits   (u32 reinterpret; unorm8x4 RGBA, unpremultiplied)
+*   float 7:    _pad        (zero)
+*
+* Arc is the short path from `theta0` to `theta1`; rendering depends on the
+* absolute span only. Use the {@link ArcShape} interface — the layer/pack
+* normalises into this form. Butt caps; no joins.
+*/
+const ARC_FLOATS = 8;
+const SHAPE_RECT = 0;
+const SHAPE_CIRCLE = 1;
+const SHAPE_ELLIPSE = 2;
+//#endregion
+//#region src/pipelines/pipelines.ts
+const CLEAR_QUAD_WGSL = `
+struct ClearOut {
+  @builtin(position) pos: vec4f,
+};
+
+@vertex
+fn vsMain(@builtin(vertex_index) vi: u32) -> ClearOut {
+  var p = vec2f(-1.0, -1.0);
+  if (vi == 1u) { p = vec2f(3.0, -1.0); }
+  else if (vi == 2u) { p = vec2f(-1.0, 3.0); }
+  return ClearOut(vec4f(p, 1.0, 1.0));
+}
+
+@group(0) @binding(0) var<uniform> clearColor: vec4f;
+
+@fragment
+fn fsMain() -> @location(0) vec4f {
+  return clearColor;
+}
+`;
+/**
+* Construct the three v3 render pipeline variants.
+*
+* @param root   TypeGPU root (provides `root.device`).
+* @param format Swapchain texture format.
+* @param shader Assembled uber-shader from {@link assembleShader}.
+*/
+function createPipelines(root, format, shader) {
+	const device = root.device;
+	const vertexModule = device.createShaderModule({ code: shader.vertex });
+	const opaqueModule = device.createShaderModule({ code: shader.opaque });
+	const transparentModule = device.createShaderModule({ code: shader.transparent });
+	const clearModule = device.createShaderModule({ code: CLEAR_QUAD_WGSL });
+	const depthBase = {
+		format: DEPTH_FORMAT,
+		depthWriteEnabled: true,
+		depthCompare: DEPTH_COMPARE
+	};
+	const cameraLayout = device.createBindGroupLayout({
+		label: "insomni-v3-camera",
+		entries: [{
+			binding: 0,
+			visibility: 1,
+			buffer: { type: "uniform" }
+		}, {
+			binding: 1,
+			visibility: 2,
+			buffer: { type: "uniform" }
+		}]
+	});
+	const instanceLayout = device.createBindGroupLayout({
+		label: "insomni-v3-instances",
+		entries: [{
+			binding: 0,
+			visibility: 3,
+			buffer: { type: "read-only-storage" }
+		}]
+	});
+	const sharedLayout = device.createPipelineLayout({
+		label: "insomni-v3-shared",
+		bindGroupLayouts: [cameraLayout, instanceLayout]
+	});
+	return {
+		opaque: device.createRenderPipeline({
+			layout: sharedLayout,
+			primitive: { topology: "triangle-strip" },
+			vertex: {
+				module: vertexModule,
+				entryPoint: "main"
+			},
+			fragment: {
+				module: opaqueModule,
+				entryPoint: "main",
+				targets: [{ format }]
+			},
+			depthStencil: depthBase,
+			multisample: { count: 1 }
+		}),
+		transparent: device.createRenderPipeline({
+			layout: sharedLayout,
+			primitive: { topology: "triangle-strip" },
+			vertex: {
+				module: vertexModule,
+				entryPoint: "main"
+			},
+			fragment: {
+				module: transparentModule,
+				entryPoint: "main",
+				targets: [{
+					format,
+					blend: ALPHA_BLEND
+				}]
+			},
+			depthStencil: {
+				...depthBase,
+				depthWriteEnabled: false
+			},
+			multisample: { count: 1 }
+		}),
+		clearQuad: device.createRenderPipeline({
+			layout: "auto",
+			primitive: { topology: "triangle-list" },
+			vertex: {
+				module: clearModule,
+				entryPoint: "vsMain"
+			},
+			fragment: {
+				module: clearModule,
+				entryPoint: "fsMain",
+				targets: [{ format }]
+			},
+			depthStencil: {
+				format: DEPTH_FORMAT,
+				depthWriteEnabled: true,
+				depthCompare: "always"
+			},
+			multisample: { count: 1 }
+		}),
+		cameraLayout,
+		instanceLayout
+	};
+}
+//#endregion
+//#region src/shader/assemble.ts
+/**
+* Pure-math WGSL helpers (`rot2`, the `sdf*` SDF primitives, `cubicAABB1D`,
+* `arcLocalAabb`, `sdSegment`, `joinOvershoot`, …) referenced by the kinds'
+* `wgslGeom()` / `wgslSdf()` contributions. Exported so the EXTERNAL-INSTANCE
+* pipeline (`pipelines/instance-pipelines.ts`) re-emits the SAME helpers around
+* the SAME kind contributions — sharing this one string keeps an external buffer
+* decoding byte-identically to the live uber path with no duplicate to drift.
+*/
+const WGSL_HELPERS = `fn rot2(v: vec2f, a: f32) -> vec2f {
+  let c = cos(a);
+  let s = sin(a);
+  return vec2f(c * v.x - s * v.y, s * v.x + c * v.y);
+}
+
+fn sdfRoundedBox(p: vec2f, b: vec2f, r: f32) -> f32 {
+  let q = abs(p) - b + r;
+  return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - r;
+}
+
+fn sdfCircle(p: vec2f, r: f32) -> f32 {
+  return length(p) - r;
+}
+
+fn sdfEllipse(p: vec2f, ab: vec2f) -> f32 {
+  let k1 = length(p / ab);
+  let k2 = length(p / (ab * ab));
+  return k1 * (k1 - 1.0) / k2;
+}
+
+fn cubicAABB1D(c0: f32, c1: f32, c2: f32, c3: f32) -> vec2f {
+  var mn = min(c0, c3);
+  var mx = max(c0, c3);
+  let alpha = -c0 + 3.0 * c1 - 3.0 * c2 + c3;
+  let beta = c0 - 2.0 * c1 + c2;
+  let gamma = -c0 + c1;
+  if (abs(alpha) < 1e-6) {
+    if (abs(beta) > 1e-6) {
+      let t = -gamma / (2.0 * beta);
+      if (t > 0.0 && t < 1.0) {
+        let u = 1.0 - t;
+        let v = u * u * u * c0 + 3.0 * u * u * t * c1 + 3.0 * u * t * t * c2 + t * t * t * c3;
+        mn = min(mn, v);
+        mx = max(mx, v);
+      }
+    }
+  } else {
+    let disc = beta * beta - alpha * gamma;
+    if (disc >= 0.0) {
+      let s = sqrt(disc);
+      let t1 = (-beta + s) / alpha;
+      if (t1 > 0.0 && t1 < 1.0) {
+        let u = 1.0 - t1;
+        let v = u * u * u * c0 + 3.0 * u * u * t1 * c1 + 3.0 * u * t1 * t1 * c2 + t1 * t1 * t1 * c3;
+        mn = min(mn, v);
+        mx = max(mx, v);
+      }
+      let t2 = (-beta - s) / alpha;
+      if (t2 > 0.0 && t2 < 1.0) {
+        let u = 1.0 - t2;
+        let v = u * u * u * c0 + 3.0 * u * u * t2 * c1 + 3.0 * u * t2 * t2 * c2 + t2 * t2 * t2 * c3;
+        mn = min(mn, v);
+        mx = max(mx, v);
+      }
+    }
+  }
+  return vec2f(mn, mx);
+}
+
+fn arcLocalAabb(r: f32, halfAng: f32, halfW: f32, pad: f32) -> vec4f {
+  let outer = r + halfW + pad;
+  let innerRaw = r - halfW - pad;
+  let inner = select(0.0, innerRaw, innerRaw > 0.0);
+  let ch = cos(halfAng);
+  let sh = sin(halfAng);
+  let xMax = outer;
+  var xMin: f32;
+  var yMax: f32;
+  var yMin: f32;
+  let PI = 3.141592653589793;
+  let HALF_PI = 1.5707963267948966;
+  if (halfAng >= PI) {
+    xMin = -outer;
+    yMax = outer;
+    yMin = -outer;
+  } else if (halfAng >= HALF_PI) {
+    yMax = outer;
+    yMin = -outer;
+    xMin = outer * ch;
+  } else {
+    yMax = outer * sh;
+    yMin = -yMax;
+    xMin = inner * ch;
+  }
+  return vec4f(xMin, yMin, xMax, yMax);
+}
+
+fn sdfArcCurve(p: vec2f, r: f32, mid: f32, halfAng: f32) -> f32 {
+  let c = cos(mid);
+  let s = sin(mid);
+  let q = vec2f(c * p.x + s * p.y, -s * p.x + c * p.y);
+  let qa = vec2f(q.x, abs(q.y));
+  let ch = cos(halfAng);
+  let sh = sin(halfAng);
+  let cross = ch * qa.y - sh * qa.x;
+  if (cross <= 0.0) {
+    return abs(length(qa) - r);
+  }
+  let endpoint = vec2f(r * ch, r * sh);
+  return length(qa - endpoint);
+}
+
+// Unsigned distance from point \`p\` to the segment [a,b]. Used by the
+// stroke-path kind (min over a polyline's sub-segments). Classic IQ form.
+fn sdSegment(p: vec2f, a: vec2f, b: vec2f) -> f32 {
+  let pa = p - a;
+  let ba = b - a;
+  let h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-12), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+
+// Decide whether a fragment in the round overshoot of an interior vertex \`b\`
+// (neighbors \`a\`,\`c\`) should be DISCARDED to reshape the FREE round join into a
+// bevel or miter. The min-of-segment SDF already yields a round join (a halfW
+// disc at \`b\`); this trims that disc on the OUTER side of the corner. Returns
+// \`true\` when the caller should drop the fragment. (The drop itself stays in
+// the kind's fragment snippet — helpers must remain side-effect-free pure math.)
+//
+//   join: 1 = bevel, 2 = miter (0 = round → caller skips this call entirely).
+//
+// Geometry: \`din\`/\`dout\` are the incoming/outgoing unit tangents; \`nin\`/\`nout\`
+// the corresponding left normals. The outward bisector \`m\` points along the
+// outer side. The bevel chord (line through the two outer offset corners) sits
+// at signed distance \`halfW * cosHalf\` from \`b\` along \`m\`; the miter apex sits
+// at \`halfW / cosHalf\`. A fragment is only in the overshoot region when it is
+// on the outer side of BOTH segment offset edges (i.e. the min-distance closest
+// point is the shared vertex \`b\`, not a segment interior). Clipping outside the
+// chord/apex there reshapes the disc into a bevel/miter without touching the
+// segment bodies.
+fn joinOvershoot(p: vec2f, a: vec2f, b: vec2f, c: vec2f, halfW: f32, join: u32, miterLimit: f32) -> bool {
+  // Zero-length guard: a degenerate incoming or outgoing segment would feed
+  // \`normalize(0)\` → NaN below. Coincident points have no join to clip, so bail.
+  let ein = b - a;
+  let eout = c - b;
+  if (dot(ein, ein) < 1e-12 || dot(eout, eout) < 1e-12) { return false; }
+  let din = normalize(b - a);
+  let dout = normalize(c - b);
+  // Degenerate (collinear / zero-length) → nothing to clip.
+  let cosTurn = dot(din, dout);
+  if (cosTurn > 0.99999) { return false; }
+  // Left normals.
+  let nin = vec2f(-din.y, din.x);
+  let nout = vec2f(-dout.y, dout.x);
+  // Outward side: the turn direction. cross > 0 = left turn ⇒ outer side is the
+  // RIGHT (-normal) side; cross < 0 ⇒ outer side is the LEFT (+normal) side.
+  let crossv = din.x * dout.y - din.y * dout.x;
+  let sgn = select(1.0, -1.0, crossv > 0.0);
+  // Outer offset normals (point toward the outer side).
+  let onin = nin * sgn;
+  let onout = nout * sgn;
+  // The outward bisector (sum of the two outer normals, renormalized).
+  let bis = onin + onout;
+  let bisLen = length(bis);
+  if (bisLen < 1e-6) { return false; }
+  let m = bis / bisLen;
+  // Only clip fragments in the join wedge: on the outer side past BOTH offset
+  // edges. \`pb = p - b\`. Past the incoming offset edge: dot(pb, onin) > halfW;
+  // past the outgoing: dot(pb, onout) > halfW. Inside the wedge both hold.
+  let pb = p - b;
+  let dIn = dot(pb, onin);
+  let dOut = dot(pb, onout);
+  if (dIn <= halfW || dOut <= halfW) { return false; }
+  // cosHalf = cos of half the exterior angle = dot(m, onin).
+  let cosHalf = max(dot(m, onin), 1e-4);
+  let along = dot(pb, m); // distance from b along the outward bisector
+  if (join == 1u) {
+    // Bevel: clip past the chord through the two outer corners.
+    return along > halfW * cosHalf;
+  }
+  // Miter: extend to the apex unless it exceeds the limit (then bevel).
+  let miterDist = halfW / cosHalf;        // apex distance along m
+  let limitDist = halfW * miterLimit;     // miterLimit is a ratio of halfW
+  let cutoff = select(halfW * cosHalf, miterDist, miterDist <= limitDist);
+  return along > cutoff;
+}`;
+/**
+* The emphasis uniform + its `@group(0) @binding(1)` declaration, shared by the
+* `transparent` and OIT-build fragments (Phase 4, decisions.md D2). It rides on
+* the camera group — `@group(0)` is already in both pipeline layouts and the
+* camera bind group binds it per slot — so no new bind group is introduced. The
+* VERTEX-only camera lives at `@binding(0)`; this is FRAGMENT-visible at
+* `@binding(1)`.
+*
+*   focusedKey — instances whose `lane4` equals this render at FULL alpha.
+*   dimAlpha   — the alpha multiplier applied to NON-focused instances.
+*   t          — emphasis amount in [0,1]; `t == 0` is an exact no-op
+*                (`mix(1, dimAlpha, 0) == 1`), so emphasis-inactive frames are
+*                byte-identical to today and cost one multiply by 1.0.
+*/
+const EMPHASIS_BINDING_WGSL = `struct Emphasis {
+  focusedKey: u32,
+  dimAlpha: f32,
+  t: f32,
+  _pad: u32,
+};
+
+@group(0) @binding(1) var<uniform> emphasis: Emphasis;`;
+/**
+* Apply the global-dim emphasis to `outColor`. `outColor` is premultiplied
+* (every kind emits premultiplied RGBA), and scaling all four channels by one
+* factor preserves premultiplication — so this is correct for both the hardware
+* alpha-blend (transparent) and the A-buffer over-composite (OIT build). The
+* focused key keeps full alpha; everything else is multiplied by
+* `mix(1, dimAlpha, t)`. Reads `inst.lane4` (the per-instance emphasis key).
+*
+* EXEMPT-ZERO semantics: `lane4 == 0u` (the default `UberPack.append` writes) is
+* NON-participating — those instances are NEVER dimmed, regardless of `t`. An
+* instance OPTS IN to emphasis by tagging a key ≥ 1; this keeps axis/grid/overlay
+* shapes (which never set a key) at full alpha during chart-mark emphasis.
+* Consequently `focusedKey: 0, t: 1` means "dim ALL tagged instances, focus none"
+* — key 0 cannot be a focus target, it is the opt-out sentinel.
+*/
+const EMPHASIS_APPLY_WGSL = `  let _emFocused = inst.lane4 == emphasis.focusedKey || inst.lane4 == 0u;
+  let _emDim = select(mix(1.0, emphasis.dimAlpha, emphasis.t), 1.0, _emFocused);
+  outColor = outColor * _emDim;`;
+/** Map an {@link INSTANCE_FIELDS} kind to its WGSL scalar/vector type. */
+function wgslType(kind) {
+	switch (kind) {
+		case "vec4f": return "vec4f";
+		case "u32": return "u32";
+		case "f32": return "f32";
+	}
+}
+/**
+* `struct InstanceStruct { ... }` emitted from the SAME {@link INSTANCE_FIELDS}
+* array the CPU offsets and the TypeGPU struct derive from. The kinds read
+* instance fields by these exact names (`inst.geom0`, `inst.lane3`, …);
+* declaring the struct here from the schema array — never a hand-typed copy —
+* keeps the WGSL field names locked to the schema. The accessor snippet
+* (caller-supplied, from `codegen.wgslAccessor()`) references this struct.
+*
+* Exported so the glyph bake pipeline (`pipelines/glyph-pipelines.ts`) can
+* interpolate the SAME struct text into its vertex stage instead of carrying a
+* hand-copied duplicate that could silently drift from the schema layout.
+*/
+const INSTANCE_STRUCT_WGSL = [
+	"struct InstanceStruct {",
+	...INSTANCE_FIELDS.map((f) => `  ${f.name}: ${wgslType(f.kind)},`),
+	"}"
+].join("\n");
+/** The dispatch chain over `typeFlag`: one `if` branch per kind, bodies joined
+* by `else`. Each kind's snippet is an already-braced block, so the chain reads
+* `if (typeFlag == 0u) { … } else if (typeFlag == 1u) { … }`. */
+function dispatch(kinds, body) {
+	return kinds.map((k) => `if (typeFlag == ${k.typeFlag}u) ${body(k)}`).join(" else ");
+}
+/**
+* Vertex-stage WGSL: schema struct + accessor + math helpers, then a
+* `@vertex fn main` that reads `typeFlag`, sets up the unit quad `q`, runs the
+* per-kind geometry switch (which writes `world` + `v0` + `v1`), applies the
+* camera transform, and returns clip-space `pos` plus the varyings. Mirrors v2's
+* varyings layout (`varying0: vec4f`, `varying1: vec4f`, flat `instanceIdx`).
+*/
+function buildVertex(geomCases) {
+	return `${INSTANCE_STRUCT_WGSL}
+
+struct Camera {
+  vpCol0: vec2f,
+  vpCol1: vec2f,
+  vpCol2: vec2f,
+};
+
+@group(0) @binding(0) var<uniform> camera: Camera;
+@group(1) @binding(0) var<storage, read> instances: array<InstanceStruct>;
+
+struct VertexOut {
+  @builtin(position) pos: vec4f,
+  @location(0) varying0: vec4f,
+  @location(1) varying1: vec4f,
+  @location(2) @interpolate(flat) instanceIdx: u32,
+};
+
+// The geom snippets are authored to read \`in.vertexIndex\` (the same name they
+// use in the v2-OIT framing). \`VertexIn\` lets us alias the entry-point builtins
+// behind that one field without rewriting every kind.
+struct VertexIn {
+  vertexIndex: u32,
+  instanceIndex: u32,
+};
+
+${WGSL_HELPERS}
+
+@vertex
+fn main(@builtin(vertex_index) vertexIndex: u32, @builtin(instance_index) instanceIndex: u32) -> VertexOut {
+  let inst = instances[instanceIndex];
+  let typeFlag = inst.typeFlag;
+
+  // Per-vertex quad corner. Shape kinds scale it to half-extents; the segment,
+  // curve, arc, and triangle kinds re-derive their own per-vertex layout from
+  // \`in.vertexIndex\` and ignore \`q\`.
+  let quad = array<vec2f, 4>(
+    vec2f(-1.0, -1.0),
+    vec2f( 1.0, -1.0),
+    vec2f(-1.0,  1.0),
+    vec2f( 1.0,  1.0),
+  );
+  let q = quad[vertexIndex];
+
+  // \`in\` aliases the entry-point builtins so the kind snippets (authored to read
+  // \`in.vertexIndex\`) compile unchanged in both the v3 and v2-OIT framings.
+  let in = VertexIn(vertexIndex, instanceIndex);
+
+  var world: vec2f = vec2f(0.0);
+  var v0: vec4f = vec4f(0.0);
+  var v1: vec4f = vec4f(0.0);
+
+  ${geomCases}
+
+  let ndc = camera.vpCol0 * world.x + camera.vpCol1 * world.y + camera.vpCol2;
+  // Explicit depth from the instance \`order\` field — never index-derived (v2
+  // used \`draw.baseZ + zStep * index\`, which coupled depth to draw count).
+  var out: VertexOut;
+  out.pos = vec4f(ndc, inst.order, 1.0);
+  out.varying0 = v0;
+  out.varying1 = v1;
+  out.instanceIdx = instanceIndex;
+  return out;
+}`;
+}
+/**
+* Fragment-stage WGSL up to (but NOT including) the terminal `return outColor;`
+* — the opaque/transparent suffix is appended by {@link assembleShader}.
+*
+* The `fwidth` derivatives are computed at the absolute top of `main`, BEFORE
+* the non-uniform `typeFlag` switch, so analytic SDF AA (`pixelLocal` /
+* `pixelLocalX`) is well-defined under WGSL's uniformity rules — exactly the
+* hoist both the opaque and OIT variants rely on.
+*/
+function buildFragBody(sdfCases, withEmphasis) {
+	return `${INSTANCE_STRUCT_WGSL}
+
+@group(1) @binding(0) var<storage, read> instances: array<InstanceStruct>;
+${withEmphasis ? `\n${EMPHASIS_BINDING_WGSL}\n` : ""}
+struct FragmentIn {
+  @location(0) varying0: vec4f,
+  @location(1) varying1: vec4f,
+  @location(2) @interpolate(flat) instanceIdx: u32,
+};
+
+${WGSL_HELPERS}
+
+@fragment
+fn main(in: FragmentIn) -> @location(0) vec4f {
+  // Hoist derivatives to the top of \`main\` — guaranteed-uniform control flow —
+  // so the analytic-AA pixel sizes are valid before the non-uniform switch.
+  let dV0 = fwidth(in.varying0.xy);
+  let pixelLocal = max(length(dV0), 1e-6);
+  let pixelLocalX = max(abs(dV0.x), 1e-6);
+
+  let inst = instances[in.instanceIdx];
+  let typeFlag = inst.typeFlag;
+  var outColor: vec4f = vec4f(0.0);
+
+  ${sdfCases}`;
+}
+/**
+* Fragment-stage WGSL for the OIT (A-buffer) build pass.
+*
+* The geometry/SDF body is IDENTICAL to {@link buildFragBody} — it reuses the
+* same `INSTANCE_STRUCT_WGSL`, the same `accessorWgsl`, the same `WGSL_HELPERS`,
+* and the same per-kind `sdfCases` switch — so the `outColor` math cannot drift
+* from the transparent variant (the exact v2 OIT bug this rework fixes). The
+* differences are I/O only:
+*
+*   - `FragmentIn` gains `@builtin(position) pos: vec4f` (to compute the integer
+*     pixel index). The opaque/transparent input drops it because hardware
+*     blending never needs the pixel coordinate.
+*   - Three extra `@group(2)` bindings declare the A-buffer (heads / slots /
+*     oitViewport). Groups 0 (camera, vertex-only) and 1 (instances) are
+*     unchanged, so the shared `vertex` source feeds this pass verbatim.
+*   - The trailing suffix does the atomic per-pixel slot reserve + write-once
+*     store instead of `return outColor;`. The slot index is
+*     `pixelIdx * K + slotIdx`; fragments past the per-pixel budget K are
+*     dropped (the resolve pass reads `min(count, K)` slots). Color is masked
+*     off by the pipeline `writeMask:0`, so the returned `vec4f(0.0)` is inert.
+*/
+function buildOitFragment(sdfCases) {
+	return `${INSTANCE_STRUCT_WGSL}
+
+struct OITNode {
+  rgba: u32,
+  depth: f32,
+};
+
+struct OITViewport {
+  width: u32,
+  height: u32,
+  K: u32,
+  _pad: u32,
+};
+
+@group(1) @binding(0) var<storage, read> instances: array<InstanceStruct>;
+${EMPHASIS_BINDING_WGSL}
+@group(2) @binding(0) var<storage, read_write> heads: array<atomic<u32>>;
+@group(2) @binding(1) var<storage, read_write> slots: array<OITNode>;
+@group(2) @binding(2) var<uniform> oitViewport: OITViewport;
+@group(2) @binding(3) var opaqueDepth: texture_depth_2d;
+
+struct FragmentIn {
+  @builtin(position) pos: vec4f,
+  @location(0) varying0: vec4f,
+  @location(1) varying1: vec4f,
+  @location(2) @interpolate(flat) instanceIdx: u32,
+};
+
+${WGSL_HELPERS}
+
+@fragment
+fn main(in: FragmentIn) -> @location(0) vec4f {
+  // Identical derivative hoist + SDF switch as the transparent variant.
+  let dV0 = fwidth(in.varying0.xy);
+  let pixelLocal = max(length(dV0), 1e-6);
+  let pixelLocalX = max(abs(dV0.x), 1e-6);
+
+  let inst = instances[in.instanceIdx];
+  let typeFlag = inst.typeFlag;
+  var outColor: vec4f = vec4f(0.0);
+
+  ${sdfCases}
+
+${EMPHASIS_APPLY_WGSL}
+
+  // ---- A-buffer insert (this is the only divergence from \`transparent\`) ----
+  // \`outColor\` is already premultiplied (every kind emits premultiplied RGBA),
+  // matching the resolve pass's premultiplied over-composite.
+  if (outColor.a >= 0.005) {
+    let px = u32(in.pos.x);
+    let py = u32(in.pos.y);
+    if (px < oitViewport.width && py < oitViewport.height) {
+      // Opaque-occlusion gate (byte-identical to oitAppend in src/oit/append-snippet.ts).
+      // The late depth test gates only attachment writes, not this storage append,
+      // so gate it in software: skip the append when this fragment is behind the
+      // opaque depth. depth24plus → texture_depth_2d; textureLoad returns scalar f32
+      // (no .r). Cleared depth = 1.0 → fragZ < 1.0 appends. Skip when fragZ >= opaqueZ.
+      let opaqueZ = textureLoad(opaqueDepth, vec2i(i32(px), i32(py)), 0);
+      if (in.pos.z >= opaqueZ) { return vec4f(0.0); }
+      let pixelIdx = py * oitViewport.width + px;
+      // Per-pixel slot allocation: atomicAdd returns this fragment's slot index.
+      // Fragments past K are dropped — saturation is local to a pixel, so a
+      // heavy pixel loses detail without blanking neighboring rasterizer tiles.
+      // No global counter / no freelist; slot \`pixelIdx*K + slotIdx\` is written
+      // exactly once (slotIdx is unique per fragment), so slot stores never race.
+      //
+      // BOUNDED-K DROP RULE: slots are claimed in RASTERIZATION (allocation)
+      // order, NOT depth order, and the K-cap drops everything past slot K. So
+      // when >K transparent fragments overlap ONE pixel (e.g. a hover-dimmed
+      // joyplot whose forced-transparent rows stack deeper than K — see
+      // classifyOpaque), a NEAR fragment can be dropped while a FAR one survives:
+      // a far row bleeds through. The fragments that DO survive still composite in
+      // correct depth order (the resolve pass sorts the kept slots). Relief valve:
+      // raise \`RendererConfig.oitFragmentsPerPixel\` (this K).
+      let slotIdx = atomicAdd(&heads[pixelIdx], 1u);
+      if (slotIdx < oitViewport.K) {
+        let r = u32(clamp(outColor.r, 0.0, 1.0) * 255.0 + 0.5);
+        let g = u32(clamp(outColor.g, 0.0, 1.0) * 255.0 + 0.5);
+        let b = u32(clamp(outColor.b, 0.0, 1.0) * 255.0 + 0.5);
+        let a = u32(clamp(outColor.a, 0.0, 1.0) * 255.0 + 0.5);
+        let packed = r | (g << 8u) | (b << 16u) | (a << 24u);
+        let base = pixelIdx * oitViewport.K + slotIdx;
+        slots[base].rgba = packed;
+        slots[base].depth = in.pos.z;
+      }
+    }
+  }
+  // Color writeMask is 0 in the build pipeline target; this is discarded.
+  return vec4f(0.0);
+}`;
+}
+/**
+* Assemble the full uber-shader from the kind contributions. Produces the
+* vertex source plus the opaque and transparent fragment sources from a SINGLE
+* fragment body — the two variants differ only by the trailing `discard`, so
+* they cannot drift.
+*
+* @param kinds The primitive kinds to dispatch over. Every kind's `typeFlag`
+*   gets a geom branch in the vertex and an sdf branch in the fragment.
+* @param _accessorWgsl Deprecated no-op parameter kept for call-site
+*   compatibility. Kinds read `inst.*` directly from the `InstanceStruct`
+*   binding; the generated `readInstance` accessor was dead code and has been
+*   removed. Pass any string (e.g. `INSTANCE_LAYOUT.wgslAccessor`) — it is
+*   ignored.
+*/
+function assembleShader(kinds, _accessorWgsl) {
+	const geomCases = dispatch(kinds, (k) => k.wgslGeom());
+	const sdfCases = dispatch(kinds, (k) => k.wgslSdf());
+	const vertex = buildVertex(geomCases);
+	const opaqueBody = buildFragBody(sdfCases, false);
+	const transparentBody = buildFragBody(sdfCases, true);
+	return {
+		vertex,
+		opaque: `${opaqueBody}\n\n  if (outColor.a < 0.5) { discard; }\n  return outColor;\n}`,
+		transparent: `${transparentBody}\n\n${EMPHASIS_APPLY_WGSL}\n  return outColor;\n}`,
+		oitBuild: buildOitFragment(sdfCases)
+	};
+}
+//#endregion
+export { mixColor as $, TYPE_ELLIPSE as A, BLACK as B, pack2xF16 as C, TYPE_ARC as D, unpackF16 as E, TYPE_STROKE_PATH as F, fade as G, WHITE as H, TYPE_TRIANGLE as I, hslToRgb as J, hex as K, INSTANCE_BYTES as L, TYPE_RECT as M, TYPE_SEGMENT as N, TYPE_CIRCLE as O, TYPE_SPRITE as P, lighten as Q, INSTANCE_FIELDS as R, bitcastF32 as S, packUnorm8x4 as T, cssHex as U, TRANSPARENT as V, darken as W, hsv as X, hslToRgba as Y, lerpColor as Z, polylineEllipseRing as _, ARC_FLOATS as a, INSTANCE_LAYOUT as b, CURVE_CAP_SQUARE as c, SHAPE_BYTES as d, rgba as et, SHAPE_CIRCLE as f, TRIANGLE_FLOATS as g, SPRITE_FLOATS as h, createPipelines as i, TYPE_GLYPH as j, TYPE_CURVE as k, CURVE_FLOATS as l, SHAPE_RECT as m, WGSL_HELPERS as n, CURVE_CAP_BUTT as o, SHAPE_ELLIPSE as p, hsl as q, assembleShader as r, CURVE_CAP_ROUND as s, INSTANCE_STRUCT_WGSL as t, withAlpha as tt, SEGMENT_FLOATS as u, polylineRectRing as v, packF16 as w, deriveLayout as x, tessellatePolyline as y, INSTANCE_FLOATS as z };