shaders 3.2.475 → 4.0.0

package/dist/core/overlay-W4DAsSzP.js

@@ -1,4712 +0,0 @@
-import { Ar as vec2u, Bn as TWO_PI$1, Br as struct, Cr as sin, Gn as typegpu_default, Jr as i32, Kn as textureDimensions, Lr as texture2d, Mr as vec4f, Ot as unpremultiplyAlpha, Rr as textureStorage2d, Tr as sqrt, Yn as textureStore, Yr as u32, _r as mix, ar as clamp, at as ZERO, er as select, fr as floor, gr as min, gt as formatFloat, hr as max, ht as Expr, lr as exp, or as cos, pr as fract, q as createGuardedCompute, qn as textureLoad, qr as f32, tr as abs } from "./lower-DtoDQ7hV.js";
-import { St as createFeedbackTrailSim } from "./porters-CQwDd2t4.js";
-import { t as createSwappableMediaTexture } from "./mediaLifecycle-BTPb5i1-.js";
-import { n as createFontDependentRaster, r as createRasterInvalidator, t as createCanvasRasterTarget } from "./canvasRaster-DDBkrdY8.js";
-import { n as loadGoogleFont } from "./fonts-BUXTd9qb.js";
-var L = formatFloat;
-function overPremul(dst, rgb, a) {
-	return `{ let av = clamp(${a}, 0.0, 1.0); ${dst} = vec4f((${rgb}) * av + ${dst}.rgb * (1.0 - av), av + ${dst}.a * (1.0 - av)); }`;
-}
-function roundRectSD(names, opts) {
-	const { q, sd } = names;
-	const { pp, half, radius } = opts;
-	if (radius === void 0) return [`let ${q} = abs(${pp}) - ${half};`, `let ${sd} = length(max(${q}, vec2f(0.0))) + min(max(${q}.x, ${q}.y), ${L(0)});`];
-	return [`let ${q} = abs(${pp}) - ${half} + ${radius};`, `let ${sd} = length(max(${q}, vec2f(0.0))) + min(max(${q}.x, ${q}.y), ${L(0)}) - ${radius};`];
-}
-function cornerBracketMask(names, opts) {
-	const { bl, inCorner } = names;
-	const { blInit, px, py, hx, hy, stroke } = opts;
-	return [
-		`let ${bl} = ${blInit};`,
-		`let ${inCorner} = abs(${px}) > ${hx} - ${bl} && abs(${py}) > ${hy} - ${bl};`,
-		`${stroke} = ${stroke} * select(${L(0)}, ${L(1)}, ${inCorner});`
-	];
-}
-function straightFromPremul(dst) {
-	return `vec4f(${dst}.rgb / max(${dst}.a, ${L(1e-4)}), ${dst}.a)`;
-}
-var ATLAS_GLYPHS = "0123456789x%";
-var ATLAS_SLOTS = 16;
-var ATLAS_CELL_W = 64;
-var ATLAS_CELL_H = 96;
-var ATLAS_W = ATLAS_SLOTS * ATLAS_CELL_W;
-var ATLAS_H = ATLAS_CELL_H;
-var WALK_SCAN = 3;
-var LEAF_SCAN = 4;
-var LUM = "vec3f(0.299, 0.587, 0.114)";
-var num$1 = (v, f) => typeof v === "number" ? v : f;
-function createGlyphStripAtlas(params, opts = {}) {
-	const { getCpuValue } = params;
-	const glyphTex = createSwappableMediaTexture(params, {
-		label: opts.label ?? "GlyphStrip:atlas",
-		initial: {
-			width: ATLAS_W,
-			height: ATLAS_H
-		}
-	});
-	const target = createCanvasRasterTarget(params, { contextAttributes: { willReadFrequently: true } });
-	const readFont = () => ({
-		family: String(getCpuValue(opts.familyProp ?? "fontFamily") ?? "Inter"),
-		weight: num$1(getCpuValue(opts.weightProp ?? "fontWeight"), 500)
-	});
-	const build = (family, weight) => {
-		if (glyphTex.disposed) return;
-		const c = target.canvas() ? target.context() : target.resize(ATLAS_W, ATLAS_H);
-		if (!c) return;
-		c.clearRect(0, 0, ATLAS_W, ATLAS_H);
-		c.fillStyle = "#ffffff";
-		c.font = `${weight} ${Math.round(ATLAS_CELL_H * .62)}px "${family}", ui-monospace, monospace`;
-		c.textAlign = "center";
-		c.textBaseline = "middle";
-		const glyphs = opts.glyphs ?? ATLAS_GLYPHS;
-		for (let i = 0; i < glyphs.length; i++) c.fillText(glyphs[i], i * ATLAS_CELL_W + ATLAS_CELL_W / 2, ATLAS_CELL_H / 2 + 1);
-		glyphTex.write(target.canvas());
-	};
-	const fp0 = readFont();
-	build(fp0.family, fp0.weight);
-	const rebuild = () => {
-		const fp = readFont();
-		build(fp.family, fp.weight);
-	};
-	const font = createFontDependentRaster({
-		key: () => {
-			const fp = readFont();
-			return `${fp.family}|${fp.weight}`;
-		},
-		load: () => {
-			const fp = readFont();
-			return loadGoogleFont(fp.family, fp.weight);
-		},
-		onLoaded: rebuild
-	});
-	setTimeout(() => font.ensure(), 0);
-	createRasterInvalidator(params, {
-		initialKey: `${fp0.family}|${fp0.weight}`,
-		minIntervalMs: 100,
-		key: () => {
-			const fp = readFont();
-			return `${fp.family}|${fp.weight}`;
-		},
-		run: () => {
-			rebuild();
-			font.ensure();
-		}
-	});
-	return glyphTex.kit;
-}
-function contentPredicate(f, sVar, uVar) {
-	const { p, L: L$1, modeStr } = f;
-	if (modeStr === "alpha") return `${sVar}.a > ${p}_thr`;
-	if (modeStr === "bright") return `dot(${uVar}.rgb, ${LUM}) > ${p}_thr && ${sVar}.a > ${L$1(.02)}`;
-	if (modeStr === "dark") return `dot(${uVar}.rgb, ${LUM}) < ${p}_thr && ${sVar}.a > ${L$1(.5)}`;
-	if (modeStr === "red") return `${uVar}.r > ${p}_thr && ${uVar}.r >= ${uVar}.g && ${uVar}.r >= ${uVar}.b && ${sVar}.a > ${L$1(.02)}`;
-	if (modeStr === "green") return `${uVar}.g > ${p}_thr && ${uVar}.g >= ${uVar}.r && ${uVar}.g >= ${uVar}.b && ${sVar}.a > ${L$1(.02)}`;
-	return `${uVar}.b > ${p}_thr && ${uVar}.b >= ${uVar}.r && ${uVar}.b >= ${uVar}.g && ${sVar}.a > ${L$1(.02)}`;
-}
-function cellScanStmts(f, sfx, originX, originY, sizeV, N, wantBounds) {
-	const { p, L: L$1, s, sampleChild, UN, modeStr } = f;
-	s.push(`var ${sfx}_cnt = ${L$1(0)};`);
-	if (wantBounds) s.push(`var ${sfx}_minX = ${L$1(1e9)}; var ${sfx}_maxX = ${L$1(-1e9)}; var ${sfx}_minY = ${L$1(1e9)}; var ${sfx}_maxY = ${L$1(-1e9)};`);
-	const inv = 1 / N;
-	let k = 0;
-	for (let sy = 0; sy < N; sy++) for (let sx = 0; sx < N; sx++) {
-		const pxX = `${sfx}_px${k}x`;
-		const pxY = `${sfx}_px${k}y`;
-		s.push(`let ${pxX} = ${originX} + ${sizeV} * ${L$1((sx + .5) * inv)};`);
-		s.push(`let ${pxY} = ${originY} + ${sizeV} * ${L$1((sy + .5) * inv)};`);
-		s.push(`let ${sfx}_s${k} = ${sampleChild(`vec2f(${pxX}, ${pxY}) / ${p}_res`)};`);
-		if (modeStr !== "alpha") s.push(`let ${sfx}_u${k} = ${UN}(${sfx}_s${k});`);
-		s.push(`let ${sfx}_c${k} = ${contentPredicate(f, `${sfx}_s${k}`, `${sfx}_u${k}`)};`);
-		s.push(`${sfx}_cnt = ${sfx}_cnt + select(${L$1(0)}, ${L$1(1)}, ${sfx}_c${k});`);
-		if (wantBounds) {
-			s.push(`${sfx}_minX = select(${sfx}_minX, min(${sfx}_minX, ${pxX}), ${sfx}_c${k});`);
-			s.push(`${sfx}_maxX = select(${sfx}_maxX, max(${sfx}_maxX, ${pxX}), ${sfx}_c${k});`);
-			s.push(`${sfx}_minY = select(${sfx}_minY, min(${sfx}_minY, ${pxY}), ${sfx}_c${k});`);
-			s.push(`${sfx}_maxY = select(${sfx}_maxY, max(${sfx}_maxY, ${pxY}), ${sfx}_c${k});`);
-		}
-		k++;
-	}
-	s.push(`let ${sfx}_coverage = ${sfx}_cnt / ${L$1(N * N)};`);
-}
-function partitionWalkStmts(f, layoutStr, D) {
-	const { p, L: L$1, s } = f;
-	s.push(`var ${p}_origin = floor(${p}_fragPx / ${p}_cellPx) * ${p}_cellPx;`);
-	s.push(`var ${p}_size = ${p}_cellPx;`);
-	for (let lvl = 0; lvl < D; lvl++) {
-		const sfx = `${p}_w${lvl}`;
-		if (layoutStr === "mosaic") {
-			s.push(`let ${sfx}_cellIx = ${p}_origin / ${p}_size;`);
-			s.push(`let ${sfx}_doSplit = fract(sin(dot(${sfx}_cellIx, vec2f(${L$1(127.1)}, ${L$1(311.7)})) + ${L$1(lvl * 53.13)}) * ${L$1(43758.5453)}) > ${L$1(.5)};`);
-		} else {
-			cellScanStmts(f, sfx, `${p}_origin.x`, `${p}_origin.y`, `${p}_size`, WALK_SCAN, false);
-			s.push(`let ${sfx}_doSplit = ${sfx}_coverage > ${L$1(.02)} && ${sfx}_coverage < ${L$1(.98)};`);
-		}
-		s.push(`let ${sfx}_half = ${p}_size * ${L$1(.5)};`);
-		s.push(`let ${sfx}_qx = step(${p}_origin.x + ${sfx}_half, ${p}_fragPx.x);`);
-		s.push(`let ${sfx}_qy = step(${p}_origin.y + ${sfx}_half, ${p}_fragPx.y);`);
-		s.push(`let ${sfx}_childOrigin = vec2f(${p}_origin.x + ${sfx}_qx * ${sfx}_half, ${p}_origin.y + ${sfx}_qy * ${sfx}_half);`);
-		s.push(`${p}_origin = select(${p}_origin, ${sfx}_childOrigin, ${sfx}_doSplit);`);
-		s.push(`${p}_size = select(${p}_size, ${sfx}_half, ${sfx}_doSplit);`);
-	}
-}
-function contentBBoxStmts(f) {
-	const { p, L: L$1, s } = f;
-	cellScanStmts(f, `${p}_leaf`, `${p}_origin.x`, `${p}_origin.y`, `${p}_size`, LEAF_SCAN, true);
-	s.push(`let ${p}_halfStep = ${p}_size / ${L$1(LEAF_SCAN)} * ${L$1(.5)};`);
-	s.push(`let ${p}_innerMinX = ${p}_origin.x + ${p}_boxInset;`);
-	s.push(`let ${p}_innerMaxX = max(${p}_origin.x + ${p}_size - ${p}_boxInset, ${p}_innerMinX);`);
-	s.push(`let ${p}_innerMinY = ${p}_origin.y + ${p}_boxInset;`);
-	s.push(`let ${p}_innerMaxY = max(${p}_origin.y + ${p}_size - ${p}_boxInset, ${p}_innerMinY);`);
-	s.push(`let ${p}_bMinX = clamp(${p}_leaf_minX - ${p}_halfStep, ${p}_innerMinX, ${p}_innerMaxX);`);
-	s.push(`let ${p}_bMaxX = clamp(${p}_leaf_maxX + ${p}_halfStep, ${p}_innerMinX, ${p}_innerMaxX);`);
-	s.push(`let ${p}_bMinY = clamp(${p}_leaf_minY - ${p}_halfStep, ${p}_innerMinY, ${p}_innerMaxY);`);
-	s.push(`let ${p}_bMaxY = clamp(${p}_leaf_maxY + ${p}_halfStep, ${p}_innerMinY, ${p}_innerMaxY);`);
-	s.push(`let ${p}_boxW = ${p}_bMaxX - ${p}_bMinX;`);
-	s.push(`let ${p}_boxH = ${p}_bMaxY - ${p}_bMinY;`);
-	s.push(`let ${p}_detected = ${p}_leaf_coverage > ${L$1(.02)} && ${p}_boxW > ${p}_minSize && ${p}_boxH > ${p}_minSize;`);
-	s.push(`let ${p}_detF = select(${L$1(0)}, ${L$1(1)}, ${p}_detected);`);
-}
-function detectionBoxStmts(f, cornerStyle) {
-	const { p, U, L: L$1, s } = f;
-	s.push(`let ${p}_center = vec2f((${p}_bMinX + ${p}_bMaxX) * ${L$1(.5)}, (${p}_bMinY + ${p}_bMaxY) * ${L$1(.5)});`);
-	s.push(`let ${p}_halfB = vec2f(${p}_boxW * ${L$1(.5)}, ${p}_boxH * ${L$1(.5)});`);
-	const cRExpr = cornerStyle ? L$1(0) : `${p}_cornerRadiusPx`;
-	s.push(`let ${p}_cR = max(min(min(${cRExpr}, ${p}_halfB.x), ${p}_halfB.y), ${L$1(0)});`);
-	s.push(`let ${p}_pp = ${p}_fragPx - ${p}_center;`);
-	s.push(...roundRectSD({
-		q: `${p}_q`,
-		sd: `${p}_sd`
-	}, {
-		pp: `${p}_pp`,
-		half: `${p}_halfB`,
-		radius: `${p}_cR`
-	}));
-	s.push(`let ${p}_fillA = (${L$1(1)} - smoothstep(${L$1(0)}, ${p}_aa, ${p}_sd)) * ${U("fillColor")}.a * ${p}_detF;`);
-	s.push(`var ${p}_strokeA = ${L$1(1)} - smoothstep(${L$1(0)}, ${p}_aa, abs(${p}_sd) - ${p}_lineHalf);`);
-	if (cornerStyle) s.push(...cornerBracketMask({
-		bl: `${p}_bl`,
-		inCorner: `${p}_inCorner`
-	}, {
-		blInit: `min(${p}_halfB.x, ${p}_halfB.y) * ${L$1(.35)}`,
-		px: `${p}_pp.x`,
-		py: `${p}_pp.y`,
-		hx: `${p}_halfB.x`,
-		hy: `${p}_halfB.y`,
-		stroke: `${p}_strokeA`
-	}));
-	s.push(`${p}_strokeA = ${p}_strokeA * ${U("strokeColor")}.a * ${p}_detF;`);
-	s.push(overPremul(`${p}_dst`, `${U("fillColor")}.rgb`, `${p}_fillA`));
-	s.push(overPremul(`${p}_dst`, `${U("strokeColor")}.rgb`, `${p}_strokeA`));
-}
-const digitsOf = (L$1, v) => `(${L$1(1)} + step(${L$1(10)}, ${v}) + step(${L$1(100)}, ${v}) + step(${L$1(1e3)}, ${v}) + step(${L$1(1e4)}, ${v}))`;
-const digitAt = (L$1, v, e) => {
-	const x = `floor(${v} / pow(${L$1(10)}, ${e}))`;
-	return `(${x} - ${L$1(10)} * floor((${x}) / ${L$1(10)}))`;
-};
-function glyphPillLabelStmts(f, opts) {
-	const { p, U, L: L$1, s } = f;
-	const { labelStr, labelPos, atlasKey } = opts;
-	s.push(`let ${p}_textH = max(${U("fontSize")} * ${p}_res.y, ${L$1(1)});`);
-	s.push(`let ${p}_glyphW = ${p}_textH * ${L$1(ATLAS_CELL_W / ATLAS_CELL_H)};`);
-	s.push(`let ${p}_advance = ${p}_glyphW + ${p}_textH * ${U("letterSpacing")};`);
-	s.push(`let ${p}_padX = ${p}_textH * ${L$1(.38)};`);
-	s.push(`let ${p}_padY = ${p}_textH * ${L$1(.24)};`);
-	s.push(`let ${p}_gap = ${p}_textH * ${L$1(.28)};`);
-	if (labelStr === "dimensions") {
-		s.push(`let ${p}_w = clamp(floor(${p}_boxW + ${L$1(.5)}), ${L$1(1)}, ${L$1(99999)});`);
-		s.push(`let ${p}_h = clamp(floor(${p}_boxH + ${L$1(.5)}), ${L$1(1)}, ${L$1(99999)});`);
-		s.push(`let ${p}_dw = ${digitsOf(L$1, `${p}_w`)};`);
-		s.push(`let ${p}_dh = ${digitsOf(L$1, `${p}_h`)};`);
-		s.push(`let ${p}_total = ${p}_dw + ${L$1(1)} + ${p}_dh;`);
-	} else {
-		s.push(`let ${p}_pc = clamp(floor(${p}_leaf_coverage * ${L$1(100)} + ${L$1(.5)}), ${L$1(0)}, ${L$1(100)});`);
-		s.push(`let ${p}_dp = ${digitsOf(L$1, `${p}_pc`)};`);
-		s.push(`let ${p}_total = ${p}_dp + ${L$1(1)};`);
-	}
-	s.push(`let ${p}_labelW = ${p}_total * ${p}_advance + ${p}_padX * ${L$1(2)};`);
-	s.push(`let ${p}_labelH = ${p}_textH + ${p}_padY * ${L$1(2)};`);
-	const isRight = labelPos === 1 || labelPos === 3;
-	const isTop = labelPos === 2 || labelPos === 3;
-	s.push(`let ${p}_inset = ${U("labelInset")} > ${L$1(.5)};`);
-	const leftIn = isRight ? `${p}_bMaxX - ${p}_labelW - ${p}_gap` : `${p}_bMinX + ${p}_gap`;
-	const leftOut = isRight ? `${p}_bMaxX - ${p}_labelW` : `${p}_bMinX`;
-	s.push(`var ${p}_labelLeft = select(${leftOut}, ${leftIn}, ${p}_inset);`);
-	const topIn = isTop ? `${p}_bMinY + ${p}_gap` : `${p}_bMaxY - ${p}_labelH - ${p}_gap`;
-	const topOut = isTop ? `${p}_bMinY - ${p}_labelH - ${p}_gap` : `${p}_bMaxY + ${p}_gap`;
-	s.push(`var ${p}_labelTop = select(${topOut}, ${topIn}, ${p}_inset);`);
-	s.push(`let ${p}_cellMaxX = ${p}_origin.x + ${p}_size;`);
-	s.push(`let ${p}_cellMaxY = ${p}_origin.y + ${p}_size;`);
-	s.push(`${p}_labelLeft = clamp(${p}_labelLeft, ${p}_origin.x, max(${p}_cellMaxX - ${p}_labelW, ${p}_origin.x));`);
-	s.push(`${p}_labelTop = clamp(${p}_labelTop, ${p}_origin.y, max(${p}_cellMaxY - ${p}_labelH, ${p}_origin.y));`);
-	s.push(`let ${p}_labelCenter = vec2f(${p}_labelLeft + ${p}_labelW * ${L$1(.5)}, ${p}_labelTop + ${p}_labelH * ${L$1(.5)});`);
-	s.push(`let ${p}_pillHalf = vec2f(${p}_labelW * ${L$1(.5)}, ${p}_labelH * ${L$1(.5)});`);
-	s.push(`let ${p}_pillR = max(min(min(${U("labelRadius")} * ${p}_scaleFactor, ${p}_pillHalf.x), ${p}_pillHalf.y), ${L$1(0)});`);
-	s.push(`let ${p}_pillP = ${p}_fragPx - ${p}_labelCenter;`);
-	s.push(...roundRectSD({
-		q: `${p}_pillQ`,
-		sd: `${p}_pillSD`
-	}, {
-		pp: `${p}_pillP`,
-		half: `${p}_pillHalf`,
-		radius: `${p}_pillR`
-	}));
-	s.push(`let ${p}_pillA = (${L$1(1)} - smoothstep(${L$1(0)}, ${p}_aa, ${p}_pillSD)) * ${U("labelBackgroundColor")}.a * ${p}_detF;`);
-	s.push(overPremul(`${p}_dst`, `${U("labelBackgroundColor")}.rgb`, `${p}_pillA`));
-	s.push(`let ${p}_rel = ${p}_fragPx.x - ${p}_labelLeft - ${p}_padX;`);
-	s.push(`let ${p}_slot = floor(${p}_rel / ${p}_advance);`);
-	s.push(`let ${p}_within = fract(${p}_rel / ${p}_advance);`);
-	s.push(`let ${p}_uInChar = ${p}_within * (${p}_advance / ${p}_glyphW);`);
-	s.push(`let ${p}_vInChar = (${p}_fragPx.y - ${p}_labelTop - ${p}_padY) / ${p}_textH;`);
-	if (labelStr === "dimensions") {
-		s.push(`let ${p}_wDigit = ${digitAt(L$1, `${p}_w`, `${p}_dw - ${L$1(1)} - ${p}_slot`)};`);
-		s.push(`let ${p}_hDigit = ${digitAt(L$1, `${p}_h`, `${p}_dh + ${p}_dw - ${p}_slot`)};`);
-		s.push(`var ${p}_g = ${p}_hDigit;`);
-		s.push(`${p}_g = select(${p}_g, ${L$1(10)}, ${p}_slot == ${p}_dw);`);
-		s.push(`${p}_g = select(${p}_g, ${p}_wDigit, ${p}_slot < ${p}_dw);`);
-	} else s.push(`var ${p}_g = select(${L$1(11)}, ${digitAt(L$1, `${p}_pc`, `${p}_dp - ${L$1(1)} - ${p}_slot`)}, ${p}_slot < ${p}_dp);`);
-	s.push(`let ${p}_atlasU = (${p}_g + clamp(${p}_uInChar, ${L$1(0)}, ${L$1(1)})) / ${L$1(ATLAS_SLOTS)};`);
-	s.push(`let ${p}_glyphCov = textureSampleLevel(tex.$.${atlasKey}, samp.$.linearClamp, vec2f(${p}_atlasU, ${p}_vInChar), 0.0).a;`);
-	s.push(`let ${p}_inText = ${p}_rel >= ${L$1(0)} && ${p}_slot >= ${L$1(0)} && ${p}_slot < ${p}_total && ${p}_uInChar <= ${L$1(1)} && ${p}_vInChar >= ${L$1(0)} && ${p}_vInChar <= ${L$1(1)};`);
-	s.push(`let ${p}_textA = ${p}_glyphCov * select(${L$1(0)}, ${L$1(1)}, ${p}_inText) * ${U("labelColor")}.a * ${p}_detF;`);
-	s.push(overPremul(`${p}_dst`, `${U("labelColor")}.rgb`, `${p}_textA`));
-}
-const diamondStamp = (f) => {
-	const { p, U, L: L$1, s } = f;
-	s.push(`let dsz = ${p}_ms * ${L$1(.16)};`);
-	s.push(`let dSd = (abs(dp.x) + abs(dp.y)) * ${L$1(.7071)} - dsz;`);
-	s.push(overPremul(`${p}_dst`, `${U("keyframeColor")}.rgb`, `(${L$1(1)} - smoothstep(${L$1(0)}, ${p}_aa, dSd)) * ${U("keyframeColor")}.a * fade * ${U("trail")}`));
-};
-function pathSegmentStamp(every) {
-	return (f) => {
-		const { p, U, L: L$1, s } = f;
-		s.push(`let validP = select(${L$1(0)}, ${L$1(1)}, abs(ePrev.w - mta.z) < ${L$1(.5)}) * select(${L$1(0)}, ${L$1(1)}, ePrev.z > ${L$1(.5)});`);
-		s.push(`let stampGap = abs(e.z - ePrev.z);`);
-		s.push(`let contiguous = select(${L$1(0)}, ${L$1(1)}, stampGap < ${L$1(every * 1.5)});`);
-		s.push(`let epp = vec2f(ePrev.x * ${p}_res.x, ePrev.y * ${p}_res.y);`);
-		s.push(`let pa = ${p}_px - epp; let ba = ep - epp;`);
-		s.push(`let h = clamp(dot(pa, ba) / max(dot(ba, ba), ${L$1(1e-4)}), ${L$1(0)}, ${L$1(1)});`);
-		s.push(`let segD = length(pa - ba * h);`);
-		s.push(overPremul(`${p}_dst`, `${U("pathColor")}.rgb`, `(${L$1(1)} - smoothstep(${p}_lw * ${L$1(.4)}, ${p}_lw * ${L$1(.4)} + ${p}_aa, segD)) * ${U("pathColor")}.a * fade * validP * contiguous * ${U("trail")} * ${L$1(.8)}`));
-	};
-}
-function ringTrailStmts(f, slots) {
-	const { p, U, L: L$1, s } = f;
-	const maxAge = slots.len * slots.every;
-	s.push(`if (${U("trail")} > ${L$1(.001)}) {`);
-	s.push(`var ePrev = ${slots.load(`${2 + slots.len - 1}u`)};`);
-	s.push(`for (var j = 0u; j < ${slots.len}u; j = j + 1u) {`);
-	s.push(`let e = ${slots.load("2u + j")};`);
-	s.push(`let valid = select(${L$1(0)}, ${L$1(1)}, abs(e.w - mta.z) < ${L$1(.5)}) * select(${L$1(0)}, ${L$1(1)}, e.z > ${L$1(.5)});`);
-	s.push(`let age = head.z - e.z;`);
-	s.push(`let fade = clamp(${L$1(1)} - age / ${L$1(maxAge)}, ${L$1(0)}, ${L$1(1)}) * valid;`);
-	s.push(`let ep = vec2f(e.x * ${p}_res.x, e.y * ${p}_res.y);`);
-	s.push(`let dp = ${p}_px - ep;`);
-	for (const stage of slots.stages) stage(f);
-	s.push(`ePrev = e;`);
-	s.push(`}`);
-	s.push(`}`);
-}
-const bracketGizmo = (f) => {
-	const { p, U, L: L$1, s } = f;
-	s.push(`let gp = ${p}_px - tp;`);
-	s.push(`let hlf = ${p}_ms * ${L$1(.5)};`);
-	s.push(...roundRectSD({
-		q: `q`,
-		sd: `boxSd`
-	}, {
-		pp: `gp`,
-		half: `vec2f(hlf)`
-	}));
-	s.push(`var strokeA = ${L$1(1)} - smoothstep(${L$1(0)}, ${p}_aa, abs(boxSd) - ${p}_lw * ${L$1(.5)});`);
-	s.push(...cornerBracketMask({
-		bl: `bl`,
-		inCorner: `inCorner`
-	}, {
-		blInit: `hlf * ${L$1(.45)}`,
-		px: `gp.x`,
-		py: `gp.y`,
-		hx: `hlf`,
-		hy: `hlf`,
-		stroke: `strokeA`
-	}));
-	s.push(overPremul(`${p}_dst`, `${U("markerColor")}.rgb`, `strokeA * ${U("markerColor")}.a * searching`));
-	s.push(`let tick = hlf * ${L$1(.55)};`);
-	s.push(`let chH = ${L$1(1)} - smoothstep(${L$1(0)}, ${p}_aa, max(abs(gp.y) - ${p}_lw * ${L$1(.5)}, abs(gp.x) - tick));`);
-	s.push(`let chV = ${L$1(1)} - smoothstep(${L$1(0)}, ${p}_aa, max(abs(gp.x) - ${p}_lw * ${L$1(.5)}, abs(gp.y) - tick));`);
-	s.push(overPremul(`${p}_dst`, `${U("markerColor")}.rgb`, `max(chH, chV) * ${L$1(.55)} * ${U("markerColor")}.a * searching`));
-	s.push(overPremul(`${p}_dst`, `vec3f(1.0, 1.0, 1.0)`, `(${L$1(1)} - smoothstep(${p}_lw, ${p}_lw + ${p}_aa, length(gp))) * searching`));
-};
-var MAX_TRACKERS = 64;
-var TRAIL_LEN = 12;
-var TRAIL_EVERY = 8;
-var AABB_COL = 14;
-var STATE_W = AABB_COL + 1;
-var STATE_FORMAT = "rgba32float";
-var FEAT_GRID = 96;
-var TWO_PI = TWO_PI$1;
-var TrackParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	dt: f32,
-	trackersF: f32,
-	agility: f32,
-	threshold: f32,
-	variance: f32,
-	lifespan: f32
-}), "TrackParams");
-var featureLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	src: { texture: texture2d(f32) },
-	grid: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
-	params: { uniform: TrackParams }
-}), "featureLayout");
-var trackLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	src: { texture: texture2d(f32) },
-	featGrid: {
-		texture: texture2d(f32),
-		sampleType: "unfilterable-float"
-	},
-	prev: {
-		texture: texture2d(f32),
-		sampleType: "unfilterable-float"
-	},
-	next: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
-	present: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
-	params: { uniform: TrackParams }
-}), "trackLayout");
-const trackHash = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
-	"use gpu";
-	return fract(__tsover_mul(sin(x), 43758.5453123));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "x"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.fract",
-			[[
-				1,
-				[
-					6,
-					"std.sin",
-					["x"]
-				],
-				"*",
-				[5, "43758.5453123"]
-			]]
-		]]]]
-	},
-	externals: {
-		"std.fract": () => fract,
-		"std.sin": () => sin
-	}
-}) && $.f)({})), "trackHash");
-function featureScoreFn(mode) {
-	return typegpu_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c) => {
-		"use gpu";
-		const a = max(c.w, 1e-4);
-		const lumaU = clamp(__tsover_div(__tsover_add(__tsover_add(__tsover_mul(c.x, .299), __tsover_mul(c.y, .587)), __tsover_mul(c.z, .114)), a), 0, 1);
-		let score = f32(0);
-		if (mode === "alpha") score = c.w;
-		else if (mode === "dark") score = __tsover_mul(__tsover_sub(1, lumaU), select(f32(0), f32(1), c.w > .5));
-		else if (mode === "red") score = __tsover_mul(__tsover_mul(__tsover_mul(clamp(__tsover_div(c.x, a), 0, 1), select(f32(0), f32(1), c.x >= c.y)), select(f32(0), f32(1), c.x >= c.z)), select(f32(0), f32(1), c.w > .02));
-		else if (mode === "green") score = __tsover_mul(__tsover_mul(__tsover_mul(clamp(__tsover_div(c.y, a), 0, 1), select(f32(0), f32(1), c.y >= c.x)), select(f32(0), f32(1), c.y >= c.z)), select(f32(0), f32(1), c.w > .02));
-		else if (mode === "blue") score = __tsover_mul(__tsover_mul(__tsover_mul(clamp(__tsover_div(c.z, a), 0, 1), select(f32(0), f32(1), c.z >= c.x)), select(f32(0), f32(1), c.z >= c.y)), select(f32(0), f32(1), c.w > .02));
-		else score = __tsover_mul(lumaU, select(f32(0), f32(1), c.w > .02));
-		return score;
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "c"
-			}],
-			"body": [0, [
-				[
-					13,
-					"a",
-					[
-						6,
-						"std.max",
-						[[
-							7,
-							"c",
-							"w"
-						], [5, "0.0001"]]
-					]
-				],
-				[
-					13,
-					"lumaU",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											1,
-											[
-												7,
-												"c",
-												"x"
-											],
-											"*",
-											[5, "0.299"]
-										],
-										"+",
-										[
-											1,
-											[
-												7,
-												"c",
-												"y"
-											],
-											"*",
-											[5, "0.587"]
-										]
-									],
-									"+",
-									[
-										1,
-										[
-											7,
-											"c",
-											"z"
-										],
-										"*",
-										[5, "0.114"]
-									]
-								],
-								"/",
-								"a"
-							],
-							[5, "0"],
-							[5, "1"]
-						]
-					]
-				],
-				[
-					12,
-					"score",
-					[
-						6,
-						"d.f32",
-						[[5, "0"]]
-					]
-				],
-				[
-					11,
-					[
-						1,
-						"mode",
-						"===",
-						[103, "alpha"]
-					],
-					[
-						2,
-						"score",
-						"=",
-						[
-							7,
-							"c",
-							"w"
-						]
-					],
-					[
-						11,
-						[
-							1,
-							"mode",
-							"===",
-							[103, "dark"]
-						],
-						[
-							2,
-							"score",
-							"=",
-							[
-								1,
-								[
-									1,
-									[5, "1"],
-									"-",
-									"lumaU"
-								],
-								"*",
-								[
-									6,
-									"std.select",
-									[
-										[
-											6,
-											"d.f32",
-											[[5, "0"]]
-										],
-										[
-											6,
-											"d.f32",
-											[[5, "1"]]
-										],
-										[
-											1,
-											[
-												7,
-												"c",
-												"w"
-											],
-											">",
-											[5, "0.5"]
-										]
-									]
-								]
-							]
-						],
-						[
-							11,
-							[
-								1,
-								"mode",
-								"===",
-								[103, "red"]
-							],
-							[
-								2,
-								"score",
-								"=",
-								[
-									1,
-									[
-										1,
-										[
-											1,
-											[
-												6,
-												"std.clamp",
-												[
-													[
-														1,
-														[
-															7,
-															"c",
-															"x"
-														],
-														"/",
-														"a"
-													],
-													[5, "0"],
-													[5, "1"]
-												]
-											],
-											"*",
-											[
-												6,
-												"std.select",
-												[
-													[
-														6,
-														"d.f32",
-														[[5, "0"]]
-													],
-													[
-														6,
-														"d.f32",
-														[[5, "1"]]
-													],
-													[
-														1,
-														[
-															7,
-															"c",
-															"x"
-														],
-														">=",
-														[
-															7,
-															"c",
-															"y"
-														]
-													]
-												]
-											]
-										],
-										"*",
-										[
-											6,
-											"std.select",
-											[
-												[
-													6,
-													"d.f32",
-													[[5, "0"]]
-												],
-												[
-													6,
-													"d.f32",
-													[[5, "1"]]
-												],
-												[
-													1,
-													[
-														7,
-														"c",
-														"x"
-													],
-													">=",
-													[
-														7,
-														"c",
-														"z"
-													]
-												]
-											]
-										]
-									],
-									"*",
-									[
-										6,
-										"std.select",
-										[
-											[
-												6,
-												"d.f32",
-												[[5, "0"]]
-											],
-											[
-												6,
-												"d.f32",
-												[[5, "1"]]
-											],
-											[
-												1,
-												[
-													7,
-													"c",
-													"w"
-												],
-												">",
-												[5, "0.02"]
-											]
-										]
-									]
-								]
-							],
-							[
-								11,
-								[
-									1,
-									"mode",
-									"===",
-									[103, "green"]
-								],
-								[
-									2,
-									"score",
-									"=",
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													"std.clamp",
-													[
-														[
-															1,
-															[
-																7,
-																"c",
-																"y"
-															],
-															"/",
-															"a"
-														],
-														[5, "0"],
-														[5, "1"]
-													]
-												],
-												"*",
-												[
-													6,
-													"std.select",
-													[
-														[
-															6,
-															"d.f32",
-															[[5, "0"]]
-														],
-														[
-															6,
-															"d.f32",
-															[[5, "1"]]
-														],
-														[
-															1,
-															[
-																7,
-																"c",
-																"y"
-															],
-															">=",
-															[
-																7,
-																"c",
-																"x"
-															]
-														]
-													]
-												]
-											],
-											"*",
-											[
-												6,
-												"std.select",
-												[
-													[
-														6,
-														"d.f32",
-														[[5, "0"]]
-													],
-													[
-														6,
-														"d.f32",
-														[[5, "1"]]
-													],
-													[
-														1,
-														[
-															7,
-															"c",
-															"y"
-														],
-														">=",
-														[
-															7,
-															"c",
-															"z"
-														]
-													]
-												]
-											]
-										],
-										"*",
-										[
-											6,
-											"std.select",
-											[
-												[
-													6,
-													"d.f32",
-													[[5, "0"]]
-												],
-												[
-													6,
-													"d.f32",
-													[[5, "1"]]
-												],
-												[
-													1,
-													[
-														7,
-														"c",
-														"w"
-													],
-													">",
-													[5, "0.02"]
-												]
-											]
-										]
-									]
-								],
-								[
-									11,
-									[
-										1,
-										"mode",
-										"===",
-										[103, "blue"]
-									],
-									[
-										2,
-										"score",
-										"=",
-										[
-											1,
-											[
-												1,
-												[
-													1,
-													[
-														6,
-														"std.clamp",
-														[
-															[
-																1,
-																[
-																	7,
-																	"c",
-																	"z"
-																],
-																"/",
-																"a"
-															],
-															[5, "0"],
-															[5, "1"]
-														]
-													],
-													"*",
-													[
-														6,
-														"std.select",
-														[
-															[
-																6,
-																"d.f32",
-																[[5, "0"]]
-															],
-															[
-																6,
-																"d.f32",
-																[[5, "1"]]
-															],
-															[
-																1,
-																[
-																	7,
-																	"c",
-																	"z"
-																],
-																">=",
-																[
-																	7,
-																	"c",
-																	"x"
-																]
-															]
-														]
-													]
-												],
-												"*",
-												[
-													6,
-													"std.select",
-													[
-														[
-															6,
-															"d.f32",
-															[[5, "0"]]
-														],
-														[
-															6,
-															"d.f32",
-															[[5, "1"]]
-														],
-														[
-															1,
-															[
-																7,
-																"c",
-																"z"
-															],
-															">=",
-															[
-																7,
-																"c",
-																"y"
-															]
-														]
-													]
-												]
-											],
-											"*",
-											[
-												6,
-												"std.select",
-												[
-													[
-														6,
-														"d.f32",
-														[[5, "0"]]
-													],
-													[
-														6,
-														"d.f32",
-														[[5, "1"]]
-													],
-													[
-														1,
-														[
-															7,
-															"c",
-															"w"
-														],
-														">",
-														[5, "0.02"]
-													]
-												]
-											]
-										]
-									],
-									[
-										2,
-										"score",
-										"=",
-										[
-											1,
-											"lumaU",
-											"*",
-											[
-												6,
-												"std.select",
-												[
-													[
-														6,
-														"d.f32",
-														[[5, "0"]]
-													],
-													[
-														6,
-														"d.f32",
-														[[5, "1"]]
-													],
-													[
-														1,
-														[
-															7,
-															"c",
-															"w"
-														],
-														">",
-														[5, "0.02"]
-													]
-												]
-											]
-										]
-									]
-								]
-							]
-						]
-					]
-				],
-				[10, "score"]
-			]]
-		},
-		externals: {
-			"std.max": () => max,
-			"std.clamp": () => clamp,
-			"d.f32": () => f32,
-			"mode": () => mode,
-			"std.select": () => select
-		}
-	}) && $.f)({})).$name(`featureScore_${mode}`);
-}
-function buildFeatureGridKernel(scoreFn) {
-	return typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
-		"use gpu";
-		const srcDims = textureDimensions(featureLayout.$.src);
-		const srcW = f32(srcDims.x);
-		const srcH = f32(srcDims.y);
-		const g = f32(FEAT_GRID);
-		const cu = __tsover_div(__tsover_add(f32(gx), .5), g);
-		const cv = __tsover_div(__tsover_add(f32(gy), .5), g);
-		const q = __tsover_div(.25, g);
-		let score = f32(0);
-		for (let sy = 0; sy < 2; sy++) for (let sx = 0; sx < 2; sx++) {
-			const u = __tsover_add(cu, __tsover_mul(__tsover_mul(__tsover_sub(f32(sx), .5), 2), q));
-			const v = __tsover_add(cv, __tsover_mul(__tsover_mul(__tsover_sub(f32(sy), .5), 2), q));
-			const tx = u32(clamp(__tsover_mul(u, srcW), f32(0), __tsover_sub(srcW, 1)));
-			const ty = u32(clamp(__tsover_mul(v, srcH), f32(0), __tsover_sub(srcH, 1)));
-			score = max(score, scoreFn(textureLoad(featureLayout.$.src, vec2u(tx, ty), 0)));
-		}
-		textureStore(featureLayout.$.grid, vec2u(gx, gy), vec4f(score, 0, 0, 1));
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "gx"
-			}, {
-				"type": "i",
-				"name": "gy"
-			}],
-			"body": [0, [
-				[
-					13,
-					"srcDims",
-					[
-						6,
-						"std.textureDimensions",
-						[[
-							7,
-							[
-								7,
-								"featureLayout",
-								"$"
-							],
-							"src"
-						]]
-					]
-				],
-				[
-					13,
-					"srcW",
-					[
-						6,
-						"d.f32",
-						[[
-							7,
-							"srcDims",
-							"x"
-						]]
-					]
-				],
-				[
-					13,
-					"srcH",
-					[
-						6,
-						"d.f32",
-						[[
-							7,
-							"srcDims",
-							"y"
-						]]
-					]
-				],
-				[
-					13,
-					"g",
-					[
-						6,
-						"d.f32",
-						["FEAT_GRID"]
-					]
-				],
-				[
-					13,
-					"cu",
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"d.f32",
-								["gx"]
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						"g"
-					]
-				],
-				[
-					13,
-					"cv",
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"d.f32",
-								["gy"]
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						"g"
-					]
-				],
-				[
-					13,
-					"q",
-					[
-						1,
-						[5, "0.25"],
-						"/",
-						"g"
-					]
-				],
-				[
-					12,
-					"score",
-					[
-						6,
-						"d.f32",
-						[[5, "0"]]
-					]
-				],
-				[
-					14,
-					[
-						12,
-						"sy",
-						[5, "0"]
-					],
-					[
-						1,
-						"sy",
-						"<",
-						[5, "2"]
-					],
-					[
-						102,
-						"++",
-						"sy"
-					],
-					[0, [[
-						14,
-						[
-							12,
-							"sx",
-							[5, "0"]
-						],
-						[
-							1,
-							"sx",
-							"<",
-							[5, "2"]
-						],
-						[
-							102,
-							"++",
-							"sx"
-						],
-						[0, [
-							[
-								13,
-								"u",
-								[
-									1,
-									"cu",
-									"+",
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													"d.f32",
-													["sx"]
-												],
-												"-",
-												[5, "0.5"]
-											],
-											"*",
-											[5, "2"]
-										],
-										"*",
-										"q"
-									]
-								]
-							],
-							[
-								13,
-								"v",
-								[
-									1,
-									"cv",
-									"+",
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													"d.f32",
-													["sy"]
-												],
-												"-",
-												[5, "0.5"]
-											],
-											"*",
-											[5, "2"]
-										],
-										"*",
-										"q"
-									]
-								]
-							],
-							[
-								13,
-								"tx",
-								[
-									6,
-									"d.u32",
-									[[
-										6,
-										"std.clamp",
-										[
-											[
-												1,
-												"u",
-												"*",
-												"srcW"
-											],
-											[
-												6,
-												"d.f32",
-												[[5, "0"]]
-											],
-											[
-												1,
-												"srcW",
-												"-",
-												[5, "1"]
-											]
-										]
-									]]
-								]
-							],
-							[
-								13,
-								"ty",
-								[
-									6,
-									"d.u32",
-									[[
-										6,
-										"std.clamp",
-										[
-											[
-												1,
-												"v",
-												"*",
-												"srcH"
-											],
-											[
-												6,
-												"d.f32",
-												[[5, "0"]]
-											],
-											[
-												1,
-												"srcH",
-												"-",
-												[5, "1"]
-											]
-										]
-									]]
-								]
-							],
-							[
-								2,
-								"score",
-								"=",
-								[
-									6,
-									"std.max",
-									["score", [
-										6,
-										"scoreFn",
-										[[
-											6,
-											"std.textureLoad",
-											[
-												[
-													7,
-													[
-														7,
-														"featureLayout",
-														"$"
-													],
-													"src"
-												],
-												[
-													6,
-													"d.vec2u",
-													["tx", "ty"]
-												],
-												[5, "0"]
-											]
-										]]
-									]]
-								]
-							]
-						]]
-					]]]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"featureLayout",
-								"$"
-							],
-							"grid"
-						],
-						[
-							6,
-							"d.vec2u",
-							["gx", "gy"]
-						],
-						[
-							6,
-							"d.vec4f",
-							[
-								"score",
-								[5, "0"],
-								[5, "0"],
-								[5, "1"]
-							]
-						]
-					]
-				]
-			]]
-		},
-		externals: {
-			"std.textureDimensions": () => textureDimensions,
-			"featureLayout": () => featureLayout,
-			"d.f32": () => f32,
-			"FEAT_GRID": () => FEAT_GRID,
-			"d.u32": () => u32,
-			"std.clamp": () => clamp,
-			"std.max": () => max,
-			"scoreFn": () => scoreFn,
-			"std.textureLoad": () => textureLoad,
-			"d.vec2u": () => vec2u,
-			"std.textureStore": () => textureStore,
-			"d.vec4f": () => vec4f
-		}
-	}) && $.f)({})).$name("featureGridScan");
-}
-function buildPursuitKernel(mode, scoreFn) {
-	const score = scoreFn ?? featureScoreFn(mode);
-	return typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ti) => {
-		"use gpu";
-		const P = trackLayout.$.params;
-		const iF = f32(ti);
-		const head = textureLoad(trackLayout.$.prev, vec2u(u32(0), ti), 0);
-		const meta = textureLoad(trackLayout.$.prev, vec2u(u32(1), ti), 0);
-		let posX = head.x;
-		let posY = head.y;
-		let frame = head.z;
-		let genStart = __tsover_sub(head.w, 1);
-		let missStreak = meta.x;
-		let gen = meta.z;
-		let crowdStreak = meta.w;
-		if (head.w < .5) {
-			posX = __tsover_add(.15, __tsover_mul(.7, trackHash(__tsover_add(__tsover_mul(iF, 7.31), 1.3))));
-			posY = __tsover_add(.15, __tsover_mul(.7, trackHash(__tsover_add(__tsover_mul(iF, 11.93), 4.7))));
-			frame = f32(0);
-			genStart = f32(0);
-			missStreak = f32(0);
-			gen = f32(1);
-		}
-		frame = __tsover_add(frame, 1);
-		const minFeat = max(P.threshold, .02);
-		const Lpref = max(__tsover_sub(1, __tsover_mul(P.variance, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 6.13), __tsover_mul(gen, .37)), 2.9)))), minFeat);
-		const srcDims = textureDimensions(trackLayout.$.src);
-		const srcW = f32(srcDims.x);
-		const srcH = f32(srcDims.y);
-		const radius = __tsover_add(.035, __tsover_mul(.11, P.agility));
-		let sumW = f32(0);
-		let sumX = f32(0);
-		let sumY = f32(0);
-		for (let dy = -3; dy <= 3; dy++) for (let dx = -3; dx <= 3; dx++) {
-			const ox = __tsover_mul(__tsover_div(f32(dx), 3), radius);
-			const oy = __tsover_mul(__tsover_div(f32(dy), 3), radius);
-			const cx01 = clamp(__tsover_add(posX, ox), .02, .98);
-			const cy01 = clamp(__tsover_add(posY, oy), .02, .98);
-			const tx = u32(clamp(__tsover_mul(cx01, srcW), f32(0), __tsover_sub(srcW, 1)));
-			const ty = u32(clamp(__tsover_mul(cy01, srcH), f32(0), __tsover_sub(srcH, 1)));
-			const s = score(textureLoad(trackLayout.$.src, vec2u(tx, ty), 0));
-			const gate = select(f32(0), f32(1), s > minFeat);
-			const dBand = __tsover_sub(s, Lpref);
-			const aff = __tsover_mul(exp(__tsover_mul(__tsover_mul(dBand, dBand), -24)), gate);
-			const off = __tsover_div(sqrt(__tsover_add(__tsover_mul(ox, ox), __tsover_mul(oy, oy))), max(radius, .001));
-			const w = __tsover_mul(aff, __tsover_sub(1, __tsover_mul(.3, off)));
-			sumW = __tsover_add(sumW, w);
-			sumX = __tsover_add(sumX, __tsover_mul(cx01, w));
-			sumY = __tsover_add(sumY, __tsover_mul(cy01, w));
-		}
-		const locked = sumW > .8;
-		let bestX = posX;
-		let bestY = posY;
-		if (locked) {
-			bestX = __tsover_div(sumX, sumW);
-			bestY = __tsover_div(sumY, sumW);
-		}
-		missStreak = select(__tsover_add(missStreak, 1), f32(0), locked);
-		if (!locked) {
-			const g = f32(FEAT_GRID);
-			let bestW = f32(0);
-			let tgtX = posX;
-			let tgtY = posY;
-			for (let gy = 0; gy < FEAT_GRID; gy++) for (let gx = 0; gx < FEAT_GRID; gx++) {
-				const cs = textureLoad(trackLayout.$.featGrid, vec2u(u32(gx), u32(gy)), 0).x;
-				const cGate = select(f32(0), f32(1), cs > minFeat);
-				const dB = __tsover_sub(cs, Lpref);
-				const aff = __tsover_mul(exp(__tsover_mul(__tsover_mul(dB, dB), -14)), cGate);
-				const cx = __tsover_div(__tsover_add(f32(gx), .5), g);
-				const cy = __tsover_div(__tsover_add(f32(gy), .5), g);
-				const ddx = __tsover_sub(cx, posX);
-				const ddy = __tsover_sub(cy, posY);
-				const pref = __tsover_add(.6, __tsover_mul(.8, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 3.17), __tsover_mul(f32(gx), 13.71)), __tsover_mul(f32(gy), 29.37)))));
-				const wgt = __tsover_div(__tsover_mul(aff, pref), __tsover_add(1, __tsover_mul(5, __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)))));
-				if (wgt > bestW) {
-					bestW = wgt;
-					tgtX = cx;
-					tgtY = cy;
-				}
-			}
-			if (bestW > .02) {
-				bestX = clamp(__tsover_add(tgtX, __tsover_div(__tsover_sub(trackHash(__tsover_add(__tsover_mul(iF, 5.77), __tsover_mul(gen, 2.13))), .5), g)), .02, .98);
-				bestY = clamp(__tsover_add(tgtY, __tsover_div(__tsover_sub(trackHash(__tsover_add(__tsover_mul(iF, 8.31), __tsover_mul(gen, 4.97))), .5), g)), .02, .98);
-			} else {
-				const ang = __tsover_add(__tsover_mul(trackHash(__tsover_add(__tsover_mul(iF, 13.77), __tsover_mul(gen, 3.19))), TWO_PI), __tsover_mul(sin(__tsover_add(__tsover_mul(frame, .02), iF)), 1.4));
-				bestX = clamp(__tsover_add(posX, __tsover_mul(cos(ang), .08)), .03, .97);
-				bestY = clamp(__tsover_add(posY, __tsover_mul(sin(ang), .08)), .03, .97);
-			}
-		}
-		const maxStep = __tsover_mul(P.dt, __tsover_add(.15, __tsover_mul(1.4, P.agility)));
-		const dX = __tsover_sub(bestX, posX);
-		const dY = __tsover_sub(bestY, posY);
-		const dist = sqrt(__tsover_add(__tsover_mul(dX, dX), __tsover_mul(dY, dY)));
-		const stepK = min(f32(1), __tsover_div(maxStep, max(dist, 1e-5)));
-		posX = __tsover_add(posX, __tsover_mul(dX, stepK));
-		posY = __tsover_add(posY, __tsover_mul(dY, stepK));
-		let crowded = f32(0);
-		const iN = i32(ti);
-		for (let k = 0; k < iN; k++) {
-			const kF = f32(k);
-			const other = textureLoad(trackLayout.$.prev, vec2u(u32(0), u32(k)), 0);
-			const odx = __tsover_sub(other.x, posX);
-			const ody = __tsover_sub(other.y, posY);
-			const near = select(f32(0), f32(1), sqrt(__tsover_add(__tsover_mul(odx, odx), __tsover_mul(ody, ody))) < .022);
-			crowded = max(crowded, __tsover_mul(__tsover_mul(near, other.w), select(f32(0), f32(1), kF < P.trackersF)));
-		}
-		crowdStreak = select(f32(0), __tsover_add(crowdStreak, 1), crowded > .5);
-		if (crowdStreak > 30) {
-			const hopAng = __tsover_mul(trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 9.13), __tsover_mul(gen, 5.77)), 2.3)), TWO_PI);
-			const hopDist = __tsover_add(.05, __tsover_mul(.08, trackHash(__tsover_add(__tsover_mul(iF, 4.71), __tsover_mul(gen, 8.11)))));
-			posX = clamp(__tsover_add(posX, __tsover_mul(cos(hopAng), hopDist)), .03, .97);
-			posY = clamp(__tsover_add(posY, __tsover_mul(sin(hopAng), hopDist)), .03, .97);
-			gen = __tsover_add(gen, 1);
-			genStart = frame;
-			missStreak = f32(0);
-			crowdStreak = f32(0);
-		}
-		const lifeFrames = __tsover_mul(__tsover_mul(P.lifespan, 60), __tsover_add(.7, __tsover_mul(.6, trackHash(__tsover_add(__tsover_mul(iF, 4.77), __tsover_mul(gen, 1.31))))));
-		const expired = __tsover_mul(select(f32(0), f32(1), __tsover_sub(frame, genStart) > lifeFrames), select(f32(0), f32(1), P.lifespan > .01));
-		const lost = select(f32(0), f32(1), missStreak > 90);
-		if (__tsover_add(expired, lost) > .5) {
-			posX = __tsover_add(.1, __tsover_mul(.8, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 7.31), __tsover_mul(gen, 13.7)), __tsover_mul(frame, .013)))));
-			posY = __tsover_add(.1, __tsover_mul(.8, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 11.93), __tsover_mul(gen, 17.3)), __tsover_mul(frame, .019)))));
-			gen = __tsover_add(gen, 1);
-			genStart = frame;
-			missStreak = f32(0);
-			crowdStreak = f32(0);
-		}
-		const writeIdx = __tsover_mod(floor(__tsover_div(frame, f32(TRAIL_EVERY))), f32(TRAIL_LEN));
-		const shouldWrite = select(f32(0), f32(1), __tsover_mod(frame, f32(TRAIL_EVERY)) < .5);
-		let bbMinX = posX;
-		let bbMinY = posY;
-		let bbMaxX = posX;
-		let bbMaxY = posY;
-		for (let j = 0; j < TRAIL_LEN; j++) {
-			const jF = f32(j);
-			let e = textureLoad(trackLayout.$.prev, vec2u(u32(__tsover_add(2, j)), ti), 0);
-			const isSlot = select(f32(0), f32(1), abs(__tsover_sub(jF, writeIdx)) < .5);
-			const doWrite = __tsover_mul(isSlot, shouldWrite);
-			e = mix(e, vec4f(posX, posY, frame, gen), doWrite);
-			textureStore(trackLayout.$.next, vec2u(u32(__tsover_add(2, j)), ti), e);
-			textureStore(trackLayout.$.present, vec2u(u32(__tsover_add(2, j)), ti), e);
-			const live = __tsover_mul(select(f32(0), f32(1), abs(__tsover_sub(e.w, gen)) < .5), select(f32(0), f32(1), e.z > .5));
-			bbMinX = min(bbMinX, mix(posX, e.x, live));
-			bbMinY = min(bbMinY, mix(posY, e.y, live));
-			bbMaxX = max(bbMaxX, mix(posX, e.x, live));
-			bbMaxY = max(bbMaxY, mix(posY, e.y, live));
-		}
-		const bbOut = vec4f(bbMinX, bbMinY, bbMaxX, bbMaxY);
-		textureStore(trackLayout.$.next, vec2u(u32(AABB_COL), ti), bbOut);
-		textureStore(trackLayout.$.present, vec2u(u32(AABB_COL), ti), bbOut);
-		const headOut = vec4f(posX, posY, frame, __tsover_add(genStart, 1));
-		const metaOut = vec4f(missStreak, sumW, gen, crowdStreak);
-		textureStore(trackLayout.$.next, vec2u(u32(0), ti), headOut);
-		textureStore(trackLayout.$.present, vec2u(u32(0), ti), headOut);
-		textureStore(trackLayout.$.next, vec2u(u32(1), ti), metaOut);
-		textureStore(trackLayout.$.present, vec2u(u32(1), ti), metaOut);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "ti"
-			}],
-			"body": [0, [
-				[
-					13,
-					"P",
-					[
-						7,
-						[
-							7,
-							"trackLayout",
-							"$"
-						],
-						"params"
-					]
-				],
-				[
-					13,
-					"iF",
-					[
-						6,
-						"d.f32",
-						["ti"]
-					]
-				],
-				[
-					13,
-					"head",
-					[
-						6,
-						"std.textureLoad",
-						[
-							[
-								7,
-								[
-									7,
-									"trackLayout",
-									"$"
-								],
-								"prev"
-							],
-							[
-								6,
-								"d.vec2u",
-								[[
-									6,
-									"d.u32",
-									[[5, "0"]]
-								], "ti"]
-							],
-							[5, "0"]
-						]
-					]
-				],
-				[
-					13,
-					"meta",
-					[
-						6,
-						"std.textureLoad",
-						[
-							[
-								7,
-								[
-									7,
-									"trackLayout",
-									"$"
-								],
-								"prev"
-							],
-							[
-								6,
-								"d.vec2u",
-								[[
-									6,
-									"d.u32",
-									[[5, "1"]]
-								], "ti"]
-							],
-							[5, "0"]
-						]
-					]
-				],
-				[
-					12,
-					"posX",
-					[
-						7,
-						"head",
-						"x"
-					]
-				],
-				[
-					12,
-					"posY",
-					[
-						7,
-						"head",
-						"y"
-					]
-				],
-				[
-					12,
-					"frame",
-					[
-						7,
-						"head",
-						"z"
-					]
-				],
-				[
-					12,
-					"genStart",
-					[
-						1,
-						[
-							7,
-							"head",
-							"w"
-						],
-						"-",
-						[5, "1"]
-					]
-				],
-				[
-					12,
-					"missStreak",
-					[
-						7,
-						"meta",
-						"x"
-					]
-				],
-				[
-					12,
-					"gen",
-					[
-						7,
-						"meta",
-						"z"
-					]
-				],
-				[
-					12,
-					"crowdStreak",
-					[
-						7,
-						"meta",
-						"w"
-					]
-				],
-				[
-					11,
-					[
-						1,
-						[
-							7,
-							"head",
-							"w"
-						],
-						"<",
-						[5, "0.5"]
-					],
-					[0, [
-						[
-							2,
-							"posX",
-							"=",
-							[
-								1,
-								[5, "0.15"],
-								"+",
-								[
-									1,
-									[5, "0.7"],
-									"*",
-									[
-										6,
-										"trackHash",
-										[[
-											1,
-											[
-												1,
-												"iF",
-												"*",
-												[5, "7.31"]
-											],
-											"+",
-											[5, "1.3"]
-										]]
-									]
-								]
-							]
-						],
-						[
-							2,
-							"posY",
-							"=",
-							[
-								1,
-								[5, "0.15"],
-								"+",
-								[
-									1,
-									[5, "0.7"],
-									"*",
-									[
-										6,
-										"trackHash",
-										[[
-											1,
-											[
-												1,
-												"iF",
-												"*",
-												[5, "11.93"]
-											],
-											"+",
-											[5, "4.7"]
-										]]
-									]
-								]
-							]
-						],
-						[
-							2,
-							"frame",
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						],
-						[
-							2,
-							"genStart",
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						],
-						[
-							2,
-							"missStreak",
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						],
-						[
-							2,
-							"gen",
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "1"]]
-							]
-						]
-					]]
-				],
-				[
-					2,
-					"frame",
-					"=",
-					[
-						1,
-						"frame",
-						"+",
-						[5, "1"]
-					]
-				],
-				[
-					13,
-					"minFeat",
-					[
-						6,
-						"std.max",
-						[[
-							7,
-							"P",
-							"threshold"
-						], [5, "0.02"]]
-					]
-				],
-				[
-					13,
-					"Lpref",
-					[
-						6,
-						"std.max",
-						[[
-							1,
-							[5, "1"],
-							"-",
-							[
-								1,
-								[
-									7,
-									"P",
-									"variance"
-								],
-								"*",
-								[
-									6,
-									"trackHash",
-									[[
-										1,
-										[
-											1,
-											[
-												1,
-												"iF",
-												"*",
-												[5, "6.13"]
-											],
-											"+",
-											[
-												1,
-												"gen",
-												"*",
-												[5, "0.37"]
-											]
-										],
-										"+",
-										[5, "2.9"]
-									]]
-								]
-							]
-						], "minFeat"]
-					]
-				],
-				[
-					13,
-					"srcDims",
-					[
-						6,
-						"std.textureDimensions",
-						[[
-							7,
-							[
-								7,
-								"trackLayout",
-								"$"
-							],
-							"src"
-						]]
-					]
-				],
-				[
-					13,
-					"srcW",
-					[
-						6,
-						"d.f32",
-						[[
-							7,
-							"srcDims",
-							"x"
-						]]
-					]
-				],
-				[
-					13,
-					"srcH",
-					[
-						6,
-						"d.f32",
-						[[
-							7,
-							"srcDims",
-							"y"
-						]]
-					]
-				],
-				[
-					13,
-					"radius",
-					[
-						1,
-						[5, "0.035"],
-						"+",
-						[
-							1,
-							[5, "0.11"],
-							"*",
-							[
-								7,
-								"P",
-								"agility"
-							]
-						]
-					]
-				],
-				[
-					12,
-					"sumW",
-					[
-						6,
-						"d.f32",
-						[[5, "0"]]
-					]
-				],
-				[
-					12,
-					"sumX",
-					[
-						6,
-						"d.f32",
-						[[5, "0"]]
-					]
-				],
-				[
-					12,
-					"sumY",
-					[
-						6,
-						"d.f32",
-						[[5, "0"]]
-					]
-				],
-				[
-					14,
-					[
-						12,
-						"dy",
-						[
-							4,
-							"-",
-							[5, "3"]
-						]
-					],
-					[
-						1,
-						"dy",
-						"<=",
-						[5, "3"]
-					],
-					[
-						102,
-						"++",
-						"dy"
-					],
-					[0, [[
-						14,
-						[
-							12,
-							"dx",
-							[
-								4,
-								"-",
-								[5, "3"]
-							]
-						],
-						[
-							1,
-							"dx",
-							"<=",
-							[5, "3"]
-						],
-						[
-							102,
-							"++",
-							"dx"
-						],
-						[0, [
-							[
-								13,
-								"ox",
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["dx"]
-										],
-										"/",
-										[5, "3"]
-									],
-									"*",
-									"radius"
-								]
-							],
-							[
-								13,
-								"oy",
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["dy"]
-										],
-										"/",
-										[5, "3"]
-									],
-									"*",
-									"radius"
-								]
-							],
-							[
-								13,
-								"cx01",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											"posX",
-											"+",
-											"ox"
-										],
-										[5, "0.02"],
-										[5, "0.98"]
-									]
-								]
-							],
-							[
-								13,
-								"cy01",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											"posY",
-											"+",
-											"oy"
-										],
-										[5, "0.02"],
-										[5, "0.98"]
-									]
-								]
-							],
-							[
-								13,
-								"tx",
-								[
-									6,
-									"d.u32",
-									[[
-										6,
-										"std.clamp",
-										[
-											[
-												1,
-												"cx01",
-												"*",
-												"srcW"
-											],
-											[
-												6,
-												"d.f32",
-												[[5, "0"]]
-											],
-											[
-												1,
-												"srcW",
-												"-",
-												[5, "1"]
-											]
-										]
-									]]
-								]
-							],
-							[
-								13,
-								"ty",
-								[
-									6,
-									"d.u32",
-									[[
-										6,
-										"std.clamp",
-										[
-											[
-												1,
-												"cy01",
-												"*",
-												"srcH"
-											],
-											[
-												6,
-												"d.f32",
-												[[5, "0"]]
-											],
-											[
-												1,
-												"srcH",
-												"-",
-												[5, "1"]
-											]
-										]
-									]]
-								]
-							],
-							[
-								13,
-								"s",
-								[
-									6,
-									"score",
-									[[
-										6,
-										"std.textureLoad",
-										[
-											[
-												7,
-												[
-													7,
-													"trackLayout",
-													"$"
-												],
-												"src"
-											],
-											[
-												6,
-												"d.vec2u",
-												["tx", "ty"]
-											],
-											[5, "0"]
-										]
-									]]
-								]
-							],
-							[
-								13,
-								"gate",
-								[
-									6,
-									"std.select",
-									[
-										[
-											6,
-											"d.f32",
-											[[5, "0"]]
-										],
-										[
-											6,
-											"d.f32",
-											[[5, "1"]]
-										],
-										[
-											1,
-											"s",
-											">",
-											"minFeat"
-										]
-									]
-								]
-							],
-							[
-								13,
-								"dBand",
-								[
-									1,
-									"s",
-									"-",
-									"Lpref"
-								]
-							],
-							[
-								13,
-								"aff",
-								[
-									1,
-									[
-										6,
-										"std.exp",
-										[[
-											1,
-											[
-												1,
-												"dBand",
-												"*",
-												"dBand"
-											],
-											"*",
-											[
-												4,
-												"-",
-												[5, "24"]
-											]
-										]]
-									],
-									"*",
-									"gate"
-								]
-							],
-							[
-								13,
-								"off",
-								[
-									1,
-									[
-										6,
-										"std.sqrt",
-										[[
-											1,
-											[
-												1,
-												"ox",
-												"*",
-												"ox"
-											],
-											"+",
-											[
-												1,
-												"oy",
-												"*",
-												"oy"
-											]
-										]]
-									],
-									"/",
-									[
-										6,
-										"std.max",
-										["radius", [5, "0.001"]]
-									]
-								]
-							],
-							[
-								13,
-								"w",
-								[
-									1,
-									"aff",
-									"*",
-									[
-										1,
-										[5, "1"],
-										"-",
-										[
-											1,
-											[5, "0.3"],
-											"*",
-											"off"
-										]
-									]
-								]
-							],
-							[
-								2,
-								"sumW",
-								"=",
-								[
-									1,
-									"sumW",
-									"+",
-									"w"
-								]
-							],
-							[
-								2,
-								"sumX",
-								"=",
-								[
-									1,
-									"sumX",
-									"+",
-									[
-										1,
-										"cx01",
-										"*",
-										"w"
-									]
-								]
-							],
-							[
-								2,
-								"sumY",
-								"=",
-								[
-									1,
-									"sumY",
-									"+",
-									[
-										1,
-										"cy01",
-										"*",
-										"w"
-									]
-								]
-							]
-						]]
-					]]]
-				],
-				[
-					13,
-					"locked",
-					[
-						1,
-						"sumW",
-						">",
-						[5, "0.8"]
-					]
-				],
-				[
-					12,
-					"bestX",
-					"posX"
-				],
-				[
-					12,
-					"bestY",
-					"posY"
-				],
-				[
-					11,
-					"locked",
-					[0, [[
-						2,
-						"bestX",
-						"=",
-						[
-							1,
-							"sumX",
-							"/",
-							"sumW"
-						]
-					], [
-						2,
-						"bestY",
-						"=",
-						[
-							1,
-							"sumY",
-							"/",
-							"sumW"
-						]
-					]]]
-				],
-				[
-					2,
-					"missStreak",
-					"=",
-					[
-						6,
-						"std.select",
-						[
-							[
-								1,
-								"missStreak",
-								"+",
-								[5, "1"]
-							],
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							],
-							"locked"
-						]
-					]
-				],
-				[
-					11,
-					[
-						4,
-						"!",
-						"locked"
-					],
-					[0, [
-						[
-							13,
-							"g",
-							[
-								6,
-								"d.f32",
-								["FEAT_GRID"]
-							]
-						],
-						[
-							12,
-							"bestW",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						],
-						[
-							12,
-							"tgtX",
-							"posX"
-						],
-						[
-							12,
-							"tgtY",
-							"posY"
-						],
-						[
-							14,
-							[
-								12,
-								"gy",
-								[5, "0"]
-							],
-							[
-								1,
-								"gy",
-								"<",
-								"FEAT_GRID"
-							],
-							[
-								102,
-								"++",
-								"gy"
-							],
-							[0, [[
-								14,
-								[
-									12,
-									"gx",
-									[5, "0"]
-								],
-								[
-									1,
-									"gx",
-									"<",
-									"FEAT_GRID"
-								],
-								[
-									102,
-									"++",
-									"gx"
-								],
-								[0, [
-									[
-										13,
-										"cs",
-										[
-											7,
-											[
-												6,
-												"std.textureLoad",
-												[
-													[
-														7,
-														[
-															7,
-															"trackLayout",
-															"$"
-														],
-														"featGrid"
-													],
-													[
-														6,
-														"d.vec2u",
-														[[
-															6,
-															"d.u32",
-															["gx"]
-														], [
-															6,
-															"d.u32",
-															["gy"]
-														]]
-													],
-													[5, "0"]
-												]
-											],
-											"x"
-										]
-									],
-									[
-										13,
-										"cGate",
-										[
-											6,
-											"std.select",
-											[
-												[
-													6,
-													"d.f32",
-													[[5, "0"]]
-												],
-												[
-													6,
-													"d.f32",
-													[[5, "1"]]
-												],
-												[
-													1,
-													"cs",
-													">",
-													"minFeat"
-												]
-											]
-										]
-									],
-									[
-										13,
-										"dB",
-										[
-											1,
-											"cs",
-											"-",
-											"Lpref"
-										]
-									],
-									[
-										13,
-										"aff",
-										[
-											1,
-											[
-												6,
-												"std.exp",
-												[[
-													1,
-													[
-														1,
-														"dB",
-														"*",
-														"dB"
-													],
-													"*",
-													[
-														4,
-														"-",
-														[5, "14"]
-													]
-												]]
-											],
-											"*",
-											"cGate"
-										]
-									],
-									[
-										13,
-										"cx",
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													"d.f32",
-													["gx"]
-												],
-												"+",
-												[5, "0.5"]
-											],
-											"/",
-											"g"
-										]
-									],
-									[
-										13,
-										"cy",
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													"d.f32",
-													["gy"]
-												],
-												"+",
-												[5, "0.5"]
-											],
-											"/",
-											"g"
-										]
-									],
-									[
-										13,
-										"ddx",
-										[
-											1,
-											"cx",
-											"-",
-											"posX"
-										]
-									],
-									[
-										13,
-										"ddy",
-										[
-											1,
-											"cy",
-											"-",
-											"posY"
-										]
-									],
-									[
-										13,
-										"pref",
-										[
-											1,
-											[5, "0.6"],
-											"+",
-											[
-												1,
-												[5, "0.8"],
-												"*",
-												[
-													6,
-													"trackHash",
-													[[
-														1,
-														[
-															1,
-															[
-																1,
-																"iF",
-																"*",
-																[5, "3.17"]
-															],
-															"+",
-															[
-																1,
-																[
-																	6,
-																	"d.f32",
-																	["gx"]
-																],
-																"*",
-																[5, "13.71"]
-															]
-														],
-														"+",
-														[
-															1,
-															[
-																6,
-																"d.f32",
-																["gy"]
-															],
-															"*",
-															[5, "29.37"]
-														]
-													]]
-												]
-											]
-										]
-									],
-									[
-										13,
-										"wgt",
-										[
-											1,
-											[
-												1,
-												"aff",
-												"*",
-												"pref"
-											],
-											"/",
-											[
-												1,
-												[5, "1"],
-												"+",
-												[
-													1,
-													[5, "5"],
-													"*",
-													[
-														1,
-														[
-															1,
-															"ddx",
-															"*",
-															"ddx"
-														],
-														"+",
-														[
-															1,
-															"ddy",
-															"*",
-															"ddy"
-														]
-													]
-												]
-											]
-										]
-									],
-									[
-										11,
-										[
-											1,
-											"wgt",
-											">",
-											"bestW"
-										],
-										[0, [
-											[
-												2,
-												"bestW",
-												"=",
-												"wgt"
-											],
-											[
-												2,
-												"tgtX",
-												"=",
-												"cx"
-											],
-											[
-												2,
-												"tgtY",
-												"=",
-												"cy"
-											]
-										]]
-									]
-								]]
-							]]]
-						],
-						[
-							11,
-							[
-								1,
-								"bestW",
-								">",
-								[5, "0.02"]
-							],
-							[0, [[
-								2,
-								"bestX",
-								"=",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											"tgtX",
-											"+",
-											[
-												1,
-												[
-													1,
-													[
-														6,
-														"trackHash",
-														[[
-															1,
-															[
-																1,
-																"iF",
-																"*",
-																[5, "5.77"]
-															],
-															"+",
-															[
-																1,
-																"gen",
-																"*",
-																[5, "2.13"]
-															]
-														]]
-													],
-													"-",
-													[5, "0.5"]
-												],
-												"/",
-												"g"
-											]
-										],
-										[5, "0.02"],
-										[5, "0.98"]
-									]
-								]
-							], [
-								2,
-								"bestY",
-								"=",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											"tgtY",
-											"+",
-											[
-												1,
-												[
-													1,
-													[
-														6,
-														"trackHash",
-														[[
-															1,
-															[
-																1,
-																"iF",
-																"*",
-																[5, "8.31"]
-															],
-															"+",
-															[
-																1,
-																"gen",
-																"*",
-																[5, "4.97"]
-															]
-														]]
-													],
-													"-",
-													[5, "0.5"]
-												],
-												"/",
-												"g"
-											]
-										],
-										[5, "0.02"],
-										[5, "0.98"]
-									]
-								]
-							]]],
-							[0, [
-								[
-									13,
-									"ang",
-									[
-										1,
-										[
-											1,
-											[
-												6,
-												"trackHash",
-												[[
-													1,
-													[
-														1,
-														"iF",
-														"*",
-														[5, "13.77"]
-													],
-													"+",
-													[
-														1,
-														"gen",
-														"*",
-														[5, "3.19"]
-													]
-												]]
-											],
-											"*",
-											"TWO_PI"
-										],
-										"+",
-										[
-											1,
-											[
-												6,
-												"std.sin",
-												[[
-													1,
-													[
-														1,
-														"frame",
-														"*",
-														[5, "0.02"]
-													],
-													"+",
-													"iF"
-												]]
-											],
-											"*",
-											[5, "1.4"]
-										]
-									]
-								],
-								[
-									2,
-									"bestX",
-									"=",
-									[
-										6,
-										"std.clamp",
-										[
-											[
-												1,
-												"posX",
-												"+",
-												[
-													1,
-													[
-														6,
-														"std.cos",
-														["ang"]
-													],
-													"*",
-													[5, "0.08"]
-												]
-											],
-											[5, "0.03"],
-											[5, "0.97"]
-										]
-									]
-								],
-								[
-									2,
-									"bestY",
-									"=",
-									[
-										6,
-										"std.clamp",
-										[
-											[
-												1,
-												"posY",
-												"+",
-												[
-													1,
-													[
-														6,
-														"std.sin",
-														["ang"]
-													],
-													"*",
-													[5, "0.08"]
-												]
-											],
-											[5, "0.03"],
-											[5, "0.97"]
-										]
-									]
-								]
-							]]
-						]
-					]]
-				],
-				[
-					13,
-					"maxStep",
-					[
-						1,
-						[
-							7,
-							"P",
-							"dt"
-						],
-						"*",
-						[
-							1,
-							[5, "0.15"],
-							"+",
-							[
-								1,
-								[5, "1.4"],
-								"*",
-								[
-									7,
-									"P",
-									"agility"
-								]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"dX",
-					[
-						1,
-						"bestX",
-						"-",
-						"posX"
-					]
-				],
-				[
-					13,
-					"dY",
-					[
-						1,
-						"bestY",
-						"-",
-						"posY"
-					]
-				],
-				[
-					13,
-					"dist",
-					[
-						6,
-						"std.sqrt",
-						[[
-							1,
-							[
-								1,
-								"dX",
-								"*",
-								"dX"
-							],
-							"+",
-							[
-								1,
-								"dY",
-								"*",
-								"dY"
-							]
-						]]
-					]
-				],
-				[
-					13,
-					"stepK",
-					[
-						6,
-						"std.min",
-						[[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						], [
-							1,
-							"maxStep",
-							"/",
-							[
-								6,
-								"std.max",
-								["dist", [5, "0.00001"]]
-							]
-						]]
-					]
-				],
-				[
-					2,
-					"posX",
-					"=",
-					[
-						1,
-						"posX",
-						"+",
-						[
-							1,
-							"dX",
-							"*",
-							"stepK"
-						]
-					]
-				],
-				[
-					2,
-					"posY",
-					"=",
-					[
-						1,
-						"posY",
-						"+",
-						[
-							1,
-							"dY",
-							"*",
-							"stepK"
-						]
-					]
-				],
-				[
-					12,
-					"crowded",
-					[
-						6,
-						"d.f32",
-						[[5, "0"]]
-					]
-				],
-				[
-					13,
-					"iN",
-					[
-						6,
-						"d.i32",
-						["ti"]
-					]
-				],
-				[
-					14,
-					[
-						12,
-						"k",
-						[5, "0"]
-					],
-					[
-						1,
-						"k",
-						"<",
-						"iN"
-					],
-					[
-						102,
-						"++",
-						"k"
-					],
-					[0, [
-						[
-							13,
-							"kF",
-							[
-								6,
-								"d.f32",
-								["k"]
-							]
-						],
-						[
-							13,
-							"other",
-							[
-								6,
-								"std.textureLoad",
-								[
-									[
-										7,
-										[
-											7,
-											"trackLayout",
-											"$"
-										],
-										"prev"
-									],
-									[
-										6,
-										"d.vec2u",
-										[[
-											6,
-											"d.u32",
-											[[5, "0"]]
-										], [
-											6,
-											"d.u32",
-											["k"]
-										]]
-									],
-									[5, "0"]
-								]
-							]
-						],
-						[
-							13,
-							"odx",
-							[
-								1,
-								[
-									7,
-									"other",
-									"x"
-								],
-								"-",
-								"posX"
-							]
-						],
-						[
-							13,
-							"ody",
-							[
-								1,
-								[
-									7,
-									"other",
-									"y"
-								],
-								"-",
-								"posY"
-							]
-						],
-						[
-							13,
-							"near",
-							[
-								6,
-								"std.select",
-								[
-									[
-										6,
-										"d.f32",
-										[[5, "0"]]
-									],
-									[
-										6,
-										"d.f32",
-										[[5, "1"]]
-									],
-									[
-										1,
-										[
-											6,
-											"std.sqrt",
-											[[
-												1,
-												[
-													1,
-													"odx",
-													"*",
-													"odx"
-												],
-												"+",
-												[
-													1,
-													"ody",
-													"*",
-													"ody"
-												]
-											]]
-										],
-										"<",
-										[5, "0.022"]
-									]
-								]
-							]
-						],
-						[
-							2,
-							"crowded",
-							"=",
-							[
-								6,
-								"std.max",
-								["crowded", [
-									1,
-									[
-										1,
-										"near",
-										"*",
-										[
-											7,
-											"other",
-											"w"
-										]
-									],
-									"*",
-									[
-										6,
-										"std.select",
-										[
-											[
-												6,
-												"d.f32",
-												[[5, "0"]]
-											],
-											[
-												6,
-												"d.f32",
-												[[5, "1"]]
-											],
-											[
-												1,
-												"kF",
-												"<",
-												[
-													7,
-													"P",
-													"trackersF"
-												]
-											]
-										]
-									]
-								]]
-							]
-						]
-					]]
-				],
-				[
-					2,
-					"crowdStreak",
-					"=",
-					[
-						6,
-						"std.select",
-						[
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							],
-							[
-								1,
-								"crowdStreak",
-								"+",
-								[5, "1"]
-							],
-							[
-								1,
-								"crowded",
-								">",
-								[5, "0.5"]
-							]
-						]
-					]
-				],
-				[
-					11,
-					[
-						1,
-						"crowdStreak",
-						">",
-						[5, "30"]
-					],
-					[0, [
-						[
-							13,
-							"hopAng",
-							[
-								1,
-								[
-									6,
-									"trackHash",
-									[[
-										1,
-										[
-											1,
-											[
-												1,
-												"iF",
-												"*",
-												[5, "9.13"]
-											],
-											"+",
-											[
-												1,
-												"gen",
-												"*",
-												[5, "5.77"]
-											]
-										],
-										"+",
-										[5, "2.3"]
-									]]
-								],
-								"*",
-								"TWO_PI"
-							]
-						],
-						[
-							13,
-							"hopDist",
-							[
-								1,
-								[5, "0.05"],
-								"+",
-								[
-									1,
-									[5, "0.08"],
-									"*",
-									[
-										6,
-										"trackHash",
-										[[
-											1,
-											[
-												1,
-												"iF",
-												"*",
-												[5, "4.71"]
-											],
-											"+",
-											[
-												1,
-												"gen",
-												"*",
-												[5, "8.11"]
-											]
-										]]
-									]
-								]
-							]
-						],
-						[
-							2,
-							"posX",
-							"=",
-							[
-								6,
-								"std.clamp",
-								[
-									[
-										1,
-										"posX",
-										"+",
-										[
-											1,
-											[
-												6,
-												"std.cos",
-												["hopAng"]
-											],
-											"*",
-											"hopDist"
-										]
-									],
-									[5, "0.03"],
-									[5, "0.97"]
-								]
-							]
-						],
-						[
-							2,
-							"posY",
-							"=",
-							[
-								6,
-								"std.clamp",
-								[
-									[
-										1,
-										"posY",
-										"+",
-										[
-											1,
-											[
-												6,
-												"std.sin",
-												["hopAng"]
-											],
-											"*",
-											"hopDist"
-										]
-									],
-									[5, "0.03"],
-									[5, "0.97"]
-								]
-							]
-						],
-						[
-							2,
-							"gen",
-							"=",
-							[
-								1,
-								"gen",
-								"+",
-								[5, "1"]
-							]
-						],
-						[
-							2,
-							"genStart",
-							"=",
-							"frame"
-						],
-						[
-							2,
-							"missStreak",
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						],
-						[
-							2,
-							"crowdStreak",
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						]
-					]]
-				],
-				[
-					13,
-					"lifeFrames",
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"P",
-								"lifespan"
-							],
-							"*",
-							[5, "60"]
-						],
-						"*",
-						[
-							1,
-							[5, "0.7"],
-							"+",
-							[
-								1,
-								[5, "0.6"],
-								"*",
-								[
-									6,
-									"trackHash",
-									[[
-										1,
-										[
-											1,
-											"iF",
-											"*",
-											[5, "4.77"]
-										],
-										"+",
-										[
-											1,
-											"gen",
-											"*",
-											[5, "1.31"]
-										]
-									]]
-								]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"expired",
-					[
-						1,
-						[
-							6,
-							"std.select",
-							[
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								],
-								[
-									6,
-									"d.f32",
-									[[5, "1"]]
-								],
-								[
-									1,
-									[
-										1,
-										"frame",
-										"-",
-										"genStart"
-									],
-									">",
-									"lifeFrames"
-								]
-							]
-						],
-						"*",
-						[
-							6,
-							"std.select",
-							[
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								],
-								[
-									6,
-									"d.f32",
-									[[5, "1"]]
-								],
-								[
-									1,
-									[
-										7,
-										"P",
-										"lifespan"
-									],
-									">",
-									[5, "0.01"]
-								]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"lost",
-					[
-						6,
-						"std.select",
-						[
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							],
-							[
-								6,
-								"d.f32",
-								[[5, "1"]]
-							],
-							[
-								1,
-								"missStreak",
-								">",
-								[5, "90"]
-							]
-						]
-					]
-				],
-				[
-					11,
-					[
-						1,
-						[
-							1,
-							"expired",
-							"+",
-							"lost"
-						],
-						">",
-						[5, "0.5"]
-					],
-					[0, [
-						[
-							2,
-							"posX",
-							"=",
-							[
-								1,
-								[5, "0.1"],
-								"+",
-								[
-									1,
-									[5, "0.8"],
-									"*",
-									[
-										6,
-										"trackHash",
-										[[
-											1,
-											[
-												1,
-												[
-													1,
-													"iF",
-													"*",
-													[5, "7.31"]
-												],
-												"+",
-												[
-													1,
-													"gen",
-													"*",
-													[5, "13.7"]
-												]
-											],
-											"+",
-											[
-												1,
-												"frame",
-												"*",
-												[5, "0.013"]
-											]
-										]]
-									]
-								]
-							]
-						],
-						[
-							2,
-							"posY",
-							"=",
-							[
-								1,
-								[5, "0.1"],
-								"+",
-								[
-									1,
-									[5, "0.8"],
-									"*",
-									[
-										6,
-										"trackHash",
-										[[
-											1,
-											[
-												1,
-												[
-													1,
-													"iF",
-													"*",
-													[5, "11.93"]
-												],
-												"+",
-												[
-													1,
-													"gen",
-													"*",
-													[5, "17.3"]
-												]
-											],
-											"+",
-											[
-												1,
-												"frame",
-												"*",
-												[5, "0.019"]
-											]
-										]]
-									]
-								]
-							]
-						],
-						[
-							2,
-							"gen",
-							"=",
-							[
-								1,
-								"gen",
-								"+",
-								[5, "1"]
-							]
-						],
-						[
-							2,
-							"genStart",
-							"=",
-							"frame"
-						],
-						[
-							2,
-							"missStreak",
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						],
-						[
-							2,
-							"crowdStreak",
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						]
-					]]
-				],
-				[
-					13,
-					"writeIdx",
-					[
-						1,
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"frame",
-								"/",
-								[
-									6,
-									"d.f32",
-									["TRAIL_EVERY"]
-								]
-							]]
-						],
-						"%",
-						[
-							6,
-							"d.f32",
-							["TRAIL_LEN"]
-						]
-					]
-				],
-				[
-					13,
-					"shouldWrite",
-					[
-						6,
-						"std.select",
-						[
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							],
-							[
-								6,
-								"d.f32",
-								[[5, "1"]]
-							],
-							[
-								1,
-								[
-									1,
-									"frame",
-									"%",
-									[
-										6,
-										"d.f32",
-										["TRAIL_EVERY"]
-									]
-								],
-								"<",
-								[5, "0.5"]
-							]
-						]
-					]
-				],
-				[
-					12,
-					"bbMinX",
-					"posX"
-				],
-				[
-					12,
-					"bbMinY",
-					"posY"
-				],
-				[
-					12,
-					"bbMaxX",
-					"posX"
-				],
-				[
-					12,
-					"bbMaxY",
-					"posY"
-				],
-				[
-					14,
-					[
-						12,
-						"j",
-						[5, "0"]
-					],
-					[
-						1,
-						"j",
-						"<",
-						"TRAIL_LEN"
-					],
-					[
-						102,
-						"++",
-						"j"
-					],
-					[0, [
-						[
-							13,
-							"jF",
-							[
-								6,
-								"d.f32",
-								["j"]
-							]
-						],
-						[
-							12,
-							"e",
-							[
-								6,
-								"std.textureLoad",
-								[
-									[
-										7,
-										[
-											7,
-											"trackLayout",
-											"$"
-										],
-										"prev"
-									],
-									[
-										6,
-										"d.vec2u",
-										[[
-											6,
-											"d.u32",
-											[[
-												1,
-												[5, "2"],
-												"+",
-												"j"
-											]]
-										], "ti"]
-									],
-									[5, "0"]
-								]
-							]
-						],
-						[
-							13,
-							"isSlot",
-							[
-								6,
-								"std.select",
-								[
-									[
-										6,
-										"d.f32",
-										[[5, "0"]]
-									],
-									[
-										6,
-										"d.f32",
-										[[5, "1"]]
-									],
-									[
-										1,
-										[
-											6,
-											"std.abs",
-											[[
-												1,
-												"jF",
-												"-",
-												"writeIdx"
-											]]
-										],
-										"<",
-										[5, "0.5"]
-									]
-								]
-							]
-						],
-						[
-							13,
-							"doWrite",
-							[
-								1,
-								"isSlot",
-								"*",
-								"shouldWrite"
-							]
-						],
-						[
-							2,
-							"e",
-							"=",
-							[
-								6,
-								"std.mix",
-								[
-									"e",
-									[
-										6,
-										"d.vec4f",
-										[
-											"posX",
-											"posY",
-											"frame",
-											"gen"
-										]
-									],
-									"doWrite"
-								]
-							]
-						],
-						[
-							6,
-							"std.textureStore",
-							[
-								[
-									7,
-									[
-										7,
-										"trackLayout",
-										"$"
-									],
-									"next"
-								],
-								[
-									6,
-									"d.vec2u",
-									[[
-										6,
-										"d.u32",
-										[[
-											1,
-											[5, "2"],
-											"+",
-											"j"
-										]]
-									], "ti"]
-								],
-								"e"
-							]
-						],
-						[
-							6,
-							"std.textureStore",
-							[
-								[
-									7,
-									[
-										7,
-										"trackLayout",
-										"$"
-									],
-									"present"
-								],
-								[
-									6,
-									"d.vec2u",
-									[[
-										6,
-										"d.u32",
-										[[
-											1,
-											[5, "2"],
-											"+",
-											"j"
-										]]
-									], "ti"]
-								],
-								"e"
-							]
-						],
-						[
-							13,
-							"live",
-							[
-								1,
-								[
-									6,
-									"std.select",
-									[
-										[
-											6,
-											"d.f32",
-											[[5, "0"]]
-										],
-										[
-											6,
-											"d.f32",
-											[[5, "1"]]
-										],
-										[
-											1,
-											[
-												6,
-												"std.abs",
-												[[
-													1,
-													[
-														7,
-														"e",
-														"w"
-													],
-													"-",
-													"gen"
-												]]
-											],
-											"<",
-											[5, "0.5"]
-										]
-									]
-								],
-								"*",
-								[
-									6,
-									"std.select",
-									[
-										[
-											6,
-											"d.f32",
-											[[5, "0"]]
-										],
-										[
-											6,
-											"d.f32",
-											[[5, "1"]]
-										],
-										[
-											1,
-											[
-												7,
-												"e",
-												"z"
-											],
-											">",
-											[5, "0.5"]
-										]
-									]
-								]
-							]
-						],
-						[
-							2,
-							"bbMinX",
-							"=",
-							[
-								6,
-								"std.min",
-								["bbMinX", [
-									6,
-									"std.mix",
-									[
-										"posX",
-										[
-											7,
-											"e",
-											"x"
-										],
-										"live"
-									]
-								]]
-							]
-						],
-						[
-							2,
-							"bbMinY",
-							"=",
-							[
-								6,
-								"std.min",
-								["bbMinY", [
-									6,
-									"std.mix",
-									[
-										"posY",
-										[
-											7,
-											"e",
-											"y"
-										],
-										"live"
-									]
-								]]
-							]
-						],
-						[
-							2,
-							"bbMaxX",
-							"=",
-							[
-								6,
-								"std.max",
-								["bbMaxX", [
-									6,
-									"std.mix",
-									[
-										"posX",
-										[
-											7,
-											"e",
-											"x"
-										],
-										"live"
-									]
-								]]
-							]
-						],
-						[
-							2,
-							"bbMaxY",
-							"=",
-							[
-								6,
-								"std.max",
-								["bbMaxY", [
-									6,
-									"std.mix",
-									[
-										"posY",
-										[
-											7,
-											"e",
-											"y"
-										],
-										"live"
-									]
-								]]
-							]
-						]
-					]]
-				],
-				[
-					13,
-					"bbOut",
-					[
-						6,
-						"d.vec4f",
-						[
-							"bbMinX",
-							"bbMinY",
-							"bbMaxX",
-							"bbMaxY"
-						]
-					]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"trackLayout",
-								"$"
-							],
-							"next"
-						],
-						[
-							6,
-							"d.vec2u",
-							[[
-								6,
-								"d.u32",
-								["AABB_COL"]
-							], "ti"]
-						],
-						"bbOut"
-					]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"trackLayout",
-								"$"
-							],
-							"present"
-						],
-						[
-							6,
-							"d.vec2u",
-							[[
-								6,
-								"d.u32",
-								["AABB_COL"]
-							], "ti"]
-						],
-						"bbOut"
-					]
-				],
-				[
-					13,
-					"headOut",
-					[
-						6,
-						"d.vec4f",
-						[
-							"posX",
-							"posY",
-							"frame",
-							[
-								1,
-								"genStart",
-								"+",
-								[5, "1"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"metaOut",
-					[
-						6,
-						"d.vec4f",
-						[
-							"missStreak",
-							"sumW",
-							"gen",
-							"crowdStreak"
-						]
-					]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"trackLayout",
-								"$"
-							],
-							"next"
-						],
-						[
-							6,
-							"d.vec2u",
-							[[
-								6,
-								"d.u32",
-								[[5, "0"]]
-							], "ti"]
-						],
-						"headOut"
-					]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"trackLayout",
-								"$"
-							],
-							"present"
-						],
-						[
-							6,
-							"d.vec2u",
-							[[
-								6,
-								"d.u32",
-								[[5, "0"]]
-							], "ti"]
-						],
-						"headOut"
-					]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"trackLayout",
-								"$"
-							],
-							"next"
-						],
-						[
-							6,
-							"d.vec2u",
-							[[
-								6,
-								"d.u32",
-								[[5, "1"]]
-							], "ti"]
-						],
-						"metaOut"
-					]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"trackLayout",
-								"$"
-							],
-							"present"
-						],
-						[
-							6,
-							"d.vec2u",
-							[[
-								6,
-								"d.u32",
-								[[5, "1"]]
-							], "ti"]
-						],
-						"metaOut"
-					]
-				]
-			]]
-		},
-		externals: {
-			"trackLayout": () => trackLayout,
-			"d.f32": () => f32,
-			"std.textureLoad": () => textureLoad,
-			"d.vec2u": () => vec2u,
-			"d.u32": () => u32,
-			"trackHash": () => trackHash,
-			"std.max": () => max,
-			"std.textureDimensions": () => textureDimensions,
-			"std.clamp": () => clamp,
-			"score": () => score,
-			"std.select": () => select,
-			"std.exp": () => exp,
-			"std.sqrt": () => sqrt,
-			"FEAT_GRID": () => FEAT_GRID,
-			"TWO_PI": () => TWO_PI,
-			"std.sin": () => sin,
-			"std.cos": () => cos,
-			"std.min": () => min,
-			"d.i32": () => i32,
-			"std.floor": () => floor,
-			"TRAIL_EVERY": () => TRAIL_EVERY,
-			"TRAIL_LEN": () => TRAIL_LEN,
-			"std.abs": () => abs,
-			"std.mix": () => mix,
-			"d.vec4f": () => vec4f,
-			"std.textureStore": () => textureStore,
-			"AABB_COL": () => AABB_COL
-		}
-	}) && $.f)({})).$name("trackerPursuit");
-}
-function createTrackerPursuitSim(slots) {
-	return (params) => {
-		const { childNode, gpu, getCpuValue } = params;
-		if (!childNode) return null;
-		const root = gpu?.root;
-		if (!root) return null;
-		const scoreFn = featureScoreFn(slots.mode);
-		const featureKernel = buildFeatureGridKernel(scoreFn);
-		const trackKernel = buildPursuitKernel(slots.mode, scoreFn);
-		const paramsBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(TrackParams), "paramsBuf");
-		const sim = createFeedbackTrailSim(params, {
-			size: [STATE_W, MAX_TRACKERS],
-			format: STATE_FORMAT,
-			textures: { grid: FEAT_GRID },
-			bindGroups: ({ childTexture, display, textures }, read, write) => root.createBindGroup(trackLayout, {
-				src: childTexture,
-				featGrid: textures.grid,
-				prev: read.state,
-				next: write.state,
-				present: display,
-				params: paramsBuf.buffer
-			}),
-			staticGroups: ({ childTexture, textures }) => root.createBindGroup(featureLayout, {
-				src: childTexture,
-				grid: textures.grid,
-				params: paramsBuf.buffer
-			})
-		});
-		if (!sim) return null;
-		const featurePipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
-			"use gpu";
-			featureKernel(gx, gy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "gx"
-				}, {
-					"type": "i",
-					"name": "gy"
-				}],
-				"body": [0, [[
-					6,
-					"featureKernel",
-					["gx", "gy"]
-				]]]
-			},
-			externals: { "featureKernel": () => featureKernel }
-		}) && $.f)({}), { size: [FEAT_GRID, FEAT_GRID] });
-		const simPipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ti) => {
-			"use gpu";
-			trackKernel(ti);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "ti"
-				}],
-				"body": [0, [[
-					6,
-					"trackKernel",
-					["ti"]
-				]]]
-			},
-			externals: { "trackKernel": () => trackKernel }
-		}) && $.f)({}), { size: [MAX_TRACKERS] });
-		return {
-			outputs: {
-				childTexture: sim.childTexture,
-				trackState: sim.display
-			},
-			bindInputs: sim.bindInputs,
-			getComputeNodes: (frameParams) => sim.tick(frameParams, ({ groups, shared, dt }) => {
-				paramsBuf.write({
-					dt,
-					trackersF: getCpuValue(slots.trackers) ?? 4,
-					agility: getCpuValue(slots.agility) ?? .5,
-					threshold: getCpuValue(slots.threshold) ?? .15,
-					variance: getCpuValue(slots.variance) ?? .5,
-					lifespan: getCpuValue(slots.lifespan) ?? 6
-				});
-				return [featurePipeline.with(shared), simPipeline.with(groups)];
-			})
-		};
-	};
-}
-var num = (v, f) => typeof v === "number" ? v : f;
-var DETECTION_REFERENCE_HEIGHT = 1080;
-function detectionOverlay(slots) {
-	return (params) => {
-		const { uniforms, ctx, childNode, convertToTexture, propValues } = params;
-		if (!childNode) return ZERO;
-		const texKey = convertToTexture(childNode).key;
-		const modeMap = {
-			alpha: 0,
-			bright: 1,
-			dark: 2,
-			red: 3,
-			green: 4,
-			blue: 5
-		};
-		const layoutMap = {
-			grid: 0,
-			quadtree: 1,
-			mosaic: 2
-		};
-		const labelMap = {
-			none: 0,
-			dimensions: 1,
-			percentage: 2
-		};
-		const posMap = {
-			"bottom-left": 0,
-			"bottom-right": 1,
-			"top-left": 2,
-			"top-right": 3
-		};
-		const rawMode = propValues[slots.detectionMode.name];
-		const modeStr = [
-			"alpha",
-			"bright",
-			"dark",
-			"red",
-			"green",
-			"blue"
-		][typeof rawMode === "number" ? rawMode : modeMap[rawMode] ?? 1];
-		const rawLayout = propValues[slots.layout.name];
-		const layoutStr = [
-			"grid",
-			"quadtree",
-			"mosaic"
-		][typeof rawLayout === "number" ? rawLayout : layoutMap[rawLayout] ?? 2];
-		let D = Math.round(num(propValues[slots.maxDepth.name], 2));
-		if (!Number.isFinite(D)) D = 2;
-		D = Math.max(0, Math.min(5, D));
-		if (layoutStr === "grid") D = 0;
-		const rawBox = propValues[slots.boxStyle.name];
-		const cornerStyle = (typeof rawBox === "string" ? rawBox : "corners") === "corners";
-		const rawLabel = propValues[slots.labelMode.name];
-		const labelStr = [
-			"none",
-			"dimensions",
-			"percentage"
-		][typeof rawLabel === "number" ? rawLabel : labelMap[rawLabel] ?? 0];
-		const labelsOn = labelStr !== "none";
-		const rawPos = propValues[slots.labelPosition.name];
-		const labelPos = typeof rawPos === "number" ? rawPos : posMap[rawPos] ?? 1;
-		const atlasKey = labelsOn ? createGlyphStripAtlas(params, {
-			label: "DetectionOverlay:atlas",
-			familyProp: slots.fontFamily.name,
-			weightProp: slots.fontWeight.name
-		}).key : void 0;
-		return new Expr((ec) => {
-			const p = ec.freshLocal("ot");
-			const s = [];
-			const f = {
-				p,
-				U: (name) => uniforms[slots[name].name]._emit(ec),
-				L: (n) => formatFloat(n),
-				s,
-				sampleChild: (uvWgsl) => `textureSampleLevel(tex.$.${texKey}, samp.$.linearClamp, ${uvWgsl}, 0.0)`,
-				UN: ec.external(unpremultiplyAlpha, "unpremultiplyAlpha"),
-				modeStr
-			};
-			const { U, L: L$1 } = f;
-			s.push(`let ${p}_res = ${ctx.logicalViewportSize._emit(ec)};`);
-			s.push(`let ${p}_scaleFactor = ${p}_res.y / ${L$1(DETECTION_REFERENCE_HEIGHT)};`);
-			const uvE = ctx.uv._emit(ec);
-			s.push(`let ${p}_fragPx = vec2f((${uvE}).x * ${p}_res.x, (${uvE}).y * ${p}_res.y);`);
-			s.push(`let ${p}_aa = max(max(fwidth(${p}_fragPx.x), fwidth(${p}_fragPx.y)), ${L$1(1e-4)});`);
-			s.push(`let ${p}_cellPx = max(${U("cellSize")} * ${p}_scaleFactor, ${L$1(4)});`);
-			s.push(`let ${p}_minSize = ${L$1(3)} * ${p}_scaleFactor;`);
-			s.push(`let ${p}_lineHalf = max(${U("lineWidth")} * ${p}_scaleFactor * ${L$1(.5)}, ${L$1(.5)});`);
-			s.push(`let ${p}_cornerRadiusPx = ${U("cornerRadius")} * ${p}_scaleFactor;`);
-			s.push(`let ${p}_boxInset = ${p}_lineHalf + ${p}_scaleFactor * ${L$1(1.5)};`);
-			s.push(`let ${p}_thr = ${U("threshold")};`);
-			partitionWalkStmts(f, layoutStr, D);
-			contentBBoxStmts(f);
-			s.push(`var ${p}_dst = ${f.sampleChild(`(${uvE})`)};`);
-			detectionBoxStmts(f, cornerStyle);
-			if (labelsOn && atlasKey) glyphPillLabelStmts(f, {
-				labelStr,
-				labelPos,
-				atlasKey
-			});
-			for (const line of s) ec.statement(line);
-			return straightFromPremul(`${p}_dst`);
-		});
-	};
-}
-function motionTrackerHud(slots) {
-	return (params) => {
-		const { uniforms, ctx, childNode, convertToTexture, computeOutputs } = params;
-		if (!childNode) return ZERO;
-		const texKey = (computeOutputs?.childTexture ?? convertToTexture(childNode)).key;
-		const stateKit = computeOutputs?.trackState;
-		return new Expr((ec) => {
-			const p = ec.freshLocal("kft");
-			const s = [];
-			const f = {
-				p,
-				U: (name) => uniforms[slots[name].name]._emit(ec),
-				L: (n) => formatFloat(n),
-				s
-			};
-			const { U, L: L$1 } = f;
-			const uvE = ctx.uv._emit(ec);
-			s.push(`let ${p}_res = ${ctx.logicalViewportSize._emit(ec)};`);
-			s.push(`let ${p}_sf = ${p}_res.y / ${L$1(DETECTION_REFERENCE_HEIGHT)};`);
-			s.push(`let ${p}_px = vec2f((${uvE}).x * ${p}_res.x, (${uvE}).y * ${p}_res.y);`);
-			s.push(`let ${p}_aa = max(max(fwidth(${p}_px.x), fwidth(${p}_px.y)), ${L$1(1e-4)});`);
-			s.push(`let ${p}_lw = max(${U("lineWidth")} * ${p}_sf, ${L$1(.5)});`);
-			s.push(`let ${p}_ms = max(${U("markerSize")} * ${p}_sf, ${L$1(4)});`);
-			s.push(`var ${p}_dst = textureSampleLevel(tex.$.${texKey}, samp.$.linearClamp, (${uvE}), 0.0);`);
-			if (stateKit) {
-				const stateKey = stateKit.key;
-				const load = (col) => `textureLoad(tex.$.${stateKey}, vec2u(${col}, ti), 0)`;
-				s.push(`let ${p}_n = u32(clamp(${U("trackers")}, ${L$1(1)}, ${L$1(64)}));`);
-				s.push(`for (var ti = 0u; ti < ${p}_n; ti = ti + 1u) {`);
-				s.push(`let head = ${load("0u")};`);
-				s.push(`if (head.w < 0.5) { continue; }`);
-				s.push(`let bb = ${load(`14u`)};`);
-				s.push(`let pad = ${p}_ms + ${p}_lw * ${L$1(4)} + ${p}_aa * ${L$1(2)};`);
-				s.push(`let bbMin = vec2f(bb.x * ${p}_res.x, bb.y * ${p}_res.y) - vec2f(pad);`);
-				s.push(`let bbMax = vec2f(bb.z * ${p}_res.x, bb.w * ${p}_res.y) + vec2f(pad);`);
-				s.push(`if (all(${p}_px >= bbMin) && all(${p}_px <= bbMax)) {`);
-				s.push(`let mta = ${load("1u")};`);
-				s.push(`let tp = vec2f(head.x * ${p}_res.x, head.y * ${p}_res.y);`);
-				s.push(`let searching = select(${L$1(1)}, ${L$1(.45)}, mta.x > ${L$1(4)});`);
-				ringTrailStmts(f, {
-					len: 12,
-					every: 8,
-					load,
-					stages: [diamondStamp, pathSegmentStamp(8)]
-				});
-				bracketGizmo(f);
-				s.push(`}`);
-				s.push(`}`);
-			}
-			for (const line of s) ec.statement(line);
-			return straightFromPremul(`${p}_dst`);
-		});
-	};
-}
-export { motionTrackerHud as n, createTrackerPursuitSim as r, detectionOverlay as t };