shaders 3.1.463 → 3.2.464

package/dist/core/blur-CXouokcq.js

@@ -1,3415 +0,0 @@
-import { Ft as vec3f, Gt as textureStorage2d, Kt as arrayOf, Lt as vec4f, Mt as vec2f, P as unpremultiplyAlpha, Pt as vec2u, Tt as round, Wt as texture2d, _t as max, cn as i32, ct as clamp, d as ZERO, dt as dot, et as typegpu_default, ht as fract, ln as u32, m as call, qt as struct, sn as f32, xt as pow, yt as mix } from "./edges-CV-BHMpI.js";
-import { I as textureLoad, M as createGuardedCompute, R as textureStore } from "./device-DKcu50_C.js";
-var DEFAULT_HALF_KERNEL = 24;
-const DEFAULT_COMPUTE_WIDTH = 1024;
-const DEFAULT_COMPUTE_HEIGHT = 640;
-var PASSTHROUGH_THRESHOLD = .5;
-var INTERMEDIATE_FORMAT = "rgba16float";
-var OUTPUT_FORMAT = "rgba16float";
-const BLUR_MAP_FORMAT = "rgba32float";
-function buildFixedWeights(halfKernel) {
-	const sigma = halfKernel / 3;
-	const size = halfKernel * 2 + 1;
-	const weights = [];
-	let sum = 0;
-	for (let i = -halfKernel; i <= halfKernel; i++) {
-		const w = Math.exp(-(i * i) / (2 * sigma * sigma));
-		weights.push(w);
-		sum += w;
-	}
-	for (let i = 0; i < size; i++) weights[i] /= sum;
-	return weights;
-}
-function buildTruncatedWeights(halfKernel, sigma) {
-	const size = halfKernel * 2 + 1;
-	const activeHalf = Math.max(1, Math.min(halfKernel, Math.ceil(sigma * 3)));
-	const weights = new Array(size).fill(0);
-	let total = 0;
-	for (let i = -halfKernel; i <= halfKernel; i++) if (Math.abs(i) <= activeHalf) {
-		const w = Math.exp(-(i * i) / (2 * sigma * sigma));
-		weights[i + halfKernel] = w;
-		total += w;
-	}
-	for (let i = 0; i < size; i++) weights[i] /= total;
-	return {
-		weights,
-		activeHalf
-	};
-}
-function fixedHParams() {
-	return struct({
-		activeHalf: i32,
-		inputWidth: f32,
-		inputHeight: f32
-	});
-}
-function fixedVParams() {
-	return struct({ activeHalf: i32 });
-}
-function buildFixedBlurGraph(halfKernel, computeWidth, computeHeight) {
-	const KERNEL_SIZE = halfKernel * 2 + 1;
-	const HALF_KERNEL = halfKernel;
-	const HParams = fixedHParams();
-	const VParams = fixedVParams();
-	const hLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		input: { texture: texture2d(f32) },
-		intermediate: { storageTexture: textureStorage2d(INTERMEDIATE_FORMAT, "write-only") },
-		weights: {
-			storage: arrayOf(f32, KERNEL_SIZE),
-			access: "readonly"
-		},
-		params: { uniform: HParams }
-	}), "hLayout");
-	const vLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		src: { storageTexture: textureStorage2d(INTERMEDIATE_FORMAT, "read-only") },
-		output: { storageTexture: textureStorage2d(OUTPUT_FORMAT, "write-only") },
-		weights: {
-			storage: arrayOf(f32, KERNEL_SIZE),
-			access: "readonly"
-		},
-		params: { uniform: VParams }
-	}), "vLayout");
-	return {
-		hLayout,
-		vLayout,
-		kernelH: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const p = hLayout.$.params;
-			const inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cx), .5), p.inputWidth), computeWidth), .5);
-			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cy), .5), p.inputHeight), computeHeight), .5);
-			const inputWm1 = i32(__tsover_sub(p.inputWidth, 1));
-			const inputHm1 = i32(__tsover_sub(p.inputHeight, 1));
-			const inputCxI = i32(round(inputCx));
-			const inputCyI = clamp(i32(round(inputCy)), 0, inputHm1);
-			const ah = p.activeHalf;
-			const count = __tsover_add(__tsover_mul(ah, 2), 1);
-			let sum = vec4f(0, 0, 0, 0);
-			for (let i = 0; i < count; i++) {
-				const off = __tsover_sub(i, ah);
-				const sampleX = clamp(__tsover_add(inputCxI, off), 0, inputWm1);
-				const texel = textureLoad(hLayout.$.input, vec2u(u32(sampleX), u32(inputCyI)), 0);
-				sum = sum.add(texel.mul(hLayout.$.weights[__tsover_add(off, HALF_KERNEL)]));
-			}
-			textureStore(hLayout.$.intermediate, vec2u(cx, cy), sum);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [
-					[
-						13,
-						"p",
-						[
-							7,
-							[
-								7,
-								"hLayout",
-								"$"
-							],
-							"params"
-						]
-					],
-					[
-						13,
-						"inputCx",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["cx"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									[
-										7,
-										"p",
-										"inputWidth"
-									]
-								],
-								"/",
-								"computeWidth"
-							],
-							"-",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"inputCy",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["cy"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									[
-										7,
-										"p",
-										"inputHeight"
-									]
-								],
-								"/",
-								"computeHeight"
-							],
-							"-",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"inputWm1",
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputWidth"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					],
-					[
-						13,
-						"inputHm1",
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputHeight"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					],
-					[
-						13,
-						"inputCxI",
-						[
-							6,
-							"d.i32",
-							[[
-								6,
-								"std.round",
-								["inputCx"]
-							]]
-						]
-					],
-					[
-						13,
-						"inputCyI",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										["inputCy"]
-									]]
-								],
-								[5, "0"],
-								"inputHm1"
-							]
-						]
-					],
-					[
-						13,
-						"ah",
-						[
-							7,
-							"p",
-							"activeHalf"
-						]
-					],
-					[
-						13,
-						"count",
-						[
-							1,
-							[
-								1,
-								"ah",
-								"*",
-								[5, "2"]
-							],
-							"+",
-							[5, "1"]
-						]
-					],
-					[
-						12,
-						"sum",
-						[
-							6,
-							"d.vec4f",
-							[
-								[5, "0"],
-								[5, "0"],
-								[5, "0"],
-								[5, "0"]
-							]
-						]
-					],
-					[
-						14,
-						[
-							12,
-							"i",
-							[5, "0"]
-						],
-						[
-							1,
-							"i",
-							"<",
-							"count"
-						],
-						[
-							102,
-							"++",
-							"i"
-						],
-						[0, [
-							[
-								13,
-								"off",
-								[
-									1,
-									"i",
-									"-",
-									"ah"
-								]
-							],
-							[
-								13,
-								"sampleX",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											"inputCxI",
-											"+",
-											"off"
-										],
-										[5, "0"],
-										"inputWm1"
-									]
-								]
-							],
-							[
-								13,
-								"texel",
-								[
-									6,
-									"std.textureLoad",
-									[
-										[
-											7,
-											[
-												7,
-												"hLayout",
-												"$"
-											],
-											"input"
-										],
-										[
-											6,
-											"d.vec2u",
-											[[
-												6,
-												"d.u32",
-												["sampleX"]
-											], [
-												6,
-												"d.u32",
-												["inputCyI"]
-											]]
-										],
-										[5, "0"]
-									]
-								]
-							],
-							[
-								2,
-								"sum",
-								"=",
-								[
-									6,
-									[
-										7,
-										"sum",
-										"add"
-									],
-									[[
-										6,
-										[
-											7,
-											"texel",
-											"mul"
-										],
-										[[
-											8,
-											[
-												7,
-												[
-													7,
-													"hLayout",
-													"$"
-												],
-												"weights"
-											],
-											[
-												1,
-												"off",
-												"+",
-												"HALF_KERNEL"
-											]
-										]]
-									]]
-								]
-							]
-						]]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"hLayout",
-									"$"
-								],
-								"intermediate"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							"sum"
-						]
-					]
-				]]
-			},
-			externals: {
-				"hLayout": () => hLayout,
-				"d.f32": () => f32,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"d.i32": () => i32,
-				"std.round": () => round,
-				"std.clamp": () => clamp,
-				"d.vec4f": () => vec4f,
-				"std.textureLoad": () => textureLoad,
-				"d.vec2u": () => vec2u,
-				"d.u32": () => u32,
-				"HALF_KERNEL": () => HALF_KERNEL,
-				"std.textureStore": () => textureStore
-			}
-		}) && $.f)({})).$name("gaussianBlurH"),
-		kernelV: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const av = vLayout.$.params.activeHalf;
-			const count = __tsover_add(__tsover_mul(av, 2), 1);
-			const cyi = i32(cy);
-			let sum = vec4f(0, 0, 0, 0);
-			for (let i = 0; i < count; i++) {
-				const off = __tsover_sub(i, av);
-				const sampleY = clamp(__tsover_add(cyi, off), 0, __tsover_sub(computeHeight, 1));
-				const texel = textureLoad(vLayout.$.src, vec2u(cx, u32(sampleY)));
-				sum = sum.add(texel.mul(vLayout.$.weights[__tsover_add(off, HALF_KERNEL)]));
-			}
-			textureStore(vLayout.$.output, vec2u(cx, cy), sum);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [
-					[
-						13,
-						"av",
-						[
-							7,
-							[
-								7,
-								[
-									7,
-									"vLayout",
-									"$"
-								],
-								"params"
-							],
-							"activeHalf"
-						]
-					],
-					[
-						13,
-						"count",
-						[
-							1,
-							[
-								1,
-								"av",
-								"*",
-								[5, "2"]
-							],
-							"+",
-							[5, "1"]
-						]
-					],
-					[
-						13,
-						"cyi",
-						[
-							6,
-							"d.i32",
-							["cy"]
-						]
-					],
-					[
-						12,
-						"sum",
-						[
-							6,
-							"d.vec4f",
-							[
-								[5, "0"],
-								[5, "0"],
-								[5, "0"],
-								[5, "0"]
-							]
-						]
-					],
-					[
-						14,
-						[
-							12,
-							"i",
-							[5, "0"]
-						],
-						[
-							1,
-							"i",
-							"<",
-							"count"
-						],
-						[
-							102,
-							"++",
-							"i"
-						],
-						[0, [
-							[
-								13,
-								"off",
-								[
-									1,
-									"i",
-									"-",
-									"av"
-								]
-							],
-							[
-								13,
-								"sampleY",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											"cyi",
-											"+",
-											"off"
-										],
-										[5, "0"],
-										[
-											1,
-											"computeHeight",
-											"-",
-											[5, "1"]
-										]
-									]
-								]
-							],
-							[
-								13,
-								"texel",
-								[
-									6,
-									"std.textureLoad",
-									[[
-										7,
-										[
-											7,
-											"vLayout",
-											"$"
-										],
-										"src"
-									], [
-										6,
-										"d.vec2u",
-										["cx", [
-											6,
-											"d.u32",
-											["sampleY"]
-										]]
-									]]
-								]
-							],
-							[
-								2,
-								"sum",
-								"=",
-								[
-									6,
-									[
-										7,
-										"sum",
-										"add"
-									],
-									[[
-										6,
-										[
-											7,
-											"texel",
-											"mul"
-										],
-										[[
-											8,
-											[
-												7,
-												[
-													7,
-													"vLayout",
-													"$"
-												],
-												"weights"
-											],
-											[
-												1,
-												"off",
-												"+",
-												"HALF_KERNEL"
-											]
-										]]
-									]]
-								]
-							]
-						]]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"vLayout",
-									"$"
-								],
-								"output"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							"sum"
-						]
-					]
-				]]
-			},
-			externals: {
-				"vLayout": () => vLayout,
-				"d.i32": () => i32,
-				"d.vec4f": () => vec4f,
-				"std.clamp": () => clamp,
-				"computeHeight": () => computeHeight,
-				"std.textureLoad": () => textureLoad,
-				"d.vec2u": () => vec2u,
-				"d.u32": () => u32,
-				"HALF_KERNEL": () => HALF_KERNEL,
-				"std.textureStore": () => textureStore
-			}
-		}) && $.f)({})).$name("gaussianBlurV"),
-		HParams,
-		VParams,
-		KERNEL_SIZE
-	};
-}
-function createGaussianBlurCompute(root, inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640) {
-	const HALF_KERNEL = halfKernel;
-	const graph = buildFixedBlurGraph(halfKernel, computeWidth, computeHeight);
-	const { hLayout, vLayout, kernelH, kernelV, KERNEL_SIZE } = graph;
-	const intermediateTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-		size: [computeWidth, computeHeight],
-		format: INTERMEDIATE_FORMAT
-	}).$usage("storage"), "intermediateTex");
-	const outputTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-		size: [computeWidth, computeHeight],
-		format: OUTPUT_FORMAT
-	}).$usage("storage", "sampled"), "outputTex");
-	const weightsHBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(arrayOf(f32, KERNEL_SIZE)).$usage("storage"), "weightsHBuf");
-	const weightsVBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(arrayOf(f32, KERNEL_SIZE)).$usage("storage"), "weightsVBuf");
-	const paramsH = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.HParams), "paramsH");
-	const paramsV = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.VParams), "paramsV");
-	onCleanup(() => {
-		intermediateTex.destroy();
-		outputTex.destroy();
-	});
-	const vBindGroup = root.createBindGroup(vLayout, {
-		src: intermediateTex,
-		output: outputTex,
-		weights: weightsVBuf,
-		params: paramsV.buffer
-	});
-	const hPipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-		"use gpu";
-		kernelH(cx, cy);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "cx"
-			}, {
-				"type": "i",
-				"name": "cy"
-			}],
-			"body": [0, [[
-				6,
-				"kernelH",
-				["cx", "cy"]
-			]]]
-		},
-		externals: { "kernelH": () => kernelH }
-	}) && $.f)({}), { size: [computeWidth, computeHeight] });
-	const computeSteps = [hPipeline, createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-		"use gpu";
-		kernelV(cx, cy);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "cx"
-			}, {
-				"type": "i",
-				"name": "cy"
-			}],
-			"body": [0, [[
-				6,
-				"kernelV",
-				["cx", "cy"]
-			]]]
-		},
-		externals: { "kernelV": () => kernelV }
-	}) && $.f)({}), {
-		size: [computeWidth, computeHeight],
-		bindGroup: vBindGroup
-	})];
-	function setInputTexture(input) {
-		const hBindGroup = root.createBindGroup(hLayout, {
-			input,
-			intermediate: intermediateTex,
-			weights: weightsHBuf,
-			params: paramsH.buffer
-		});
-		computeSteps[0] = hPipeline.with(hBindGroup);
-	}
-	if (inputTexture != null) setInputTexture(inputTexture);
-	let scaleY = inputHeight / computeHeight;
-	let curInputWidth = inputWidth;
-	let curInputHeight = inputHeight;
-	let lastRadius = -1;
-	function updateWeights() {
-		const pixelRadius = lastRadius < 0 ? 4 : lastRadius;
-		const sigmaH = Math.max(pixelRadius * .5, .001);
-		const sigmaV = Math.max(sigmaH / scaleY, .001);
-		const h = buildTruncatedWeights(HALF_KERNEL, sigmaH);
-		const v = buildTruncatedWeights(HALF_KERNEL, sigmaV);
-		weightsHBuf.write(h.weights);
-		weightsVBuf.write(v.weights);
-		paramsH.write({
-			activeHalf: h.activeHalf,
-			inputWidth: curInputWidth,
-			inputHeight: curInputHeight
-		});
-		paramsV.write({ activeHalf: v.activeHalf });
-	}
-	function updateRadius(pixelRadius) {
-		if (Math.abs(pixelRadius - lastRadius) < .01) return;
-		lastRadius = pixelRadius;
-		updateWeights();
-	}
-	updateRadius(4);
-	return {
-		computeSteps,
-		outputTexture: outputTex,
-		updateRadius,
-		computeWidth,
-		computeHeight,
-		setInputTexture,
-		setInputDimensions: (newW, newH) => {
-			curInputWidth = newW;
-			curInputHeight = newH;
-			paramsH.patch({
-				inputWidth: newW,
-				inputHeight: newH
-			});
-			const newScaleY = newH / computeHeight;
-			if (Math.abs(newScaleY - scaleY) > .001) {
-				scaleY = newScaleY;
-				updateWeights();
-			}
-		}
-	};
-}
-function variableHParams() {
-	return struct({
-		inputWidth: f32,
-		inputHeight: f32
-	});
-}
-function variableVParams() {
-	return struct({ scaleY: f32 });
-}
-function buildVariableBlurGraph(halfKernel, computeWidth, computeHeight, jitterTaps) {
-	const KERNEL_SIZE = halfKernel * 2 + 1;
-	const HALF_KERNEL = halfKernel;
-	const invHalf = 1 / HALF_KERNEL;
-	const HParams = variableHParams();
-	const VParams = variableVParams();
-	const hLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "read-only") },
-		input: { texture: texture2d(f32) },
-		intermediate: { storageTexture: textureStorage2d(INTERMEDIATE_FORMAT, "write-only") },
-		weights: {
-			storage: arrayOf(f32, KERNEL_SIZE),
-			access: "readonly"
-		},
-		params: { uniform: HParams }
-	}), "hLayout");
-	const vLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "read-only") },
-		src: { storageTexture: textureStorage2d(INTERMEDIATE_FORMAT, "read-only") },
-		output: { storageTexture: textureStorage2d(OUTPUT_FORMAT, "write-only") },
-		weights: {
-			storage: arrayOf(f32, KERNEL_SIZE),
-			access: "readonly"
-		},
-		params: { uniform: VParams }
-	}), "vLayout");
-	return {
-		hLayout,
-		vLayout,
-		kernelH: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const p = hLayout.$.params;
-			const blurRadius = textureLoad(hLayout.$.blurMap, vec2u(cx, cy)).r;
-			const inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cx), .5), p.inputWidth), computeWidth), .5);
-			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cy), .5), p.inputHeight), computeHeight), .5);
-			const inputWm1 = i32(__tsover_sub(p.inputWidth, 1));
-			const inputHm1 = i32(__tsover_sub(p.inputHeight, 1));
-			const inputCyI = clamp(i32(round(inputCy)), 0, inputHm1);
-			if (blurRadius < PASSTHROUGH_THRESHOLD) {
-				const cxClamp = clamp(i32(round(inputCx)), 0, inputWm1);
-				const texel = textureLoad(hLayout.$.input, vec2u(u32(cxClamp), u32(inputCyI)), 0);
-				textureStore(hLayout.$.intermediate, vec2u(cx, cy), texel);
-			} else {
-				const jitterH = jitterTaps ? __tsover_sub(fract(__tsover_mul(52.9829189, fract(__tsover_add(__tsover_mul(f32(cx), .06711056), __tsover_mul(f32(cy), .00583715))))), .5) : f32(0);
-				let sum = vec4f(0, 0, 0, 0);
-				for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
-					const offset = __tsover_mul(__tsover_mul(__tsover_add(f32(i), jitterH), invHalf), blurRadius);
-					const sampleX = clamp(i32(round(__tsover_add(inputCx, offset))), 0, inputWm1);
-					const texel = textureLoad(hLayout.$.input, vec2u(u32(sampleX), u32(inputCyI)), 0);
-					sum = sum.add(texel.mul(hLayout.$.weights[__tsover_add(i, HALF_KERNEL)]));
-				}
-				textureStore(hLayout.$.intermediate, vec2u(cx, cy), sum);
-			}
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [
-					[
-						13,
-						"p",
-						[
-							7,
-							[
-								7,
-								"hLayout",
-								"$"
-							],
-							"params"
-						]
-					],
-					[
-						13,
-						"blurRadius",
-						[
-							7,
-							[
-								6,
-								"std.textureLoad",
-								[[
-									7,
-									[
-										7,
-										"hLayout",
-										"$"
-									],
-									"blurMap"
-								], [
-									6,
-									"d.vec2u",
-									["cx", "cy"]
-								]]
-							],
-							"r"
-						]
-					],
-					[
-						13,
-						"inputCx",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["cx"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									[
-										7,
-										"p",
-										"inputWidth"
-									]
-								],
-								"/",
-								"computeWidth"
-							],
-							"-",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"inputCy",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["cy"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									[
-										7,
-										"p",
-										"inputHeight"
-									]
-								],
-								"/",
-								"computeHeight"
-							],
-							"-",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"inputWm1",
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputWidth"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					],
-					[
-						13,
-						"inputHm1",
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputHeight"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					],
-					[
-						13,
-						"inputCyI",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										["inputCy"]
-									]]
-								],
-								[5, "0"],
-								"inputHm1"
-							]
-						]
-					],
-					[
-						11,
-						[
-							1,
-							"blurRadius",
-							"<",
-							"PASSTHROUGH_THRESHOLD"
-						],
-						[0, [
-							[
-								13,
-								"cxClamp",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											6,
-											"d.i32",
-											[[
-												6,
-												"std.round",
-												["inputCx"]
-											]]
-										],
-										[5, "0"],
-										"inputWm1"
-									]
-								]
-							],
-							[
-								13,
-								"texel",
-								[
-									6,
-									"std.textureLoad",
-									[
-										[
-											7,
-											[
-												7,
-												"hLayout",
-												"$"
-											],
-											"input"
-										],
-										[
-											6,
-											"d.vec2u",
-											[[
-												6,
-												"d.u32",
-												["cxClamp"]
-											], [
-												6,
-												"d.u32",
-												["inputCyI"]
-											]]
-										],
-										[5, "0"]
-									]
-								]
-							],
-							[
-								6,
-								"std.textureStore",
-								[
-									[
-										7,
-										[
-											7,
-											"hLayout",
-											"$"
-										],
-										"intermediate"
-									],
-									[
-										6,
-										"d.vec2u",
-										["cx", "cy"]
-									],
-									"texel"
-								]
-							]
-						]],
-						[0, [
-							[
-								13,
-								"jitterH",
-								[
-									105,
-									"jitterTaps",
-									[
-										1,
-										[
-											6,
-											"std.fract",
-											[[
-												1,
-												[5, "52.9829189"],
-												"*",
-												[
-													6,
-													"std.fract",
-													[[
-														1,
-														[
-															1,
-															[
-																6,
-																"d.f32",
-																["cx"]
-															],
-															"*",
-															[5, "0.06711056"]
-														],
-														"+",
-														[
-															1,
-															[
-																6,
-																"d.f32",
-																["cy"]
-															],
-															"*",
-															[5, "0.00583715"]
-														]
-													]]
-												]
-											]]
-										],
-										"-",
-										[5, "0.5"]
-									],
-									[
-										6,
-										"d.f32",
-										[[5, "0"]]
-									]
-								]
-							],
-							[
-								12,
-								"sum",
-								[
-									6,
-									"d.vec4f",
-									[
-										[5, "0"],
-										[5, "0"],
-										[5, "0"],
-										[5, "0"]
-									]
-								]
-							],
-							[
-								14,
-								[
-									12,
-									"i",
-									[
-										4,
-										"-",
-										"HALF_KERNEL"
-									]
-								],
-								[
-									1,
-									"i",
-									"<=",
-									"HALF_KERNEL"
-								],
-								[
-									102,
-									"++",
-									"i"
-								],
-								[0, [
-									[
-										13,
-										"offset",
-										[
-											1,
-											[
-												1,
-												[
-													1,
-													[
-														6,
-														"d.f32",
-														["i"]
-													],
-													"+",
-													"jitterH"
-												],
-												"*",
-												"invHalf"
-											],
-											"*",
-											"blurRadius"
-										]
-									],
-									[
-										13,
-										"sampleX",
-										[
-											6,
-											"std.clamp",
-											[
-												[
-													6,
-													"d.i32",
-													[[
-														6,
-														"std.round",
-														[[
-															1,
-															"inputCx",
-															"+",
-															"offset"
-														]]
-													]]
-												],
-												[5, "0"],
-												"inputWm1"
-											]
-										]
-									],
-									[
-										13,
-										"texel",
-										[
-											6,
-											"std.textureLoad",
-											[
-												[
-													7,
-													[
-														7,
-														"hLayout",
-														"$"
-													],
-													"input"
-												],
-												[
-													6,
-													"d.vec2u",
-													[[
-														6,
-														"d.u32",
-														["sampleX"]
-													], [
-														6,
-														"d.u32",
-														["inputCyI"]
-													]]
-												],
-												[5, "0"]
-											]
-										]
-									],
-									[
-										2,
-										"sum",
-										"=",
-										[
-											6,
-											[
-												7,
-												"sum",
-												"add"
-											],
-											[[
-												6,
-												[
-													7,
-													"texel",
-													"mul"
-												],
-												[[
-													8,
-													[
-														7,
-														[
-															7,
-															"hLayout",
-															"$"
-														],
-														"weights"
-													],
-													[
-														1,
-														"i",
-														"+",
-														"HALF_KERNEL"
-													]
-												]]
-											]]
-										]
-									]
-								]]
-							],
-							[
-								6,
-								"std.textureStore",
-								[
-									[
-										7,
-										[
-											7,
-											"hLayout",
-											"$"
-										],
-										"intermediate"
-									],
-									[
-										6,
-										"d.vec2u",
-										["cx", "cy"]
-									],
-									"sum"
-								]
-							]
-						]]
-					]
-				]]
-			},
-			externals: {
-				"hLayout": () => hLayout,
-				"std.textureLoad": () => textureLoad,
-				"d.vec2u": () => vec2u,
-				"d.f32": () => f32,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"d.i32": () => i32,
-				"std.clamp": () => clamp,
-				"std.round": () => round,
-				"PASSTHROUGH_THRESHOLD": () => PASSTHROUGH_THRESHOLD,
-				"d.u32": () => u32,
-				"std.textureStore": () => textureStore,
-				"jitterTaps": () => jitterTaps,
-				"std.fract": () => fract,
-				"d.vec4f": () => vec4f,
-				"HALF_KERNEL": () => HALF_KERNEL,
-				"invHalf": () => invHalf
-			}
-		}) && $.f)({})).$name("variableBlurH"),
-		kernelV: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const blurRadius = textureLoad(vLayout.$.blurMap, vec2u(cx, cy)).r;
-			if (blurRadius < PASSTHROUGH_THRESHOLD) {
-				const texel = textureLoad(vLayout.$.src, vec2u(cx, cy));
-				textureStore(vLayout.$.output, vec2u(cx, cy), texel);
-			} else {
-				const yi = i32(cy);
-				const radiusComputeY = __tsover_div(blurRadius, vLayout.$.params.scaleY);
-				const jitterV = jitterTaps ? __tsover_sub(fract(__tsover_mul(52.9829189, fract(__tsover_add(__tsover_mul(f32(cx), .00583715), __tsover_mul(f32(cy), .06711056))))), .5) : f32(0);
-				let sum = vec4f(0, 0, 0, 0);
-				for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
-					const offset = __tsover_mul(__tsover_mul(__tsover_add(f32(i), jitterV), invHalf), radiusComputeY);
-					const sampleY = clamp(__tsover_add(yi, i32(round(offset))), 0, __tsover_sub(computeHeight, 1));
-					const texel = textureLoad(vLayout.$.src, vec2u(cx, u32(sampleY)));
-					sum = sum.add(texel.mul(vLayout.$.weights[__tsover_add(i, HALF_KERNEL)]));
-				}
-				textureStore(vLayout.$.output, vec2u(cx, cy), sum);
-			}
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					13,
-					"blurRadius",
-					[
-						7,
-						[
-							6,
-							"std.textureLoad",
-							[[
-								7,
-								[
-									7,
-									"vLayout",
-									"$"
-								],
-								"blurMap"
-							], [
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							]]
-						],
-						"r"
-					]
-				], [
-					11,
-					[
-						1,
-						"blurRadius",
-						"<",
-						"PASSTHROUGH_THRESHOLD"
-					],
-					[0, [[
-						13,
-						"texel",
-						[
-							6,
-							"std.textureLoad",
-							[[
-								7,
-								[
-									7,
-									"vLayout",
-									"$"
-								],
-								"src"
-							], [
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							]]
-						]
-					], [
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"vLayout",
-									"$"
-								],
-								"output"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							"texel"
-						]
-					]]],
-					[0, [
-						[
-							13,
-							"yi",
-							[
-								6,
-								"d.i32",
-								["cy"]
-							]
-						],
-						[
-							13,
-							"radiusComputeY",
-							[
-								1,
-								"blurRadius",
-								"/",
-								[
-									7,
-									[
-										7,
-										[
-											7,
-											"vLayout",
-											"$"
-										],
-										"params"
-									],
-									"scaleY"
-								]
-							]
-						],
-						[
-							13,
-							"jitterV",
-							[
-								105,
-								"jitterTaps",
-								[
-									1,
-									[
-										6,
-										"std.fract",
-										[[
-											1,
-											[5, "52.9829189"],
-											"*",
-											[
-												6,
-												"std.fract",
-												[[
-													1,
-													[
-														1,
-														[
-															6,
-															"d.f32",
-															["cx"]
-														],
-														"*",
-														[5, "0.00583715"]
-													],
-													"+",
-													[
-														1,
-														[
-															6,
-															"d.f32",
-															["cy"]
-														],
-														"*",
-														[5, "0.06711056"]
-													]
-												]]
-											]
-										]]
-									],
-									"-",
-									[5, "0.5"]
-								],
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								]
-							]
-						],
-						[
-							12,
-							"sum",
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0"],
-									[5, "0"],
-									[5, "0"],
-									[5, "0"]
-								]
-							]
-						],
-						[
-							14,
-							[
-								12,
-								"i",
-								[
-									4,
-									"-",
-									"HALF_KERNEL"
-								]
-							],
-							[
-								1,
-								"i",
-								"<=",
-								"HALF_KERNEL"
-							],
-							[
-								102,
-								"++",
-								"i"
-							],
-							[0, [
-								[
-									13,
-									"offset",
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													"d.f32",
-													["i"]
-												],
-												"+",
-												"jitterV"
-											],
-											"*",
-											"invHalf"
-										],
-										"*",
-										"radiusComputeY"
-									]
-								],
-								[
-									13,
-									"sampleY",
-									[
-										6,
-										"std.clamp",
-										[
-											[
-												1,
-												"yi",
-												"+",
-												[
-													6,
-													"d.i32",
-													[[
-														6,
-														"std.round",
-														["offset"]
-													]]
-												]
-											],
-											[5, "0"],
-											[
-												1,
-												"computeHeight",
-												"-",
-												[5, "1"]
-											]
-										]
-									]
-								],
-								[
-									13,
-									"texel",
-									[
-										6,
-										"std.textureLoad",
-										[[
-											7,
-											[
-												7,
-												"vLayout",
-												"$"
-											],
-											"src"
-										], [
-											6,
-											"d.vec2u",
-											["cx", [
-												6,
-												"d.u32",
-												["sampleY"]
-											]]
-										]]
-									]
-								],
-								[
-									2,
-									"sum",
-									"=",
-									[
-										6,
-										[
-											7,
-											"sum",
-											"add"
-										],
-										[[
-											6,
-											[
-												7,
-												"texel",
-												"mul"
-											],
-											[[
-												8,
-												[
-													7,
-													[
-														7,
-														"vLayout",
-														"$"
-													],
-													"weights"
-												],
-												[
-													1,
-													"i",
-													"+",
-													"HALF_KERNEL"
-												]
-											]]
-										]]
-									]
-								]
-							]]
-						],
-						[
-							6,
-							"std.textureStore",
-							[
-								[
-									7,
-									[
-										7,
-										"vLayout",
-										"$"
-									],
-									"output"
-								],
-								[
-									6,
-									"d.vec2u",
-									["cx", "cy"]
-								],
-								"sum"
-							]
-						]
-					]]
-				]]]
-			},
-			externals: {
-				"std.textureLoad": () => textureLoad,
-				"vLayout": () => vLayout,
-				"d.vec2u": () => vec2u,
-				"PASSTHROUGH_THRESHOLD": () => PASSTHROUGH_THRESHOLD,
-				"std.textureStore": () => textureStore,
-				"d.i32": () => i32,
-				"jitterTaps": () => jitterTaps,
-				"std.fract": () => fract,
-				"d.f32": () => f32,
-				"d.vec4f": () => vec4f,
-				"HALF_KERNEL": () => HALF_KERNEL,
-				"invHalf": () => invHalf,
-				"std.clamp": () => clamp,
-				"std.round": () => round,
-				"computeHeight": () => computeHeight,
-				"d.u32": () => u32
-			}
-		}) && $.f)({})).$name("variableBlurV"),
-		HParams,
-		VParams,
-		KERNEL_SIZE
-	};
-}
-function createVariableGaussianBlurCompute(root, inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640, options) {
-	const HALF_KERNEL = halfKernel;
-	const graph = buildVariableBlurGraph(halfKernel, computeWidth, computeHeight, options?.jitterTaps === true);
-	const { hLayout, vLayout, kernelH, kernelV, KERNEL_SIZE } = graph;
-	const blurMapTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-		size: [computeWidth, computeHeight],
-		format: BLUR_MAP_FORMAT
-	}).$usage("storage"), "blurMapTex");
-	const intermediateTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-		size: [computeWidth, computeHeight],
-		format: INTERMEDIATE_FORMAT
-	}).$usage("storage"), "intermediateTex");
-	const outputTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-		size: [computeWidth, computeHeight],
-		format: OUTPUT_FORMAT
-	}).$usage("storage", "sampled"), "outputTex");
-	const weightsBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(arrayOf(f32, KERNEL_SIZE)).$usage("storage"), "weightsBuf");
-	weightsBuf.write(buildFixedWeights(HALF_KERNEL));
-	const paramsH = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.HParams), "paramsH");
-	const paramsV = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.VParams), "paramsV");
-	paramsH.write({
-		inputWidth,
-		inputHeight
-	});
-	paramsV.write({ scaleY: inputHeight / computeHeight });
-	onCleanup(() => {
-		blurMapTex.destroy();
-		intermediateTex.destroy();
-		outputTex.destroy();
-	});
-	const vBindGroup = root.createBindGroup(vLayout, {
-		blurMap: blurMapTex,
-		src: intermediateTex,
-		output: outputTex,
-		weights: weightsBuf,
-		params: paramsV.buffer
-	});
-	const hPipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-		"use gpu";
-		kernelH(cx, cy);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "cx"
-			}, {
-				"type": "i",
-				"name": "cy"
-			}],
-			"body": [0, [[
-				6,
-				"kernelH",
-				["cx", "cy"]
-			]]]
-		},
-		externals: { "kernelH": () => kernelH }
-	}) && $.f)({}), { size: [computeWidth, computeHeight] });
-	const computeSteps = [hPipeline, createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-		"use gpu";
-		kernelV(cx, cy);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "cx"
-			}, {
-				"type": "i",
-				"name": "cy"
-			}],
-			"body": [0, [[
-				6,
-				"kernelV",
-				["cx", "cy"]
-			]]]
-		},
-		externals: { "kernelV": () => kernelV }
-	}) && $.f)({}), {
-		size: [computeWidth, computeHeight],
-		bindGroup: vBindGroup
-	})];
-	function setInputTexture(input) {
-		const hBindGroup = root.createBindGroup(hLayout, {
-			blurMap: blurMapTex,
-			input,
-			intermediate: intermediateTex,
-			weights: weightsBuf,
-			params: paramsH.buffer
-		});
-		computeSteps[0] = hPipeline.with(hBindGroup);
-	}
-	if (inputTexture != null) setInputTexture(inputTexture);
-	return {
-		computeSteps,
-		outputTexture: outputTex,
-		blurMapTexture: blurMapTex,
-		computeWidth,
-		computeHeight,
-		setInputTexture,
-		setInputDimensions: (newW, newH) => {
-			paramsH.patch({
-				inputWidth: newW,
-				inputHeight: newH
-			});
-			paramsV.patch({ scaleY: newH / computeHeight });
-		}
-	};
-}
-function gaussianTapWeights(count, sigma) {
-	const variance = Number((sigma * sigma).toPrecision(15));
-	const last = count - 1;
-	const raw = Array.from({ length: count }, (_, i) => {
-		const t = (i / last - .5) * 2;
-		return Math.exp(-.5 * t * t / variance);
-	});
-	const sum = raw.reduce((a, b) => a + b);
-	return raw.map((w) => w / sum);
-}
-function unrolledTapGather(config) {
-	const { weights, tapCoord, sample, component } = config;
-	let total;
-	for (let i = 0; i < weights.length; i++) {
-		const raw = sample(tapCoord(i));
-		const weighted = (component ? raw.member(component) : raw).mul(weights[i]);
-		total = total ? total.add(weighted) : weighted;
-	}
-	return total;
-}
-const MAP_SOURCE_DIM_FIELDS = {
-	inputWidth: f32,
-	inputHeight: f32
-};
-const REMAP_WINDOW_FIELDS = {
-	inputMin: f32,
-	inputMax: f32,
-	outputMin: f32,
-	outputMax: f32,
-	curve: f32
-};
-var mapSourceScalarCache = /* @__PURE__ */ new Map();
-function mapSourceScalar(channel) {
-	const cached = mapSourceScalarCache.get(channel);
-	if (cached) return cached;
-	const fn = typegpu_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sample) => {
-		"use gpu";
-		return channel === "alpha" ? sample.w : channel === "alphaInverted" ? __tsover_sub(1, sample.w) : channel === "luminanceInverted" ? __tsover_sub(1, dot(sample.xyz, vec3f(.2126, .7152, .0722))) : dot(sample.xyz, vec3f(.2126, .7152, .0722));
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "sample"
-			}],
-			"body": [0, [[10, [
-				105,
-				[
-					1,
-					"channel",
-					"===",
-					[103, "alpha"]
-				],
-				[
-					7,
-					"sample",
-					"w"
-				],
-				[
-					105,
-					[
-						1,
-						"channel",
-						"===",
-						[103, "alphaInverted"]
-					],
-					[
-						1,
-						[5, "1"],
-						"-",
-						[
-							7,
-							"sample",
-							"w"
-						]
-					],
-					[
-						105,
-						[
-							1,
-							"channel",
-							"===",
-							[103, "luminanceInverted"]
-						],
-						[
-							1,
-							[5, "1"],
-							"-",
-							[
-								6,
-								"std.dot",
-								[[
-									7,
-									"sample",
-									"xyz"
-								], [
-									6,
-									"d.vec3f",
-									[
-										[5, "0.2126"],
-										[5, "0.7152"],
-										[5, "0.0722"]
-									]
-								]]
-							]
-						],
-						[
-							6,
-							"std.dot",
-							[[
-								7,
-								"sample",
-								"xyz"
-							], [
-								6,
-								"d.vec3f",
-								[
-									[5, "0.2126"],
-									[5, "0.7152"],
-									[5, "0.0722"]
-								]
-							]]
-						]
-					]
-				]
-			]]]]
-		},
-		externals: {
-			"channel": () => channel,
-			"std.dot": () => dot,
-			"d.vec3f": () => vec3f
-		}
-	}) && $.f)({})).$name(`mapSourceScalar_${channel}`);
-	mapSourceScalarCache.set(channel, fn);
-	return fn;
-}
-const applyRemapWindow = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((raw, inputMin, inputMax, outputMin, outputMax, curve) => {
-	"use gpu";
-	const inputRange = max(__tsover_sub(inputMax, inputMin), 1e-4);
-	return mix(outputMin, outputMax, pow(clamp(__tsover_div(__tsover_sub(raw, inputMin), inputRange), 0, 1), pow(2, __tsover_mul(-curve, 2))));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "raw"
-			},
-			{
-				"type": "i",
-				"name": "inputMin"
-			},
-			{
-				"type": "i",
-				"name": "inputMax"
-			},
-			{
-				"type": "i",
-				"name": "outputMin"
-			},
-			{
-				"type": "i",
-				"name": "outputMax"
-			},
-			{
-				"type": "i",
-				"name": "curve"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"inputRange",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"inputMax",
-						"-",
-						"inputMin"
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"normalised",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"raw",
-								"-",
-								"inputMin"
-							],
-							"/",
-							"inputRange"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"exponent",
-				[
-					6,
-					"std.pow",
-					[[5, "2"], [
-						1,
-						[
-							4,
-							"-",
-							"curve"
-						],
-						"*",
-						[5, "2"]
-					]]
-				]
-			],
-			[
-				13,
-				"eased",
-				[
-					6,
-					"std.pow",
-					["normalised", "exponent"]
-				]
-			],
-			[10, [
-				6,
-				"std.mix",
-				[
-					"outputMin",
-					"outputMax",
-					"eased"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.clamp": () => clamp,
-		"std.pow": () => pow,
-		"std.mix": () => mix
-	}
-}) && $.f)({})).$name("applyRemapWindow");
-function remapWindowValues(window) {
-	return {
-		inputMin: window.inputMin,
-		inputMax: window.inputMax,
-		outputMin: window.outputMin,
-		outputMax: window.outputMax,
-		curve: window.curve
-	};
-}
-const bloomExtractSoftKnee = typegpu_default.fn([
-	texture2d(f32),
-	u32,
-	u32,
-	vec2f,
-	vec2f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childTexture, cx, cy, inputSize, computeSize, threshold) => {
-	"use gpu";
-	const iw = inputSize.x;
-	const ih = inputSize.y;
-	const inputWm1 = i32(__tsover_sub(iw, 1));
-	const inputHm1 = i32(__tsover_sub(ih, 1));
-	let sample = vec4f(0, 0, 0, 0);
-	for (let ty = 0; ty < 4; ty++) for (let tx = 0; tx < 4; tx++) {
-		const su = __tsover_div(__tsover_add(f32(cx), __tsover_div(__tsover_add(f32(tx), .5), 4)), computeSize.x);
-		const sv = __tsover_div(__tsover_add(f32(cy), __tsover_div(__tsover_add(f32(ty), .5), 4)), computeSize.y);
-		const sx = clamp(i32(__tsover_mul(su, iw)), 0, inputWm1);
-		const sy = clamp(i32(__tsover_mul(sv, ih)), 0, inputHm1);
-		sample = sample.add(textureLoad(childTexture, vec2u(u32(sx), u32(sy)), 0));
-	}
-	sample = sample.mul(.0625);
-	const knee = __tsover_add(__tsover_mul(threshold, .5), 1e-4);
-	const lum = dot(sample.xyz, vec3f(.2126, .7152, .0722));
-	const soft = clamp(__tsover_add(__tsover_sub(lum, threshold), knee), 0, __tsover_mul(knee, 2));
-	const softCurve = __tsover_div(__tsover_mul(soft, soft), __tsover_mul(knee, 4));
-	const mask = __tsover_div(max(softCurve, __tsover_sub(lum, threshold)), max(lum, 1e-4));
-	return vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "childTexture"
-			},
-			{
-				"type": "i",
-				"name": "cx"
-			},
-			{
-				"type": "i",
-				"name": "cy"
-			},
-			{
-				"type": "i",
-				"name": "inputSize"
-			},
-			{
-				"type": "i",
-				"name": "computeSize"
-			},
-			{
-				"type": "i",
-				"name": "threshold"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"iw",
-				[
-					7,
-					"inputSize",
-					"x"
-				]
-			],
-			[
-				13,
-				"ih",
-				[
-					7,
-					"inputSize",
-					"y"
-				]
-			],
-			[
-				13,
-				"inputWm1",
-				[
-					6,
-					"d.i32",
-					[[
-						1,
-						"iw",
-						"-",
-						[5, "1"]
-					]]
-				]
-			],
-			[
-				13,
-				"inputHm1",
-				[
-					6,
-					"d.i32",
-					[[
-						1,
-						"ih",
-						"-",
-						[5, "1"]
-					]]
-				]
-			],
-			[
-				12,
-				"sample",
-				[
-					6,
-					"d.vec4f",
-					[
-						[5, "0"],
-						[5, "0"],
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				14,
-				[
-					12,
-					"ty",
-					[5, "0"]
-				],
-				[
-					1,
-					"ty",
-					"<",
-					[5, "4"]
-				],
-				[
-					102,
-					"++",
-					"ty"
-				],
-				[0, [[
-					14,
-					[
-						12,
-						"tx",
-						[5, "0"]
-					],
-					[
-						1,
-						"tx",
-						"<",
-						[5, "4"]
-					],
-					[
-						102,
-						"++",
-						"tx"
-					],
-					[0, [
-						[
-							13,
-							"su",
-							[
-								1,
-								[
-									1,
-									[
-										6,
-										"d.f32",
-										["cx"]
-									],
-									"+",
-									[
-										1,
-										[
-											1,
-											[
-												6,
-												"d.f32",
-												["tx"]
-											],
-											"+",
-											[5, "0.5"]
-										],
-										"/",
-										[5, "4"]
-									]
-								],
-								"/",
-								[
-									7,
-									"computeSize",
-									"x"
-								]
-							]
-						],
-						[
-							13,
-							"sv",
-							[
-								1,
-								[
-									1,
-									[
-										6,
-										"d.f32",
-										["cy"]
-									],
-									"+",
-									[
-										1,
-										[
-											1,
-											[
-												6,
-												"d.f32",
-												["ty"]
-											],
-											"+",
-											[5, "0.5"]
-										],
-										"/",
-										[5, "4"]
-									]
-								],
-								"/",
-								[
-									7,
-									"computeSize",
-									"y"
-								]
-							]
-						],
-						[
-							13,
-							"sx",
-							[
-								6,
-								"std.clamp",
-								[
-									[
-										6,
-										"d.i32",
-										[[
-											1,
-											"su",
-											"*",
-											"iw"
-										]]
-									],
-									[5, "0"],
-									"inputWm1"
-								]
-							]
-						],
-						[
-							13,
-							"sy",
-							[
-								6,
-								"std.clamp",
-								[
-									[
-										6,
-										"d.i32",
-										[[
-											1,
-											"sv",
-											"*",
-											"ih"
-										]]
-									],
-									[5, "0"],
-									"inputHm1"
-								]
-							]
-						],
-						[
-							2,
-							"sample",
-							"=",
-							[
-								6,
-								[
-									7,
-									"sample",
-									"add"
-								],
-								[[
-									6,
-									"std.textureLoad",
-									[
-										"childTexture",
-										[
-											6,
-											"d.vec2u",
-											[[
-												6,
-												"d.u32",
-												["sx"]
-											], [
-												6,
-												"d.u32",
-												["sy"]
-											]]
-										],
-										[5, "0"]
-									]
-								]]
-							]
-						]
-					]]
-				]]]
-			],
-			[
-				2,
-				"sample",
-				"=",
-				[
-					6,
-					[
-						7,
-						"sample",
-						"mul"
-					],
-					[[5, "0.0625"]]
-				]
-			],
-			[
-				13,
-				"knee",
-				[
-					1,
-					[
-						1,
-						"threshold",
-						"*",
-						[5, "0.5"]
-					],
-					"+",
-					[5, "0.0001"]
-				]
-			],
-			[
-				13,
-				"lum",
-				[
-					6,
-					"std.dot",
-					[[
-						7,
-						"sample",
-						"xyz"
-					], [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.2126"],
-							[5, "0.7152"],
-							[5, "0.0722"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"soft",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"lum",
-								"-",
-								"threshold"
-							],
-							"+",
-							"knee"
-						],
-						[5, "0"],
-						[
-							1,
-							"knee",
-							"*",
-							[5, "2"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"softCurve",
-				[
-					1,
-					[
-						1,
-						"soft",
-						"*",
-						"soft"
-					],
-					"/",
-					[
-						1,
-						"knee",
-						"*",
-						[5, "4"]
-					]
-				]
-			],
-			[
-				13,
-				"mask",
-				[
-					1,
-					[
-						6,
-						"std.max",
-						["softCurve", [
-							1,
-							"lum",
-							"-",
-							"threshold"
-						]]
-					],
-					"/",
-					[
-						6,
-						"std.max",
-						["lum", [5, "0.0001"]]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[[
-					6,
-					[
-						7,
-						[
-							7,
-							"sample",
-							"xyz"
-						],
-						"mul"
-					],
-					["mask"]
-				], [
-					1,
-					[
-						7,
-						"sample",
-						"w"
-					],
-					"*",
-					"mask"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"d.i32": () => i32,
-		"d.vec4f": () => vec4f,
-		"d.f32": () => f32,
-		"std.clamp": () => clamp,
-		"std.textureLoad": () => textureLoad,
-		"d.vec2u": () => vec2u,
-		"d.u32": () => u32,
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.max": () => max
-	}
-}) && $.f)({})).$name("bloomExtractSoftKnee");
-var BRIGHT_FORMAT = "rgba16float";
-function buildBloomExtractGraph(computeWidth, computeHeight, kernelName) {
-	const Params = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-		threshold: f32,
-		size: f32,
-		...MAP_SOURCE_DIM_FIELDS
-	}), "Params");
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		childTexture: { texture: texture2d(f32) },
-		brightMap: { storageTexture: textureStorage2d(BRIGHT_FORMAT, "write-only") },
-		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
-		params: { uniform: Params }
-	}), "layout");
-	return {
-		layout,
-		kernel: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const p = layout.$.params;
-			const bright = bloomExtractSoftKnee(layout.$.childTexture, cx, cy, vec2f(p.inputWidth, p.inputHeight), vec2f(computeWidth, computeHeight), p.threshold);
-			textureStore(layout.$.brightMap, vec2u(cx, cy), bright);
-			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(p.size, 0, 0, 1));
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [
-					[
-						13,
-						"p",
-						[
-							7,
-							[
-								7,
-								"layout",
-								"$"
-							],
-							"params"
-						]
-					],
-					[
-						13,
-						"bright",
-						[
-							6,
-							"bloomExtractSoftKnee",
-							[
-								[
-									7,
-									[
-										7,
-										"layout",
-										"$"
-									],
-									"childTexture"
-								],
-								"cx",
-								"cy",
-								[
-									6,
-									"d.vec2f",
-									[[
-										7,
-										"p",
-										"inputWidth"
-									], [
-										7,
-										"p",
-										"inputHeight"
-									]]
-								],
-								[
-									6,
-									"d.vec2f",
-									["computeWidth", "computeHeight"]
-								],
-								[
-									7,
-									"p",
-									"threshold"
-								]
-							]
-						]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"layout",
-									"$"
-								],
-								"brightMap"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							"bright"
-						]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"layout",
-									"$"
-								],
-								"blurMap"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									[
-										7,
-										"p",
-										"size"
-									],
-									[5, "0"],
-									[5, "0"],
-									[5, "1"]
-								]
-							]
-						]
-					]
-				]]
-			},
-			externals: {
-				"layout": () => layout,
-				"bloomExtractSoftKnee": () => bloomExtractSoftKnee,
-				"d.vec2f": () => vec2f,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"std.textureStore": () => textureStore,
-				"d.vec2u": () => vec2u,
-				"d.vec4f": () => vec4f
-			}
-		}) && $.f)({})).$name(kernelName),
-		Params
-	};
-}
-function buildBloomExtractMapGraph(computeWidth, computeHeight, kernelName, channel) {
-	const Params = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-		threshold: f32,
-		...MAP_SOURCE_DIM_FIELDS,
-		...REMAP_WINDOW_FIELDS
-	}), "Params");
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		childTexture: { texture: texture2d(f32) },
-		source: { texture: texture2d(f32) },
-		brightMap: { storageTexture: textureStorage2d(BRIGHT_FORMAT, "write-only") },
-		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
-		params: { uniform: Params }
-	}), "layout");
-	const channelScalar = mapSourceScalar(channel);
-	return {
-		layout,
-		kernel: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const p = layout.$.params;
-			const iw = p.inputWidth;
-			const ih = p.inputHeight;
-			const bright = bloomExtractSoftKnee(layout.$.childTexture, cx, cy, vec2f(iw, ih), vec2f(computeWidth, computeHeight), p.threshold);
-			textureStore(layout.$.brightMap, vec2u(cx, cy), bright);
-			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
-			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
-			const srcX = clamp(i32(round(__tsover_mul(u, iw))), 0, i32(__tsover_sub(iw, 1)));
-			const srcY = clamp(i32(round(__tsover_mul(v, ih))), 0, i32(__tsover_sub(ih, 1)));
-			const radius = applyRemapWindow(channelScalar(textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0)), p.inputMin, p.inputMax, p.outputMin, p.outputMax, p.curve);
-			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(radius, 0, 0, 1));
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [
-					[
-						13,
-						"p",
-						[
-							7,
-							[
-								7,
-								"layout",
-								"$"
-							],
-							"params"
-						]
-					],
-					[
-						13,
-						"iw",
-						[
-							7,
-							"p",
-							"inputWidth"
-						]
-					],
-					[
-						13,
-						"ih",
-						[
-							7,
-							"p",
-							"inputHeight"
-						]
-					],
-					[
-						13,
-						"bright",
-						[
-							6,
-							"bloomExtractSoftKnee",
-							[
-								[
-									7,
-									[
-										7,
-										"layout",
-										"$"
-									],
-									"childTexture"
-								],
-								"cx",
-								"cy",
-								[
-									6,
-									"d.vec2f",
-									["iw", "ih"]
-								],
-								[
-									6,
-									"d.vec2f",
-									["computeWidth", "computeHeight"]
-								],
-								[
-									7,
-									"p",
-									"threshold"
-								]
-							]
-						]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"layout",
-									"$"
-								],
-								"brightMap"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							"bright"
-						]
-					],
-					[
-						13,
-						"u",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cx"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeWidth"
-						]
-					],
-					[
-						13,
-						"v",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cy"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeHeight"
-						]
-					],
-					[
-						13,
-						"srcX",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										[[
-											1,
-											"u",
-											"*",
-											"iw"
-										]]
-									]]
-								],
-								[5, "0"],
-								[
-									6,
-									"d.i32",
-									[[
-										1,
-										"iw",
-										"-",
-										[5, "1"]
-									]]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"srcY",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										[[
-											1,
-											"v",
-											"*",
-											"ih"
-										]]
-									]]
-								],
-								[5, "0"],
-								[
-									6,
-									"d.i32",
-									[[
-										1,
-										"ih",
-										"-",
-										[5, "1"]
-									]]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"mapSample",
-						[
-							6,
-							"std.textureLoad",
-							[
-								[
-									7,
-									[
-										7,
-										"layout",
-										"$"
-									],
-									"source"
-								],
-								[
-									6,
-									"d.vec2u",
-									[[
-										6,
-										"d.u32",
-										["srcX"]
-									], [
-										6,
-										"d.u32",
-										["srcY"]
-									]]
-								],
-								[5, "0"]
-							]
-						]
-					],
-					[
-						13,
-						"radius",
-						[
-							6,
-							"applyRemapWindow",
-							[
-								[
-									6,
-									"channelScalar",
-									["mapSample"]
-								],
-								[
-									7,
-									"p",
-									"inputMin"
-								],
-								[
-									7,
-									"p",
-									"inputMax"
-								],
-								[
-									7,
-									"p",
-									"outputMin"
-								],
-								[
-									7,
-									"p",
-									"outputMax"
-								],
-								[
-									7,
-									"p",
-									"curve"
-								]
-							]
-						]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"layout",
-									"$"
-								],
-								"blurMap"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									"radius",
-									[5, "0"],
-									[5, "0"],
-									[5, "1"]
-								]
-							]
-						]
-					]
-				]]
-			},
-			externals: {
-				"layout": () => layout,
-				"bloomExtractSoftKnee": () => bloomExtractSoftKnee,
-				"d.vec2f": () => vec2f,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"std.textureStore": () => textureStore,
-				"d.vec2u": () => vec2u,
-				"d.f32": () => f32,
-				"std.clamp": () => clamp,
-				"d.i32": () => i32,
-				"std.round": () => round,
-				"std.textureLoad": () => textureLoad,
-				"d.u32": () => u32,
-				"applyRemapWindow": () => applyRemapWindow,
-				"channelScalar": () => channelScalar,
-				"d.vec4f": () => vec4f
-			}
-		}) && $.f)({})).$name(kernelName),
-		Params
-	};
-}
-function aspectAwareComputeRes(canvasWidth, canvasHeight) {
-	const LONG_EDGE = Math.max(DEFAULT_COMPUTE_WIDTH, 640);
-	const aspect = canvasHeight > 0 ? canvasWidth / canvasHeight : 1;
-	return {
-		width: Math.max(8, aspect >= 1 ? LONG_EDGE : Math.round(LONG_EDGE * aspect)),
-		height: Math.max(8, aspect >= 1 ? Math.round(LONG_EDGE / aspect) : LONG_EDGE)
-	};
-}
-var DEFAULT_BLURRED_KEY = "blurredTexture";
-function canvasPixels(dimensions) {
-	return {
-		width: Math.max(1, Math.round(dimensions.width)),
-		height: Math.max(1, Math.round(dimensions.height))
-	};
-}
-function withFixedBlurCompute(params, config) {
-	const { childNode, gpu, convertToTexture, registerComputeTexture, onCleanup, onResize, dimensions } = params;
-	if (!childNode) return null;
-	const root = gpu?.root;
-	if (!root) return null;
-	const outputKey = config.outputKey ?? DEFAULT_BLURRED_KEY;
-	const childTexture = convertToTexture(childNode);
-	const canvas = canvasPixels(dimensions);
-	const gaussian = createGaussianBlurCompute(root, null, canvas.width, canvas.height, onCleanup, config.halfKernel);
-	const blurredTexture = registerComputeTexture(gaussian.outputTexture);
-	onResize(({ width, height }) => {
-		const next = canvasPixels({
-			width,
-			height
-		});
-		gaussian.setInputDimensions(next.width, next.height);
-	});
-	return {
-		outputs: {
-			childTexture,
-			[outputKey]: blurredTexture
-		},
-		bindInputs: (resolve) => {
-			const src = resolve(childTexture.key);
-			if (src) gaussian.setInputTexture(src.texture);
-		},
-		getComputeNodes: () => {
-			gaussian.updateRadius(config.radius());
-			return gaussian.computeSteps;
-		}
-	};
-}
-function withVariableBlurCompute(params, config) {
-	const { childNode, gpu, convertToTexture, registerComputeTexture, onCleanup, onResize, dimensions } = params;
-	if (!childNode) return null;
-	const root = gpu?.root;
-	if (!root) return null;
-	const outputKey = config.outputKey ?? DEFAULT_BLURRED_KEY;
-	const source = config.source;
-	const childTexture = convertToTexture(childNode);
-	let canvas = canvasPixels(dimensions);
-	const variable = createVariableGaussianBlurCompute(root, null, canvas.width, canvas.height, onCleanup, config.halfKernel);
-	const blurredTexture = registerComputeTexture(variable.outputTexture);
-	const fill = config.buildFill(variable.computeWidth, variable.computeHeight);
-	const fillParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(fill.Params), "fillParams");
-	const blurMap = variable.blurMapTexture;
-	const fillStepOpts = { size: [variable.computeWidth, variable.computeHeight] };
-	let fillStep = source ? createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-		"use gpu";
-		fill.kernel(cx, cy);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "cx"
-			}, {
-				"type": "i",
-				"name": "cy"
-			}],
-			"body": [0, [[
-				6,
-				"fill.kernel",
-				["cx", "cy"]
-			]]]
-		},
-		externals: { "fill.kernel": () => fill.kernel }
-	}) && $.f)({}), fillStepOpts) : createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-		"use gpu";
-		fill.kernel(cx, cy);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "cx"
-			}, {
-				"type": "i",
-				"name": "cy"
-			}],
-			"body": [0, [[
-				6,
-				"fill.kernel",
-				["cx", "cy"]
-			]]]
-		},
-		externals: { "fill.kernel": () => fill.kernel }
-	}) && $.f)({}), {
-		...fillStepOpts,
-		bindGroup: root.createBindGroup(fill.layout, {
-			blurMap,
-			params: fillParams.buffer
-		})
-	});
-	onResize(({ width, height }) => {
-		canvas = canvasPixels({
-			width,
-			height
-		});
-		variable.setInputDimensions(canvas.width, canvas.height);
-	});
-	return {
-		outputs: {
-			childTexture,
-			[outputKey]: blurredTexture
-		},
-		bindInputs: (resolve) => {
-			const src = resolve(childTexture.key);
-			if (src) variable.setInputTexture(src.texture);
-			if (!source) return;
-			const mapSrc = resolve(source.sourceTexture.key);
-			if (mapSrc) {
-				const bg = root.createBindGroup(fill.layout, {
-					source: mapSrc.texture,
-					blurMap,
-					params: fillParams.buffer
-				});
-				fillStep = fillStep.with(bg);
-			}
-		},
-		getComputeNodes: () => {
-			fillParams.write(config.fillValues(canvas, source?.window()));
-			return [fillStep, ...variable.computeSteps];
-		}
-	};
-}
-function withBloomCompute(params, config) {
-	const { childNode, gpu, convertToTexture, registerComputeTexture, onCleanup, onResize, dimensions } = params;
-	if (!childNode) return null;
-	const root = gpu?.root;
-	if (!root) return null;
-	const outputKey = config.outputKey ?? DEFAULT_BLURRED_KEY;
-	const mapInfo = config.mapInfo ?? null;
-	const childTexture = convertToTexture(childNode);
-	let canvas = canvasPixels(dimensions);
-	const res = aspectAwareComputeRes(canvas.width, canvas.height);
-	const brightBuffer = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-		size: [res.width, res.height],
-		format: BRIGHT_FORMAT
-	}).$usage("storage", "sampled"), "brightBuffer");
-	onCleanup(() => brightBuffer.destroy());
-	const variable = createVariableGaussianBlurCompute(root, brightBuffer, res.width, res.height, onCleanup, void 0, res.width, res.height, { jitterTaps: true });
-	const blurredTexture = registerComputeTexture(variable.outputTexture);
-	onResize(({ width, height }) => {
-		canvas = canvasPixels({
-			width,
-			height
-		});
-	});
-	const graph = mapInfo && config.buildExtractMap ? config.buildExtractMap(res.width, res.height, mapInfo.channel) : config.buildExtract(res.width, res.height);
-	const prepassParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.Params), "prepassParams");
-	let prepassStep = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-		"use gpu";
-		graph.kernel(cx, cy);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "cx"
-			}, {
-				"type": "i",
-				"name": "cy"
-			}],
-			"body": [0, [[
-				6,
-				"graph.kernel",
-				["cx", "cy"]
-			]]]
-		},
-		externals: { "graph.kernel": () => graph.kernel }
-	}) && $.f)({}), { size: [res.width, res.height] });
-	return {
-		outputs: {
-			childTexture,
-			[outputKey]: blurredTexture
-		},
-		bindInputs: (resolve) => {
-			const src = resolve(childTexture.key);
-			if (!src) return;
-			const mapSrc = mapInfo ? resolve(mapInfo.sourceTexture.key) : void 0;
-			if (mapInfo && !mapSrc) return;
-			const entries = {
-				childTexture: src.texture,
-				brightMap: brightBuffer,
-				blurMap: variable.blurMapTexture,
-				params: prepassParams.buffer
-			};
-			if (mapSrc) entries.source = mapSrc.texture;
-			prepassStep = prepassStep.with(root.createBindGroup(graph.layout, entries));
-		},
-		getComputeNodes: () => {
-			const threshold = config.threshold();
-			const values = mapInfo ? {
-				threshold,
-				inputWidth: canvas.width,
-				inputHeight: canvas.height,
-				...remapWindowValues(mapInfo.window())
-			} : {
-				threshold,
-				size: config.radius(),
-				inputWidth: canvas.width,
-				inputHeight: canvas.height
-			};
-			prepassParams.write(values);
-			return [prepassStep, ...variable.computeSteps];
-		}
-	};
-}
-function composeBlurredOverSharp(params, compose, options) {
-	const { childNode, computeOutputs, ctx, convertToTexture } = params;
-	if (!childNode) return ZERO;
-	const blurred = computeOutputs?.[options?.blurredKey ?? DEFAULT_BLURRED_KEY];
-	const sharp = computeOutputs?.[options?.sharpKey ?? "childTexture"];
-	if (!blurred || !sharp) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [convertToTexture(childNode).sample(ctx.uv)]);
-	const sharpSample = sharp.sample(ctx.uv);
-	return call(unpremultiplyAlpha, "unpremultiplyAlpha", [compose(blurred.sample(ctx.uv), sharpSample)]);
-}
-export { withVariableBlurCompute as _, REMAP_WINDOW_FIELDS as a, buildBloomExtractMapGraph as c, gaussianTapWeights as d, mapSourceScalar as f, withFixedBlurCompute as g, withBloomCompute as h, MAP_SOURCE_DIM_FIELDS as i, composeBlurredOverSharp as l, unrolledTapGather as m, DEFAULT_COMPUTE_HEIGHT as n, applyRemapWindow as o, remapWindowValues as p, DEFAULT_COMPUTE_WIDTH as r, buildBloomExtractGraph as s, BLUR_MAP_FORMAT as t, createGaussianBlurCompute as u };