shaders 3.1.463 → 3.2.465

package/dist/core/stylize-AZmEMszr.js

@@ -0,0 +1,4541 @@
+import { $n as clamp, An as DEG_TO_RAD, Br as f32, En as value12, Et as unpremultiplyAlpha, Jn as select, Nr as struct, Pn as TAU, Tr as vec4f, Yn as abs, Zn as atan2, _r as smoothstep, ar as floor, at as asLocal, cr as max, er as cos, fr as pow, ft as vec4, gr as sin, lr as min, lt as expr, mn as hash12, nr as dot, o as uniformOf, or as fract, ot as call, rt as ZERO, sr as length, ur as mix, ut as floatE, vn as mxNoiseFloat2, vr as sqrt, wr as vec3f, xr as vec2f, yr as step, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { n as gather } from "./filter-VJlLs3Zs.js";
+const watercolorUvBase = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, bleed, time) => {
+	"use gpu";
+	const t = __tsover_mul(time, .03);
+	const wob = vec2f(value12(uv.mul(5).add(vec2f(t, t))), value12(uv.mul(5).add(vec2f(31.4, 31.4)).add(vec2f(t, t)))).sub(vec2f(.5, .5));
+	const texel = vec2f(__tsover_div(1, viewport.x), __tsover_div(1, viewport.y));
+	return uv.add(wob.mul(bleed).mul(texel).mul(8));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "bleed"
+			},
+			{
+				"type": "i",
+				"name": "time"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"t",
+				[
+					1,
+					"time",
+					"*",
+					[5, "0.03"]
+				]
+			],
+			[
+				13,
+				"wob",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							"d.vec2f",
+							[[
+								6,
+								"noise.value12",
+								[[
+									6,
+									[
+										7,
+										[
+											6,
+											[
+												7,
+												"uv",
+												"mul"
+											],
+											[[5, "5"]]
+										],
+										"add"
+									],
+									[[
+										6,
+										"d.vec2f",
+										["t", "t"]
+									]]
+								]]
+							], [
+								6,
+								"noise.value12",
+								[[
+									6,
+									[
+										7,
+										[
+											6,
+											[
+												7,
+												[
+													6,
+													[
+														7,
+														"uv",
+														"mul"
+													],
+													[[5, "5"]]
+												],
+												"add"
+											],
+											[[
+												6,
+												"d.vec2f",
+												[[5, "31.4"], [5, "31.4"]]
+											]]
+										],
+										"add"
+									],
+									[[
+										6,
+										"d.vec2f",
+										["t", "t"]
+									]]
+								]]
+							]]
+						],
+						"sub"
+					],
+					[[
+						6,
+						"d.vec2f",
+						[[5, "0.5"], [5, "0.5"]]
+					]]
+				]
+			],
+			[
+				13,
+				"texel",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[5, "1"],
+						"/",
+						[
+							7,
+							"viewport",
+							"x"
+						]
+					], [
+						1,
+						[5, "1"],
+						"/",
+						[
+							7,
+							"viewport",
+							"y"
+						]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"uv",
+					"add"
+				],
+				[[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"wob",
+										"mul"
+									],
+									["bleed"]
+								],
+								"mul"
+							],
+							["texel"]
+						],
+						"mul"
+					],
+					[[5, "8"]]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"noise.value12": () => value12
+	}
+}) && $.f)({}));
+const watercolorTapUV = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvBase, viewport, ox, oy) => {
+	"use gpu";
+	return vec2f(__tsover_add(uvBase.x, __tsover_div(ox, viewport.x)), __tsover_add(uvBase.y, __tsover_div(oy, viewport.y)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uvBase"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "ox"
+			},
+			{
+				"type": "i",
+				"name": "oy"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"d.vec2f",
+			[[
+				1,
+				[
+					7,
+					"uvBase",
+					"x"
+				],
+				"+",
+				[
+					1,
+					"ox",
+					"/",
+					[
+						7,
+						"viewport",
+						"x"
+					]
+				]
+			], [
+				1,
+				[
+					7,
+					"uvBase",
+					"y"
+				],
+				"+",
+				[
+					1,
+					"oy",
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
+				]
+			]]
+		]]]]
+	},
+	externals: { "d.vec2f": () => vec2f }
+}) && $.f)({}));
+const watercolorGrain = typegpu_default.fn([vec2f, vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport) => {
+	"use gpu";
+	return value12(uv.mul(viewport).mul(.5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}, {
+			"type": "i",
+			"name": "viewport"
+		}],
+		"body": [0, [[10, [
+			6,
+			"noise.value12",
+			[[
+				6,
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"uv",
+							"mul"
+						],
+						["viewport"]
+					],
+					"mul"
+				],
+				[[5, "0.5"]]
+			]]
+		]]]]
+	},
+	externals: { "noise.value12": () => value12 }
+}) && $.f)({}));
+const watercolorCompose = typegpu_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f,
+	f32,
+	vec4f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sum0, sum1, sum2, sum3, sq0, sq1, sq2, sq3, invN, originalBleed, paperColor, paper, strength, grain) => {
+	"use gpu";
+	const mean0 = sum0.mul(invN);
+	const mean1 = sum1.mul(invN);
+	const mean2 = sum2.mul(invN);
+	const mean3 = sum3.mul(invN);
+	const rgb0 = vec3f(mean0.x, mean0.y, mean0.z);
+	const rgb1 = vec3f(mean1.x, mean1.y, mean1.z);
+	const rgb2 = vec3f(mean2.x, mean2.y, mean2.z);
+	const rgb3 = vec3f(mean3.x, mean3.y, mean3.z);
+	const var0 = sq0.mul(invN).sub(rgb0.mul(rgb0));
+	const var1 = sq1.mul(invN).sub(rgb1.mul(rgb1));
+	const var2 = sq2.mul(invN).sub(rgb2.mul(rgb2));
+	const var3 = sq3.mul(invN).sub(rgb3.mul(rgb3));
+	const sigma0 = __tsover_add(__tsover_add(var0.x, var0.y), var0.z);
+	const sigma1 = __tsover_add(__tsover_add(var1.x, var1.y), var1.z);
+	const sigma2 = __tsover_add(__tsover_add(var2.x, var2.y), var2.z);
+	const sigma3 = __tsover_add(__tsover_add(var3.x, var3.y), var3.z);
+	let picked = vec4f(mean0.x, mean0.y, mean0.z, mean0.w);
+	let best = sigma0;
+	picked = select(picked, mean1, sigma1 < best);
+	best = min(best, sigma1);
+	picked = select(picked, mean2, sigma2 < best);
+	best = min(best, sigma2);
+	picked = select(picked, mean3, sigma3 < best);
+	best = min(best, sigma3);
+	const straight = unpremultiplyAlpha(picked);
+	let result = vec3f(straight.x, straight.y, straight.z);
+	const paperMul = mix(1, grain, paper);
+	const paperTint = vec3f(paperColor.x, paperColor.y, paperColor.z);
+	result = mix(result.mul(paperMul), result.mul(paperTint), vec3f(__tsover_mul(paper, .4)));
+	return mix(vec3f(originalBleed.x, originalBleed.y, originalBleed.z), result, vec3f(strength));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sum0"
+			},
+			{
+				"type": "i",
+				"name": "sum1"
+			},
+			{
+				"type": "i",
+				"name": "sum2"
+			},
+			{
+				"type": "i",
+				"name": "sum3"
+			},
+			{
+				"type": "i",
+				"name": "sq0"
+			},
+			{
+				"type": "i",
+				"name": "sq1"
+			},
+			{
+				"type": "i",
+				"name": "sq2"
+			},
+			{
+				"type": "i",
+				"name": "sq3"
+			},
+			{
+				"type": "i",
+				"name": "invN"
+			},
+			{
+				"type": "i",
+				"name": "originalBleed"
+			},
+			{
+				"type": "i",
+				"name": "paperColor"
+			},
+			{
+				"type": "i",
+				"name": "paper"
+			},
+			{
+				"type": "i",
+				"name": "strength"
+			},
+			{
+				"type": "i",
+				"name": "grain"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"mean0",
+				[
+					6,
+					[
+						7,
+						"sum0",
+						"mul"
+					],
+					["invN"]
+				]
+			],
+			[
+				13,
+				"mean1",
+				[
+					6,
+					[
+						7,
+						"sum1",
+						"mul"
+					],
+					["invN"]
+				]
+			],
+			[
+				13,
+				"mean2",
+				[
+					6,
+					[
+						7,
+						"sum2",
+						"mul"
+					],
+					["invN"]
+				]
+			],
+			[
+				13,
+				"mean3",
+				[
+					6,
+					[
+						7,
+						"sum3",
+						"mul"
+					],
+					["invN"]
+				]
+			],
+			[
+				13,
+				"rgb0",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							7,
+							"mean0",
+							"x"
+						],
+						[
+							7,
+							"mean0",
+							"y"
+						],
+						[
+							7,
+							"mean0",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rgb1",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							7,
+							"mean1",
+							"x"
+						],
+						[
+							7,
+							"mean1",
+							"y"
+						],
+						[
+							7,
+							"mean1",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rgb2",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							7,
+							"mean2",
+							"x"
+						],
+						[
+							7,
+							"mean2",
+							"y"
+						],
+						[
+							7,
+							"mean2",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rgb3",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							7,
+							"mean3",
+							"x"
+						],
+						[
+							7,
+							"mean3",
+							"y"
+						],
+						[
+							7,
+							"mean3",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"var0",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"sq0",
+								"mul"
+							],
+							["invN"]
+						],
+						"sub"
+					],
+					[[
+						6,
+						[
+							7,
+							"rgb0",
+							"mul"
+						],
+						["rgb0"]
+					]]
+				]
+			],
+			[
+				13,
+				"var1",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"sq1",
+								"mul"
+							],
+							["invN"]
+						],
+						"sub"
+					],
+					[[
+						6,
+						[
+							7,
+							"rgb1",
+							"mul"
+						],
+						["rgb1"]
+					]]
+				]
+			],
+			[
+				13,
+				"var2",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"sq2",
+								"mul"
+							],
+							["invN"]
+						],
+						"sub"
+					],
+					[[
+						6,
+						[
+							7,
+							"rgb2",
+							"mul"
+						],
+						["rgb2"]
+					]]
+				]
+			],
+			[
+				13,
+				"var3",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"sq3",
+								"mul"
+							],
+							["invN"]
+						],
+						"sub"
+					],
+					[[
+						6,
+						[
+							7,
+							"rgb3",
+							"mul"
+						],
+						["rgb3"]
+					]]
+				]
+			],
+			[
+				13,
+				"sigma0",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"var0",
+							"x"
+						],
+						"+",
+						[
+							7,
+							"var0",
+							"y"
+						]
+					],
+					"+",
+					[
+						7,
+						"var0",
+						"z"
+					]
+				]
+			],
+			[
+				13,
+				"sigma1",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"var1",
+							"x"
+						],
+						"+",
+						[
+							7,
+							"var1",
+							"y"
+						]
+					],
+					"+",
+					[
+						7,
+						"var1",
+						"z"
+					]
+				]
+			],
+			[
+				13,
+				"sigma2",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"var2",
+							"x"
+						],
+						"+",
+						[
+							7,
+							"var2",
+							"y"
+						]
+					],
+					"+",
+					[
+						7,
+						"var2",
+						"z"
+					]
+				]
+			],
+			[
+				13,
+				"sigma3",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"var3",
+							"x"
+						],
+						"+",
+						[
+							7,
+							"var3",
+							"y"
+						]
+					],
+					"+",
+					[
+						7,
+						"var3",
+						"z"
+					]
+				]
+			],
+			[
+				12,
+				"picked",
+				[
+					6,
+					"d.vec4f",
+					[
+						[
+							7,
+							"mean0",
+							"x"
+						],
+						[
+							7,
+							"mean0",
+							"y"
+						],
+						[
+							7,
+							"mean0",
+							"z"
+						],
+						[
+							7,
+							"mean0",
+							"w"
+						]
+					]
+				]
+			],
+			[
+				12,
+				"best",
+				"sigma0"
+			],
+			[
+				2,
+				"picked",
+				"=",
+				[
+					6,
+					"std.select",
+					[
+						"picked",
+						"mean1",
+						[
+							1,
+							"sigma1",
+							"<",
+							"best"
+						]
+					]
+				]
+			],
+			[
+				2,
+				"best",
+				"=",
+				[
+					6,
+					"std.min",
+					["best", "sigma1"]
+				]
+			],
+			[
+				2,
+				"picked",
+				"=",
+				[
+					6,
+					"std.select",
+					[
+						"picked",
+						"mean2",
+						[
+							1,
+							"sigma2",
+							"<",
+							"best"
+						]
+					]
+				]
+			],
+			[
+				2,
+				"best",
+				"=",
+				[
+					6,
+					"std.min",
+					["best", "sigma2"]
+				]
+			],
+			[
+				2,
+				"picked",
+				"=",
+				[
+					6,
+					"std.select",
+					[
+						"picked",
+						"mean3",
+						[
+							1,
+							"sigma3",
+							"<",
+							"best"
+						]
+					]
+				]
+			],
+			[
+				2,
+				"best",
+				"=",
+				[
+					6,
+					"std.min",
+					["best", "sigma3"]
+				]
+			],
+			[
+				13,
+				"straight",
+				[
+					6,
+					"blend.unpremultiplyAlpha",
+					["picked"]
+				]
+			],
+			[
+				12,
+				"result",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							7,
+							"straight",
+							"x"
+						],
+						[
+							7,
+							"straight",
+							"y"
+						],
+						[
+							7,
+							"straight",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"paperMul",
+				[
+					6,
+					"std.mix",
+					[
+						[5, "1"],
+						"grain",
+						"paper"
+					]
+				]
+			],
+			[
+				13,
+				"paperTint",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							7,
+							"paperColor",
+							"x"
+						],
+						[
+							7,
+							"paperColor",
+							"y"
+						],
+						[
+							7,
+							"paperColor",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				2,
+				"result",
+				"=",
+				[
+					6,
+					"std.mix",
+					[
+						[
+							6,
+							[
+								7,
+								"result",
+								"mul"
+							],
+							["paperMul"]
+						],
+						[
+							6,
+							[
+								7,
+								"result",
+								"mul"
+							],
+							["paperTint"]
+						],
+						[
+							6,
+							"d.vec3f",
+							[[
+								1,
+								"paper",
+								"*",
+								[5, "0.4"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"origRgb",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							7,
+							"originalBleed",
+							"x"
+						],
+						[
+							7,
+							"originalBleed",
+							"y"
+						],
+						[
+							7,
+							"originalBleed",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"finalRGB",
+				[
+					6,
+					"std.mix",
+					[
+						"origRgb",
+						"result",
+						[
+							6,
+							"d.vec3f",
+							["strength"]
+						]
+					]
+				]
+			],
+			[10, "finalRGB"]
+		]]
+	},
+	externals: {
+		"d.vec3f": () => vec3f,
+		"d.vec4f": () => vec4f,
+		"std.select": () => select,
+		"std.min": () => min,
+		"blend.unpremultiplyAlpha": () => unpremultiplyAlpha,
+		"std.mix": () => mix
+	}
+}) && $.f)({}));
+var SIN_045 = Math.sin(.785);
+var COS_045 = Math.cos(.785);
+var SIN_N45 = Math.sin(-.785);
+var COS_N45 = Math.cos(-.785);
+var chalkHash21 = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+	"use gpu";
+	return hash12(p);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}],
+		"body": [0, [[10, [
+			6,
+			"noise.hash12",
+			["p"]
+		]]]]
+	},
+	externals: { "noise.hash12": () => hash12 }
+}) && $.f)({}));
+var chalkVnoise = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+	"use gpu";
+	const i = floor(p);
+	const f = fract(p);
+	const u = f.mul(f).mul(f.mul(-2).add(3));
+	const a = chalkHash21(i);
+	const b = chalkHash21(vec2f(__tsover_add(i.x, 1), i.y));
+	const c = chalkHash21(vec2f(i.x, __tsover_add(i.y, 1)));
+	const dd = chalkHash21(vec2f(__tsover_add(i.x, 1), __tsover_add(i.y, 1)));
+	return mix(mix(a, b, u.x), mix(c, dd, u.x), u.y);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}],
+		"body": [0, [
+			[
+				13,
+				"i",
+				[
+					6,
+					"std.floor",
+					["p"]
+				]
+			],
+			[
+				13,
+				"f",
+				[
+					6,
+					"std.fract",
+					["p"]
+				]
+			],
+			[
+				13,
+				"u",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"f",
+								"mul"
+							],
+							["f"]
+						],
+						"mul"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"f",
+									"mul"
+								],
+								[[
+									4,
+									"-",
+									[5, "2"]
+								]]
+							],
+							"add"
+						],
+						[[5, "3"]]
+					]]
+				]
+			],
+			[
+				13,
+				"a",
+				[
+					6,
+					"chalkHash21",
+					["i"]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					6,
+					"chalkHash21",
+					[[
+						6,
+						"d.vec2f",
+						[[
+							1,
+							[
+								7,
+								"i",
+								"x"
+							],
+							"+",
+							[5, "1"]
+						], [
+							7,
+							"i",
+							"y"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"c",
+				[
+					6,
+					"chalkHash21",
+					[[
+						6,
+						"d.vec2f",
+						[[
+							7,
+							"i",
+							"x"
+						], [
+							1,
+							[
+								7,
+								"i",
+								"y"
+							],
+							"+",
+							[5, "1"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"dd",
+				[
+					6,
+					"chalkHash21",
+					[[
+						6,
+						"d.vec2f",
+						[[
+							1,
+							[
+								7,
+								"i",
+								"x"
+							],
+							"+",
+							[5, "1"]
+						], [
+							1,
+							[
+								7,
+								"i",
+								"y"
+							],
+							"+",
+							[5, "1"]
+						]]
+					]]
+				]
+			],
+			[10, [
+				6,
+				"std.mix",
+				[
+					[
+						6,
+						"std.mix",
+						[
+							"a",
+							"b",
+							[
+								7,
+								"u",
+								"x"
+							]
+						]
+					],
+					[
+						6,
+						"std.mix",
+						[
+							"c",
+							"dd",
+							[
+								7,
+								"u",
+								"x"
+							]
+						]
+					],
+					[
+						7,
+						"u",
+						"y"
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.floor": () => floor,
+		"std.fract": () => fract,
+		"chalkHash21": () => chalkHash21,
+		"d.vec2f": () => vec2f,
+		"std.mix": () => mix
+	}
+}) && $.f)({}));
+const chalkLuma = typegpu_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
+	"use gpu";
+	return dot(vec3f(color.x, color.y, color.z), vec3f(.299, .587, .114));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "color"
+		}],
+		"body": [0, [[10, [
+			6,
+			"std.dot",
+			[[
+				6,
+				"d.vec3f",
+				[
+					[
+						7,
+						"color",
+						"x"
+					],
+					[
+						7,
+						"color",
+						"y"
+					],
+					[
+						7,
+						"color",
+						"z"
+					]
+				]
+			], [
+				6,
+				"d.vec3f",
+				[
+					[5, "0.299"],
+					[5, "0.587"],
+					[5, "0.114"]
+				]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.dot": () => dot,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const chalkOffsetUV = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, edgeThickness, ox, oy) => {
+	"use gpu";
+	const texelX = __tsover_div(1, viewport.x);
+	const texelY = __tsover_div(1, viewport.y);
+	return vec2f(__tsover_add(uv.x, __tsover_mul(__tsover_mul(texelX, edgeThickness), ox)), __tsover_add(uv.y, __tsover_mul(__tsover_mul(texelY, edgeThickness), oy)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "edgeThickness"
+			},
+			{
+				"type": "i",
+				"name": "ox"
+			},
+			{
+				"type": "i",
+				"name": "oy"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"texelX",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						7,
+						"viewport",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"texelY",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							"texelX",
+							"*",
+							"edgeThickness"
+						],
+						"*",
+						"ox"
+					]
+				], [
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							"texelY",
+							"*",
+							"edgeThickness"
+						],
+						"*",
+						"oy"
+					]
+				]]
+			]]
+		]]
+	},
+	externals: { "d.vec2f": () => vec2f }
+}) && $.f)({}));
+var chalkHatchLine = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((P, hatchScale, shade, sa, ca, thr) => {
+	"use gpu";
+	const ry = __tsover_add(__tsover_mul(P.x, sa), __tsover_mul(P.y, ca));
+	const hl = __tsover_mul(abs(__tsover_sub(fract(__tsover_div(ry, hatchScale)), .5)), 2);
+	const line = __tsover_sub(1, smoothstep(0, .35, hl));
+	return __tsover_mul(line, step(thr, shade));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "P"
+			},
+			{
+				"type": "i",
+				"name": "hatchScale"
+			},
+			{
+				"type": "i",
+				"name": "shade"
+			},
+			{
+				"type": "i",
+				"name": "sa"
+			},
+			{
+				"type": "i",
+				"name": "ca"
+			},
+			{
+				"type": "i",
+				"name": "thr"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ry",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"P",
+							"x"
+						],
+						"*",
+						"sa"
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"P",
+							"y"
+						],
+						"*",
+						"ca"
+					]
+				]
+			],
+			[
+				13,
+				"hl",
+				[
+					1,
+					[
+						6,
+						"std.abs",
+						[[
+							1,
+							[
+								6,
+								"std.fract",
+								[[
+									1,
+									"ry",
+									"/",
+									"hatchScale"
+								]]
+							],
+							"-",
+							[5, "0.5"]
+						]]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[
+				13,
+				"line",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						"std.smoothstep",
+						[
+							[5, "0"],
+							[5, "0.35"],
+							"hl"
+						]
+					]
+				]
+			],
+			[10, [
+				1,
+				"line",
+				"*",
+				[
+					6,
+					"std.step",
+					["thr", "shade"]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.abs": () => abs,
+		"std.fract": () => fract,
+		"std.smoothstep": () => smoothstep,
+		"std.step": () => step
+	}
+}) && $.f)({}));
+const chalkboardCompose = typegpu_default.fn([
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sobelA, sobelB, uv, viewport, misc, params, boardColor, chalkColor) => {
+	"use gpu";
+	const tl = sobelA.x;
+	const t = sobelA.y;
+	const tr = sobelA.z;
+	const l = sobelA.w;
+	const r = sobelB.x;
+	const bl = sobelB.y;
+	const bo = sobelB.z;
+	const br = sobelB.w;
+	const centerLum = misc.x;
+	const centerAlpha = misc.y;
+	const edgeSensitivity = params.x;
+	const hatchScale = params.y;
+	const shading = params.z;
+	const grain = params.w;
+	const gx = __tsover_add(__tsover_add(__tsover_add(__tsover_sub(__tsover_sub(-tl, __tsover_mul(l, 2)), bl), tr), __tsover_mul(r, 2)), br);
+	const gy = __tsover_add(__tsover_add(__tsover_add(__tsover_sub(__tsover_sub(-tl, __tsover_mul(t, 2)), tr), bl), __tsover_mul(bo, 2)), br);
+	const edgeMag = sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy)));
+	const edgeHigh = mix(f32(1), .08, edgeSensitivity);
+	const edge = smoothstep(__tsover_mul(edgeHigh, .4), edgeHigh, edgeMag);
+	const shade = __tsover_sub(1, centerLum);
+	const P = uv.mul(viewport);
+	const hatch = __tsover_mul(max(max(chalkHatchLine(P, hatchScale, shade, SIN_045, COS_045, .22), chalkHatchLine(P, hatchScale, shade, SIN_N45, COS_N45, .5)), chalkHatchLine(P, hatchScale, shade, 0, 1, .78)), shading);
+	const dust = mix(__tsover_sub(1, grain), f32(1), chalkVnoise(P.mul(.5)));
+	const chalkMask = clamp(__tsover_mul(max(edge, hatch), dust), 0, 1);
+	const boardGrain = __tsover_mul(__tsover_sub(chalkVnoise(P.mul(.9)), .5), .04);
+	return vec4f(mix(boardColor.xyz.add(boardGrain), chalkColor.xyz, vec3f(chalkMask)), centerAlpha);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sobelA"
+			},
+			{
+				"type": "i",
+				"name": "sobelB"
+			},
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "misc"
+			},
+			{
+				"type": "i",
+				"name": "params"
+			},
+			{
+				"type": "i",
+				"name": "boardColor"
+			},
+			{
+				"type": "i",
+				"name": "chalkColor"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"tl",
+				[
+					7,
+					"sobelA",
+					"x"
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					7,
+					"sobelA",
+					"y"
+				]
+			],
+			[
+				13,
+				"tr",
+				[
+					7,
+					"sobelA",
+					"z"
+				]
+			],
+			[
+				13,
+				"l",
+				[
+					7,
+					"sobelA",
+					"w"
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					7,
+					"sobelB",
+					"x"
+				]
+			],
+			[
+				13,
+				"bl",
+				[
+					7,
+					"sobelB",
+					"y"
+				]
+			],
+			[
+				13,
+				"bo",
+				[
+					7,
+					"sobelB",
+					"z"
+				]
+			],
+			[
+				13,
+				"br",
+				[
+					7,
+					"sobelB",
+					"w"
+				]
+			],
+			[
+				13,
+				"centerLum",
+				[
+					7,
+					"misc",
+					"x"
+				]
+			],
+			[
+				13,
+				"centerAlpha",
+				[
+					7,
+					"misc",
+					"y"
+				]
+			],
+			[
+				13,
+				"edgeSensitivity",
+				[
+					7,
+					"params",
+					"x"
+				]
+			],
+			[
+				13,
+				"hatchScale",
+				[
+					7,
+					"params",
+					"y"
+				]
+			],
+			[
+				13,
+				"shading",
+				[
+					7,
+					"params",
+					"z"
+				]
+			],
+			[
+				13,
+				"grain",
+				[
+					7,
+					"params",
+					"w"
+				]
+			],
+			[
+				13,
+				"gx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										4,
+										"-",
+										"tl"
+									],
+									"-",
+									[
+										1,
+										"l",
+										"*",
+										[5, "2"]
+									]
+								],
+								"-",
+								"bl"
+							],
+							"+",
+							"tr"
+						],
+						"+",
+						[
+							1,
+							"r",
+							"*",
+							[5, "2"]
+						]
+					],
+					"+",
+					"br"
+				]
+			],
+			[
+				13,
+				"gy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										4,
+										"-",
+										"tl"
+									],
+									"-",
+									[
+										1,
+										"t",
+										"*",
+										[5, "2"]
+									]
+								],
+								"-",
+								"tr"
+							],
+							"+",
+							"bl"
+						],
+						"+",
+						[
+							1,
+							"bo",
+							"*",
+							[5, "2"]
+						]
+					],
+					"+",
+					"br"
+				]
+			],
+			[
+				13,
+				"edgeMag",
+				[
+					6,
+					"std.sqrt",
+					[[
+						1,
+						[
+							1,
+							"gx",
+							"*",
+							"gx"
+						],
+						"+",
+						[
+							1,
+							"gy",
+							"*",
+							"gy"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"edgeHigh",
+				[
+					6,
+					"std.mix",
+					[
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						[5, "0.08"],
+						"edgeSensitivity"
+					]
+				]
+			],
+			[
+				13,
+				"edge",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[
+							1,
+							"edgeHigh",
+							"*",
+							[5, "0.4"]
+						],
+						"edgeHigh",
+						"edgeMag"
+					]
+				]
+			],
+			[
+				13,
+				"shade",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"centerLum"
+				]
+			],
+			[
+				13,
+				"P",
+				[
+					6,
+					[
+						7,
+						"uv",
+						"mul"
+					],
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"hatch",
+				[
+					1,
+					[
+						6,
+						"std.max",
+						[[
+							6,
+							"std.max",
+							[[
+								6,
+								"chalkHatchLine",
+								[
+									"P",
+									"hatchScale",
+									"shade",
+									"SIN_045",
+									"COS_045",
+									[5, "0.22"]
+								]
+							], [
+								6,
+								"chalkHatchLine",
+								[
+									"P",
+									"hatchScale",
+									"shade",
+									"SIN_N45",
+									"COS_N45",
+									[5, "0.5"]
+								]
+							]]
+						], [
+							6,
+							"chalkHatchLine",
+							[
+								"P",
+								"hatchScale",
+								"shade",
+								[5, "0"],
+								[5, "1"],
+								[5, "0.78"]
+							]
+						]]
+					],
+					"*",
+					"shading"
+				]
+			],
+			[
+				13,
+				"dust",
+				[
+					6,
+					"std.mix",
+					[
+						[
+							1,
+							[5, "1"],
+							"-",
+							"grain"
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						[
+							6,
+							"chalkVnoise",
+							[[
+								6,
+								[
+									7,
+									"P",
+									"mul"
+								],
+								[[5, "0.5"]]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"chalkMask",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								6,
+								"std.max",
+								["edge", "hatch"]
+							],
+							"*",
+							"dust"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"boardGrain",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"chalkVnoise",
+							[[
+								6,
+								[
+									7,
+									"P",
+									"mul"
+								],
+								[[5, "0.9"]]
+							]]
+						],
+						"-",
+						[5, "0.5"]
+					],
+					"*",
+					[5, "0.04"]
+				]
+			],
+			[
+				13,
+				"boardRGB",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"boardColor",
+							"xyz"
+						],
+						"add"
+					],
+					["boardGrain"]
+				]
+			],
+			[
+				13,
+				"col",
+				[
+					6,
+					"std.mix",
+					[
+						"boardRGB",
+						[
+							7,
+							"chalkColor",
+							"xyz"
+						],
+						[
+							6,
+							"d.vec3f",
+							["chalkMask"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec4f",
+				["col", "centerAlpha"]
+			]]
+		]]
+	},
+	externals: {
+		"std.sqrt": () => sqrt,
+		"std.mix": () => mix,
+		"d.f32": () => f32,
+		"std.smoothstep": () => smoothstep,
+		"std.max": () => max,
+		"chalkHatchLine": () => chalkHatchLine,
+		"SIN_045": () => SIN_045,
+		"COS_045": () => COS_045,
+		"SIN_N45": () => SIN_N45,
+		"COS_N45": () => COS_N45,
+		"chalkVnoise": () => chalkVnoise,
+		"std.clamp": () => clamp,
+		"d.vec3f": () => vec3f,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({}));
+var REFERENCE_HEIGHT = 1080;
+var AsciiGrid = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	cellCenter: vec2f,
+	cellUV: vec2f,
+	isOutside: f32
+}), "AsciiGrid");
+const asciiGrid = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], AsciiGrid)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cellSize, spacing) => {
+	"use gpu";
+	const scaleFactor = __tsover_div(viewport.y, REFERENCE_HEIGHT);
+	const effectiveCellSize = __tsover_mul(cellSize, scaleFactor);
+	const mainGridSize = vec2f(__tsover_div(viewport.x, effectiveCellSize), __tsover_div(viewport.y, effectiveCellSize));
+	const gridCoords = vec2f(__tsover_mul(uv.x, mainGridSize.x), __tsover_mul(uv.y, mainGridSize.y));
+	const cellCoords = floor(gridCoords);
+	const rawCellUV = fract(gridCoords);
+	const centeredU = __tsover_sub(rawCellUV.x, .5);
+	const centeredV = __tsover_sub(rawCellUV.y, .5);
+	const cellUV = vec2f(__tsover_add(__tsover_div(centeredU, spacing), .5), __tsover_add(__tsover_div(centeredV, spacing), .5));
+	const half = __tsover_mul(spacing, .5);
+	const isOutside = select(f32(0), f32(1), abs(centeredU) > half || abs(centeredV) > half);
+	return AsciiGrid({
+		cellCenter: vec2f(__tsover_div(__tsover_add(cellCoords.x, .5), mainGridSize.x), __tsover_div(__tsover_add(cellCoords.y, .5), mainGridSize.y)),
+		cellUV,
+		isOutside
+	});
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "cellSize"
+			},
+			{
+				"type": "i",
+				"name": "spacing"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"scaleFactor",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"y"
+					],
+					"/",
+					"REFERENCE_HEIGHT"
+				]
+			],
+			[
+				13,
+				"effectiveCellSize",
+				[
+					1,
+					"cellSize",
+					"*",
+					"scaleFactor"
+				]
+			],
+			[
+				13,
+				"mainGridSize",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"viewport",
+							"x"
+						],
+						"/",
+						"effectiveCellSize"
+					], [
+						1,
+						[
+							7,
+							"viewport",
+							"y"
+						],
+						"/",
+						"effectiveCellSize"
+					]]
+				]
+			],
+			[
+				13,
+				"gridCoords",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						[
+							7,
+							"mainGridSize",
+							"x"
+						]
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"*",
+						[
+							7,
+							"mainGridSize",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"cellCoords",
+				[
+					6,
+					"std.floor",
+					["gridCoords"]
+				]
+			],
+			[
+				13,
+				"rawCellUV",
+				[
+					6,
+					"std.fract",
+					["gridCoords"]
+				]
+			],
+			[
+				13,
+				"centeredU",
+				[
+					1,
+					[
+						7,
+						"rawCellUV",
+						"x"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"centeredV",
+				[
+					1,
+					[
+						7,
+						"rawCellUV",
+						"y"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"cellUV",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							"centeredU",
+							"/",
+							"spacing"
+						],
+						"+",
+						[5, "0.5"]
+					], [
+						1,
+						[
+							1,
+							"centeredV",
+							"/",
+							"spacing"
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"half",
+				[
+					1,
+					"spacing",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"isOutside",
+				[
+					6,
+					"std.select",
+					[
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						[
+							3,
+							[
+								1,
+								[
+									6,
+									"std.abs",
+									["centeredU"]
+								],
+								">",
+								"half"
+							],
+							"||",
+							[
+								1,
+								[
+									6,
+									"std.abs",
+									["centeredV"]
+								],
+								">",
+								"half"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"cellCenter",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"cellCoords",
+								"x"
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							7,
+							"mainGridSize",
+							"x"
+						]
+					], [
+						1,
+						[
+							1,
+							[
+								7,
+								"cellCoords",
+								"y"
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							7,
+							"mainGridSize",
+							"y"
+						]
+					]]
+				]
+			],
+			[10, [
+				6,
+				"AsciiGrid",
+				[[104, {
+					"cellCenter": "cellCenter",
+					"cellUV": "cellUV",
+					"isOutside": "isOutside"
+				}]]
+			]]
+		]]
+	},
+	externals: {
+		"REFERENCE_HEIGHT": () => REFERENCE_HEIGHT,
+		"d.vec2f": () => vec2f,
+		"std.floor": () => floor,
+		"std.fract": () => fract,
+		"std.select": () => select,
+		"d.f32": () => f32,
+		"std.abs": () => abs,
+		"AsciiGrid": () => AsciiGrid
+	}
+}) && $.f)({})).$name("asciiGrid");
+const asciiAtlasUV = typegpu_default.fn([
+	vec3f,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cellRgb, gamma, charCount, atlasSize, atlasScale, cellUV) => {
+	"use gpu";
+	const adjustedBrightness = pow(dot(cellRgb, vec3f(.299, .587, .114)), gamma);
+	const invertedBrightness = __tsover_sub(1, adjustedBrightness);
+	const charIndex = clamp(floor(__tsover_mul(invertedBrightness, charCount)), 0, __tsover_sub(charCount, 1));
+	const atlasCol = __tsover_sub(charIndex, __tsover_mul(atlasSize, floor(__tsover_div(charIndex, atlasSize))));
+	const atlasRow = floor(__tsover_div(charIndex, atlasSize));
+	const atlasCellSize = __tsover_mul(__tsover_div(1, atlasSize), atlasScale);
+	const baseU = __tsover_mul(atlasCol, atlasCellSize);
+	const baseV = __tsover_mul(atlasRow, atlasCellSize);
+	return vec2f(__tsover_add(baseU, __tsover_mul(cellUV.x, atlasCellSize)), __tsover_add(baseV, __tsover_mul(cellUV.y, atlasCellSize)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "cellRgb"
+			},
+			{
+				"type": "i",
+				"name": "gamma"
+			},
+			{
+				"type": "i",
+				"name": "charCount"
+			},
+			{
+				"type": "i",
+				"name": "atlasSize"
+			},
+			{
+				"type": "i",
+				"name": "atlasScale"
+			},
+			{
+				"type": "i",
+				"name": "cellUV"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rawBrightness",
+				[
+					6,
+					"std.dot",
+					["cellRgb", [
+						6,
+						"d.vec3f",
+						[
+							[5, "0.299"],
+							[5, "0.587"],
+							[5, "0.114"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"adjustedBrightness",
+				[
+					6,
+					"std.pow",
+					["rawBrightness", "gamma"]
+				]
+			],
+			[
+				13,
+				"invertedBrightness",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"adjustedBrightness"
+				]
+			],
+			[
+				13,
+				"scaledBrightness",
+				[
+					1,
+					"invertedBrightness",
+					"*",
+					"charCount"
+				]
+			],
+			[
+				13,
+				"charIndex",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							6,
+							"std.floor",
+							["scaledBrightness"]
+						],
+						[5, "0"],
+						[
+							1,
+							"charCount",
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"atlasCol",
+				[
+					1,
+					"charIndex",
+					"-",
+					[
+						1,
+						"atlasSize",
+						"*",
+						[
+							6,
+							"std.floor",
+							[[
+								1,
+								"charIndex",
+								"/",
+								"atlasSize"
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"atlasRow",
+				[
+					6,
+					"std.floor",
+					[[
+						1,
+						"charIndex",
+						"/",
+						"atlasSize"
+					]]
+				]
+			],
+			[
+				13,
+				"atlasCellSize",
+				[
+					1,
+					[
+						1,
+						[5, "1"],
+						"/",
+						"atlasSize"
+					],
+					"*",
+					"atlasScale"
+				]
+			],
+			[
+				13,
+				"baseU",
+				[
+					1,
+					"atlasCol",
+					"*",
+					"atlasCellSize"
+				]
+			],
+			[
+				13,
+				"baseV",
+				[
+					1,
+					"atlasRow",
+					"*",
+					"atlasCellSize"
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					1,
+					"baseU",
+					"+",
+					[
+						1,
+						[
+							7,
+							"cellUV",
+							"x"
+						],
+						"*",
+						"atlasCellSize"
+					]
+				], [
+					1,
+					"baseV",
+					"+",
+					[
+						1,
+						[
+							7,
+							"cellUV",
+							"y"
+						],
+						"*",
+						"atlasCellSize"
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.dot": () => dot,
+		"d.vec3f": () => vec3f,
+		"std.pow": () => pow,
+		"std.clamp": () => clamp,
+		"std.floor": () => floor,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({})).$name("asciiAtlasUV");
+const asciiCompose = typegpu_default.fn([
+	vec3f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((asciiRgb, cellColor, isOutside, alphaThreshold, preserveAlpha) => {
+	"use gpu";
+	const isBackground = dot(asciiRgb, vec3f(.299, .587, .114)) < .1;
+	const sourceAlpha = cellColor.w;
+	const isBelowThreshold = sourceAlpha < alphaThreshold;
+	const outputAlpha = select(f32(1), sourceAlpha, preserveAlpha > .5);
+	const hide = isBackground || isOutside > .5 || isBelowThreshold;
+	const finalAlpha = select(outputAlpha, f32(0), hide);
+	return vec4f(__tsover_mul(asciiRgb.x, cellColor.x), __tsover_mul(asciiRgb.y, cellColor.y), __tsover_mul(asciiRgb.z, cellColor.z), finalAlpha);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "asciiRgb"
+			},
+			{
+				"type": "i",
+				"name": "cellColor"
+			},
+			{
+				"type": "i",
+				"name": "isOutside"
+			},
+			{
+				"type": "i",
+				"name": "alphaThreshold"
+			},
+			{
+				"type": "i",
+				"name": "preserveAlpha"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"charBrightness",
+				[
+					6,
+					"std.dot",
+					["asciiRgb", [
+						6,
+						"d.vec3f",
+						[
+							[5, "0.299"],
+							[5, "0.587"],
+							[5, "0.114"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"isBackground",
+				[
+					1,
+					"charBrightness",
+					"<",
+					[5, "0.1"]
+				]
+			],
+			[
+				13,
+				"sourceAlpha",
+				[
+					7,
+					"cellColor",
+					"w"
+				]
+			],
+			[
+				13,
+				"isBelowThreshold",
+				[
+					1,
+					"sourceAlpha",
+					"<",
+					"alphaThreshold"
+				]
+			],
+			[
+				13,
+				"outputAlpha",
+				[
+					6,
+					"std.select",
+					[
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						"sourceAlpha",
+						[
+							1,
+							"preserveAlpha",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"hide",
+				[
+					3,
+					[
+						3,
+						"isBackground",
+						"||",
+						[
+							1,
+							"isOutside",
+							">",
+							[5, "0.5"]
+						]
+					],
+					"||",
+					"isBelowThreshold"
+				]
+			],
+			[
+				13,
+				"finalAlpha",
+				[
+					6,
+					"std.select",
+					[
+						"outputAlpha",
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						],
+						"hide"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec4f",
+				[
+					[
+						1,
+						[
+							7,
+							"asciiRgb",
+							"x"
+						],
+						"*",
+						[
+							7,
+							"cellColor",
+							"x"
+						]
+					],
+					[
+						1,
+						[
+							7,
+							"asciiRgb",
+							"y"
+						],
+						"*",
+						[
+							7,
+							"cellColor",
+							"y"
+						]
+					],
+					[
+						1,
+						[
+							7,
+							"asciiRgb",
+							"z"
+						],
+						"*",
+						[
+							7,
+							"cellColor",
+							"z"
+						]
+					],
+					"finalAlpha"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.dot": () => dot,
+		"d.vec3f": () => vec3f,
+		"std.select": () => select,
+		"d.f32": () => f32,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({})).$name("asciiCompose");
+function shared(build) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (params) => {
+		const hit = cache.get(params);
+		if (hit !== void 0) return hit;
+		const v = build(params);
+		cache.set(params, v);
+		return v;
+	};
+}
+function bleedWarp(slots) {
+	return shared((params) => {
+		if ((params.propValues[slots.amount.name] ?? 0) === 0) return params.ctx.uv;
+		return asLocal(call(watercolorUvBase, "watercolorUvBase", [
+			params.ctx.uv,
+			params.ctx.logicalViewportSize,
+			uniformOf(slots.amount, params),
+			params.ctx.time
+		]), "wcUvBase");
+	});
+}
+function kuwahara(slots) {
+	return shared((params) => {
+		const R = Math.max(1, Math.min(8, Math.round(params.propValues[slots.radius.name] ?? 4)));
+		const taps = Math.max(2, Math.ceil((R + 1) / 2));
+		const invN = 1 / (taps * taps);
+		const uvBase = slots.at(params);
+		const lvp = params.ctx.logicalViewportSize;
+		const quadrant = (dx, dy) => {
+			let sum = expr("vec4f(0.0, 0.0, 0.0, 0.0)");
+			let sq = expr("vec3f(0.0, 0.0, 0.0)");
+			for (let j = 0; j < taps; j++) for (let i = 0; i < taps; i++) {
+				const uv = call(watercolorTapUV, "watercolorTapUV", [
+					uvBase,
+					lvp,
+					floatE((2 * i + .5) * dx),
+					floatE((2 * j + .5) * dy)
+				]);
+				const c = asLocal(params.texture.sample(uv), "wcTap");
+				const rgb = c.member("rgb");
+				sum = sum.add(c);
+				sq = sq.add(rgb.mul(rgb));
+			}
+			return {
+				sum,
+				sq
+			};
+		};
+		return {
+			quadrants: [
+				quadrant(-1, -1),
+				quadrant(1, -1),
+				quadrant(-1, 1),
+				quadrant(1, 1)
+			],
+			invN
+		};
+	});
+}
+function paperGrain(slots) {
+	return (params) => {
+		return (params.propValues[slots.amount.name] ?? 0) === 0 ? floatE(0) : call(watercolorGrain, "watercolorGrain", [params.ctx.uv, params.ctx.viewportSize]);
+	};
+}
+function wash(slots) {
+	return gather({
+		resultAlpha: "straight",
+		build: (params) => {
+			const u = (ref) => uniformOf(ref, params);
+			const original = asLocal(params.sampleStraight(slots.at(params)), "wcOriginal");
+			if ((params.propValues[slots.strength.name] ?? 1) === 0) return original;
+			const { quadrants: [q0, q1, q2, q3], invN } = slots.brush(params);
+			const grain = slots.grain(params);
+			return vec4(call(watercolorCompose, "watercolorCompose", [
+				q0.sum,
+				q1.sum,
+				q2.sum,
+				q3.sum,
+				q0.sq,
+				q1.sq,
+				q2.sq,
+				q3.sq,
+				floatE(invN),
+				original,
+				u(slots.paperColor),
+				u(slots.paper),
+				u(slots.strength),
+				grain
+			]), original.member("a"));
+		}
+	});
+}
+function sobelTaps(slots) {
+	return shared((params) => {
+		const { sampleStraight, ctx } = params;
+		const viewport = ctx.viewportSize;
+		const lumAt = (ox, oy) => {
+			return call(chalkLuma, "chalkLuma", [sampleStraight(call(chalkOffsetUV, "chalkOffsetUV", [
+				ctx.uv,
+				viewport,
+				uniformOf(slots.spacing, params),
+				floatE(ox),
+				floatE(oy)
+			]))]);
+		};
+		const tl = lumAt(-1, -1);
+		const t = lumAt(0, -1);
+		const tr = lumAt(1, -1);
+		const l = lumAt(-1, 0);
+		const r = lumAt(1, 0);
+		const bl = lumAt(-1, 1);
+		const bo = lumAt(0, 1);
+		const br = lumAt(1, 1);
+		const centre = sampleStraight(ctx.uv);
+		const centreLum = call(chalkLuma, "chalkLuma", [centre]);
+		return {
+			sobelA: vec4(tl, t, tr, l),
+			sobelB: vec4(r, bl, bo, br),
+			centre,
+			centreLum
+		};
+	});
+}
+function chalkSketch(slots) {
+	return gather({
+		resultAlpha: "straight",
+		build: (params) => {
+			const u = (ref) => uniformOf(ref, params);
+			const { sobelA, sobelB, centre, centreLum } = slots.edges(params);
+			const misc = vec4(centreLum, centre.member("a"), 0, 0);
+			const tuning = vec4(u(slots.sensitivity), u(slots.hatchScale), u(slots.shading), u(slots.grain));
+			return call(chalkboardCompose, "chalkboardCompose", [
+				sobelA,
+				sobelB,
+				params.ctx.uv,
+				params.ctx.viewportSize,
+				misc,
+				tuning,
+				u(slots.board),
+				u(slots.chalk)
+			]);
+		}
+	});
+}
+function charGrid(slots) {
+	return shared((params) => call(asciiGrid, "asciiGrid", [
+		params.ctx.uv,
+		params.ctx.viewportSize,
+		uniformOf(slots.cellSize, params),
+		uniformOf(slots.spacing, params)
+	]));
+}
+function cellSample(slots) {
+	return shared((params) => {
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [params.convertToTexture(params.childNode).sample(slots.grid(params).member("cellCenter"))]);
+	});
+}
+function glyphFor(slots) {
+	return (params) => {
+		const atlasKit = slots.atlas(params);
+		const atlasUV = call(asciiAtlasUV, "asciiAtlasUV", [
+			slots.cell(params).member("rgb"),
+			uniformOf(slots.gamma, params),
+			params.uniforms._charCount,
+			params.uniforms._atlasSize,
+			params.uniforms._atlasScale,
+			slots.grid(params).member("cellUV")
+		]);
+		return atlasKit.sample(atlasUV, "nearestClamp");
+	};
+}
+function glyphTint(slots) {
+	return (params) => {
+		if (!params.childNode) return ZERO;
+		const cellColor = slots.cell(params);
+		return call(asciiCompose, "asciiCompose", [
+			slots.glyph(params).member("rgb"),
+			cellColor,
+			slots.grid(params).member("isOutside"),
+			uniformOf(slots.alphaThreshold, params),
+			uniformOf(slots.preserveAlpha, params)
+		]);
+	};
+}
+var OBF_DEG_TO_RAD = DEG_TO_RAD;
+const orientedBoxField = typegpu_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, center, rotationDeg, halfW, halfH) => {
+	"use gpu";
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const centerPos = vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
+	const dx = __tsover_sub(aspectUV.x, centerPos.x);
+	const dy = __tsover_sub(aspectUV.y, centerPos.y);
+	const rotRad = __tsover_mul(rotationDeg, OBF_DEG_TO_RAD);
+	const cosR = cos(rotRad);
+	const sinR = sin(rotRad);
+	const rdx = __tsover_add(__tsover_mul(dx, cosR), __tsover_mul(dy, sinR));
+	const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dx, sinR));
+	const localU = __tsover_add(__tsover_div(rdx, __tsover_mul(halfW, 2)), .5);
+	const localV = __tsover_add(__tsover_div(rdy, __tsover_mul(halfH, 2)), .5);
+	return vec3f(localU, localV, __tsover_mul(__tsover_mul(__tsover_mul(step(0, localU), step(localU, 1)), step(0, localV)), step(localV, 1)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "center"
+			},
+			{
+				"type": "i",
+				"name": "rotationDeg"
+			},
+			{
+				"type": "i",
+				"name": "halfW"
+			},
+			{
+				"type": "i",
+				"name": "halfH"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspectUV",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"centerPos",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"center",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"center",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					1,
+					[
+						7,
+						"aspectUV",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"centerPos",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					[
+						7,
+						"aspectUV",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"centerPos",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"rotRad",
+				[
+					1,
+					"rotationDeg",
+					"*",
+					"OBF_DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"cosR",
+				[
+					6,
+					"std.cos",
+					["rotRad"]
+				]
+			],
+			[
+				13,
+				"sinR",
+				[
+					6,
+					"std.sin",
+					["rotRad"]
+				]
+			],
+			[
+				13,
+				"rdx",
+				[
+					1,
+					[
+						1,
+						"dx",
+						"*",
+						"cosR"
+					],
+					"+",
+					[
+						1,
+						"dy",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[
+				13,
+				"rdy",
+				[
+					1,
+					[
+						1,
+						"dy",
+						"*",
+						"cosR"
+					],
+					"-",
+					[
+						1,
+						"dx",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[
+				13,
+				"localU",
+				[
+					1,
+					[
+						1,
+						"rdx",
+						"/",
+						[
+							1,
+							"halfW",
+							"*",
+							[5, "2"]
+						]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"localV",
+				[
+					1,
+					[
+						1,
+						"rdy",
+						"/",
+						[
+							1,
+							"halfH",
+							"*",
+							[5, "2"]
+						]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"insideMask",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.step",
+								[[5, "0"], "localU"]
+							],
+							"*",
+							[
+								6,
+								"std.step",
+								["localU", [5, "1"]]
+							]
+						],
+						"*",
+						[
+							6,
+							"std.step",
+							[[5, "0"], "localV"]
+						]
+					],
+					"*",
+					[
+						6,
+						"std.step",
+						["localV", [5, "1"]]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec3f",
+				[
+					"localU",
+					"localV",
+					"insideMask"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"OBF_DEG_TO_RAD": () => OBF_DEG_TO_RAD,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"std.step": () => step,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+var HP_TAU = TAU;
+var HP_DEG_TO_RAD = DEG_TO_RAD;
+const hatchPlate = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, angleDeg, frequency, reliefPhase, level, aa) => {
+	"use gpu";
+	const angleRad = __tsover_mul(angleDeg, HP_DEG_TO_RAD);
+	const c = cos(angleRad);
+	const s = sin(angleRad);
+	const w = __tsover_add(__tsover_mul(p.x, __tsover_mul(s, -1)), __tsover_mul(p.y, c));
+	const v = cos(__tsover_add(__tsover_mul(__tsover_mul(w, frequency), HP_TAU), reliefPhase));
+	const thr = mix(-1.15, 1.15, clamp(level, 0, 1));
+	return smoothstep(__tsover_sub(thr, aa), __tsover_add(thr, aa), v);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "angleDeg"
+			},
+			{
+				"type": "i",
+				"name": "frequency"
+			},
+			{
+				"type": "i",
+				"name": "reliefPhase"
+			},
+			{
+				"type": "i",
+				"name": "level"
+			},
+			{
+				"type": "i",
+				"name": "aa"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"angleRad",
+				[
+					1,
+					"angleDeg",
+					"*",
+					"HP_DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"c",
+				[
+					6,
+					"std.cos",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"s",
+				[
+					6,
+					"std.sin",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"w",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"p",
+							"x"
+						],
+						"*",
+						[
+							1,
+							"s",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"y"
+						],
+						"*",
+						"c"
+					]
+				]
+			],
+			[
+				13,
+				"phase",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"w",
+							"*",
+							"frequency"
+						],
+						"*",
+						"HP_TAU"
+					],
+					"+",
+					"reliefPhase"
+				]
+			],
+			[
+				13,
+				"v",
+				[
+					6,
+					"std.cos",
+					["phase"]
+				]
+			],
+			[
+				13,
+				"thr",
+				[
+					6,
+					"std.mix",
+					[
+						[
+							4,
+							"-",
+							[5, "1.15"]
+						],
+						[5, "1.15"],
+						[
+							6,
+							"std.clamp",
+							[
+								"level",
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.smoothstep",
+				[
+					[
+						1,
+						"thr",
+						"-",
+						"aa"
+					],
+					[
+						1,
+						"thr",
+						"+",
+						"aa"
+					],
+					"v"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"HP_DEG_TO_RAD": () => HP_DEG_TO_RAD,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"HP_TAU": () => HP_TAU,
+		"std.mix": () => mix,
+		"std.clamp": () => clamp,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+const spiralPlate = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, c, frequency, reliefPhase, level, aa) => {
+	"use gpu";
+	const dv = p.sub(c);
+	const r = length(dv);
+	const theta = atan2(dv.y, dv.x);
+	const v = cos(__tsover_add(__tsover_mul(__tsover_sub(__tsover_mul(r, frequency), __tsover_mul(theta, __tsover_div(1, HP_TAU))), HP_TAU), reliefPhase));
+	const thr = mix(-1.15, 1.15, clamp(level, 0, 1));
+	return smoothstep(__tsover_sub(thr, aa), __tsover_add(thr, aa), v);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "c"
+			},
+			{
+				"type": "i",
+				"name": "frequency"
+			},
+			{
+				"type": "i",
+				"name": "reliefPhase"
+			},
+			{
+				"type": "i",
+				"name": "level"
+			},
+			{
+				"type": "i",
+				"name": "aa"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"dv",
+				[
+					6,
+					[
+						7,
+						"p",
+						"sub"
+					],
+					["c"]
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					6,
+					"std.length",
+					["dv"]
+				]
+			],
+			[
+				13,
+				"theta",
+				[
+					6,
+					"std.atan2",
+					[[
+						7,
+						"dv",
+						"y"
+					], [
+						7,
+						"dv",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"phase",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"r",
+								"*",
+								"frequency"
+							],
+							"-",
+							[
+								1,
+								"theta",
+								"*",
+								[
+									1,
+									[5, "1"],
+									"/",
+									"HP_TAU"
+								]
+							]
+						],
+						"*",
+						"HP_TAU"
+					],
+					"+",
+					"reliefPhase"
+				]
+			],
+			[
+				13,
+				"v",
+				[
+					6,
+					"std.cos",
+					["phase"]
+				]
+			],
+			[
+				13,
+				"thr",
+				[
+					6,
+					"std.mix",
+					[
+						[
+							4,
+							"-",
+							[5, "1.15"]
+						],
+						[5, "1.15"],
+						[
+							6,
+							"std.clamp",
+							[
+								"level",
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.smoothstep",
+				[
+					[
+						1,
+						"thr",
+						"-",
+						"aa"
+					],
+					[
+						1,
+						"thr",
+						"+",
+						"aa"
+					],
+					"v"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.length": () => length,
+		"std.atan2": () => atan2,
+		"HP_TAU": () => HP_TAU,
+		"std.cos": () => cos,
+		"std.mix": () => mix,
+		"std.clamp": () => clamp,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+function makeLineworkComposite(style) {
+	return typegpu_default.fn([
+		vec4f,
+		vec2f,
+		f32,
+		vec4f,
+		vec4f,
+		vec2f,
+		vec4f,
+		vec4f
+	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, uv, aspect, paper, ink, center, p0, p1) => {
+		"use gpu";
+		const angleDeg = p0.x;
+		const frequency = p0.y;
+		const relief = p0.z;
+		const waviness = p0.w;
+		const contrast = p1.x;
+		const viewportY = p1.y;
+		const lum = dot(vec3f(childColor.x, childColor.y, childColor.z), vec3f(.299, .587, .114));
+		const level = clamp(__tsover_add(.5, __tsover_mul(__tsover_sub(lum, .5), contrast)), 0, 1);
+		const pa = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+		const nx = mxNoiseFloat2(pa.mul(3.1));
+		const ny = mxNoiseFloat2(pa.mul(3.1).add(vec2f(7.31, 3.77)));
+		const p = pa.add(vec2f(nx, ny).mul(__tsover_mul(waviness, .06)));
+		const aa = clamp(__tsover_div(__tsover_mul(frequency, HP_TAU), max(viewportY, 1)), .02, 1);
+		const reliefPhase = __tsover_mul(__tsover_mul(relief, level), 9.42);
+		let cover = f32(0);
+		if (style === 2) cover = spiralPlate(p, vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y)), frequency, reliefPhase, level, aa);
+		else if (style === 1) {
+			const ink1 = hatchPlate(p, angleDeg, frequency, reliefPhase, level, aa);
+			const level2 = clamp(__tsover_div(level, .55), 0, 1);
+			const ink2 = hatchPlate(p, __tsover_add(angleDeg, 72), __tsover_mul(frequency, .92), __tsover_mul(reliefPhase, .7), level2, aa);
+			const level3 = clamp(__tsover_div(level, .28), 0, 1);
+			cover = max(ink1, max(ink2, hatchPlate(p, __tsover_sub(angleDeg, 38), __tsover_mul(frequency, 1.13), __tsover_mul(reliefPhase, .5), level3, aa)));
+		} else cover = hatchPlate(p, angleDeg, frequency, reliefPhase, level, aa);
+		const rgb = mix(vec3f(paper.x, paper.y, paper.z), vec3f(ink.x, ink.y, ink.z), vec3f(cover));
+		const alpha = __tsover_mul(childColor.w, mix(paper.w, ink.w, cover));
+		return vec4f(rgb.x, rgb.y, rgb.z, alpha);
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "childColor"
+				},
+				{
+					"type": "i",
+					"name": "uv"
+				},
+				{
+					"type": "i",
+					"name": "aspect"
+				},
+				{
+					"type": "i",
+					"name": "paper"
+				},
+				{
+					"type": "i",
+					"name": "ink"
+				},
+				{
+					"type": "i",
+					"name": "center"
+				},
+				{
+					"type": "i",
+					"name": "p0"
+				},
+				{
+					"type": "i",
+					"name": "p1"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"angleDeg",
+					[
+						7,
+						"p0",
+						"x"
+					]
+				],
+				[
+					13,
+					"frequency",
+					[
+						7,
+						"p0",
+						"y"
+					]
+				],
+				[
+					13,
+					"relief",
+					[
+						7,
+						"p0",
+						"z"
+					]
+				],
+				[
+					13,
+					"waviness",
+					[
+						7,
+						"p0",
+						"w"
+					]
+				],
+				[
+					13,
+					"contrast",
+					[
+						7,
+						"p1",
+						"x"
+					]
+				],
+				[
+					13,
+					"viewportY",
+					[
+						7,
+						"p1",
+						"y"
+					]
+				],
+				[
+					13,
+					"lum",
+					[
+						6,
+						"std.dot",
+						[[
+							6,
+							"d.vec3f",
+							[
+								[
+									7,
+									"childColor",
+									"x"
+								],
+								[
+									7,
+									"childColor",
+									"y"
+								],
+								[
+									7,
+									"childColor",
+									"z"
+								]
+							]
+						], [
+							6,
+							"d.vec3f",
+							[
+								[5, "0.299"],
+								[5, "0.587"],
+								[5, "0.114"]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"level",
+					[
+						6,
+						"std.clamp",
+						[
+							[
+								1,
+								[5, "0.5"],
+								"+",
+								[
+									1,
+									[
+										1,
+										"lum",
+										"-",
+										[5, "0.5"]
+									],
+									"*",
+									"contrast"
+								]
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					13,
+					"pa",
+					[
+						6,
+						"d.vec2f",
+						[[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"*",
+							"aspect"
+						], [
+							7,
+							"uv",
+							"y"
+						]]
+					]
+				],
+				[
+					13,
+					"nx",
+					[
+						6,
+						"noise.mxNoiseFloat2",
+						[[
+							6,
+							[
+								7,
+								"pa",
+								"mul"
+							],
+							[[5, "3.1"]]
+						]]
+					]
+				],
+				[
+					13,
+					"ny",
+					[
+						6,
+						"noise.mxNoiseFloat2",
+						[[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"pa",
+										"mul"
+									],
+									[[5, "3.1"]]
+								],
+								"add"
+							],
+							[[
+								6,
+								"d.vec2f",
+								[[5, "7.31"], [5, "3.77"]]
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"p",
+					[
+						6,
+						[
+							7,
+							"pa",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								[
+									6,
+									"d.vec2f",
+									["nx", "ny"]
+								],
+								"mul"
+							],
+							[[
+								1,
+								"waviness",
+								"*",
+								[5, "0.06"]
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"aa",
+					[
+						6,
+						"std.clamp",
+						[
+							[
+								1,
+								[
+									1,
+									"frequency",
+									"*",
+									"HP_TAU"
+								],
+								"/",
+								[
+									6,
+									"std.max",
+									["viewportY", [5, "1"]]
+								]
+							],
+							[5, "0.02"],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					13,
+					"reliefPhase",
+					[
+						1,
+						[
+							1,
+							"relief",
+							"*",
+							"level"
+						],
+						"*",
+						[5, "9.42"]
+					]
+				],
+				[
+					12,
+					"cover",
+					[
+						6,
+						"d.f32",
+						[[5, "0"]]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						"style",
+						"===",
+						[5, "2"]
+					],
+					[0, [[
+						13,
+						"sc",
+						[
+							6,
+							"d.vec2f",
+							[[
+								1,
+								[
+									7,
+									"center",
+									"x"
+								],
+								"*",
+								"aspect"
+							], [
+								1,
+								[5, "1"],
+								"-",
+								[
+									7,
+									"center",
+									"y"
+								]
+							]]
+						]
+					], [
+						2,
+						"cover",
+						"=",
+						[
+							6,
+							"spiralPlate",
+							[
+								"p",
+								"sc",
+								"frequency",
+								"reliefPhase",
+								"level",
+								"aa"
+							]
+						]
+					]]],
+					[
+						11,
+						[
+							1,
+							"style",
+							"===",
+							[5, "1"]
+						],
+						[0, [
+							[
+								13,
+								"ink1",
+								[
+									6,
+									"hatchPlate",
+									[
+										"p",
+										"angleDeg",
+										"frequency",
+										"reliefPhase",
+										"level",
+										"aa"
+									]
+								]
+							],
+							[
+								13,
+								"level2",
+								[
+									6,
+									"std.clamp",
+									[
+										[
+											1,
+											"level",
+											"/",
+											[5, "0.55"]
+										],
+										[5, "0"],
+										[5, "1"]
+									]
+								]
+							],
+							[
+								13,
+								"ink2",
+								[
+									6,
+									"hatchPlate",
+									[
+										"p",
+										[
+											1,
+											"angleDeg",
+											"+",
+											[5, "72"]
+										],
+										[
+											1,
+											"frequency",
+											"*",
+											[5, "0.92"]
+										],
+										[
+											1,
+											"reliefPhase",
+											"*",
+											[5, "0.7"]
+										],
+										"level2",
+										"aa"
+									]
+								]
+							],
+							[
+								13,
+								"level3",
+								[
+									6,
+									"std.clamp",
+									[
+										[
+											1,
+											"level",
+											"/",
+											[5, "0.28"]
+										],
+										[5, "0"],
+										[5, "1"]
+									]
+								]
+							],
+							[
+								13,
+								"ink3",
+								[
+									6,
+									"hatchPlate",
+									[
+										"p",
+										[
+											1,
+											"angleDeg",
+											"-",
+											[5, "38"]
+										],
+										[
+											1,
+											"frequency",
+											"*",
+											[5, "1.13"]
+										],
+										[
+											1,
+											"reliefPhase",
+											"*",
+											[5, "0.5"]
+										],
+										"level3",
+										"aa"
+									]
+								]
+							],
+							[
+								2,
+								"cover",
+								"=",
+								[
+									6,
+									"std.max",
+									["ink1", [
+										6,
+										"std.max",
+										["ink2", "ink3"]
+									]]
+								]
+							]
+						]],
+						[0, [[
+							2,
+							"cover",
+							"=",
+							[
+								6,
+								"hatchPlate",
+								[
+									"p",
+									"angleDeg",
+									"frequency",
+									"reliefPhase",
+									"level",
+									"aa"
+								]
+							]
+						]]]
+					]
+				],
+				[
+					13,
+					"rgb",
+					[
+						6,
+						"std.mix",
+						[
+							[
+								6,
+								"d.vec3f",
+								[
+									[
+										7,
+										"paper",
+										"x"
+									],
+									[
+										7,
+										"paper",
+										"y"
+									],
+									[
+										7,
+										"paper",
+										"z"
+									]
+								]
+							],
+							[
+								6,
+								"d.vec3f",
+								[
+									[
+										7,
+										"ink",
+										"x"
+									],
+									[
+										7,
+										"ink",
+										"y"
+									],
+									[
+										7,
+										"ink",
+										"z"
+									]
+								]
+							],
+							[
+								6,
+								"d.vec3f",
+								["cover"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"alpha",
+					[
+						1,
+						[
+							7,
+							"childColor",
+							"w"
+						],
+						"*",
+						[
+							6,
+							"std.mix",
+							[
+								[
+									7,
+									"paper",
+									"w"
+								],
+								[
+									7,
+									"ink",
+									"w"
+								],
+								"cover"
+							]
+						]
+					]
+				],
+				[10, [
+					6,
+					"d.vec4f",
+					[
+						[
+							7,
+							"rgb",
+							"x"
+						],
+						[
+							7,
+							"rgb",
+							"y"
+						],
+						[
+							7,
+							"rgb",
+							"z"
+						],
+						"alpha"
+					]
+				]]
+			]]
+		},
+		externals: {
+			"std.dot": () => dot,
+			"d.vec3f": () => vec3f,
+			"std.clamp": () => clamp,
+			"d.vec2f": () => vec2f,
+			"noise.mxNoiseFloat2": () => mxNoiseFloat2,
+			"HP_TAU": () => HP_TAU,
+			"std.max": () => max,
+			"d.f32": () => f32,
+			"style": () => style,
+			"spiralPlate": () => spiralPlate,
+			"hatchPlate": () => hatchPlate,
+			"std.mix": () => mix,
+			"d.vec4f": () => vec4f
+		}
+	}) && $.f)({})).$name(`lineworkComposite_${style}`);
+}
+var LINEWORK_MODES = {
+	line: 0,
+	crosshatch: 1,
+	spiral: 2
+};
+function linework(slots) {
+	return gather({
+		resultAlpha: "straight",
+		build: ({ sampleStraight, ctx, uniforms, propValues }) => {
+			const childColor = sampleStraight(ctx.uv);
+			const raw = propValues[slots.style.name];
+			const style = typeof raw === "number" ? raw : LINEWORK_MODES[String(raw)] ?? 1;
+			const composite = makeLineworkComposite(style);
+			const p0 = vec4(uniforms[slots.angle.name], uniforms[slots.frequency.name], uniforms[slots.relief.name], uniforms[slots.waviness.name]);
+			const p1 = vec4(uniforms[slots.contrast.name], ctx.viewportSize.member("y"), floatE(0), floatE(0));
+			return call(composite, `lineworkComposite_${style}`, [
+				childColor,
+				ctx.uv,
+				ctx.aspect,
+				uniforms[slots.paper.name],
+				uniforms[slots.ink.name],
+				uniforms[slots.center.name],
+				p0,
+				p1
+			]);
+		}
+	});
+}
+export { glyphFor as a, linework as c, sobelTaps as d, wash as f, charGrid as i, orientedBoxField as l, cellSample as n, glyphTint as o, chalkSketch as r, kuwahara as s, bleedWarp as t, paperGrain as u };