shaders 3.0.440 → 3.0.442

package/dist/core/ReactionDiffusion-BpLbPwbw.js

@@ -0,0 +1,4640 @@
+import { Ft as floatE, H as createStateBuffer, Kt as colorMixing_exports, Lt as vec4, V as createGuardedCompute, jt as call, kt as ZERO, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
+import { a as transformColor, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
+var cm = colorMixing_exports;
+var N = 512;
+var COUNT = N * N;
+var STATE_FORMAT = "rgba16float";
+var MAX_ITERATIONS = 16;
+var SEED_DENSITY = .06;
+var RELIEF_EPS = 1.5 / N;
+var RELIEF_STRENGTH = 6;
+var RELIEF_AMBIENT = .42;
+var RELIEF_LIGHT_XY = .85;
+var RELIEF_LIGHT_Z = .55;
+var RELIEF_SHININESS = 18;
+var RELIEF_SPEC = .35;
+var DEG2RAD = Math.PI / 180;
+var PRESETS = {
+	coral: {
+		feed: .0545,
+		kill: .062
+	},
+	mitosis: {
+		feed: .0367,
+		kill: .0649
+	},
+	spots: {
+		feed: .03,
+		kill: .062
+	},
+	maze: {
+		feed: .029,
+		kill: .057
+	},
+	worms: {
+		feed: .078,
+		kill: .061
+	},
+	fingerprints: {
+		feed: .037,
+		kill: .06
+	},
+	holes: {
+		feed: .039,
+		kill: .058
+	},
+	solitons: {
+		feed: .074,
+		kill: .064
+	},
+	bubbles: {
+		feed: .098,
+		kill: .0555
+	},
+	waves: {
+		feed: .014,
+		kill: .045
+	},
+	flowers: {
+		feed: .062,
+		kill: .06093
+	}
+};
+var CHILD_CONTRAST_MAX = 8;
+var CHILD_DFEED = .022;
+var CHILD_DKILL = .014;
+var CHILD_FEED_MIN = .008;
+var CHILD_FEED_MAX = .11;
+var CHILD_KILL_MIN = .03;
+var CHILD_KILL_MAX = .075;
+var RDParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	feed: d.f32,
+	kill: d.f32,
+	dv: d.f32,
+	brushRadSq: d.f32,
+	brushStrength: d.f32,
+	cursorX: d.f32,
+	cursorY: d.f32,
+	cursorActive: d.f32,
+	childInfluence: d.f32,
+	childContrast: d.f32,
+	childThreshold: d.f32,
+	childInvert: d.f32,
+	childMapX: d.f32,
+	childMapY: d.f32,
+	_pad0: d.f32,
+	_pad1: d.f32
+}), "RDParams");
+var reactionLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	readBuf: {
+		storage: d.arrayOf(d.vec2f, COUNT),
+		access: "readonly"
+	},
+	writeBuf: {
+		storage: d.arrayOf(d.vec2f, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: RDParams }
+}), "reactionLayout");
+var seedLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({ stateBuf: {
+	storage: d.arrayOf(d.vec2f, COUNT),
+	access: "mutable"
+} }), "seedLayout");
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	srcBuf: {
+		storage: d.arrayOf(d.vec2f, COUNT),
+		access: "readonly"
+	},
+	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+}), "outputLayout");
+var reactionChildLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	readBuf: {
+		storage: d.arrayOf(d.vec2f, COUNT),
+		access: "readonly"
+	},
+	writeBuf: {
+		storage: d.arrayOf(d.vec2f, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: RDParams },
+	childTex: { texture: d.texture2d(d.f32) }
+}), "reactionChildLayout");
+var nbrState = tgpu.fn([
+	d.i32,
+	d.i32,
+	d.i32,
+	d.i32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
+	"use gpu";
+	const row = std.clamp(__tsover_add(ii, di), 0, __tsover_sub(N, 1));
+	const col = std.clamp(__tsover_add(ji, dj), 0, __tsover_sub(N, 1));
+	return reactionLayout.$.readBuf[d.u32(__tsover_add(__tsover_mul(row, N), col))];
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "ii"
+			},
+			{
+				"type": "i",
+				"name": "ji"
+			},
+			{
+				"type": "i",
+				"name": "di"
+			},
+			{
+				"type": "i",
+				"name": "dj"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"row",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"ii",
+							"+",
+							"di"
+						],
+						[5, "0"],
+						[
+							1,
+							"N",
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"col",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"ji",
+							"+",
+							"dj"
+						],
+						[5, "0"],
+						[
+							1,
+							"N",
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[10, [
+				8,
+				[
+					7,
+					[
+						7,
+						"reactionLayout",
+						"$"
+					],
+					"readBuf"
+				],
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						1,
+						[
+							1,
+							"row",
+							"*",
+							"N"
+						],
+						"+",
+						"col"
+					]]
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"N",
+			"reactionLayout",
+			"d"
+		]
+	},
+	externals: () => ({
+		std,
+		N,
+		reactionLayout,
+		d
+	})
+}) && $.f)({})).$name("reactionDiffusionNbr");
+const reactionKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = reactionLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const self = reactionLayout.$.readBuf[idx];
+	const ii = d.i32(cy);
+	const ji = d.i32(cx);
+	const L = nbrState(ii, ji, 0, -1);
+	const R = nbrState(ii, ji, 0, 1);
+	const T = nbrState(ii, ji, -1, 0);
+	const B = nbrState(ii, ji, 1, 0);
+	const TL = nbrState(ii, ji, -1, -1);
+	const TR = nbrState(ii, ji, -1, 1);
+	const BL = nbrState(ii, ji, 1, -1);
+	const BR = nbrState(ii, ji, 1, 1);
+	const lapU = __tsover_sub(__tsover_add(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(L.x, R.x), T.x), B.x), .2), __tsover_mul(__tsover_add(__tsover_add(__tsover_add(TL.x, TR.x), BL.x), BR.x), .05)), self.x);
+	const lapV = __tsover_sub(__tsover_add(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(L.y, R.y), T.y), B.y), .2), __tsover_mul(__tsover_add(__tsover_add(__tsover_add(TL.y, TR.y), BL.y), BR.y), .05)), self.y);
+	const U = self.x;
+	const V = self.y;
+	const uvv = __tsover_mul(__tsover_mul(U, V), V);
+	let newU = __tsover_add(U, __tsover_add(__tsover_sub(lapU, uvv), __tsover_mul(p.feed, __tsover_sub(1, U))));
+	let newV = __tsover_add(V, __tsover_sub(__tsover_add(__tsover_mul(p.dv, lapV), uvv), __tsover_mul(__tsover_add(p.feed, p.kill), V)));
+	if (p.cursorActive > 0) {
+		const cellX = __tsover_add(d.f32(cx), .5);
+		const cellY = __tsover_add(d.f32(cy), .5);
+		const dxp = __tsover_sub(cellX, p.cursorX);
+		const dyp = __tsover_sub(cellY, p.cursorY);
+		const distSq = __tsover_add(__tsover_mul(dxp, dxp), __tsover_mul(dyp, dyp));
+		const inf = __tsover_mul(std.exp(__tsover_mul(__tsover_div(distSq, std.max(p.brushRadSq, d.f32(1))), -1)), p.cursorActive);
+		newV = std.min(__tsover_add(newV, __tsover_mul(inf, p.brushStrength)), d.f32(1));
+	}
+	newU = std.clamp(newU, 0, 1);
+	newV = std.clamp(newV, 0, 1);
+	reactionLayout.$.writeBuf[idx] = d.vec2f(newU, newV);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"reactionLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"self",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"reactionLayout",
+							"$"
+						],
+						"readBuf"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"ii",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"ji",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"L",
+				[
+					6,
+					"nbrState",
+					[
+						"ii",
+						"ji",
+						[5, "0"],
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"R",
+				[
+					6,
+					"nbrState",
+					[
+						"ii",
+						"ji",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"T",
+				[
+					6,
+					"nbrState",
+					[
+						"ii",
+						"ji",
+						[
+							4,
+							"-",
+							[5, "1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"B",
+				[
+					6,
+					"nbrState",
+					[
+						"ii",
+						"ji",
+						[5, "1"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"TL",
+				[
+					6,
+					"nbrState",
+					[
+						"ii",
+						"ji",
+						[
+							4,
+							"-",
+							[5, "1"]
+						],
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"TR",
+				[
+					6,
+					"nbrState",
+					[
+						"ii",
+						"ji",
+						[
+							4,
+							"-",
+							[5, "1"]
+						],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"BL",
+				[
+					6,
+					"nbrState",
+					[
+						"ii",
+						"ji",
+						[5, "1"],
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"BR",
+				[
+					6,
+					"nbrState",
+					[
+						"ii",
+						"ji",
+						[5, "1"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"lapU",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"L",
+											"x"
+										],
+										"+",
+										[
+											7,
+											"R",
+											"x"
+										]
+									],
+									"+",
+									[
+										7,
+										"T",
+										"x"
+									]
+								],
+								"+",
+								[
+									7,
+									"B",
+									"x"
+								]
+							],
+							"*",
+							[5, "0.2"]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"TL",
+											"x"
+										],
+										"+",
+										[
+											7,
+											"TR",
+											"x"
+										]
+									],
+									"+",
+									[
+										7,
+										"BL",
+										"x"
+									]
+								],
+								"+",
+								[
+									7,
+									"BR",
+									"x"
+								]
+							],
+							"*",
+							[5, "0.05"]
+						]
+					],
+					"-",
+					[
+						7,
+						"self",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"lapV",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"L",
+											"y"
+										],
+										"+",
+										[
+											7,
+											"R",
+											"y"
+										]
+									],
+									"+",
+									[
+										7,
+										"T",
+										"y"
+									]
+								],
+								"+",
+								[
+									7,
+									"B",
+									"y"
+								]
+							],
+							"*",
+							[5, "0.2"]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"TL",
+											"y"
+										],
+										"+",
+										[
+											7,
+											"TR",
+											"y"
+										]
+									],
+									"+",
+									[
+										7,
+										"BL",
+										"y"
+									]
+								],
+								"+",
+								[
+									7,
+									"BR",
+									"y"
+								]
+							],
+							"*",
+							[5, "0.05"]
+						]
+					],
+					"-",
+					[
+						7,
+						"self",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"U",
+				[
+					7,
+					"self",
+					"x"
+				]
+			],
+			[
+				13,
+				"V",
+				[
+					7,
+					"self",
+					"y"
+				]
+			],
+			[
+				13,
+				"uvv",
+				[
+					1,
+					[
+						1,
+						"U",
+						"*",
+						"V"
+					],
+					"*",
+					"V"
+				]
+			],
+			[
+				12,
+				"newU",
+				[
+					1,
+					"U",
+					"+",
+					[
+						1,
+						[
+							1,
+							"lapU",
+							"-",
+							"uvv"
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"p",
+								"feed"
+							],
+							"*",
+							[
+								1,
+								[5, "1"],
+								"-",
+								"U"
+							]
+						]
+					]
+				]
+			],
+			[
+				12,
+				"newV",
+				[
+					1,
+					"V",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"dv"
+								],
+								"*",
+								"lapV"
+							],
+							"+",
+							"uvv"
+						],
+						"-",
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"feed"
+								],
+								"+",
+								[
+									7,
+									"p",
+									"kill"
+								]
+							],
+							"*",
+							"V"
+						]
+					]
+				]
+			],
+			[
+				11,
+				[
+					1,
+					[
+						7,
+						"p",
+						"cursorActive"
+					],
+					">",
+					[5, "0"]
+				],
+				[0, [
+					[
+						13,
+						"cellX",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cx"]
+							],
+							"+",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"cellY",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cy"]
+							],
+							"+",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"dxp",
+						[
+							1,
+							"cellX",
+							"-",
+							[
+								7,
+								"p",
+								"cursorX"
+							]
+						]
+					],
+					[
+						13,
+						"dyp",
+						[
+							1,
+							"cellY",
+							"-",
+							[
+								7,
+								"p",
+								"cursorY"
+							]
+						]
+					],
+					[
+						13,
+						"distSq",
+						[
+							1,
+							[
+								1,
+								"dxp",
+								"*",
+								"dxp"
+							],
+							"+",
+							[
+								1,
+								"dyp",
+								"*",
+								"dyp"
+							]
+						]
+					],
+					[
+						13,
+						"inf",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"exp"
+								],
+								[[
+									1,
+									[
+										1,
+										"distSq",
+										"/",
+										[
+											6,
+											[
+												7,
+												"std",
+												"max"
+											],
+											[[
+												7,
+												"p",
+												"brushRadSq"
+											], [
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												[[5, "1"]]
+											]]
+										]
+									],
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								]]
+							],
+							"*",
+							[
+								7,
+								"p",
+								"cursorActive"
+							]
+						]
+					],
+					[
+						2,
+						"newV",
+						"=",
+						[
+							6,
+							[
+								7,
+								"std",
+								"min"
+							],
+							[[
+								1,
+								"newV",
+								"+",
+								[
+									1,
+									"inf",
+									"*",
+									[
+										7,
+										"p",
+										"brushStrength"
+									]
+								]
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							]]
+						]
+					]
+				]]
+			],
+			[
+				2,
+				"newU",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"newU",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				2,
+				"newV",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"newV",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"reactionLayout",
+							"$"
+						],
+						"writeBuf"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					["newU", "newV"]
+				]
+			]
+		]],
+		"externalNames": [
+			"reactionLayout",
+			"d",
+			"N",
+			"nbrState",
+			"std"
+		]
+	},
+	externals: () => ({
+		reactionLayout,
+		d,
+		N,
+		nbrState,
+		std
+	})
+}) && $.f)({})).$name("reactionDiffusionReact");
+var nbrStateChild = tgpu.fn([
+	d.i32,
+	d.i32,
+	d.i32,
+	d.i32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
+	"use gpu";
+	const row = std.clamp(__tsover_add(ii, di), 0, __tsover_sub(N, 1));
+	const col = std.clamp(__tsover_add(ji, dj), 0, __tsover_sub(N, 1));
+	return reactionChildLayout.$.readBuf[d.u32(__tsover_add(__tsover_mul(row, N), col))];
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "ii"
+			},
+			{
+				"type": "i",
+				"name": "ji"
+			},
+			{
+				"type": "i",
+				"name": "di"
+			},
+			{
+				"type": "i",
+				"name": "dj"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"row",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"ii",
+							"+",
+							"di"
+						],
+						[5, "0"],
+						[
+							1,
+							"N",
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"col",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"ji",
+							"+",
+							"dj"
+						],
+						[5, "0"],
+						[
+							1,
+							"N",
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[10, [
+				8,
+				[
+					7,
+					[
+						7,
+						"reactionChildLayout",
+						"$"
+					],
+					"readBuf"
+				],
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						1,
+						[
+							1,
+							"row",
+							"*",
+							"N"
+						],
+						"+",
+						"col"
+					]]
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"N",
+			"reactionChildLayout",
+			"d"
+		]
+	},
+	externals: () => ({
+		std,
+		N,
+		reactionChildLayout,
+		d
+	})
+}) && $.f)({})).$name("reactionDiffusionNbrChild");
+const rdChildDrive = tgpu.fn([d.u32, d.u32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = reactionChildLayout.$.params;
+	const dims = std.textureDimensions(reactionChildLayout.$.childTex);
+	const fw = d.f32(dims.x);
+	const fh = d.f32(dims.y);
+	const fx = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(N));
+	const fy = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(N));
+	const cu = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(fx, .5), p.childMapX), .5), d.f32(0), d.f32(1));
+	const cv = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(fy, .5), p.childMapY), .5), d.f32(0), d.f32(1));
+	const px = d.u32(std.min(__tsover_mul(cu, fw), __tsover_sub(fw, 1)));
+	const py = d.u32(std.min(__tsover_mul(cv, fh), __tsover_sub(fh, 1)));
+	const texel = std.textureLoad(reactionChildLayout.$.childTex, d.vec2u(px, py), 0);
+	const cov = std.clamp(texel.w, d.f32(0), d.f32(1));
+	const rgb = texel.xyz.div(std.max(texel.w, d.f32(.001)));
+	const luma = std.dot(rgb, d.vec3f(.2126, .7152, .0722));
+	const gain = __tsover_add(d.f32(1), __tsover_mul(p.childContrast, d.f32(CHILD_CONTRAST_MAX)));
+	const shaped = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(luma, p.childThreshold), gain), .5), d.f32(0), d.f32(1));
+	let signed = __tsover_mul(__tsover_sub(shaped, .5), 2);
+	signed = std.select(signed, __tsover_mul(signed, -1), p.childInvert > .5);
+	return __tsover_mul(signed, cov);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"reactionChildLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"dims",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureDimensions"
+					],
+					[[
+						7,
+						[
+							7,
+							"reactionChildLayout",
+							"$"
+						],
+						"childTex"
+					]]
+				]
+			],
+			[
+				13,
+				"fw",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[
+						7,
+						"dims",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"fh",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[
+						7,
+						"dims",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cx"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["N"]
+					]
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cy"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["N"]
+					]
+				]
+			],
+			[
+				13,
+				"cu",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"fx",
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								[
+									7,
+									"p",
+									"childMapX"
+								]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"cv",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"fy",
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								[
+									7,
+									"p",
+									"childMapY"
+								]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"px",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							1,
+							"cu",
+							"*",
+							"fw"
+						], [
+							1,
+							"fw",
+							"-",
+							[5, "1"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							1,
+							"cv",
+							"*",
+							"fh"
+						], [
+							1,
+							"fh",
+							"-",
+							[5, "1"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"texel",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"reactionChildLayout",
+								"$"
+							],
+							"childTex"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["px", "py"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"cov",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							7,
+							"texel",
+							"w"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"texel",
+							"xyz"
+						],
+						"div"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"texel",
+							"w"
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0.001"]]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"luma",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["rgb", [
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "0.2126"],
+							[5, "0.7152"],
+							[5, "0.0722"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"gain",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "1"]]
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"childContrast"
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["CHILD_CONTRAST_MAX"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"shaped",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"luma",
+									"-",
+									[
+										7,
+										"p",
+										"childThreshold"
+									]
+								],
+								"*",
+								"gain"
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[
+				12,
+				"signed",
+				[
+					1,
+					[
+						1,
+						"shaped",
+						"-",
+						[5, "0.5"]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[
+				2,
+				"signed",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"signed",
+						[
+							1,
+							"signed",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"p",
+								"childInvert"
+							],
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[10, [
+				1,
+				"signed",
+				"*",
+				"cov"
+			]]
+		]],
+		"externalNames": [
+			"reactionChildLayout",
+			"std",
+			"d",
+			"N",
+			"CHILD_CONTRAST_MAX"
+		]
+	},
+	externals: () => ({
+		reactionChildLayout,
+		std,
+		d,
+		N,
+		CHILD_CONTRAST_MAX
+	})
+}) && $.f)({})).$name("reactionDiffusionChildDrive");
+const reactionKernelChild = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = reactionChildLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const self = reactionChildLayout.$.readBuf[idx];
+	const ii = d.i32(cy);
+	const ji = d.i32(cx);
+	const L = nbrStateChild(ii, ji, 0, -1);
+	const R = nbrStateChild(ii, ji, 0, 1);
+	const T = nbrStateChild(ii, ji, -1, 0);
+	const B = nbrStateChild(ii, ji, 1, 0);
+	const TL = nbrStateChild(ii, ji, -1, -1);
+	const TR = nbrStateChild(ii, ji, -1, 1);
+	const BL = nbrStateChild(ii, ji, 1, -1);
+	const BR = nbrStateChild(ii, ji, 1, 1);
+	const lapU = __tsover_sub(__tsover_add(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(L.x, R.x), T.x), B.x), .2), __tsover_mul(__tsover_add(__tsover_add(__tsover_add(TL.x, TR.x), BL.x), BR.x), .05)), self.x);
+	const lapV = __tsover_sub(__tsover_add(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(L.y, R.y), T.y), B.y), .2), __tsover_mul(__tsover_add(__tsover_add(__tsover_add(TL.y, TR.y), BL.y), BR.y), .05)), self.y);
+	const mod = __tsover_mul(rdChildDrive(cx, cy), p.childInfluence);
+	const feedCell = std.clamp(__tsover_add(p.feed, __tsover_mul(mod, d.f32(CHILD_DFEED))), d.f32(CHILD_FEED_MIN), d.f32(CHILD_FEED_MAX));
+	const killCell = std.clamp(__tsover_sub(p.kill, __tsover_mul(mod, d.f32(CHILD_DKILL))), d.f32(CHILD_KILL_MIN), d.f32(CHILD_KILL_MAX));
+	const U = self.x;
+	const V = self.y;
+	const uvv = __tsover_mul(__tsover_mul(U, V), V);
+	let newU = __tsover_add(U, __tsover_add(__tsover_sub(lapU, uvv), __tsover_mul(feedCell, __tsover_sub(1, U))));
+	let newV = __tsover_add(V, __tsover_sub(__tsover_add(__tsover_mul(p.dv, lapV), uvv), __tsover_mul(__tsover_add(feedCell, killCell), V)));
+	if (p.cursorActive > 0) {
+		const cellX = __tsover_add(d.f32(cx), .5);
+		const cellY = __tsover_add(d.f32(cy), .5);
+		const dxp = __tsover_sub(cellX, p.cursorX);
+		const dyp = __tsover_sub(cellY, p.cursorY);
+		const distSq = __tsover_add(__tsover_mul(dxp, dxp), __tsover_mul(dyp, dyp));
+		const inf = __tsover_mul(std.exp(__tsover_mul(__tsover_div(distSq, std.max(p.brushRadSq, d.f32(1))), -1)), p.cursorActive);
+		newV = std.min(__tsover_add(newV, __tsover_mul(inf, p.brushStrength)), d.f32(1));
+	}
+	newU = std.clamp(newU, 0, 1);
+	newV = std.clamp(newV, 0, 1);
+	reactionChildLayout.$.writeBuf[idx] = d.vec2f(newU, newV);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"reactionChildLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"self",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"reactionChildLayout",
+							"$"
+						],
+						"readBuf"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"ii",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"ji",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"L",
+				[
+					6,
+					"nbrStateChild",
+					[
+						"ii",
+						"ji",
+						[5, "0"],
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"R",
+				[
+					6,
+					"nbrStateChild",
+					[
+						"ii",
+						"ji",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"T",
+				[
+					6,
+					"nbrStateChild",
+					[
+						"ii",
+						"ji",
+						[
+							4,
+							"-",
+							[5, "1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"B",
+				[
+					6,
+					"nbrStateChild",
+					[
+						"ii",
+						"ji",
+						[5, "1"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"TL",
+				[
+					6,
+					"nbrStateChild",
+					[
+						"ii",
+						"ji",
+						[
+							4,
+							"-",
+							[5, "1"]
+						],
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"TR",
+				[
+					6,
+					"nbrStateChild",
+					[
+						"ii",
+						"ji",
+						[
+							4,
+							"-",
+							[5, "1"]
+						],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"BL",
+				[
+					6,
+					"nbrStateChild",
+					[
+						"ii",
+						"ji",
+						[5, "1"],
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"BR",
+				[
+					6,
+					"nbrStateChild",
+					[
+						"ii",
+						"ji",
+						[5, "1"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"lapU",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"L",
+											"x"
+										],
+										"+",
+										[
+											7,
+											"R",
+											"x"
+										]
+									],
+									"+",
+									[
+										7,
+										"T",
+										"x"
+									]
+								],
+								"+",
+								[
+									7,
+									"B",
+									"x"
+								]
+							],
+							"*",
+							[5, "0.2"]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"TL",
+											"x"
+										],
+										"+",
+										[
+											7,
+											"TR",
+											"x"
+										]
+									],
+									"+",
+									[
+										7,
+										"BL",
+										"x"
+									]
+								],
+								"+",
+								[
+									7,
+									"BR",
+									"x"
+								]
+							],
+							"*",
+							[5, "0.05"]
+						]
+					],
+					"-",
+					[
+						7,
+						"self",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"lapV",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"L",
+											"y"
+										],
+										"+",
+										[
+											7,
+											"R",
+											"y"
+										]
+									],
+									"+",
+									[
+										7,
+										"T",
+										"y"
+									]
+								],
+								"+",
+								[
+									7,
+									"B",
+									"y"
+								]
+							],
+							"*",
+							[5, "0.2"]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"TL",
+											"y"
+										],
+										"+",
+										[
+											7,
+											"TR",
+											"y"
+										]
+									],
+									"+",
+									[
+										7,
+										"BL",
+										"y"
+									]
+								],
+								"+",
+								[
+									7,
+									"BR",
+									"y"
+								]
+							],
+							"*",
+							[5, "0.05"]
+						]
+					],
+					"-",
+					[
+						7,
+						"self",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"mod",
+				[
+					1,
+					[
+						6,
+						"rdChildDrive",
+						["cx", "cy"]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"childInfluence"
+					]
+				]
+			],
+			[
+				13,
+				"feedCell",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"p",
+								"feed"
+							],
+							"+",
+							[
+								1,
+								"mod",
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["CHILD_DFEED"]
+								]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["CHILD_FEED_MIN"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["CHILD_FEED_MAX"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"killCell",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"p",
+								"kill"
+							],
+							"-",
+							[
+								1,
+								"mod",
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["CHILD_DKILL"]
+								]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["CHILD_KILL_MIN"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["CHILD_KILL_MAX"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"U",
+				[
+					7,
+					"self",
+					"x"
+				]
+			],
+			[
+				13,
+				"V",
+				[
+					7,
+					"self",
+					"y"
+				]
+			],
+			[
+				13,
+				"uvv",
+				[
+					1,
+					[
+						1,
+						"U",
+						"*",
+						"V"
+					],
+					"*",
+					"V"
+				]
+			],
+			[
+				12,
+				"newU",
+				[
+					1,
+					"U",
+					"+",
+					[
+						1,
+						[
+							1,
+							"lapU",
+							"-",
+							"uvv"
+						],
+						"+",
+						[
+							1,
+							"feedCell",
+							"*",
+							[
+								1,
+								[5, "1"],
+								"-",
+								"U"
+							]
+						]
+					]
+				]
+			],
+			[
+				12,
+				"newV",
+				[
+					1,
+					"V",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"dv"
+								],
+								"*",
+								"lapV"
+							],
+							"+",
+							"uvv"
+						],
+						"-",
+						[
+							1,
+							[
+								1,
+								"feedCell",
+								"+",
+								"killCell"
+							],
+							"*",
+							"V"
+						]
+					]
+				]
+			],
+			[
+				11,
+				[
+					1,
+					[
+						7,
+						"p",
+						"cursorActive"
+					],
+					">",
+					[5, "0"]
+				],
+				[0, [
+					[
+						13,
+						"cellX",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cx"]
+							],
+							"+",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"cellY",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cy"]
+							],
+							"+",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"dxp",
+						[
+							1,
+							"cellX",
+							"-",
+							[
+								7,
+								"p",
+								"cursorX"
+							]
+						]
+					],
+					[
+						13,
+						"dyp",
+						[
+							1,
+							"cellY",
+							"-",
+							[
+								7,
+								"p",
+								"cursorY"
+							]
+						]
+					],
+					[
+						13,
+						"distSq",
+						[
+							1,
+							[
+								1,
+								"dxp",
+								"*",
+								"dxp"
+							],
+							"+",
+							[
+								1,
+								"dyp",
+								"*",
+								"dyp"
+							]
+						]
+					],
+					[
+						13,
+						"inf",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"exp"
+								],
+								[[
+									1,
+									[
+										1,
+										"distSq",
+										"/",
+										[
+											6,
+											[
+												7,
+												"std",
+												"max"
+											],
+											[[
+												7,
+												"p",
+												"brushRadSq"
+											], [
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												[[5, "1"]]
+											]]
+										]
+									],
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								]]
+							],
+							"*",
+							[
+								7,
+								"p",
+								"cursorActive"
+							]
+						]
+					],
+					[
+						2,
+						"newV",
+						"=",
+						[
+							6,
+							[
+								7,
+								"std",
+								"min"
+							],
+							[[
+								1,
+								"newV",
+								"+",
+								[
+									1,
+									"inf",
+									"*",
+									[
+										7,
+										"p",
+										"brushStrength"
+									]
+								]
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							]]
+						]
+					]
+				]]
+			],
+			[
+				2,
+				"newU",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"newU",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				2,
+				"newV",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"newV",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"reactionChildLayout",
+							"$"
+						],
+						"writeBuf"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					["newU", "newV"]
+				]
+			]
+		]],
+		"externalNames": [
+			"reactionChildLayout",
+			"d",
+			"N",
+			"nbrStateChild",
+			"rdChildDrive",
+			"std",
+			"CHILD_DFEED",
+			"CHILD_FEED_MIN",
+			"CHILD_FEED_MAX",
+			"CHILD_DKILL",
+			"CHILD_KILL_MIN",
+			"CHILD_KILL_MAX"
+		]
+	},
+	externals: () => ({
+		reactionChildLayout,
+		d,
+		N,
+		nbrStateChild,
+		rdChildDrive,
+		std,
+		CHILD_DFEED,
+		CHILD_FEED_MIN,
+		CHILD_FEED_MAX,
+		CHILD_DKILL,
+		CHILD_KILL_MIN,
+		CHILD_KILL_MAX
+	})
+}) && $.f)({})).$name("reactionDiffusionReactChild");
+const seedKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const s = __tsover_mul(std.sin(__tsover_add(__tsover_mul(d.f32(cx), 12.9898), __tsover_mul(d.f32(cy), 78.233))), 43758.5453);
+	const h = __tsover_sub(s, std.floor(s));
+	const vSeed = std.select(d.f32(0), d.f32(1), h < SEED_DENSITY);
+	seedLayout.$.stateBuf[idx] = d.vec2f(1, vSeed);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"s",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["cx"]
+								],
+								"*",
+								[5, "12.9898"]
+							],
+							"+",
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["cy"]
+								],
+								"*",
+								[5, "78.233"]
+							]
+						]]
+					],
+					"*",
+					[5, "43758.5453"]
+				]
+			],
+			[
+				13,
+				"h",
+				[
+					1,
+					"s",
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						["s"]
+					]
+				]
+			],
+			[
+				13,
+				"vSeed",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						[
+							1,
+							"h",
+							"<",
+							"SEED_DENSITY"
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"seedLayout",
+							"$"
+						],
+						"stateBuf"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[5, "1"], "vSeed"]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"std",
+			"SEED_DENSITY",
+			"seedLayout"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		std,
+		SEED_DENSITY,
+		seedLayout
+	})
+}) && $.f)({})).$name("reactionDiffusionSeed");
+const outputKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const s = outputLayout.$.srcBuf[idx];
+	std.textureStore(outputLayout.$.outTex, d.vec2u(cx, cy), d.vec4f(s.x, s.y, 0, 0));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"s",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"outputLayout",
+							"$"
+						],
+						"srcBuf"
+					],
+					"idx"
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"outputLayout",
+							"$"
+						],
+						"outTex"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["cx", "cy"]
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								7,
+								"s",
+								"x"
+							],
+							[
+								7,
+								"s",
+								"y"
+							],
+							[5, "0"],
+							[5, "0"]
+						]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"outputLayout",
+			"std"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		outputLayout,
+		std
+	})
+}) && $.f)({})).$name("reactionDiffusionOutput");
+const rdSampleUV = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, featureSize) => {
+	"use gpu";
+	const view = __tsover_div(1, featureSize);
+	const sx = std.min(aspect, 1);
+	const sy = std.min(__tsover_div(1, aspect), 1);
+	const fx = __tsover_add(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), sx), view), .5);
+	const fy = __tsover_add(__tsover_mul(__tsover_mul(__tsover_sub(uv.y, .5), sy), view), .5);
+	return d.vec2f(fx, fy);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "featureSize"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"view",
+				[
+					1,
+					[5, "1"],
+					"/",
+					"featureSize"
+				]
+			],
+			[
+				13,
+				"sx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					["aspect", [5, "1"]]
+				]
+			],
+			[
+				13,
+				"sy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						1,
+						[5, "1"],
+						"/",
+						"aspect"
+					], [5, "1"]]
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"uv",
+									"x"
+								],
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							"sx"
+						],
+						"*",
+						"view"
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"uv",
+									"y"
+								],
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							"sy"
+						],
+						"*",
+						"view"
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				["fx", "fy"]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({})).$name("reactionDiffusionSampleUV");
+const rdRampT = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v, contrast, threshold) => {
+	"use gpu";
+	const w = std.max(__tsover_sub(.6, __tsover_mul(contrast, .55)), .02);
+	return std.smoothstep(__tsover_sub(threshold, w), __tsover_add(threshold, w), v);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "v"
+			},
+			{
+				"type": "i",
+				"name": "contrast"
+			},
+			{
+				"type": "i",
+				"name": "threshold"
+			}
+		],
+		"body": [0, [[
+			13,
+			"w",
+			[
+				6,
+				[
+					7,
+					"std",
+					"max"
+				],
+				[[
+					1,
+					[5, "0.6"],
+					"-",
+					[
+						1,
+						"contrast",
+						"*",
+						[5, "0.55"]
+					]
+				], [5, "0.02"]]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"std",
+				"smoothstep"
+			],
+			[
+				[
+					1,
+					"threshold",
+					"-",
+					"w"
+				],
+				[
+					1,
+					"threshold",
+					"+",
+					"w"
+				],
+				"v"
+			]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const rdSeg = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, offset) => {
+	"use gpu";
+	return std.clamp(__tsover_sub(__tsover_mul(t, 2), offset), 0, 1);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}, {
+			"type": "i",
+			"name": "offset"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"clamp"
+			],
+			[
+				[
+					1,
+					[
+						1,
+						"t",
+						"*",
+						[5, "2"]
+					],
+					"-",
+					"offset"
+				],
+				[5, "0"],
+				[5, "1"]
+			]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const rdPickSeg = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lo, hi, t) => {
+	"use gpu";
+	const useHi = t > .5;
+	return d.vec4f(std.select(lo.x, hi.x, useHi), std.select(lo.y, hi.y, useHi), std.select(lo.z, hi.z, useHi), std.select(lo.w, hi.w, useHi));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "lo"
+			},
+			{
+				"type": "i",
+				"name": "hi"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			}
+		],
+		"body": [0, [[
+			13,
+			"useHi",
+			[
+				1,
+				"t",
+				">",
+				[5, "0.5"]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"d",
+				"vec4f"
+			],
+			[
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							7,
+							"lo",
+							"x"
+						],
+						[
+							7,
+							"hi",
+							"x"
+						],
+						"useHi"
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							7,
+							"lo",
+							"y"
+						],
+						[
+							7,
+							"hi",
+							"y"
+						],
+						"useHi"
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							7,
+							"lo",
+							"z"
+						],
+						[
+							7,
+							"hi",
+							"z"
+						],
+						"useHi"
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							7,
+							"lo",
+							"w"
+						],
+						[
+							7,
+							"hi",
+							"w"
+						],
+						"useHi"
+					]
+				]
+			]
+		]]]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d,
+		std
+	})
+}) && $.f)({}));
+const rdShiftUV = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, ox, oy) => {
+	"use gpu";
+	return d.vec2f(__tsover_add(uv.x, ox), __tsover_add(uv.y, oy));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "ox"
+			},
+			{
+				"type": "i",
+				"name": "oy"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				1,
+				[
+					7,
+					"uv",
+					"x"
+				],
+				"+",
+				"ox"
+			], [
+				1,
+				[
+					7,
+					"uv",
+					"y"
+				],
+				"+",
+				"oy"
+			]]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({})).$name("reactionDiffusionShiftUV");
+const rdShade = tgpu.fn([
+	d.vec4f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, vL, vR, vT, vB, relief, lightAngle) => {
+	"use gpu";
+	const gx = __tsover_mul(__tsover_sub(vR, vL), d.f32(RELIEF_STRENGTH));
+	const gy = __tsover_mul(__tsover_sub(vB, vT), d.f32(RELIEF_STRENGTH));
+	const n = std.normalize(d.vec3f(-gx, -gy, d.f32(1)));
+	const ang = __tsover_mul(lightAngle, DEG2RAD);
+	const lightDir = std.normalize(d.vec3f(__tsover_mul(std.cos(ang), RELIEF_LIGHT_XY), __tsover_mul(std.sin(ang), RELIEF_LIGHT_XY), RELIEF_LIGHT_Z));
+	const diff = std.clamp(std.dot(n, lightDir), d.f32(0), d.f32(1));
+	const shade = __tsover_add(RELIEF_AMBIENT, __tsover_mul(__tsover_sub(d.f32(1), RELIEF_AMBIENT), diff));
+	const halfVec = std.normalize(lightDir.add(d.vec3f(d.f32(0), d.f32(0), d.f32(1))));
+	const spec = __tsover_mul(std.pow(std.clamp(std.dot(n, halfVec), d.f32(0), d.f32(1)), d.f32(RELIEF_SHININESS)), RELIEF_SPEC);
+	const litRgb = base.xyz.mul(shade).add(d.vec3f(spec, spec, spec));
+	const outRgb = std.mix(base.xyz, litRgb, relief);
+	return d.vec4f(outRgb.x, outRgb.y, outRgb.z, base.w);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "base"
+			},
+			{
+				"type": "i",
+				"name": "vL"
+			},
+			{
+				"type": "i",
+				"name": "vR"
+			},
+			{
+				"type": "i",
+				"name": "vT"
+			},
+			{
+				"type": "i",
+				"name": "vB"
+			},
+			{
+				"type": "i",
+				"name": "relief"
+			},
+			{
+				"type": "i",
+				"name": "lightAngle"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"gx",
+				[
+					1,
+					[
+						1,
+						"vR",
+						"-",
+						"vL"
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["RELIEF_STRENGTH"]
+					]
+				]
+			],
+			[
+				13,
+				"gy",
+				[
+					1,
+					[
+						1,
+						"vB",
+						"-",
+						"vT"
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["RELIEF_STRENGTH"]
+					]
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								4,
+								"-",
+								"gx"
+							],
+							[
+								4,
+								"-",
+								"gy"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"ang",
+				[
+					1,
+					"lightAngle",
+					"*",
+					"DEG2RAD"
+				]
+			],
+			[
+				13,
+				"lightDir",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"cos"
+									],
+									["ang"]
+								],
+								"*",
+								"RELIEF_LIGHT_XY"
+							],
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									["ang"]
+								],
+								"*",
+								"RELIEF_LIGHT_XY"
+							],
+							"RELIEF_LIGHT_Z"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"diff",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"dot"
+							],
+							["n", "lightDir"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"shade",
+				[
+					1,
+					"RELIEF_AMBIENT",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							],
+							"-",
+							"RELIEF_AMBIENT"
+						],
+						"*",
+						"diff"
+					]
+				]
+			],
+			[
+				13,
+				"halfVec",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"lightDir",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "1"]]
+								]
+							]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"spec",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"pow"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"std",
+										"dot"
+									],
+									["n", "halfVec"]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "1"]]
+								]
+							]
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["RELIEF_SHININESS"]
+						]]
+					],
+					"*",
+					"RELIEF_SPEC"
+				]
+			],
+			[
+				13,
+				"litRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									7,
+									"base",
+									"xyz"
+								],
+								"mul"
+							],
+							["shade"]
+						],
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							"spec",
+							"spec",
+							"spec"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"outRgb",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							7,
+							"base",
+							"xyz"
+						],
+						"litRgb",
+						"relief"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"outRgb",
+						"x"
+					],
+					[
+						7,
+						"outRgb",
+						"y"
+					],
+					[
+						7,
+						"outRgb",
+						"z"
+					],
+					[
+						7,
+						"base",
+						"w"
+					]
+				]
+			]]
+		]],
+		"externalNames": [
+			"d",
+			"RELIEF_STRENGTH",
+			"std",
+			"DEG2RAD",
+			"RELIEF_LIGHT_XY",
+			"RELIEF_LIGHT_Z",
+			"RELIEF_AMBIENT",
+			"RELIEF_SHININESS",
+			"RELIEF_SPEC"
+		]
+	},
+	externals: () => ({
+		d,
+		RELIEF_STRENGTH,
+		std,
+		DEG2RAD,
+		RELIEF_LIGHT_XY,
+		RELIEF_LIGHT_Z,
+		RELIEF_AMBIENT,
+		RELIEF_SHININESS,
+		RELIEF_SPEC
+	})
+}) && $.f)({})).$name("reactionDiffusionShade");
+const componentDefinition = {
+	name: "ReactionDiffusion",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "A living Gray-Scott reaction-diffusion pattern that fills the layer and blooms wherever you drag the cursor",
+	requiresRTT: false,
+	requiresChild: false,
+	acceptsOptionalChild: true,
+	usesPointer: true,
+	props: {
+		preset: {
+			default: "coral",
+			description: "Named Gray-Scott regime — drives the feed & kill rates for a whole family of patterns. Choose Custom to dial feed & kill by hand",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Coral",
+						value: "coral"
+					},
+					{
+						label: "Mitosis",
+						value: "mitosis"
+					},
+					{
+						label: "Spots",
+						value: "spots"
+					},
+					{
+						label: "Maze",
+						value: "maze"
+					},
+					{
+						label: "Worms",
+						value: "worms"
+					},
+					{
+						label: "Fingerprints",
+						value: "fingerprints"
+					},
+					{
+						label: "Holes",
+						value: "holes"
+					},
+					{
+						label: "Solitons",
+						value: "solitons"
+					},
+					{
+						label: "Bubbles",
+						value: "bubbles"
+					},
+					{
+						label: "Waves",
+						value: "waves"
+					},
+					{
+						label: "Flowers",
+						value: "flowers"
+					},
+					{
+						label: "Custom",
+						value: "custom"
+					}
+				],
+				label: "Pattern",
+				group: "Pattern"
+			}
+		},
+		feed: {
+			default: .0545,
+			description: "Feed rate — how fast chemical U is replenished (used when Pattern = Custom)",
+			ui: {
+				type: "range",
+				min: .01,
+				max: .1,
+				step: .001,
+				label: "Feed",
+				group: "Pattern",
+				condition: { preset: "custom" }
+			}
+		},
+		kill: {
+			default: .062,
+			description: "Kill rate — how fast chemical V is removed (used when Pattern = Custom)",
+			ui: {
+				type: "range",
+				min: .03,
+				max: .07,
+				step: .001,
+				label: "Kill",
+				group: "Pattern",
+				condition: { preset: "custom" }
+			}
+		},
+		diffusionRatio: {
+			default: .5,
+			description: "Ratio of the two chemicals' diffusion rates — shifts the pattern character (lower = tighter, more filament-like)",
+			ui: {
+				type: "range",
+				min: .2,
+				max: .9,
+				step: .01,
+				label: "Diffusion Ratio",
+				group: "Pattern"
+			}
+		},
+		featureSize: {
+			default: 3,
+			description: "Size of the pattern features — lower shows finer, smaller cells; higher magnifies them into larger cells",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 6,
+				step: .1,
+				label: "Feature Size",
+				group: "Pattern"
+			}
+		},
+		speed: {
+			default: 6,
+			description: "Simulation steps per frame — higher evolves the pattern faster",
+			ui: {
+				type: "range",
+				min: 1,
+				max: MAX_ITERATIONS,
+				step: 1,
+				label: "Speed",
+				group: "Pattern"
+			}
+		},
+		brushSize: {
+			default: .04,
+			description: "Radius of the cursor brush that seeds new reagent as you drag",
+			ui: {
+				type: "range",
+				min: .01,
+				max: .3,
+				step: .01,
+				label: "Brush Size",
+				group: "Interaction"
+			}
+		},
+		brushStrength: {
+			default: .6,
+			description: "How much reagent the cursor injects while dragging",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Brush Strength",
+				group: "Interaction"
+			}
+		},
+		colorA: {
+			default: "transparent",
+			transform: transformColor,
+			description: "Background color (empty regions between cells)",
+			ui: {
+				type: "color",
+				label: "Background",
+				group: "Colors"
+			}
+		},
+		colorC: {
+			default: "#38bdf8",
+			transform: transformColor,
+			description: "Accent color at the cell walls (mid pattern values)",
+			ui: {
+				type: "color",
+				label: "Wall Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#e2f5ff",
+			transform: transformColor,
+			description: "Color of the dense cell interiors (high pattern values)",
+			ui: {
+				type: "color",
+				label: "Cell Color",
+				group: "Colors"
+			}
+		},
+		contrast: {
+			default: .5,
+			description: "Sharpness of the cell walls — higher gives crisper, more graphic edges",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Contrast",
+				group: "Colors"
+			}
+		},
+		threshold: {
+			default: .28,
+			description: "Pattern level the colors are centered on — shifts the balance of background vs. cells",
+			ui: {
+				type: ["range", "map"],
+				min: .05,
+				max: .6,
+				step: .01,
+				label: "Threshold",
+				group: "Colors"
+			}
+		},
+		colorSpace: {
+			default: "oklch",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		relief: {
+			default: .4,
+			description: "Treats the pattern as a raised surface and shades it with a light — higher gives a more sculpted, three-dimensional look (0 for a flat, graphic look)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Relief",
+				group: "Lighting"
+			}
+		},
+		lightAngle: {
+			default: 135,
+			description: "Direction the surface light comes from, in degrees",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Lighting"
+			}
+		},
+		childInfluence: {
+			default: .6,
+			description: "When a child layer is nested, how strongly its brightness biases the pattern — the preset sets the character, the child steers where it grows dense vs. sparse (0 ignores the child)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Influence",
+				group: "Child"
+			}
+		},
+		childContrast: {
+			default: .5,
+			description: "Contrast applied to the child's brightness before it drives the pattern — higher pushes toward a crisp two-tone split (edges), lower keeps smooth tonal shading",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Contrast",
+				group: "Child"
+			}
+		},
+		childThreshold: {
+			default: .5,
+			description: "Brightness level of the child that reads as neutral — shifts which tones grow the pattern vs. clear it",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Threshold",
+				group: "Child"
+			}
+		},
+		childInvert: {
+			default: false,
+			transform: transformBoolean,
+			description: "Flip which tones of the child grow the pattern (bright vs. dark areas)",
+			ui: {
+				type: "checkbox",
+				label: "Invert",
+				group: "Child"
+			}
+		}
+	},
+	compute: (params) => {
+		const { gpu, getCpuValue, registerComputeTexture, onCleanup, childNode, convertToTexture } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const hasChild = !!childNode;
+		const childTexture = hasChild && convertToTexture ? convertToTexture(childNode) : null;
+		const bufferA = createStateBuffer(root, d.vec2f, COUNT);
+		const bufferB = createStateBuffer(root, d.vec2f, COUNT);
+		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [N, N],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "outTex");
+		onCleanup(() => outTex.destroy());
+		const rdTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(RDParams), "paramsU");
+		const size = [N, N];
+		const output = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			outputKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"outputKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["outputKernel"]
+			},
+			externals: () => ({ outputKernel })
+		}) && $.f)({}), { size });
+		const outFromA = output.with(root.createBindGroup(outputLayout, {
+			srcBuf: bufferA,
+			outTex
+		}));
+		const outFromB = output.with(root.createBindGroup(outputLayout, {
+			srcBuf: bufferB,
+			outTex
+		}));
+		const seed = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			seedKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"seedKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["seedKernel"]
+			},
+			externals: () => ({ seedKernel })
+		}) && $.f)({}), {
+			size,
+			bindGroup: root.createBindGroup(seedLayout, { stateBuf: bufferA })
+		});
+		let reactAB = null;
+		let reactBA = null;
+		let reactionChild = null;
+		if (hasChild) reactionChild = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			reactionKernelChild(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"reactionKernelChild",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["reactionKernelChild"]
+			},
+			externals: () => ({ reactionKernelChild })
+		}) && $.f)({}), { size });
+		else {
+			const reaction = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+				"use gpu";
+				reactionKernel(cx, cy);
+			}), {
+				v: 1,
+				name: void 0,
+				ast: {
+					"params": [{
+						"type": "i",
+						"name": "cx"
+					}, {
+						"type": "i",
+						"name": "cy"
+					}],
+					"body": [0, [[
+						6,
+						"reactionKernel",
+						["cx", "cy"]
+					]]],
+					"externalNames": ["reactionKernel"]
+				},
+				externals: () => ({ reactionKernel })
+			}) && $.f)({}), { size });
+			reactAB = reaction.with(root.createBindGroup(reactionLayout, {
+				readBuf: bufferA,
+				writeBuf: bufferB,
+				params: paramsU.buffer
+			}));
+			reactBA = reaction.with(root.createBindGroup(reactionLayout, {
+				readBuf: bufferB,
+				writeBuf: bufferA,
+				params: paramsU.buffer
+			}));
+		}
+		let curIsA = true;
+		let needsSeed = true;
+		let lastPreset = "";
+		let prevMx = .5;
+		let prevMy = .5;
+		return {
+			outputs: { rdTexture },
+			...hasChild ? { bindInputs: (resolve) => {
+				const src = childTexture ? resolve(childTexture.key) : void 0;
+				if (!src || !reactionChild) return;
+				reactAB = reactionChild.with(root.createBindGroup(reactionChildLayout, {
+					readBuf: bufferA,
+					writeBuf: bufferB,
+					params: paramsU.buffer,
+					childTex: src.texture
+				}));
+				reactBA = reactionChild.with(root.createBindGroup(reactionChildLayout, {
+					readBuf: bufferB,
+					writeBuf: bufferA,
+					params: paramsU.buffer,
+					childTex: src.texture
+				}));
+			} } : {},
+			getComputeNodes: (frameParams) => {
+				if (hasChild && (!reactAB || !reactBA)) return null;
+				const fp = frameParams;
+				const g = (key, fallback) => {
+					const v = getCpuValue(key);
+					return typeof v === "number" ? v : fallback;
+				};
+				const hgt = fp.dimensions?.height ?? 0;
+				const aspect = hgt > 0 ? (fp.dimensions?.width ?? 0) / hgt : 1;
+				const preset = getCpuValue("preset") || "coral";
+				if (preset !== lastPreset) {
+					lastPreset = preset;
+					needsSeed = true;
+				}
+				const pk = PRESETS[preset];
+				const feed = pk ? pk.feed : g("feed", .055);
+				const kill = pk ? pk.kill : g("kill", .062);
+				const view = 1 / Math.max(g("featureSize", 3), 1e-4);
+				const sx = Math.min(aspect, 1);
+				const sy = Math.min(1 / aspect, 1);
+				const mx = fp.pointer?.x ?? prevMx;
+				const my = fp.pointer?.y ?? prevMy;
+				const fieldX = (mx - .5) * sx * view + .5;
+				const fieldY = (my - .5) * sy * view + .5;
+				const cursorSpeed = Math.sqrt((mx - prevMx) * (mx - prevMx) + (my - prevMy) * (my - prevMy));
+				prevMx = mx;
+				prevMy = my;
+				const velScale = cursorSpeed > 5e-4 && g("brushStrength", .6) > 0 ? Math.min(cursorSpeed / .02, 1) : 0;
+				const brushRadGrid = g("brushSize", .04) * N * view;
+				const invRaw = getCpuValue("childInvert");
+				paramsU.write({
+					feed,
+					kill,
+					dv: g("diffusionRatio", .5),
+					brushRadSq: brushRadGrid * brushRadGrid,
+					brushStrength: g("brushStrength", .6),
+					cursorX: fieldX * N,
+					cursorY: fieldY * N,
+					cursorActive: velScale,
+					childInfluence: g("childInfluence", .6),
+					childContrast: g("childContrast", .5),
+					childThreshold: g("childThreshold", .5),
+					childInvert: invRaw === true || invRaw === 1 ? 1 : 0,
+					childMapX: 1 / (sx * view),
+					childMapY: 1 / (sy * view),
+					_pad0: 0,
+					_pad1: 0
+				});
+				const nodes = [];
+				if (needsSeed) {
+					needsSeed = false;
+					curIsA = true;
+					nodes.push(seed);
+				}
+				const iters = Math.min(MAX_ITERATIONS, Math.max(1, Math.round(g("speed", 6))));
+				for (let i = 0; i < iters; i++) {
+					nodes.push(curIsA ? reactAB : reactBA);
+					curIsA = !curIsA;
+				}
+				nodes.push(curIsA ? outFromA : outFromB);
+				return nodes;
+			}
+		};
+	},
+	fragment: (params) => {
+		const { ctx, computeOutputs, propValues, uniforms } = params;
+		const rdField = computeOutputs?.rdTexture;
+		if (!rdField) return ZERO;
+		const sampleUV = call(rdSampleUV, "rdSampleUV", [
+			ctx.uv,
+			ctx.aspect,
+			uniforms.featureSize
+		]);
+		const t = call(rdRampT, "rdRampT", [
+			rdField.sample(sampleUV, "linearClamp").member("y"),
+			uniforms.contrast,
+			uniforms.threshold
+		]);
+		const colorSpaceMode = propValues.colorSpace ?? 0;
+		const variant = cm.mixColorsVariants[colorSpaceMode] ?? cm.mixColorsLinear;
+		const lit = call(rdShade, "rdShade", [
+			call(rdPickSeg, "rdPickSeg", [
+				call(variant, "mixColors", [
+					uniforms.colorA,
+					uniforms.colorC,
+					call(rdSeg, "rdSeg", [t, floatE(0)])
+				]),
+				call(variant, "mixColors", [
+					uniforms.colorC,
+					uniforms.colorB,
+					call(rdSeg, "rdSeg", [t, floatE(1)])
+				]),
+				t
+			]),
+			rdField.sample(call(rdShiftUV, "rdShiftL", [
+				sampleUV,
+				floatE(-RELIEF_EPS),
+				floatE(0)
+			]), "linearClamp").member("y"),
+			rdField.sample(call(rdShiftUV, "rdShiftR", [
+				sampleUV,
+				floatE(RELIEF_EPS),
+				floatE(0)
+			]), "linearClamp").member("y"),
+			rdField.sample(call(rdShiftUV, "rdShiftT", [
+				sampleUV,
+				floatE(0),
+				floatE(-RELIEF_EPS)
+			]), "linearClamp").member("y"),
+			rdField.sample(call(rdShiftUV, "rdShiftB", [
+				sampleUV,
+				floatE(0),
+				floatE(RELIEF_EPS)
+			]), "linearClamp").member("y"),
+			uniforms.relief,
+			uniforms.lightAngle
+		]);
+		return vec4(lit.member("rgb"), lit.member("a"));
+	}
+};
+var ReactionDiffusion_default = componentDefinition;
+export { rdPickSeg as a, rdSeg as c, reactionKernel as d, reactionKernelChild as f, rdChildDrive as i, rdShade as l, componentDefinition as n, rdRampT as o, seedKernel as p, outputKernel as r, rdSampleUV as s, ReactionDiffusion_default as t, rdShiftUV as u };