shaders 3.0.441 → 3.0.443

package/dist/core/InkFlow-CY7sCKpI.js

@@ -0,0 +1,4983 @@
+import { Bt as call, J as std, Kt as vec4, Rt as ZERO, Wt as floatE, X as createGuardedCompute, Z as createStateBuffer, an as convertP3ToMixSpaceCPU, bn as d, fn as mixPreconvertedLinear, n as tgpu, pn as mixPreconvertedVariants } from "./coords-0A7CojvN.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
+var N = 256;
+var COUNT = N * N;
+var JACOBI_ITERS = 10;
+var PRESSURE_DISSIPATION = .8;
+var STATE_FORMAT = "rgba16float";
+var IMPULSE_K = .16;
+var MAX_STEPS = 16;
+var CYCLE_PER_SPLAT = .006;
+var CYCLE_TIME_RATE = .06;
+var VEL_FADE_MAX = 4;
+var VEL_FADE_MIN = .05;
+var GAIN = 1.35;
+var FlowParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	dt: d.f32,
+	curlStrength: d.f32,
+	velFade: d.f32,
+	dyeFade: d.f32
+}), "FlowParams");
+var SplatParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	posX: d.f32,
+	posY: d.f32,
+	velX: d.f32,
+	velY: d.f32,
+	colR: d.f32,
+	colG: d.f32,
+	colB: d.f32,
+	col2R: d.f32,
+	col2G: d.f32,
+	col2B: d.f32,
+	mixT: d.f32,
+	radius: d.f32,
+	strength: d.f32
+}), "SplatParams");
+var fluidLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	velA: {
+		storage: d.arrayOf(d.vec4f, COUNT),
+		access: "mutable"
+	},
+	velB: {
+		storage: d.arrayOf(d.vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeA: {
+		storage: d.arrayOf(d.vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeB: {
+		storage: d.arrayOf(d.vec4f, COUNT),
+		access: "mutable"
+	},
+	pressure: {
+		storage: d.arrayOf(d.f32, COUNT),
+		access: "mutable"
+	},
+	divergence: {
+		storage: d.arrayOf(d.f32, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: FlowParams }
+}), "fluidLayout");
+var splatLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	velA: {
+		storage: d.arrayOf(d.vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeA: {
+		storage: d.arrayOf(d.vec4f, COUNT),
+		access: "mutable"
+	},
+	sparams: { uniform: SplatParams }
+}), "splatLayout");
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	dyeA: {
+		storage: d.arrayOf(d.vec4f, COUNT),
+		access: "readonly"
+	},
+	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+}), "outputLayout");
+var nidx = tgpu.fn([
+	d.i32,
+	d.i32,
+	d.i32,
+	d.i32
+], d.u32)(/* @__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 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, [
+				6,
+				[
+					7,
+					"d",
+					"u32"
+				],
+				[[
+					1,
+					[
+						1,
+						"row",
+						"*",
+						"N"
+					],
+					"+",
+					"col"
+				]]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"N",
+			"d"
+		]
+	},
+	externals: () => ({
+		std,
+		N,
+		d
+	})
+}) && $.f)({}));
+var makeSplatKernel = (colorSpaceMode) => {
+	const mixFn = mixPreconvertedVariants[colorSpaceMode] ?? mixPreconvertedLinear;
+	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		const p = splatLayout.$.sparams;
+		const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+		const cellX = __tsover_add(d.f32(cx), .5);
+		const cellY = __tsover_add(d.f32(cy), .5);
+		const dx = __tsover_sub(cellX, p.posX);
+		const dy = __tsover_sub(cellY, p.posY);
+		const distSq = __tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy));
+		const radSq = std.max(__tsover_mul(p.radius, p.radius), d.f32(1));
+		const inf = std.exp(__tsover_mul(__tsover_div(distSq, radSq), -1));
+		const w = std.clamp(__tsover_mul(inf, p.strength), d.f32(0), d.f32(1));
+		const brush = mixFn(d.vec3f(p.colR, p.colG, p.colB), d.vec3f(p.col2R, p.col2G, p.col2B), 1, 1, p.mixT);
+		const cell = splatLayout.$.dyeA[idx];
+		splatLayout.$.dyeA[idx] = d.vec4f(std.mix(cell.x, brush.x, w), std.mix(cell.y, brush.y, w), std.mix(cell.z, brush.z, w), 0);
+		const vel = splatLayout.$.velA[idx];
+		splatLayout.$.velA[idx] = d.vec4f(__tsover_add(vel.x, __tsover_mul(p.velX, inf)), __tsover_add(vel.y, __tsover_mul(p.velY, inf)), vel.z, 0);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"p",
+					[
+						7,
+						[
+							7,
+							"splatLayout",
+							"$"
+						],
+						"sparams"
+					]
+				],
+				[
+					13,
+					"idx",
+					[
+						1,
+						[
+							1,
+							"cy",
+							"*",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["N"]
+							]
+						],
+						"+",
+						"cx"
+					]
+				],
+				[
+					13,
+					"cellX",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cx"]
+						],
+						"+",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"cellY",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cy"]
+						],
+						"+",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"dx",
+					[
+						1,
+						"cellX",
+						"-",
+						[
+							7,
+							"p",
+							"posX"
+						]
+					]
+				],
+				[
+					13,
+					"dy",
+					[
+						1,
+						"cellY",
+						"-",
+						[
+							7,
+							"p",
+							"posY"
+						]
+					]
+				],
+				[
+					13,
+					"distSq",
+					[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"dx"
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							"dy"
+						]
+					]
+				],
+				[
+					13,
+					"radSq",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							[
+								7,
+								"p",
+								"radius"
+							],
+							"*",
+							[
+								7,
+								"p",
+								"radius"
+							]
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]]
+					]
+				],
+				[
+					13,
+					"inf",
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							[
+								1,
+								"distSq",
+								"/",
+								"radSq"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"w",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"inf",
+								"*",
+								[
+									7,
+									"p",
+									"strength"
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"brush",
+					[
+						6,
+						"mixFn",
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[
+										7,
+										"p",
+										"colR"
+									],
+									[
+										7,
+										"p",
+										"colG"
+									],
+									[
+										7,
+										"p",
+										"colB"
+									]
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[
+										7,
+										"p",
+										"col2R"
+									],
+									[
+										7,
+										"p",
+										"col2G"
+									],
+									[
+										7,
+										"p",
+										"col2B"
+									]
+								]
+							],
+							[5, "1"],
+							[5, "1"],
+							[
+								7,
+								"p",
+								"mixT"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"cell",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatLayout",
+								"$"
+							],
+							"dyeA"
+						],
+						"idx"
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatLayout",
+								"$"
+							],
+							"dyeA"
+						],
+						"idx"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"cell",
+										"x"
+									],
+									[
+										7,
+										"brush",
+										"x"
+									],
+									"w"
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"cell",
+										"y"
+									],
+									[
+										7,
+										"brush",
+										"y"
+									],
+									"w"
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"cell",
+										"z"
+									],
+									[
+										7,
+										"brush",
+										"z"
+									],
+									"w"
+								]
+							],
+							[5, "0"]
+						]
+					]
+				],
+				[
+					13,
+					"vel",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatLayout",
+								"$"
+							],
+							"velA"
+						],
+						"idx"
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatLayout",
+								"$"
+							],
+							"velA"
+						],
+						"idx"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								1,
+								[
+									7,
+									"vel",
+									"x"
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"p",
+										"velX"
+									],
+									"*",
+									"inf"
+								]
+							],
+							[
+								1,
+								[
+									7,
+									"vel",
+									"y"
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"p",
+										"velY"
+									],
+									"*",
+									"inf"
+								]
+							],
+							[
+								7,
+								"vel",
+								"z"
+							],
+							[5, "0"]
+						]
+					]
+				]
+			]],
+			"externalNames": [
+				"splatLayout",
+				"d",
+				"N",
+				"std",
+				"mixFn"
+			]
+		},
+		externals: () => ({
+			splatLayout,
+			d,
+			N,
+			std,
+			mixFn
+		})
+	}) && $.f)({})).$name(`inkFlowSplat${colorSpaceMode}`);
+};
+var splatKernelVariants = {
+	0: makeSplatKernel(0),
+	1: makeSplatKernel(1),
+	2: makeSplatKernel(2),
+	3: makeSplatKernel(3),
+	4: makeSplatKernel(4),
+	5: makeSplatKernel(5)
+};
+const splatKernel = splatKernelVariants[2];
+const curlKernel = 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 ii = d.i32(cy);
+	const ji = d.i32(cx);
+	const vL = fluidLayout.$.velA[nidx(ii, ji, 0, -1)];
+	const vR = fluidLayout.$.velA[nidx(ii, ji, 0, 1)];
+	const vU = fluidLayout.$.velA[nidx(ii, ji, -1, 0)];
+	const vD = fluidLayout.$.velA[nidx(ii, ji, 1, 0)];
+	const curl = __tsover_mul(__tsover_sub(__tsover_sub(vR.y, vL.y), __tsover_sub(vD.x, vU.x)), .5);
+	const vel = fluidLayout.$.velA[idx];
+	fluidLayout.$.velA[idx] = d.vec4f(vel.x, vel.y, curl, 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,
+				"ii",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"ji",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"vL",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "0"],
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"vR",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"vU",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[
+								4,
+								"-",
+								[5, "1"]
+							],
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"vD",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "1"],
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"curl",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"vR",
+								"y"
+							],
+							"-",
+							[
+								7,
+								"vL",
+								"y"
+							]
+						],
+						"-",
+						[
+							1,
+							[
+								7,
+								"vD",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"vU",
+								"x"
+							]
+						]
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"vel",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							7,
+							"vel",
+							"x"
+						],
+						[
+							7,
+							"vel",
+							"y"
+						],
+						"curl",
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"fluidLayout",
+			"nidx"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		fluidLayout,
+		nidx
+	})
+}) && $.f)({})).$name("inkFlowCurl");
+const vorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = fluidLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const ii = d.i32(cy);
+	const ji = d.i32(cx);
+	const cL = std.abs(fluidLayout.$.velA[nidx(ii, ji, 0, -1)].z);
+	const cR = std.abs(fluidLayout.$.velA[nidx(ii, ji, 0, 1)].z);
+	const cU = std.abs(fluidLayout.$.velA[nidx(ii, ji, -1, 0)].z);
+	const cD = std.abs(fluidLayout.$.velA[nidx(ii, ji, 1, 0)].z);
+	const cc = fluidLayout.$.velA[idx].z;
+	const gx = __tsover_mul(__tsover_sub(cR, cL), .5);
+	const gy = __tsover_mul(__tsover_sub(cD, cU), .5);
+	const gl = std.max(std.sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy))), d.f32(1e-5));
+	const fx = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gy, gl), cc), p.curlStrength), p.dt);
+	const fy = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gx, gl), -1), cc), p.curlStrength), p.dt);
+	const vel = fluidLayout.$.velA[idx];
+	fluidLayout.$.velA[idx] = d.vec4f(__tsover_add(vel.x, fx), __tsover_add(vel.y, fy), vel.z, 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"fluidLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"ii",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"ji",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"cL",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					[[
+						7,
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"fluidLayout",
+									"$"
+								],
+								"velA"
+							],
+							[
+								6,
+								"nidx",
+								[
+									"ii",
+									"ji",
+									[5, "0"],
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								]
+							]
+						],
+						"z"
+					]]
+				]
+			],
+			[
+				13,
+				"cR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					[[
+						7,
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"fluidLayout",
+									"$"
+								],
+								"velA"
+							],
+							[
+								6,
+								"nidx",
+								[
+									"ii",
+									"ji",
+									[5, "0"],
+									[5, "1"]
+								]
+							]
+						],
+						"z"
+					]]
+				]
+			],
+			[
+				13,
+				"cU",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					[[
+						7,
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"fluidLayout",
+									"$"
+								],
+								"velA"
+							],
+							[
+								6,
+								"nidx",
+								[
+									"ii",
+									"ji",
+									[
+										4,
+										"-",
+										[5, "1"]
+									],
+									[5, "0"]
+								]
+							]
+						],
+						"z"
+					]]
+				]
+			],
+			[
+				13,
+				"cD",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					[[
+						7,
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"fluidLayout",
+									"$"
+								],
+								"velA"
+							],
+							[
+								6,
+								"nidx",
+								[
+									"ii",
+									"ji",
+									[5, "1"],
+									[5, "0"]
+								]
+							]
+						],
+						"z"
+					]]
+				]
+			],
+			[
+				13,
+				"cc",
+				[
+					7,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fluidLayout",
+								"$"
+							],
+							"velA"
+						],
+						"idx"
+					],
+					"z"
+				]
+			],
+			[
+				13,
+				"gx",
+				[
+					1,
+					[
+						1,
+						"cR",
+						"-",
+						"cL"
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"gy",
+				[
+					1,
+					[
+						1,
+						"cD",
+						"-",
+						"cU"
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"gl",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							1,
+							[
+								1,
+								"gx",
+								"*",
+								"gx"
+							],
+							"+",
+							[
+								1,
+								"gy",
+								"*",
+								"gy"
+							]
+						]]
+					], [
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "0.00001"]]
+					]]
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"gy",
+								"/",
+								"gl"
+							],
+							"*",
+							"cc"
+						],
+						"*",
+						[
+							7,
+							"p",
+							"curlStrength"
+						]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"dt"
+					]
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"gx",
+									"/",
+									"gl"
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"*",
+							"cc"
+						],
+						"*",
+						[
+							7,
+							"p",
+							"curlStrength"
+						]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"dt"
+					]
+				]
+			],
+			[
+				13,
+				"vel",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"vel",
+								"x"
+							],
+							"+",
+							"fx"
+						],
+						[
+							1,
+							[
+								7,
+								"vel",
+								"y"
+							],
+							"+",
+							"fy"
+						],
+						[
+							7,
+							"vel",
+							"z"
+						],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"fluidLayout",
+			"d",
+			"N",
+			"std",
+			"nidx"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d,
+		N,
+		std,
+		nidx
+	})
+}) && $.f)({})).$name("inkFlowVorticity");
+const divergenceKernel = 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 ii = d.i32(cy);
+	const ji = d.i32(cx);
+	const jf = d.f32(cx);
+	const iF = d.f32(cy);
+	const selfVel = fluidLayout.$.velA[idx];
+	const normalL = fluidLayout.$.velA[nidx(ii, ji, 0, -1)].x;
+	const normalR = fluidLayout.$.velA[nidx(ii, ji, 0, 1)].x;
+	const normalU = fluidLayout.$.velA[nidx(ii, ji, -1, 0)].y;
+	const normalD = fluidLayout.$.velA[nidx(ii, ji, 1, 0)].y;
+	const L = std.select(normalL, __tsover_mul(selfVel.x, -1), jf < .5);
+	const R = std.select(normalR, __tsover_mul(selfVel.x, -1), jf > d.f32(__tsover_sub(N, 1.5)));
+	const T = std.select(normalU, __tsover_mul(selfVel.y, -1), iF < .5);
+	const B = std.select(normalD, __tsover_mul(selfVel.y, -1), iF > d.f32(__tsover_sub(N, 1.5)));
+	const div = __tsover_mul(__tsover_add(__tsover_sub(R, L), __tsover_sub(B, T)), .5);
+	fluidLayout.$.pressure[idx] = __tsover_mul(fluidLayout.$.pressure[idx], PRESSURE_DISSIPATION);
+	fluidLayout.$.divergence[idx] = div;
+}), {
+	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,
+				"ii",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"ji",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"jf",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"iF",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"selfVel",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"normalL",
+				[
+					7,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fluidLayout",
+								"$"
+							],
+							"velA"
+						],
+						[
+							6,
+							"nidx",
+							[
+								"ii",
+								"ji",
+								[5, "0"],
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]
+						]
+					],
+					"x"
+				]
+			],
+			[
+				13,
+				"normalR",
+				[
+					7,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fluidLayout",
+								"$"
+							],
+							"velA"
+						],
+						[
+							6,
+							"nidx",
+							[
+								"ii",
+								"ji",
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					],
+					"x"
+				]
+			],
+			[
+				13,
+				"normalU",
+				[
+					7,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fluidLayout",
+								"$"
+							],
+							"velA"
+						],
+						[
+							6,
+							"nidx",
+							[
+								"ii",
+								"ji",
+								[
+									4,
+									"-",
+									[5, "1"]
+								],
+								[5, "0"]
+							]
+						]
+					],
+					"y"
+				]
+			],
+			[
+				13,
+				"normalD",
+				[
+					7,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fluidLayout",
+								"$"
+							],
+							"velA"
+						],
+						[
+							6,
+							"nidx",
+							[
+								"ii",
+								"ji",
+								[5, "1"],
+								[5, "0"]
+							]
+						]
+					],
+					"y"
+				]
+			],
+			[
+				13,
+				"L",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"normalL",
+						[
+							1,
+							[
+								7,
+								"selfVel",
+								"x"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							"jf",
+							"<",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"R",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"normalR",
+						[
+							1,
+							[
+								7,
+								"selfVel",
+								"x"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							"jf",
+							">",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[
+									1,
+									"N",
+									"-",
+									[5, "1.5"]
+								]]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"T",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"normalU",
+						[
+							1,
+							[
+								7,
+								"selfVel",
+								"y"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							"iF",
+							"<",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"B",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"normalD",
+						[
+							1,
+							[
+								7,
+								"selfVel",
+								"y"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							"iF",
+							">",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[
+									1,
+									"N",
+									"-",
+									[5, "1.5"]
+								]]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"div",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"R",
+							"-",
+							"L"
+						],
+						"+",
+						[
+							1,
+							"B",
+							"-",
+							"T"
+						]
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					"idx"
+				],
+				"=",
+				[
+					1,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fluidLayout",
+								"$"
+							],
+							"pressure"
+						],
+						"idx"
+					],
+					"*",
+					"PRESSURE_DISSIPATION"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"divergence"
+					],
+					"idx"
+				],
+				"=",
+				"div"
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"fluidLayout",
+			"nidx",
+			"std",
+			"PRESSURE_DISSIPATION"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		fluidLayout,
+		nidx,
+		std,
+		PRESSURE_DISSIPATION
+	})
+}) && $.f)({})).$name("inkFlowDivergence");
+const jacobiKernel = 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 ii = d.i32(cy);
+	const ji = d.i32(cx);
+	const pL = fluidLayout.$.pressure[nidx(ii, ji, 0, -1)];
+	const pR = fluidLayout.$.pressure[nidx(ii, ji, 0, 1)];
+	const pU = fluidLayout.$.pressure[nidx(ii, ji, -1, 0)];
+	const pD = fluidLayout.$.pressure[nidx(ii, ji, 1, 0)];
+	const div = fluidLayout.$.divergence[idx];
+	fluidLayout.$.pressure[idx] = __tsover_mul(__tsover_sub(__tsover_add(__tsover_add(__tsover_add(pL, pR), pU), pD), div), .25);
+}), {
+	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,
+				"ii",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"ji",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"pL",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "0"],
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pR",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pU",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[
+								4,
+								"-",
+								[5, "1"]
+							],
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pD",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "1"],
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"div",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"divergence"
+					],
+					"idx"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					"idx"
+				],
+				"=",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"pL",
+									"+",
+									"pR"
+								],
+								"+",
+								"pU"
+							],
+							"+",
+							"pD"
+						],
+						"-",
+						"div"
+					],
+					"*",
+					[5, "0.25"]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"fluidLayout",
+			"nidx"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		fluidLayout,
+		nidx
+	})
+}) && $.f)({})).$name("inkFlowJacobi");
+const gradSubtractKernel = 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 ii = d.i32(cy);
+	const ji = d.i32(cx);
+	const pL = fluidLayout.$.pressure[nidx(ii, ji, 0, -1)];
+	const pR = fluidLayout.$.pressure[nidx(ii, ji, 0, 1)];
+	const pU = fluidLayout.$.pressure[nidx(ii, ji, -1, 0)];
+	const pD = fluidLayout.$.pressure[nidx(ii, ji, 1, 0)];
+	const vel = fluidLayout.$.velA[idx];
+	fluidLayout.$.velA[idx] = d.vec4f(__tsover_sub(vel.x, __tsover_mul(__tsover_sub(pR, pL), .5)), __tsover_sub(vel.y, __tsover_mul(__tsover_sub(pD, pU), .5)), vel.z, 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,
+				"ii",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"ji",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"pL",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "0"],
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pR",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pU",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[
+								4,
+								"-",
+								[5, "1"]
+							],
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pD",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					[
+						6,
+						"nidx",
+						[
+							"ii",
+							"ji",
+							[5, "1"],
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"vel",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"vel",
+								"x"
+							],
+							"-",
+							[
+								1,
+								[
+									1,
+									"pR",
+									"-",
+									"pL"
+								],
+								"*",
+								[5, "0.5"]
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"vel",
+								"y"
+							],
+							"-",
+							[
+								1,
+								[
+									1,
+									"pD",
+									"-",
+									"pU"
+								],
+								"*",
+								[5, "0.5"]
+							]
+						],
+						[
+							7,
+							"vel",
+							"z"
+						],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"fluidLayout",
+			"nidx"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		fluidLayout,
+		nidx
+	})
+}) && $.f)({})).$name("inkFlowGradSubtract");
+const advectVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = fluidLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const vel = fluidLayout.$.velA[idx];
+	const srcX = std.clamp(__tsover_sub(d.f32(cx), __tsover_mul(vel.x, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
+	const srcY = std.clamp(__tsover_sub(d.f32(cy), __tsover_mul(vel.y, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
+	const x0 = std.clamp(std.floor(srcX), 0, d.f32(__tsover_sub(N, 2)));
+	const y0 = std.clamp(std.floor(srcY), 0, d.f32(__tsover_sub(N, 2)));
+	const sx = __tsover_sub(srcX, x0);
+	const sy = __tsover_sub(srcY, y0);
+	const ix0 = d.i32(x0);
+	const iy0 = d.i32(y0);
+	const v00 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
+	const v10 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
+	const v01 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
+	const v11 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
+	const decay = __tsover_add(1, __tsover_mul(p.velFade, p.dt));
+	fluidLayout.$.velB[idx] = d.vec4f(__tsover_div(std.mix(std.mix(v00.x, v10.x, sx), std.mix(v01.x, v11.x, sx), sy), decay), __tsover_div(std.mix(std.mix(v00.y, v10.y, sx), std.mix(v01.y, v11.y, sx), sy), decay), 0, 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"fluidLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"vel",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"srcX",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cx"]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"vel",
+									"x"
+								],
+								"*",
+								[
+									7,
+									"p",
+									"dt"
+								]
+							]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								1,
+								"N",
+								"-",
+								[5, "1"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"srcY",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cy"]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"vel",
+									"y"
+								],
+								"*",
+								[
+									7,
+									"p",
+									"dt"
+								]
+							]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								1,
+								"N",
+								"-",
+								[5, "1"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"x0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["srcX"]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								1,
+								"N",
+								"-",
+								[5, "2"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"y0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["srcY"]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								1,
+								"N",
+								"-",
+								[5, "2"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"sx",
+				[
+					1,
+					"srcX",
+					"-",
+					"x0"
+				]
+			],
+			[
+				13,
+				"sy",
+				[
+					1,
+					"srcY",
+					"-",
+					"y0"
+				]
+			],
+			[
+				13,
+				"ix0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["x0"]
+				]
+			],
+			[
+				13,
+				"iy0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["y0"]
+				]
+			],
+			[
+				13,
+				"v00",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							1,
+							[
+								1,
+								"iy0",
+								"*",
+								"N"
+							],
+							"+",
+							"ix0"
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"v10",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"iy0",
+									"*",
+									"N"
+								],
+								"+",
+								"ix0"
+							],
+							"+",
+							[5, "1"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"v01",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"iy0",
+									"+",
+									[5, "1"]
+								],
+								"*",
+								"N"
+							],
+							"+",
+							"ix0"
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"v11",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"iy0",
+										"+",
+										[5, "1"]
+									],
+									"*",
+									"N"
+								],
+								"+",
+								"ix0"
+							],
+							"+",
+							[5, "1"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"decay",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"velFade"
+						],
+						"*",
+						[
+							7,
+							"p",
+							"dt"
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velB"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"std",
+											"mix"
+										],
+										[
+											[
+												7,
+												"v00",
+												"x"
+											],
+											[
+												7,
+												"v10",
+												"x"
+											],
+											"sx"
+										]
+									],
+									[
+										6,
+										[
+											7,
+											"std",
+											"mix"
+										],
+										[
+											[
+												7,
+												"v01",
+												"x"
+											],
+											[
+												7,
+												"v11",
+												"x"
+											],
+											"sx"
+										]
+									],
+									"sy"
+								]
+							],
+							"/",
+							"decay"
+						],
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"std",
+											"mix"
+										],
+										[
+											[
+												7,
+												"v00",
+												"y"
+											],
+											[
+												7,
+												"v10",
+												"y"
+											],
+											"sx"
+										]
+									],
+									[
+										6,
+										[
+											7,
+											"std",
+											"mix"
+										],
+										[
+											[
+												7,
+												"v01",
+												"y"
+											],
+											[
+												7,
+												"v11",
+												"y"
+											],
+											"sx"
+										]
+									],
+									"sy"
+								]
+							],
+							"/",
+							"decay"
+						],
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"fluidLayout",
+			"d",
+			"N",
+			"std"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d,
+		N,
+		std
+	})
+}) && $.f)({})).$name("inkFlowAdvectVel");
+const copyVelKernel = 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 v = fluidLayout.$.velB[idx];
+	fluidLayout.$.velA[idx] = d.vec4f(v.x, v.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,
+				"v",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velB"
+					],
+					"idx"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							7,
+							"v",
+							"x"
+						],
+						[
+							7,
+							"v",
+							"y"
+						],
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"fluidLayout"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		fluidLayout
+	})
+}) && $.f)({})).$name("inkFlowCopyVel");
+const advectDyeKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = fluidLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const vel = fluidLayout.$.velA[idx];
+	const srcX = std.clamp(__tsover_sub(d.f32(cx), __tsover_mul(vel.x, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
+	const srcY = std.clamp(__tsover_sub(d.f32(cy), __tsover_mul(vel.y, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
+	const x0 = std.clamp(std.floor(srcX), 0, d.f32(__tsover_sub(N, 2)));
+	const y0 = std.clamp(std.floor(srcY), 0, d.f32(__tsover_sub(N, 2)));
+	const sx = __tsover_sub(srcX, x0);
+	const sy = __tsover_sub(srcY, y0);
+	const ix0 = d.i32(x0);
+	const iy0 = d.i32(y0);
+	const c00 = fluidLayout.$.dyeA[d.u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
+	const c10 = fluidLayout.$.dyeA[d.u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
+	const c01 = fluidLayout.$.dyeA[d.u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
+	const c11 = fluidLayout.$.dyeA[d.u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
+	const r = std.mix(std.mix(c00.x, c10.x, sx), std.mix(c01.x, c11.x, sx), sy);
+	const g = std.mix(std.mix(c00.y, c10.y, sx), std.mix(c01.y, c11.y, sx), sy);
+	const b = std.mix(std.mix(c00.z, c10.z, sx), std.mix(c01.z, c11.z, sx), sy);
+	const decay = __tsover_add(1, __tsover_mul(p.dyeFade, p.dt));
+	fluidLayout.$.dyeB[idx] = d.vec4f(std.max(__tsover_div(r, decay), d.f32(0)), std.max(__tsover_div(g, decay), d.f32(0)), std.max(__tsover_div(b, decay), d.f32(0)), 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"fluidLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"vel",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"srcX",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cx"]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"vel",
+									"x"
+								],
+								"*",
+								[
+									7,
+									"p",
+									"dt"
+								]
+							]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								1,
+								"N",
+								"-",
+								[5, "1"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"srcY",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cy"]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"vel",
+									"y"
+								],
+								"*",
+								[
+									7,
+									"p",
+									"dt"
+								]
+							]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								1,
+								"N",
+								"-",
+								[5, "1"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"x0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["srcX"]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								1,
+								"N",
+								"-",
+								[5, "2"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"y0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["srcY"]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								1,
+								"N",
+								"-",
+								[5, "2"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"sx",
+				[
+					1,
+					"srcX",
+					"-",
+					"x0"
+				]
+			],
+			[
+				13,
+				"sy",
+				[
+					1,
+					"srcY",
+					"-",
+					"y0"
+				]
+			],
+			[
+				13,
+				"ix0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["x0"]
+				]
+			],
+			[
+				13,
+				"iy0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["y0"]
+				]
+			],
+			[
+				13,
+				"c00",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							1,
+							[
+								1,
+								"iy0",
+								"*",
+								"N"
+							],
+							"+",
+							"ix0"
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"c10",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"iy0",
+									"*",
+									"N"
+								],
+								"+",
+								"ix0"
+							],
+							"+",
+							[5, "1"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"c01",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"iy0",
+									"+",
+									[5, "1"]
+								],
+								"*",
+								"N"
+							],
+							"+",
+							"ix0"
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"c11",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"iy0",
+										"+",
+										[5, "1"]
+									],
+									"*",
+									"N"
+								],
+								"+",
+								"ix0"
+							],
+							"+",
+							[5, "1"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"c00",
+									"x"
+								],
+								[
+									7,
+									"c10",
+									"x"
+								],
+								"sx"
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"c01",
+									"x"
+								],
+								[
+									7,
+									"c11",
+									"x"
+								],
+								"sx"
+							]
+						],
+						"sy"
+					]
+				]
+			],
+			[
+				13,
+				"g",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"c00",
+									"y"
+								],
+								[
+									7,
+									"c10",
+									"y"
+								],
+								"sx"
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"c01",
+									"y"
+								],
+								[
+									7,
+									"c11",
+									"y"
+								],
+								"sx"
+							]
+						],
+						"sy"
+					]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"c00",
+									"z"
+								],
+								[
+									7,
+									"c10",
+									"z"
+								],
+								"sx"
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"c01",
+									"z"
+								],
+								[
+									7,
+									"c11",
+									"z"
+								],
+								"sx"
+							]
+						],
+						"sy"
+					]
+				]
+			],
+			[
+				13,
+				"decay",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"dyeFade"
+						],
+						"*",
+						[
+							7,
+							"p",
+							"dt"
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeB"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								1,
+								"r",
+								"/",
+								"decay"
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								1,
+								"g",
+								"/",
+								"decay"
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								1,
+								"b",
+								"/",
+								"decay"
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]]
+						],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"fluidLayout",
+			"d",
+			"N",
+			"std"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d,
+		N,
+		std
+	})
+}) && $.f)({})).$name("inkFlowAdvectDye");
+const copyDyeKernel = 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 c = fluidLayout.$.dyeB[idx];
+	fluidLayout.$.dyeA[idx] = d.vec4f(c.x, c.y, c.z, 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,
+				"c",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeB"
+					],
+					"idx"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							7,
+							"c",
+							"x"
+						],
+						[
+							7,
+							"c",
+							"y"
+						],
+						[
+							7,
+							"c",
+							"z"
+						],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"fluidLayout"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		fluidLayout
+	})
+}) && $.f)({})).$name("inkFlowCopyDye");
+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 c = outputLayout.$.dyeA[idx];
+	std.textureStore(outputLayout.$.outTex, d.vec2u(cx, cy), d.vec4f(c.x, c.y, c.z, 1));
+}), {
+	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,
+				"c",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"outputLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					"idx"
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"outputLayout",
+							"$"
+						],
+						"outTex"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["cx", "cy"]
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								7,
+								"c",
+								"x"
+							],
+							[
+								7,
+								"c",
+								"y"
+							],
+							[
+								7,
+								"c",
+								"z"
+							],
+							[5, "1"]
+						]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"N",
+			"outputLayout",
+			"std"
+		]
+	},
+	externals: () => ({
+		d,
+		N,
+		outputLayout,
+		std
+	})
+}) && $.f)({})).$name("inkFlowOutput");
+const inkFlowComposite = tgpu.fn([d.vec3f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dye, gain) => {
+	"use gpu";
+	const lum = std.max(dye.x, std.max(dye.y, dye.z));
+	const coverage = std.clamp(__tsover_mul(lum, gain), d.f32(0), d.f32(1));
+	return d.vec4f(dye, coverage);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "dye"
+		}, {
+			"type": "i",
+			"name": "gain"
+		}],
+		"body": [0, [
+			[
+				13,
+				"lum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"dye",
+						"x"
+					], [
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"dye",
+							"y"
+						], [
+							7,
+							"dye",
+							"z"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"coverage",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"lum",
+							"*",
+							"gain"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				["dye", "coverage"]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({})).$name("inkFlowComposite");
+function srgbToLinear(c) {
+	return c <= .04045 ? c / 12.92 : Math.pow((c + .055) / 1.055, 2.4);
+}
+function hueToLinearRgb(hue) {
+	const h = (hue % 1 + 1) % 1;
+	const i = Math.floor(h * 6);
+	const f = h * 6 - i;
+	const q = 1 - f;
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	if (i === 0) {
+		r = 1;
+		g = f;
+		b = 0;
+	} else if (i === 1) {
+		r = q;
+		g = 1;
+		b = 0;
+	} else if (i === 2) {
+		r = 0;
+		g = 1;
+		b = f;
+	} else if (i === 3) {
+		r = 0;
+		g = q;
+		b = 1;
+	} else if (i === 4) {
+		r = f;
+		g = 0;
+		b = 1;
+	} else {
+		r = 1;
+		g = 0;
+		b = q;
+	}
+	return [
+		srgbToLinear(r),
+		srgbToLinear(g),
+		srgbToLinear(b)
+	];
+}
+const componentDefinition = {
+	name: "InkFlow",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "Drag to paint swirling ribbons of ink through a real fluid field — eddies keep evolving after you let go",
+	requiresRTT: false,
+	requiresChild: false,
+	usesPointer: true,
+	props: {
+		colorMode: {
+			default: "rainbow",
+			description: "How the brush colour is chosen: an ever-cycling rainbow, a single fixed colour, or a custom three-colour cycle",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Rainbow",
+						value: "rainbow"
+					},
+					{
+						label: "Single Color",
+						value: "single"
+					},
+					{
+						label: "Custom Colors",
+						value: "custom"
+					}
+				],
+				label: "Color Mode",
+				group: "Color"
+			}
+		},
+		colorSpeed: {
+			default: 1,
+			description: "How quickly the brush cycles through the rainbow or the custom colours as you paint",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .05,
+				label: "Color Speed",
+				group: "Color",
+				condition: { colorMode: ["rainbow", "custom"] }
+			}
+		},
+		color: {
+			default: "#ff2d7e",
+			transform: transformColor,
+			description: "Brush colour used when Color Mode is Single",
+			ui: {
+				type: "color",
+				label: "Brush Color",
+				group: "Color",
+				condition: { colorMode: "single" }
+			}
+		},
+		color1: {
+			default: "#4338ff",
+			transform: transformColor,
+			description: "First colour of the custom brush cycle",
+			ui: {
+				type: "color",
+				label: "Color 1",
+				group: "Color",
+				condition: { colorMode: "custom" }
+			}
+		},
+		color2: {
+			default: "#ff2d7e",
+			transform: transformColor,
+			description: "Second colour of the custom brush cycle",
+			ui: {
+				type: "color",
+				label: "Color 2",
+				group: "Color",
+				condition: { colorMode: "custom" }
+			}
+		},
+		color3: {
+			default: "#19e3ff",
+			transform: transformColor,
+			description: "Third colour of the custom brush cycle",
+			ui: {
+				type: "color",
+				label: "Color 3",
+				group: "Color",
+				condition: { colorMode: "custom" }
+			}
+		},
+		colorSpace: {
+			default: "oklab",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Colour space the custom colours blend through as the brush cycles between them",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Color",
+				condition: { colorMode: "custom" }
+			}
+		},
+		radius: {
+			default: .3,
+			description: "Size of the ink splat painted under the cursor",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 5,
+				step: .05,
+				label: "Radius",
+				group: "Brush"
+			}
+		},
+		force: {
+			default: 1,
+			description: "How hard the cursor's motion pushes the fluid — higher throws faster, more violent jets and curls",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .05,
+				label: "Force",
+				group: "Brush"
+			}
+		},
+		curl: {
+			default: 0,
+			description: "Vorticity confinement — swirl energy that spins the ink into persistent eddies and curls",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 60,
+				step: 1,
+				label: "Swirl",
+				group: "Dynamics"
+			}
+		},
+		decay: {
+			default: .5,
+			description: "How fast the ink fades away — low values leave long, lingering trails",
+			ui: {
+				type: "range",
+				min: .05,
+				max: 4,
+				step: .05,
+				label: "Decay",
+				group: "Dynamics"
+			}
+		},
+		momentum: {
+			default: .6,
+			description: "How long the fluid keeps flowing after a stroke — high momentum lets the motion carry on and on",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Momentum",
+				group: "Dynamics"
+			}
+		}
+	},
+	compute: (params) => {
+		const { gpu, getCpuValue, propValues, registerComputeTexture, onCleanup } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const velA = createStateBuffer(root, d.vec4f, COUNT);
+		const velB = createStateBuffer(root, d.vec4f, COUNT);
+		const dyeA = createStateBuffer(root, d.vec4f, COUNT);
+		const dyeB = createStateBuffer(root, d.vec4f, COUNT);
+		const pressure = createStateBuffer(root, d.f32, COUNT);
+		const divergence = createStateBuffer(root, d.f32, 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 dyeTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(FlowParams), "paramsU");
+		const splatU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(SplatParams), "splatU");
+		const size = [N, N];
+		const fluidBg = root.createBindGroup(fluidLayout, {
+			velA,
+			velB,
+			dyeA,
+			dyeB,
+			pressure,
+			divergence,
+			params: paramsU.buffer
+		});
+		const splatBg = root.createBindGroup(splatLayout, {
+			velA,
+			dyeA,
+			sparams: splatU.buffer
+		});
+		const outputBg = root.createBindGroup(outputLayout, {
+			dyeA,
+			outTex
+		});
+		const mk = (kernel) => createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			kernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"kernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["kernel"]
+			},
+			externals: () => ({ kernel })
+		}) && $.f)({}), {
+			size,
+			bindGroup: fluidBg
+		});
+		const spaceMode = propValues.colorSpace ?? 2;
+		const activeSplatKernel = splatKernelVariants[spaceMode] ?? splatKernelVariants[2];
+		const splat = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			activeSplatKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"activeSplatKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["activeSplatKernel"]
+			},
+			externals: () => ({ activeSplatKernel })
+		}) && $.f)({}), {
+			size,
+			bindGroup: splatBg
+		});
+		const curl = mk(curlKernel);
+		const vorticity = mk(vorticityKernel);
+		const divergencePass = mk(divergenceKernel);
+		const jacobi = mk(jacobiKernel);
+		const gradSubtract = mk(gradSubtractKernel);
+		const advectVel = mk(advectVelKernel);
+		const copyVel = mk(copyVelKernel);
+		const advectDye = mk(advectDyeKernel);
+		const copyDye = mk(copyDyeKernel);
+		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,
+			bindGroup: outputBg
+		});
+		let lastTime = Date.now();
+		let prevMx = .5;
+		let prevMy = .5;
+		let lastActiveAt = 0;
+		let hueCursor = 0;
+		const num = (key, fallback) => {
+			const v = getCpuValue(key);
+			return typeof v === "number" ? v : fallback;
+		};
+		return {
+			outputs: { dyeTexture },
+			getComputeNodes: (frameParams) => {
+				const fp = frameParams;
+				const now = Date.now();
+				const dt = Math.min(fp.deltaTime ?? (now - lastTime) / 1e3, .033);
+				lastTime = now;
+				if (dt < .001) return null;
+				const force = num("force", 1);
+				const radiusGrid = Math.max(num("radius", .3) * .1 * N, 1);
+				const colorSpeed = num("colorSpeed", 1);
+				const mode = getCpuValue("colorMode") || "rainbow";
+				hueCursor += dt * CYCLE_TIME_RATE * colorSpeed;
+				const toRgb = (v, fallback) => {
+					const c = v;
+					return c && typeof c.r === "number" ? [
+						c.r,
+						c.g ?? 0,
+						c.b ?? 0
+					] : fallback;
+				};
+				const conv = (c) => convertP3ToMixSpaceCPU(c[0], c[1], c[2], spaceMode);
+				const customStops = mode === "custom" ? [
+					conv(toRgb(getCpuValue("color1"), [
+						.26,
+						.22,
+						1
+					])),
+					conv(toRgb(getCpuValue("color2"), [
+						1,
+						.18,
+						.49
+					])),
+					conv(toRgb(getCpuValue("color3"), [
+						.1,
+						.89,
+						1
+					]))
+				] : null;
+				const brushSplat = () => {
+					hueCursor += CYCLE_PER_SPLAT * colorSpeed;
+					if (customStops) {
+						const h = (hueCursor % 1 + 1) % 1;
+						const seg = Math.min(2, Math.floor(h * 3));
+						return {
+							a: customStops[seg],
+							b: customStops[(seg + 1) % 3],
+							t: h * 3 - seg
+						};
+					}
+					if (mode === "single") {
+						const c$1 = conv(toRgb(getCpuValue("color"), [
+							1,
+							.18,
+							.49
+						]));
+						return {
+							a: c$1,
+							b: c$1,
+							t: 0
+						};
+					}
+					const c = conv(hueToLinearRgb(hueCursor));
+					return {
+						a: c,
+						b: c,
+						t: 0
+					};
+				};
+				const oldMx = prevMx;
+				const oldMy = prevMy;
+				const mx = fp.pointer?.x ?? prevMx;
+				const my = fp.pointer?.y ?? prevMy;
+				const dxp = mx - oldMx;
+				const dyp = my - oldMy;
+				prevMx = mx;
+				prevMy = my;
+				const dragDist = Math.sqrt(dxp * dxp + dyp * dyp);
+				const moving = dragDist > 6e-4 && dragDist < .25;
+				if (moving) lastActiveAt = now;
+				const idleFadeSecs = Math.log(64) / Math.max(num("decay", .5), .05);
+				if (lastActiveAt === 0 || (now - lastActiveAt) / 1e3 > idleFadeSecs) return null;
+				const momentum = Math.min(Math.max(num("momentum", .6), 0), 1);
+				paramsU.write({
+					dt,
+					curlStrength: num("curl", 0),
+					velFade: VEL_FADE_MAX * Math.pow(VEL_FADE_MIN / VEL_FADE_MAX, momentum),
+					dyeFade: num("decay", .5)
+				});
+				const nodes = [];
+				if (moving) {
+					const velX = dxp / dt * N * force * IMPULSE_K;
+					const velY = dyp / dt * N * force * IMPULSE_K;
+					const stepSize = Math.max(.004, radiusGrid / N * .6);
+					const numSteps = Math.min(MAX_STEPS, Math.max(1, Math.ceil(dragDist / stepSize)));
+					for (let s = 0; s < numSteps; s++) {
+						const t = (s + .5) / numSteps;
+						const posX = (oldMx + dxp * t) * N;
+						const posY = (oldMy + dyp * t) * N;
+						const bc = brushSplat();
+						nodes.push(() => splatU.write({
+							posX,
+							posY,
+							velX,
+							velY,
+							colR: bc.a[0],
+							colG: bc.a[1],
+							colB: bc.a[2],
+							col2R: bc.b[0],
+							col2G: bc.b[1],
+							col2B: bc.b[2],
+							mixT: bc.t,
+							radius: radiusGrid,
+							strength: 1
+						}));
+						nodes.push(splat);
+					}
+				}
+				nodes.push(curl, vorticity, divergencePass);
+				for (let iter = 0; iter < JACOBI_ITERS; iter++) nodes.push(jacobi);
+				nodes.push(gradSubtract, advectVel, copyVel, advectDye, copyDye, output);
+				return nodes;
+			}
+		};
+	},
+	fragment: ({ ctx, computeOutputs }) => {
+		const dyeField = computeOutputs?.dyeTexture;
+		if (!dyeField) return ZERO;
+		const out = call(inkFlowComposite, "inkFlowComposite", [dyeField.sample(ctx.uv, "linearClamp").member("rgb"), floatE(GAIN)]);
+		return vec4(out.member("rgb"), out.member("a"));
+	}
+};
+var InkFlow_default = componentDefinition;
+export { copyDyeKernel as a, divergenceKernel as c, jacobiKernel as d, outputKernel as f, componentDefinition as i, gradSubtractKernel as l, vorticityKernel as m, advectDyeKernel as n, copyVelKernel as o, splatKernel as p, advectVelKernel as r, curlKernel as s, InkFlow_default as t, inkFlowComposite as u };