matrix-rain-webgpu 1.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,3231 @@
+import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+import { useConfigureContext as i, useFrame as a, useRoot as o, useRootWithStatus as s } from "@typegpu/react";
+import { common as c, d as l, std as u, tgpu as d } from "typegpu";
+import { randf as f } from "@typegpu/noise";
+import { jsx as p } from "react/jsx-runtime";
+//#region src/gpu/atlas/glyph-set.ts
+var m = "ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘｱﾎﾃﾏｹﾒｴｶｷﾑﾕﾗｾﾈｽﾀﾇﾍ012345789Z:.=*+-<>".split(""), h = m.length, g = 8, _ = .75, v = 32e3, y = [
+	{
+		dx: -1,
+		dy: -1
+	},
+	{
+		dx: 0,
+		dy: -1
+	},
+	{
+		dx: 1,
+		dy: -1
+	},
+	{
+		dx: -1,
+		dy: 0
+	}
+], b = [
+	{
+		dx: 1,
+		dy: 1
+	},
+	{
+		dx: 0,
+		dy: 1
+	},
+	{
+		dx: -1,
+		dy: 1
+	},
+	{
+		dx: 1,
+		dy: 0
+	}
+];
+async function x() {
+	let e = m.length, t = new Uint8Array(e * 64 * 64), n = new OffscreenCanvas(64, 64).getContext("2d");
+	if (!n) throw Error("OffscreenCanvas 2D context unavailable");
+	n.fillStyle = "white", n.textAlign = "center", n.textBaseline = "middle", n.font = `${Math.floor(64 * _)}px monospace`;
+	for (let r = 0; r < e; r++) n.clearRect(0, 0, 64, 64), n.fillText(m[r], 64 / 2, 64 / 2), T(C(S(n.getImageData(0, 0, 64, 64)), 64), t, r * 64 * 64);
+	return {
+		data: t,
+		layerCount: e,
+		layerSize: 64
+	};
+}
+function S(e) {
+	let t = e.data, n = new Uint8Array(t.length / 4);
+	for (let e = 0; e < n.length; e++) n[e] = +(t[e * 4 + 3] >= 128);
+	return n;
+}
+function C(e, t) {
+	let n = w(e, t, 1), r = w(e, t, 0), i = new Float32Array(e.length);
+	for (let t = 0; t < i.length; t++) i[t] = e[t] ? r[t] : -n[t];
+	return i;
+}
+function w(e, t, n) {
+	let r = e.length, i = new Int16Array(r), a = new Int16Array(r);
+	for (let t = 0; t < r; t++) e[t] === n ? (i[t] = 0, a[t] = 0) : (i[t] = v, a[t] = v);
+	let o = (e, n) => n * t + e;
+	function s(e, t, n, r) {
+		let o = i[t] - n, s = a[t] - r;
+		o * o + s * s < i[e] * i[e] + a[e] * a[e] && (i[e] = o, a[e] = s);
+	}
+	function c(e, n, r) {
+		let i = o(e, n);
+		for (let { dx: a, dy: c } of r) {
+			let r = e + a, l = n + c;
+			r < 0 || l < 0 || r >= t || l >= t || s(i, o(r, l), -a, -c);
+		}
+	}
+	for (let e = 0; e < t; e++) for (let n = 0; n < t; n++) c(n, e, y);
+	for (let e = t - 1; e >= 0; e--) for (let n = t - 1; n >= 0; n--) c(n, e, b);
+	let l = new Float32Array(r);
+	for (let e = 0; e < r; e++) l[e] = Math.sqrt(i[e] * i[e] + a[e] * a[e]);
+	return l;
+}
+function T(e, t, n) {
+	for (let r = 0; r < e.length; r++) {
+		let i = (e[r] + g) / (2 * g), a = Math.max(0, Math.min(255, Math.round(i * 255)));
+		t[n + r] = a;
+	}
+}
+//#endregion
+//#region src/gpu/schemas/column.ts
+var E = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(l.struct({
+	headY: l.f32,
+	speed: l.f32,
+	depth: l.f32,
+	tailLength: l.f32,
+	seed: l.u32
+}), "Column"), D = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(l.struct({
+	time: l.f32,
+	stepProgress: l.f32,
+	resolution: l.vec2f,
+	cellSize: l.f32,
+	density: l.f32,
+	depthDim: l.f32,
+	bloomThreshold: l.f32,
+	bloomIntensity: l.f32,
+	headEmission: l.f32,
+	scanlineStrength: l.f32,
+	aberration: l.f32
+}), "Uniforms"), O = 4294967295;
+function ee(e, t, n) {
+	let r = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.computeFn({
+		workgroupSize: [64],
+		in: { gid: l.builtin.globalInvocationId }
+	})(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ gid: e }) => {
+		"use gpu";
+		let r = l.u32(u.floor(__tsover_div(n.$.resolution.x, n.$.cellSize)));
+		if (e.x >= r) return;
+		let i = t.$[e.x];
+		f.seed2(l.vec2f(__tsover_div(l.f32(i.seed), O), n.$.time));
+		let a = __tsover_add(i.headY, i.speed), o = i.seed;
+		__tsover_mul(a, n.$.cellSize) > n.$.resolution.y && f.sample() > n.$.density && (a = l.f32(0), o = l.u32(__tsover_mul(f.sample(), O))), t.$[e.x] = E({
+			headY: a,
+			speed: i.speed,
+			depth: i.depth,
+			tailLength: i.tailLength,
+			seed: o
+		});
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			params: [{
+				type: "d",
+				props: [{
+					name: "gid",
+					alias: "gid"
+				}]
+			}],
+			body: [0, [
+				[
+					13,
+					"columnCount",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									7,
+									[
+										7,
+										[
+											7,
+											"uniforms",
+											"$"
+										],
+										"resolution"
+									],
+									"x"
+								],
+								"/",
+								[
+									7,
+									[
+										7,
+										"uniforms",
+										"$"
+									],
+									"cellSize"
+								]
+							]]
+						]]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						[
+							7,
+							"gid",
+							"x"
+						],
+						">=",
+						"columnCount"
+					],
+					[0, [[10]]]
+				],
+				[
+					13,
+					"column",
+					[
+						8,
+						[
+							7,
+							"columns",
+							"$"
+						],
+						[
+							7,
+							"gid",
+							"x"
+						]
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"randf",
+						"seed2"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[
+									7,
+									"column",
+									"seed"
+								]]
+							],
+							"/",
+							"U32_MAX_F"
+						], [
+							7,
+							[
+								7,
+								"uniforms",
+								"$"
+							],
+							"time"
+						]]
+					]]
+				],
+				[
+					12,
+					"nextHeadY",
+					[
+						1,
+						[
+							7,
+							"column",
+							"headY"
+						],
+						"+",
+						[
+							7,
+							"column",
+							"speed"
+						]
+					]
+				],
+				[
+					12,
+					"nextSeed",
+					[
+						7,
+						"column",
+						"seed"
+					]
+				],
+				[
+					13,
+					"offscreen",
+					[
+						1,
+						[
+							1,
+							"nextHeadY",
+							"*",
+							[
+								7,
+								[
+									7,
+									"uniforms",
+									"$"
+								],
+								"cellSize"
+							]
+						],
+						">",
+						[
+							7,
+							[
+								7,
+								[
+									7,
+									"uniforms",
+									"$"
+								],
+								"resolution"
+							],
+							"y"
+						]
+					]
+				],
+				[
+					11,
+					[
+						3,
+						"offscreen",
+						"&&",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"randf",
+									"sample"
+								],
+								[]
+							],
+							">",
+							[
+								7,
+								[
+									7,
+									"uniforms",
+									"$"
+								],
+								"density"
+							]
+						]
+					],
+					[0, [[
+						2,
+						"nextHeadY",
+						"=",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]
+					], [
+						2,
+						"nextSeed",
+						"=",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							[[
+								1,
+								[
+									6,
+									[
+										7,
+										"randf",
+										"sample"
+									],
+									[]
+								],
+								"*",
+								"U32_MAX_F"
+							]]
+						]
+					]]]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							"columns",
+							"$"
+						],
+						[
+							7,
+							"gid",
+							"x"
+						]
+					],
+					"=",
+					[
+						6,
+						"Column",
+						[[104, {
+							headY: "nextHeadY",
+							speed: [
+								7,
+								"column",
+								"speed"
+							],
+							depth: [
+								7,
+								"column",
+								"depth"
+							],
+							tailLength: [
+								7,
+								"column",
+								"tailLength"
+							],
+							seed: "nextSeed"
+						}]]
+					]
+				]
+			]],
+			externalNames: [
+				"d",
+				"std",
+				"uniforms",
+				"columns",
+				"randf",
+				"U32_MAX_F",
+				"Column"
+			]
+		},
+		externals: () => ({
+			d: l,
+			std: u,
+			uniforms: n,
+			columns: t,
+			randf: f,
+			U32_MAX_F: O,
+			Column: E
+		})
+	}) && e.f)({})), "computeMain");
+	return e.createComputePipeline({ compute: r });
+}
+//#endregion
+//#region src/gpu/atlas/bindings.ts
+var k = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.bindGroupLayout({
+	atlas: { texture: l.texture2dArray(l.f32) },
+	sampler: { sampler: "filtering" }
+}), "atlasBindings"), A = 4294967295, j = .01, M = 1.5, N = .6, P = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.fn([l.u32, l.u32], l.u32)(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = ((e, t) => {
+	"use gpu";
+	return f.seed2(l.vec2f(__tsover_div(l.f32(e), A), __tsover_mul(l.f32(t), j))), l.u32(__tsover_mul(f.sample(), l.f32(h)));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		params: [{
+			type: "i",
+			name: "seed"
+		}, {
+			type: "i",
+			name: "slotY"
+		}],
+		body: [0, [[
+			6,
+			[
+				7,
+				"randf",
+				"seed2"
+			],
+			[[
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["seed"]
+					],
+					"/",
+					"U32_MAX_F"
+				], [
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["slotY"]
+					],
+					"*",
+					"SLOT_Y_SCALE"
+				]]
+			]]
+		], [10, [
+			6,
+			[
+				7,
+				"d",
+				"u32"
+			],
+			[[
+				1,
+				[
+					6,
+					[
+						7,
+						"randf",
+						"sample"
+					],
+					[]
+				],
+				"*",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["GLYPH_COUNT"]
+				]
+			]]
+		]]]],
+		externalNames: [
+			"randf",
+			"d",
+			"U32_MAX_F",
+			"SLOT_Y_SCALE",
+			"GLYPH_COUNT"
+		]
+	},
+	externals: () => ({
+		randf: f,
+		d: l,
+		U32_MAX_F: A,
+		SLOT_Y_SCALE: j,
+		GLYPH_COUNT: h
+	})
+}) && e.f)({})), "glyphIndex"), F = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.fn([l.u32, l.u32], l.f32)(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = ((e, t) => {
+	"use gpu";
+	return f.seed2(l.vec2f(__tsover_div(l.f32(e), A), __tsover_add(__tsover_mul(l.f32(t), j), M))), __tsover_mul(__tsover_mul(__tsover_sub(f.sample(), .5), 2), N);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		params: [{
+			type: "i",
+			name: "seed"
+		}, {
+			type: "i",
+			name: "slotY"
+		}],
+		body: [0, [[
+			6,
+			[
+				7,
+				"randf",
+				"seed2"
+			],
+			[[
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["seed"]
+					],
+					"/",
+					"U32_MAX_F"
+				], [
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["slotY"]
+						],
+						"*",
+						"SLOT_Y_SCALE"
+					],
+					"+",
+					"BRIGHTNESS_SALT"
+				]]
+			]]
+		], [10, [
+			1,
+			[
+				1,
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"randf",
+							"sample"
+						],
+						[]
+					],
+					"-",
+					[5, "0.5"]
+				],
+				"*",
+				[5, "2"]
+			],
+			"*",
+			"JITTER_RANGE"
+		]]]],
+		externalNames: [
+			"randf",
+			"d",
+			"U32_MAX_F",
+			"SLOT_Y_SCALE",
+			"BRIGHTNESS_SALT",
+			"JITTER_RANGE"
+		]
+	},
+	externals: () => ({
+		randf: f,
+		d: l,
+		U32_MAX_F: A,
+		SLOT_Y_SCALE: j,
+		BRIGHTNESS_SALT: M,
+		JITTER_RANGE: N
+	})
+}) && e.f)({})), "brightnessJitter"), I = {
+	background: [
+		0,
+		5 / 255,
+		0,
+		1
+	],
+	head: [
+		180 / 255,
+		255 / 255,
+		180 / 255,
+		1
+	],
+	trail: [
+		0,
+		255 / 255,
+		65 / 255,
+		1
+	],
+	fade: [
+		0,
+		61 / 255,
+		16 / 255,
+		1
+	]
+}, L = 1.5, R = 2.5;
+function z(e, t, n, r) {
+	let i = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.fragmentFn({
+		in: { uv: l.vec2f },
+		out: l.vec4f
+	})(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ uv: e }) => {
+		"use gpu";
+		let r = n.$.resolution, i = n.$.cellSize, a = l.u32(u.floor(__tsover_div(r.x, i))), o = __tsover_mul(e, r), s = u.min(l.u32(u.floor(__tsover_div(o.x, i))), __tsover_sub(a, 1)), c = l.u32(u.floor(__tsover_div(o.y, i))), d = l.vec2f(u.fract(__tsover_div(o.x, i)), u.fract(__tsover_div(o.y, i))), f = t.$[s], p = l.i32(u.floor(f.headY)), m = __tsover_sub(p, l.i32(c)), h = l.i32(f.tailLength), g = m >= 0 && m <= h, _ = P(f.seed, c), v = u.textureSample(k.$.atlas, k.$.sampler, d, l.i32(_)), y = u.mix(R, 1, f.depth), b = __tsover_mul(__tsover_mul(u.fwidth(d.x), .5), y), x = u.smoothstep(__tsover_sub(.5, b), __tsover_add(.5, b), v.x), S = __tsover_div(l.f32(m), f.tailLength), C = u.pow(u.clamp(__tsover_sub(1, S), 0, 1), L), w = u.mix(__tsover_sub(1, n.$.depthDim), 1, f.depth), T = u.select(F(f.seed, c), l.f32(0), m === 0), E = u.clamp(__tsover_mul(__tsover_mul(C, w), __tsover_add(1, T)), 0, 1), D = l.vec3f(I.head[0], I.head[1], I.head[2]), O = l.vec3f(I.trail[0], I.trail[1], I.trail[2]), ee = l.vec3f(I.fade[0], I.fade[1], I.fade[2]), A = l.vec3f(I.background[0], I.background[1], I.background[2]), j = u.mix(O, ee, u.clamp(S, 0, 1)), M = u.select(j, D, m === 0), N = u.mix(1, n.$.headEmission, C), z = __tsover_mul(__tsover_mul(M, E), N), B = u.mix(A, z, x), V = u.select(A, B, g);
+		return l.vec4f(V, 1);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			params: [{
+				type: "d",
+				props: [{
+					name: "uv",
+					alias: "uv"
+				}]
+			}],
+			body: [0, [
+				[
+					13,
+					"resolution",
+					[
+						7,
+						[
+							7,
+							"uniforms",
+							"$"
+						],
+						"resolution"
+					]
+				],
+				[
+					13,
+					"cellSize",
+					[
+						7,
+						[
+							7,
+							"uniforms",
+							"$"
+						],
+						"cellSize"
+					]
+				],
+				[
+					13,
+					"columnCount",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									7,
+									"resolution",
+									"x"
+								],
+								"/",
+								"cellSize"
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"pixelPos",
+					[
+						1,
+						"uv",
+						"*",
+						"resolution"
+					]
+				],
+				[
+					13,
+					"col",
+					[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"floor"
+								],
+								[[
+									1,
+									[
+										7,
+										"pixelPos",
+										"x"
+									],
+									"/",
+									"cellSize"
+								]]
+							]]
+						], [
+							1,
+							"columnCount",
+							"-",
+							[5, "1"]
+						]]
+					]
+				],
+				[
+					13,
+					"row",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									7,
+									"pixelPos",
+									"y"
+								],
+								"/",
+								"cellSize"
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"localUv",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"fract"
+							],
+							[[
+								1,
+								[
+									7,
+									"pixelPos",
+									"x"
+								],
+								"/",
+								"cellSize"
+							]]
+						], [
+							6,
+							[
+								7,
+								"std",
+								"fract"
+							],
+							[[
+								1,
+								[
+									7,
+									"pixelPos",
+									"y"
+								],
+								"/",
+								"cellSize"
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"column",
+					[
+						8,
+						[
+							7,
+							"columns",
+							"$"
+						],
+						"col"
+					]
+				],
+				[
+					13,
+					"headRow",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								7,
+								"column",
+								"headY"
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"k",
+					[
+						1,
+						"headRow",
+						"-",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							["row"]
+						]
+					]
+				],
+				[
+					13,
+					"tailLengthI",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							7,
+							"column",
+							"tailLength"
+						]]
+					]
+				],
+				[
+					13,
+					"inTail",
+					[
+						3,
+						[
+							1,
+							"k",
+							">=",
+							[5, "0"]
+						],
+						"&&",
+						[
+							1,
+							"k",
+							"<=",
+							"tailLengthI"
+						]
+					]
+				],
+				[
+					13,
+					"layer",
+					[
+						6,
+						"glyphIndex",
+						[[
+							7,
+							"column",
+							"seed"
+						], "row"]
+					]
+				],
+				[
+					13,
+					"sample",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureSample"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"atlasBindings",
+									"$"
+								],
+								"atlas"
+							],
+							[
+								7,
+								[
+									7,
+									"atlasBindings",
+									"$"
+								],
+								"sampler"
+							],
+							"localUv",
+							[
+								6,
+								[
+									7,
+									"d",
+									"i32"
+								],
+								["layer"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"softness",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"FAR_SOFTNESS",
+							[5, "1"],
+							[
+								7,
+								"column",
+								"depth"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"edgeHalfBand",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"fwidth"
+								],
+								[[
+									7,
+									"localUv",
+									"x"
+								]]
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"*",
+						"softness"
+					]
+				],
+				[
+					13,
+					"coverage",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[
+								1,
+								[5, "0.5"],
+								"-",
+								"edgeHalfBand"
+							],
+							[
+								1,
+								[5, "0.5"],
+								"+",
+								"edgeHalfBand"
+							],
+							[
+								7,
+								"sample",
+								"x"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"tailProgress",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["k"]
+						],
+						"/",
+						[
+							7,
+							"column",
+							"tailLength"
+						]
+					]
+				],
+				[
+					13,
+					"tailFalloff",
+					[
+						6,
+						[
+							7,
+							"std",
+							"pow"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									[5, "1"],
+									"-",
+									"tailProgress"
+								],
+								[5, "0"],
+								[5, "1"]
+							]
+						], "FALLOFF_POWER"]
+					]
+				],
+				[
+					13,
+					"depthDimming",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								1,
+								[5, "1"],
+								"-",
+								[
+									7,
+									[
+										7,
+										"uniforms",
+										"$"
+									],
+									"depthDim"
+								]
+							],
+							[5, "1"],
+							[
+								7,
+								"column",
+								"depth"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"trailJitter",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							[
+								6,
+								"brightnessJitter",
+								[[
+									7,
+									"column",
+									"seed"
+								], "row"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								1,
+								"k",
+								"===",
+								[5, "0"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"brightness",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									"tailFalloff",
+									"*",
+									"depthDimming"
+								],
+								"*",
+								[
+									1,
+									[5, "1"],
+									"+",
+									"trailJitter"
+								]
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					13,
+					"head",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"head"
+								],
+								[5, "0"]
+							],
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"head"
+								],
+								[5, "1"]
+							],
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"head"
+								],
+								[5, "2"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"trail",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"trail"
+								],
+								[5, "0"]
+							],
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"trail"
+								],
+								[5, "1"]
+							],
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"trail"
+								],
+								[5, "2"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"fade",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"fade"
+								],
+								[5, "0"]
+							],
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"fade"
+								],
+								[5, "1"]
+							],
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"fade"
+								],
+								[5, "2"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"bg",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"background"
+								],
+								[5, "0"]
+							],
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"background"
+								],
+								[5, "1"]
+							],
+							[
+								8,
+								[
+									7,
+									"PALETTE",
+									"background"
+								],
+								[5, "2"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"trailColor",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"trail",
+							"fade",
+							[
+								6,
+								[
+									7,
+									"std",
+									"clamp"
+								],
+								[
+									"tailProgress",
+									[5, "0"],
+									[5, "1"]
+								]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"baseColor",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							"trailColor",
+							"head",
+							[
+								1,
+								"k",
+								"===",
+								[5, "0"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"emission",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[5, "1"],
+							[
+								7,
+								[
+									7,
+									"uniforms",
+									"$"
+								],
+								"headEmission"
+							],
+							"tailFalloff"
+						]
+					]
+				],
+				[
+					13,
+					"glyphColor",
+					[
+						1,
+						[
+							1,
+							"baseColor",
+							"*",
+							"brightness"
+						],
+						"*",
+						"emission"
+					]
+				],
+				[
+					13,
+					"finalRgb",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"bg",
+							"glyphColor",
+							"coverage"
+						]
+					]
+				],
+				[
+					13,
+					"color",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							"bg",
+							"finalRgb",
+							"inTail"
+						]
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					["color", [5, "1"]]
+				]]
+			]],
+			externalNames: [
+				"uniforms",
+				"d",
+				"std",
+				"columns",
+				"glyphIndex",
+				"atlasBindings",
+				"FAR_SOFTNESS",
+				"FALLOFF_POWER",
+				"brightnessJitter",
+				"PALETTE"
+			]
+		},
+		externals: () => ({
+			uniforms: n,
+			d: l,
+			std: u,
+			columns: t,
+			glyphIndex: P,
+			atlasBindings: k,
+			FAR_SOFTNESS: R,
+			FALLOFF_POWER: L,
+			brightnessJitter: F,
+			PALETTE: I
+		})
+	}) && e.f)({})), "fragMain");
+	return e.createRenderPipeline({
+		vertex: c.fullScreenTriangle,
+		fragment: i,
+		targets: { format: r }
+	});
+}
+//#endregion
+//#region src/gpu/pipelines/blit.ts
+var B = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.bindGroupLayout({
+	source: { texture: l.texture2d(l.f32) },
+	sampler: { sampler: "filtering" }
+}), "blitBindings");
+function V(e) {
+	let t = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.fragmentFn({
+		in: { uv: l.vec2f },
+		out: l.vec4f
+	})(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ uv: e }) => {
+		"use gpu";
+		return u.textureSample(B.$.source, B.$.sampler, e);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			params: [{
+				type: "d",
+				props: [{
+					name: "uv",
+					alias: "uv"
+				}]
+			}],
+			body: [0, [[10, [
+				6,
+				[
+					7,
+					"std",
+					"textureSample"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"blitBindings",
+							"$"
+						],
+						"source"
+					],
+					[
+						7,
+						[
+							7,
+							"blitBindings",
+							"$"
+						],
+						"sampler"
+					],
+					"uv"
+				]
+			]]]],
+			externalNames: ["std", "blitBindings"]
+		},
+		externals: () => ({
+			std: u,
+			blitBindings: B
+		})
+	}) && e.f)({})), "fragMain");
+	return e.createRenderPipeline({
+		vertex: c.fullScreenTriangle,
+		fragment: t
+	});
+}
+//#endregion
+//#region src/gpu/pipelines/crt.ts
+var H = 4;
+function te(e, t) {
+	let n = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.fragmentFn({
+		in: { uv: l.vec2f },
+		out: l.vec4f
+	})(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ uv: e }) => {
+		"use gpu";
+		let n = l.vec2f(__tsover_div(t.$.aberration, t.$.resolution.x), 0), r = u.textureSample(B.$.source, B.$.sampler, __tsover_add(e, n)).x, i = u.textureSample(B.$.source, B.$.sampler, e).y, a = u.textureSample(B.$.source, B.$.sampler, __tsover_sub(e, n)).z, o = u.saturate(l.vec3f(r, i, a)), s = __tsover_mul(t.$.resolution.y, __tsover_div(__tsover_mul(2, Math.PI), H)), c = __tsover_sub(1, __tsover_mul(t.$.scanlineStrength, __tsover_add(.5, __tsover_mul(.5, u.sin(__tsover_mul(e.y, s))))));
+		return o = __tsover_mul(o, c), l.vec4f(o, 1);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			params: [{
+				type: "d",
+				props: [{
+					name: "uv",
+					alias: "uv"
+				}]
+			}],
+			body: [0, [
+				[
+					13,
+					"offset",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								7,
+								[
+									7,
+									"uniforms",
+									"$"
+								],
+								"aberration"
+							],
+							"/",
+							[
+								7,
+								[
+									7,
+									[
+										7,
+										"uniforms",
+										"$"
+									],
+									"resolution"
+								],
+								"x"
+							]
+						], [5, "0"]]
+					]
+				],
+				[
+					13,
+					"r",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"+",
+									"offset"
+								]
+							]
+						],
+						"x"
+					]
+				],
+				[
+					13,
+					"g",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								"uv"
+							]
+						],
+						"y"
+					]
+				],
+				[
+					13,
+					"b",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"-",
+									"offset"
+								]
+							]
+						],
+						"z"
+					]
+				],
+				[
+					12,
+					"color",
+					[
+						6,
+						[
+							7,
+							"std",
+							"saturate"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								"r",
+								"g",
+								"b"
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"scanFreq",
+					[
+						1,
+						[
+							7,
+							[
+								7,
+								[
+									7,
+									"uniforms",
+									"$"
+								],
+								"resolution"
+							],
+							"y"
+						],
+						"*",
+						[
+							1,
+							[
+								1,
+								[5, "2"],
+								"*",
+								[
+									7,
+									"Math",
+									"PI"
+								]
+							],
+							"/",
+							"SCANLINE_PERIOD_PX"
+						]
+					]
+				],
+				[
+					13,
+					"scan",
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"uniforms",
+									"$"
+								],
+								"scanlineStrength"
+							],
+							"*",
+							[
+								1,
+								[5, "0.5"],
+								"+",
+								[
+									1,
+									[5, "0.5"],
+									"*",
+									[
+										6,
+										[
+											7,
+											"std",
+											"sin"
+										],
+										[[
+											1,
+											[
+												7,
+												"uv",
+												"y"
+											],
+											"*",
+											"scanFreq"
+										]]
+									]
+								]
+							]
+						]
+					]
+				],
+				[
+					2,
+					"color",
+					"=",
+					[
+						1,
+						"color",
+						"*",
+						"scan"
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					["color", [5, "1"]]
+				]]
+			]],
+			externalNames: [
+				"d",
+				"uniforms",
+				"std",
+				"blitBindings",
+				"Math",
+				"SCANLINE_PERIOD_PX"
+			]
+		},
+		externals: () => ({
+			d: l,
+			uniforms: t,
+			std: u,
+			blitBindings: B,
+			Math,
+			SCANLINE_PERIOD_PX: H
+		})
+	}) && e.f)({})), "fragMain");
+	return e.createRenderPipeline({
+		vertex: c.fullScreenTriangle,
+		fragment: n
+	});
+}
+//#endregion
+//#region src/gpu/pipelines/bloom.ts
+function ne(e, t, n) {
+	let r = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.fragmentFn({
+		in: { uv: l.vec2f },
+		out: l.vec4f
+	})(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ uv: e }) => {
+		"use gpu";
+		let n = u.textureSample(B.$.source, B.$.sampler, e), r = t.$.bloomThreshold, i = u.max(__tsover_sub(n.rgb, l.vec3f(r)), l.vec3f(0));
+		return l.vec4f(i, 1);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			params: [{
+				type: "d",
+				props: [{
+					name: "uv",
+					alias: "uv"
+				}]
+			}],
+			body: [0, [
+				[
+					13,
+					"src",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureSample"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"blitBindings",
+									"$"
+								],
+								"source"
+							],
+							[
+								7,
+								[
+									7,
+									"blitBindings",
+									"$"
+								],
+								"sampler"
+							],
+							"uv"
+						]
+					]
+				],
+				[
+					13,
+					"threshold",
+					[
+						7,
+						[
+							7,
+							"uniforms",
+							"$"
+						],
+						"bloomThreshold"
+					]
+				],
+				[
+					13,
+					"bright",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							[
+								7,
+								"src",
+								"rgb"
+							],
+							"-",
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								["threshold"]
+							]
+						], [
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[[5, "0"]]
+						]]
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					["bright", [5, "1"]]
+				]]
+			]],
+			externalNames: [
+				"std",
+				"blitBindings",
+				"uniforms",
+				"d"
+			]
+		},
+		externals: () => ({
+			std: u,
+			blitBindings: B,
+			uniforms: t,
+			d: l
+		})
+	}) && e.f)({})), "fragMain");
+	return e.createRenderPipeline({
+		vertex: c.fullScreenTriangle,
+		fragment: r,
+		targets: { format: n }
+	});
+}
+var U = 1.8;
+function W(e, t) {
+	let n = [];
+	for (let r = 0; r <= t; r++) n.push(Math.exp(-(r * r) / (2 * e * e)));
+	let r = n[0] + 2 * n.slice(1).reduce((e, t) => e + t, 0);
+	return n.map((e) => e / r);
+}
+function G(e, t, n, r) {
+	let [i, a, o, s, f] = W(U, 4), p = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.fragmentFn({
+		in: { uv: l.vec2f },
+		out: l.vec4f
+	})(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ uv: e }) => {
+		"use gpu";
+		let n = __tsover_div(l.vec2f(2, 2), t.$.resolution), c = __tsover_mul(l.vec2f(r[0], r[1]), n), d = u.textureSample(B.$.source, B.$.sampler, e).rgb, p = u.textureSample(B.$.source, B.$.sampler, __tsover_add(e, c)).rgb, m = u.textureSample(B.$.source, B.$.sampler, __tsover_sub(e, c)).rgb, h = u.textureSample(B.$.source, B.$.sampler, __tsover_add(e, __tsover_mul(c, 2))).rgb, g = u.textureSample(B.$.source, B.$.sampler, __tsover_sub(e, __tsover_mul(c, 2))).rgb, _ = u.textureSample(B.$.source, B.$.sampler, __tsover_add(e, __tsover_mul(c, 3))).rgb, v = u.textureSample(B.$.source, B.$.sampler, __tsover_sub(e, __tsover_mul(c, 3))).rgb, y = u.textureSample(B.$.source, B.$.sampler, __tsover_add(e, __tsover_mul(c, 4))).rgb, b = u.textureSample(B.$.source, B.$.sampler, __tsover_sub(e, __tsover_mul(c, 4))).rgb, x = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(d, i), __tsover_mul(__tsover_add(p, m), a)), __tsover_mul(__tsover_add(h, g), o)), __tsover_mul(__tsover_add(_, v), s)), __tsover_mul(__tsover_add(y, b), f));
+		return l.vec4f(x, 1);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			params: [{
+				type: "d",
+				props: [{
+					name: "uv",
+					alias: "uv"
+				}]
+			}],
+			body: [0, [
+				[
+					13,
+					"texelDimension",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "2"], [5, "2"]]
+						],
+						"/",
+						[
+							7,
+							[
+								7,
+								"uniforms",
+								"$"
+							],
+							"resolution"
+						]
+					]
+				],
+				[
+					13,
+					"step",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								8,
+								"direction",
+								[5, "0"]
+							], [
+								8,
+								"direction",
+								[5, "1"]
+							]]
+						],
+						"*",
+						"texelDimension"
+					]
+				],
+				[
+					13,
+					"c",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								"uv"
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"p1",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"+",
+									"step"
+								]
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"n1",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"-",
+									"step"
+								]
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"p2",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"+",
+									[
+										1,
+										"step",
+										"*",
+										[5, "2"]
+									]
+								]
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"n2",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"-",
+									[
+										1,
+										"step",
+										"*",
+										[5, "2"]
+									]
+								]
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"p3",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"+",
+									[
+										1,
+										"step",
+										"*",
+										[5, "3"]
+									]
+								]
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"n3",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"-",
+									[
+										1,
+										"step",
+										"*",
+										[5, "3"]
+									]
+								]
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"p4",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"+",
+									[
+										1,
+										"step",
+										"*",
+										[5, "4"]
+									]
+								]
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"n4",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureSample"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"source"
+								],
+								[
+									7,
+									[
+										7,
+										"blitBindings",
+										"$"
+									],
+									"sampler"
+								],
+								[
+									1,
+									"uv",
+									"-",
+									[
+										1,
+										"step",
+										"*",
+										[5, "4"]
+									]
+								]
+							]
+						],
+						"rgb"
+					]
+				],
+				[
+					13,
+					"blurred",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"c",
+										"*",
+										"w0"
+									],
+									"+",
+									[
+										1,
+										[
+											1,
+											"p1",
+											"+",
+											"n1"
+										],
+										"*",
+										"w1"
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										1,
+										"p2",
+										"+",
+										"n2"
+									],
+									"*",
+									"w2"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									1,
+									"p3",
+									"+",
+									"n3"
+								],
+								"*",
+								"w3"
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								"p4",
+								"+",
+								"n4"
+							],
+							"*",
+							"w4"
+						]
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					["blurred", [5, "1"]]
+				]]
+			]],
+			externalNames: [
+				"d",
+				"uniforms",
+				"direction",
+				"std",
+				"blitBindings",
+				"w0",
+				"w1",
+				"w2",
+				"w3",
+				"w4"
+			]
+		},
+		externals: () => ({
+			d: l,
+			uniforms: t,
+			direction: r,
+			std: u,
+			blitBindings: B,
+			w0: i,
+			w1: a,
+			w2: o,
+			w3: s,
+			w4: f
+		})
+	}) && e.f)({})), "fragMain");
+	return e.createRenderPipeline({
+		vertex: c.fullScreenTriangle,
+		fragment: p,
+		targets: { format: n }
+	});
+}
+var K = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.bindGroupLayout({
+	scene: { texture: l.texture2d(l.f32) },
+	bloom: { texture: l.texture2d(l.f32) },
+	sampler: { sampler: "filtering" }
+}), "combineBindings");
+function re(e, t, n) {
+	let r = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(d.fragmentFn({
+		in: { uv: l.vec2f },
+		out: l.vec4f
+	})(/*#__PURE__*/ ((e) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(e.f = (({ uv: e }) => {
+		"use gpu";
+		let n = u.textureSample(K.$.scene, K.$.sampler, e), r = u.textureSample(K.$.bloom, K.$.sampler, e), i = __tsover_add(n.rgb, __tsover_mul(r.rgb, t.$.bloomIntensity));
+		return l.vec4f(i, 1);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			params: [{
+				type: "d",
+				props: [{
+					name: "uv",
+					alias: "uv"
+				}]
+			}],
+			body: [0, [
+				[
+					13,
+					"scene",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureSample"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"combineBindings",
+									"$"
+								],
+								"scene"
+							],
+							[
+								7,
+								[
+									7,
+									"combineBindings",
+									"$"
+								],
+								"sampler"
+							],
+							"uv"
+						]
+					]
+				],
+				[
+					13,
+					"bloom",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureSample"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"combineBindings",
+									"$"
+								],
+								"bloom"
+							],
+							[
+								7,
+								[
+									7,
+									"combineBindings",
+									"$"
+								],
+								"sampler"
+							],
+							"uv"
+						]
+					]
+				],
+				[
+					13,
+					"combined",
+					[
+						1,
+						[
+							7,
+							"scene",
+							"rgb"
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"bloom",
+								"rgb"
+							],
+							"*",
+							[
+								7,
+								[
+									7,
+									"uniforms",
+									"$"
+								],
+								"bloomIntensity"
+							]
+						]
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					["combined", [5, "1"]]
+				]]
+			]],
+			externalNames: [
+				"std",
+				"combineBindings",
+				"uniforms",
+				"d"
+			]
+		},
+		externals: () => ({
+			std: u,
+			combineBindings: K,
+			uniforms: t,
+			d: l
+		})
+	}) && e.f)({})), "fragMain");
+	return e.createRenderPipeline({
+		vertex: c.fullScreenTriangle,
+		fragment: r,
+		targets: { format: n }
+	});
+}
+//#endregion
+//#region src/gpu/render-graph.ts
+var q = "rgba16float";
+function J(e, t, n, r, i) {
+	let a = Math.max(1, Math.floor(t / n)), [o, s] = r, [c, l] = i;
+	return Array.from({ length: e }, () => {
+		let e = s - o, t = e > 0 ? o + e * Math.random() : o, n = e > 0 ? (t - o) / e : 1, r = c + (l - c) * Math.random();
+		return {
+			headY: Math.random() * 2 * a - a,
+			speed: t,
+			depth: n,
+			tailLength: r,
+			seed: Math.floor(Math.random() * 4294967295)
+		};
+	});
+}
+function Y(e) {
+	let { root: t, ctx: n, atlas: r, cellSize: i } = e, a = e.density, o = e.stepRate, s = e.tailRange, c = e.bloom, u = e.crt, d = e.parallax, f = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t.createUniform(D, {
+		time: 0,
+		stepProgress: 0,
+		resolution: l.vec2f(0, 0),
+		cellSize: i,
+		density: a,
+		depthDim: d.depthDim,
+		bloomThreshold: c.threshold,
+		bloomIntensity: c.intensity,
+		headEmission: c.enabled ? c.emission : 1,
+		scanlineStrength: u.scanlineStrength,
+		aberration: u.aberration
+	}), "uniforms"), p = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t.createTexture({
+		size: [
+			r.layerSize,
+			r.layerSize,
+			r.layerCount
+		],
+		format: "r8unorm"
+	}).$usage("sampled"), "atlasTexture"), m = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t.createSampler({
+		magFilter: "linear",
+		minFilter: "linear",
+		addressModeU: "clamp-to-edge",
+		addressModeV: "clamp-to-edge"
+	}), "atlasSampler"), h = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t.createSampler({
+		magFilter: "linear",
+		minFilter: "linear",
+		addressModeU: "clamp-to-edge",
+		addressModeV: "clamp-to-edge"
+	}), "blitSampler");
+	t.device.queue.writeTexture({ texture: t.unwrap(p) }, r.data, {
+		bytesPerRow: r.layerSize,
+		rowsPerImage: r.layerSize
+	}, [
+		r.layerSize,
+		r.layerSize,
+		r.layerCount
+	]);
+	let g = t.createBindGroup(k, {
+		atlas: /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(p.createView(l.texture2dArray(l.f32)), "atlas"),
+		sampler: m
+	}), _ = V(t), v = ne(t, f, q), y = G(t, f, q, [1, 0]), b = G(t, f, q, [0, 1]), x = re(t, f, q), S = te(t, f), C = null, w = null, T = null, O = 0, A = 0, j = 0;
+	function M(e, n) {
+		let r = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t.createTexture({
+			size: [e, n],
+			format: q
+		}).$usage("sampled", "render"), "texture");
+		return {
+			texture: r,
+			bindGroup: t.createBindGroup(B, {
+				source: /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(r.createView(l.texture2d(l.f32)), "source"),
+				sampler: h
+			})
+		};
+	}
+	function N(e, n) {
+		return t.createBindGroup(K, {
+			scene: /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(e.texture.createView(l.texture2d(l.f32)), "scene"),
+			bloom: /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(n.texture.createView(l.texture2d(l.f32)), "bloom"),
+			sampler: h
+		});
+	}
+	let P = null, F = null, I = null, L = null, R = null, H = null, U = 0, W = 0;
+	function Y(e, n) {
+		A = n;
+		let r = Math.max(1, Math.floor(e / i));
+		if (r !== O && (C?.buffer.destroy(), O = r, C = /*#__PURE__*/ (globalThis.__TYPEGPU_AUTONAME__ ?? ((e) => e))(t.createMutable(l.arrayOf(E, O)), "columns"), C.write(J(O, n, i, d.speedRange, s)), w = ee(t, C, f), T = z(t, C, f, q)), e !== U || n !== W) {
+			U = e, W = n;
+			let t = Math.max(1, Math.floor(e / 2)), r = Math.max(1, Math.floor(n / 2));
+			P?.texture.destroy(), P = M(e, n), F?.texture.destroy(), F = M(t, r), I?.texture.destroy(), I = M(t, r), L?.texture.destroy(), L = M(t, r), R?.texture.destroy(), R = M(e, n), H = N(P, L);
+		}
+		f.patch({ resolution: l.vec2f(e, n) });
+	}
+	function X() {
+		C && C.write(J(O, A, i, d.speedRange, s));
+	}
+	function Z(e, t) {
+		j += e;
+		let n = 1 / o;
+		f.patch({
+			time: t,
+			density: a,
+			depthDim: d.depthDim,
+			bloomThreshold: c.threshold,
+			bloomIntensity: c.intensity,
+			headEmission: c.enabled ? c.emission : 1,
+			scanlineStrength: u.scanlineStrength,
+			aberration: u.aberration
+		});
+		let r = Math.ceil(O / 64);
+		for (; j >= n;) j -= n, w && r > 0 && w.dispatchWorkgroups(r);
+		f.patch({ stepProgress: j / n });
+	}
+	function Q() {
+		let e = Math.ceil(O / 64);
+		if (!w || e <= 0 || A <= 0) return;
+		let t = A / i, n = Math.max((d.speedRange[0] + d.speedRange[1]) / 2, 1e-4), r = Math.max(1, Math.ceil(t / n)), a = 1 / o;
+		for (let t = 0; t < r; t++) f.patch({ time: (t + 1) * a }), w.dispatchWorkgroups(e);
+		f.patch({ stepProgress: 0 });
+	}
+	function ie() {
+		if (!T || !P) return;
+		T.with(g).withColorAttachment({ view: P.texture }).draw(3);
+		let e = P;
+		c.enabled && F && I && L && H && R && (v.with(P.bindGroup).withColorAttachment({ view: F.texture }).draw(3), y.with(F.bindGroup).withColorAttachment({ view: I.texture }).draw(3), b.with(I.bindGroup).withColorAttachment({ view: L.texture }).draw(3), x.with(H).withColorAttachment({ view: R.texture }).draw(3), e = R), (u.enabled ? S : _).with(e.bindGroup).withColorAttachment({ view: n }).draw(3);
+	}
+	function ae(e) {
+		a = e;
+	}
+	function oe(e) {
+		o = e;
+	}
+	function se(e) {
+		s = e;
+	}
+	function ce(e) {
+		c = e;
+	}
+	function le(e) {
+		u = e;
+	}
+	function $(e) {
+		d = e;
+	}
+	function ue() {
+		f.buffer.destroy(), C?.buffer.destroy(), C = null, w = null, T = null, P?.texture.destroy(), P = null, F?.texture.destroy(), F = null, I?.texture.destroy(), I = null, L?.texture.destroy(), L = null, R?.texture.destroy(), R = null;
+	}
+	function de() {
+		return O;
+	}
+	return {
+		resize: Y,
+		step: Z,
+		settle: Q,
+		render: ie,
+		setDensity: ae,
+		setStepRate: oe,
+		setTailRange: se,
+		setBloom: ce,
+		setCrt: le,
+		setParallax: $,
+		regenerate: X,
+		getColumnCount: de,
+		dispose: ue
+	};
+}
+//#endregion
+//#region src/hooks/use-matrix-rain-renderer.ts
+function X(i) {
+	let a = o(), s = n(null), c = n(i);
+	c.current = i;
+	let [l, u] = r(0), d = n(0), f = n(null), p = n(!1);
+	t(() => {
+		let e = !1;
+		return x().then((t) => {
+			e || (f.current = t);
+		}), () => {
+			e = !0;
+		};
+	}, []), t(() => () => {
+		s.current?.dispose(), s.current = null, d.current = 0, u(0);
+	}, [i.cellSize]);
+	let [m, h] = i.parallax.speedRange, [g, _] = i.tailRange;
+	t(() => {
+		let e = s.current;
+		e && (e.setParallax(i.parallax), e.setTailRange(i.tailRange), e.regenerate());
+	}, [
+		m,
+		h,
+		g,
+		_
+	]);
+	function v(e, t) {
+		if (!p.current) try {
+			y(e, t);
+		} catch (e) {
+			p.current = !0, s.current?.dispose(), s.current = null;
+			let t = e instanceof Error ? e : Error(String(e)), n = c.current.onError;
+			n ? n(t) : console.error("[matrix-rain] renderer stopped after error:", t);
+		}
+	}
+	function y(e, t) {
+		let n = c.current.ctxRef.current, r = f.current;
+		if (!n || !r) return;
+		let i = n.canvas, o = i.width === 300 && i.height === 150, l = "clientWidth" in i && (i.clientWidth !== 300 || i.clientHeight !== 150);
+		if (o && l) return;
+		if (!s.current) {
+			let e = Y({
+				root: a,
+				ctx: n,
+				atlas: r,
+				cellSize: c.current.cellSize,
+				density: c.current.density,
+				stepRate: c.current.stepRate,
+				tailRange: c.current.tailRange,
+				bloom: c.current.bloom,
+				crt: c.current.crt,
+				parallax: c.current.parallax
+			});
+			e.resize(n.canvas.width, n.canvas.height), e.settle(), s.current = e;
+		}
+		let p = s.current;
+		p.resize(i.width, i.height), p.setDensity(c.current.density), p.setStepRate(c.current.stepRate), p.setParallax(c.current.parallax), p.setBloom(c.current.bloom), p.setCrt(c.current.crt), c.current.paused || p.step(e, t), p.render();
+		let m = p.getColumnCount();
+		m !== d.current && (d.current = m, u(m));
+	}
+	return {
+		tick: v,
+		regenerate: e(() => {
+			s.current?.regenerate();
+		}, []),
+		columnCount: l
+	};
+}
+//#endregion
+//#region src/matrix-rain.tsx
+var Z = {
+	rain: {
+		fontSize: 20,
+		density: .95,
+		stepRate: 10,
+		tailRange: [8, 35]
+	},
+	parallax: {
+		speedRange: [.4, 1.5],
+		depthDim: .3
+	},
+	bloom: {
+		intensity: 1.5,
+		threshold: .8,
+		emission: 1.1
+	},
+	crt: {
+		scanlineStrength: .3,
+		aberration: 1
+	}
+}, Q = typeof window > "u" ? 1 : window.devicePixelRatio || 1, [ie, ae, oe] = I.background, se = {
+	position: "absolute",
+	inset: 0,
+	width: "100%",
+	height: "100%",
+	display: "block",
+	pointerEvents: "none",
+	backgroundColor: `rgb(${Math.round(ie * 255)}, ${Math.round(ae * 255)}, ${Math.round(oe * 255)})`
+};
+function ce(e) {
+	return {
+		fontSize: e?.fontSize ?? Z.rain.fontSize,
+		density: e?.density ?? Z.rain.density,
+		stepRate: e?.stepRate ?? Z.rain.stepRate,
+		tailRange: e?.tailRange ?? Z.rain.tailRange
+	};
+}
+function le(e) {
+	return {
+		enabled: e !== !1,
+		intensity: (e || void 0)?.intensity ?? Z.bloom.intensity,
+		threshold: (e || void 0)?.threshold ?? Z.bloom.threshold,
+		emission: (e || void 0)?.emission ?? Z.bloom.emission
+	};
+}
+function $(e) {
+	return {
+		enabled: e !== !1,
+		scanlineStrength: (e || void 0)?.scanlineStrength ?? Z.crt.scanlineStrength,
+		aberration: (e || void 0)?.aberration ?? Z.crt.aberration
+	};
+}
+function ue(e) {
+	return e === !1 ? {
+		speedRange: [1, 1],
+		depthDim: 0
+	} : {
+		speedRange: e?.speedRange ?? Z.parallax.speedRange,
+		depthDim: e?.depthDim ?? Z.parallax.depthDim
+	};
+}
+function de(e) {
+	let n = s(), r = n.status, i = r === "rejected" ? n.error : void 0, a = e.onError;
+	return t(() => {
+		if (r !== "rejected") return;
+		let e = i instanceof Error ? i : Error(String(i));
+		a ? a(e) : console.warn("[matrix-rain] WebGPU unavailable; rendering nothing.", e);
+	}, [
+		r,
+		i,
+		a
+	]), t(() => {
+		n.status === "resolved" && n.value.device.lost.then((e) => {
+			console.warn("[matrix-rain] GPUDevice lost:", e.reason, e.message);
+		});
+	}, [n]), r === "resolved" ? /* @__PURE__ */ p(fe, { ...e }) : null;
+}
+function fe(e) {
+	let { ref: t, ctxRef: n } = i({
+		autoResize: !0,
+		alphaMode: "premultiplied"
+	}), r = ce(e.rain), o = X({
+		ctxRef: n,
+		cellSize: r.fontSize * Q,
+		density: r.density,
+		stepRate: r.stepRate,
+		tailRange: r.tailRange,
+		bloom: le(e.bloom),
+		crt: $(e.crt),
+		parallax: ue(e.parallax),
+		paused: e.paused ?? !1,
+		onError: e.onError
+	});
+	return a(({ deltaSeconds: e, elapsedSeconds: t }) => {
+		o.tick(e, t);
+	}), /* @__PURE__ */ p("canvas", {
+		ref: t,
+		className: e.className,
+		style: se
+	});
+}
+//#endregion
+//#region src/gpu/feature-detect.ts
+var pe = () => typeof navigator < "u" && "gpu" in navigator;
+//#endregion
+export { de as MatrixRainWebGPU, pe as isWebGPUSupported };