shaders 3.1.463 → 3.2.465

package/dist/core/blurs-D1HfQTGP.js

@@ -0,0 +1,1751 @@
+import { $n as clamp, An as DEG_TO_RAD, Br as f32, Cr as vec2u, Et as unpremultiplyAlpha, G as createGuardedCompute, Hr as u32, J as applyEdgeHandlingExpr, Nr as struct, Tr as vec4f, Un as textureStore, _r as smoothstep, at as asLocal, cr as max, dt as mixExpr, er as cos, ft as vec4, gr as sin, i as resolveArg, jr as textureStorage2d, lt as expr, mt as formatFloat, o as uniformOf, ot as call, rt as ZERO, tt as sampleCatmullRomExpr, ur as mix, ut as floatE, wr as vec3f, xr as vec2f, yr as step, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { t as animatedTime } from "./porters-j4QbEOqj.js";
+import { D as rgbSplitTaps, E as revealShadow$1, O as rimComposite, S as pagePeelGeom, b as overhangShade, c as curlSheen$1, d as edgeClipSample, j as sphereBulge, k as rimLight, m as flutedGlassGeom, r as blinnHighlight, s as curlShade, x as pagePeelCompose } from "./warpMaps-051QhmeG.js";
+import { C as intensityToRadius, D as withBloomCompute, O as withFixedBlurCompute, S as glowCompose, T as tiltShiftBlurAmount, _ as channelBlurCompose, a as DEFAULT_COMPUTE_WIDTH, c as buildBokehGraph, d as buildGlowPrepassGraph, f as buildGlowPrepassMapGraph, g as buildTiltShiftFillMapGraph, h as buildTiltShiftFillGraph, i as DEFAULT_COMPUTE_HEIGHT, k as withVariableBlurCompute, l as buildBokehMapGraph, m as buildProgressiveBlurFillMapGraph, n as BOKEH_TAP_COUNT, o as bokehRadiusToPixels, p as buildProgressiveBlurFillGraph, r as CHANNEL_INTENSITY_TO_RADIUS, s as buildBloomExtractGraph, t as BLUR_MAP_FORMAT, u as buildFillBlurMapGraph, v as composeBlurredOverSharp, w as remapWindowValues, x as generateBokehTaps } from "./blur-BwjlF0Uk.js";
+import { C as vignetteShade, S as vhsSampleUVs, _ as scatterGather, a as dropShadowComposite, b as vhsAcBeat, d as glitchSplitUVs, f as motionBlurGather, g as scanlineShade, h as rgbSplitCombine, i as distortScanShade, m as pixelateGather, n as beatShade, o as dropShadowUV, p as phosphorShade, r as crtSampleUV, s as fillBarsShade, t as adjustShade, u as glitchGeom, v as sharpenGather, w as yiqRecombine, x as vhsChromaTapUV, y as silhouetteBlur } from "./motionBlur-CiNghKu6.js";
+function gatherStack(sample, overlays, opts) {
+	return {
+		kind: "gather",
+		resultAlpha: opts?.resultAlpha,
+		build: (params) => overlays.reduce((color, stage) => stage(color, params), sample(params))
+	};
+}
+function frameOf(make) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (params) => {
+		const hit = cache.get(params);
+		if (hit) return hit;
+		const made = make(params);
+		cache.set(params, made);
+		return made;
+	};
+}
+function rgbSplit(opts) {
+	return (params) => {
+		const amount = resolveArg(opts.amount, params);
+		const redUV = call(crtSampleUV, "crtSampleUV", [
+			params.ctx.uv,
+			amount,
+			floatE(1)
+		]);
+		const blueUV = call(crtSampleUV, "crtSampleUV", [
+			params.ctx.uv,
+			amount,
+			floatE(-1)
+		]);
+		return call(rgbSplitCombine, "rgbSplitCombine", [
+			params.texture.sample(redUV),
+			params.texture.sample(params.ctx.uv),
+			params.texture.sample(blueUV)
+		]);
+	};
+}
+function tapeWarp(opts) {
+	return (params) => call(vhsSampleUVs, "vhsSampleUVs", [
+		params.ctx.uv,
+		params.ctx.time,
+		resolveArg(opts.speed, params),
+		resolveArg(opts.wobble, params),
+		resolveArg(opts.jitter, params)
+	]);
+}
+function chromaSmearTaps(opts) {
+	return (params) => {
+		const uvs = asLocal(opts.warp(params), "tapeUVs");
+		const chromaUV = uvs.member("zw");
+		const lumaSample = params.texture.sample(uvs.member("xy"));
+		const smearScale = resolveArg(opts.smear, params).mul(.0075);
+		const tap = (i) => params.texture.sample(call(vhsChromaTapUV, "vhsChromaTapUV", [
+			chromaUV,
+			smearScale,
+			floatE(i)
+		]));
+		return vec4(call(yiqRecombine, "yiqRecombine", [
+			lumaSample,
+			tap(1),
+			tap(2),
+			tap(3),
+			tap(4),
+			tap(5)
+		]), lumaSample.member("a"));
+	};
+}
+function adjust(opts) {
+	return (color, params) => call(adjustShade, "adjustShade", [
+		color,
+		resolveArg(opts.contrast, params),
+		resolveArg(opts.brightness, params)
+	]);
+}
+function scanlines(opts) {
+	return (color, params) => call(scanlineShade, "scanlineShade", [
+		color,
+		params.ctx.uv.member("y"),
+		resolveArg(opts.frequency, params),
+		resolveArg(opts.intensity, params)
+	]);
+}
+function phosphorMask(opts) {
+	return (color, params) => call(phosphorShade, "phosphorShade", [
+		color,
+		params.ctx.uv,
+		resolveArg(opts.pitch, params)
+	]);
+}
+function vignetteOverlay(opts) {
+	return (color, params) => call(vignetteShade, "vignetteShade", [
+		color,
+		params.ctx.uv,
+		params.ctx.aspect,
+		resolveArg(opts.radius, params),
+		resolveArg(opts.intensity, params)
+	]);
+}
+function opaque() {
+	return (color) => vec4(color, floatE(1));
+}
+function beatPulse(opts) {
+	return (color, params) => call(beatShade, "beatShade", [color, call(vhsAcBeat, "vhsAcBeat", [
+		params.ctx.uv,
+		params.ctx.time,
+		resolveArg(opts.speed, params),
+		resolveArg(opts.wobble, params)
+	])]);
+}
+const blurPath = {
+	linear: (angle) => ({
+		kind: "linear",
+		focus: angle
+	}),
+	orbit: (center) => ({
+		kind: "orbit",
+		focus: center
+	}),
+	zoom: (center) => ({
+		kind: "zoom",
+		focus: center
+	})
+};
+function motionBlur(opts) {
+	const { path, amount } = opts;
+	return {
+		kind: "gather",
+		build: (params) => motionBlurGather(path.kind, {
+			focus: resolveArg(path.focus, params),
+			amount: resolveArg(amount, params),
+			uv: params.ctx.uv,
+			aspect: params.ctx.aspect,
+			viewportSize: params.ctx.viewportSize
+		}, (coord) => params.texture.sample(coord))
+	};
+}
+function scatter(opts) {
+	const { amount, edges } = opts;
+	return {
+		kind: "gather",
+		build: (params) => scatterGather({
+			uv: params.ctx.uv,
+			amount: resolveArg(amount, params),
+			viewportSize: params.ctx.viewportSize,
+			edgeMode: params.propValues[edges.name] ?? 0,
+			sample: (coord) => params.texture.sample(coord)
+		})
+	};
+}
+function sharpen(amount) {
+	return {
+		kind: "gather",
+		build: (params) => sharpenGather({
+			uv: params.ctx.uv,
+			viewportSize: params.ctx.viewportSize,
+			amount: resolveArg(amount, params),
+			sample: (coord) => params.texture.sample(coord)
+		})
+	};
+}
+function pixelate(opts) {
+	const { scale, gap, roundness } = opts;
+	return {
+		kind: "gather",
+		resultAlpha: "straight",
+		build: (params) => pixelateGather({
+			uv: params.ctx.uv,
+			aspect: params.ctx.aspect,
+			scale: resolveArg(scale, params),
+			gap: resolveArg(gap, params),
+			roundness: resolveArg(roundness, params),
+			sampleStraight: params.sampleStraight
+		})
+	};
+}
+function sphereFrame(opts) {
+	return frameOf((params) => asLocal(call(sphereBulge, "sphereBulge", [
+		params.ctx.uv,
+		params.ctx.viewportSize,
+		resolveArg(opts.center, params),
+		resolveArg(opts.radius, params),
+		resolveArg(opts.depth, params)
+	]), "sphere"));
+}
+function crispTap(frame) {
+	return (params) => call(unpremultiplyAlpha, "unpremultiplyAlpha", [sampleCatmullRomExpr(params.texture, frame(params).member("uv"))]);
+}
+function rimLit(frame, opts) {
+	return (color, params) => {
+		const rim = call(rimLight, "rimLight", [
+			frame(params).member("normal"),
+			resolveArg(opts.position, params),
+			resolveArg(opts.intensity, params),
+			resolveArg(opts.softness, params)
+		]);
+		return call(rimComposite, "rimComposite", [
+			color,
+			resolveArg(opts.color, params).member("rgb"),
+			rim,
+			frame(params).member("coverage")
+		]);
+	};
+}
+function glitchFrame(opts) {
+	return frameOf((params) => asLocal(call(glitchGeom, "glitchGeom", [
+		params.ctx.uv,
+		params.ctx.time,
+		resolveArg(opts.intensity, params),
+		resolveArg(opts.speed, params),
+		resolveArg(opts.blockDensity, params),
+		resolveArg(opts.mirrorAmount, params)
+	]), "glitch"));
+}
+function glitchRgbSplit(frame, opts) {
+	return (params) => {
+		const geom = frame(params);
+		const splitUVs = asLocal(call(glitchSplitUVs, "glitchSplitUVs", [
+			geom.member("mirroredUV"),
+			resolveArg(opts.shift, params),
+			geom.member("spread")
+		]), "splitUVs");
+		const greenSample = params.texture.sample(geom.member("mirroredUV"));
+		return vec4(params.texture.sample(splitUVs.member("xy")).member("r"), greenSample.member("g"), params.texture.sample(splitUVs.member("zw")).member("b"), greenSample.member("a"));
+	};
+}
+function colorBarFills(frame, opts) {
+	return (color, params) => {
+		const geom = frame(params);
+		return call(fillBarsShade, "fillBarsShade", [
+			color,
+			params.ctx.uv,
+			geom.member("bandY1"),
+			geom.member("slowFrame"),
+			resolveArg(opts.intensity, params),
+			geom.member("strength"),
+			geom.member("bandGate"),
+			geom.member("blockGate")
+		]);
+	};
+}
+function distortedScanlines(frame, opts) {
+	return (color, params) => call(distortScanShade, "distortScanShade", [
+		color,
+		params.ctx.uv.member("y"),
+		params.ctx.viewportSize.member("y"),
+		resolveArg(opts.intensity, params),
+		frame(params).member("distortion")
+	]);
+}
+function gaussianBlur(opts) {
+	const prop = opts.intensity.name;
+	return {
+		compute: (params) => {
+			const { getCpuValue, getMapInfo } = params;
+			const mapInfo = getMapInfo(prop);
+			if (mapInfo) return withVariableBlurCompute(params, {
+				source: mapInfo,
+				buildFill: (cw, ch) => buildFillBlurMapGraph(cw, ch, mapInfo.channel),
+				fillValues: (dims, window) => ({
+					inputWidth: dims.width,
+					inputHeight: dims.height,
+					...remapWindowValues(window)
+				})
+			});
+			return withFixedBlurCompute(params, { radius: () => {
+				const raw = getCpuValue(prop);
+				return typeof raw === "number" ? intensityToRadius(raw) : 4;
+			} });
+		},
+		gpu: { fragment: (params) => composeBlurredOverSharp(params, (blurred, sharp) => vec4(blurred.member("rgb"), sharp.member("a"))) }
+	};
+}
+function channelBlur(opts) {
+	const { red, green, blue } = opts;
+	return {
+		compute: (params) => withFixedBlurCompute(params, { radius: () => {
+			const r = (params.getCpuValue(red.name) ?? 0) * CHANNEL_INTENSITY_TO_RADIUS;
+			const g = (params.getCpuValue(green.name) ?? 0) * CHANNEL_INTENSITY_TO_RADIUS;
+			const b = (params.getCpuValue(blue.name) ?? 0) * CHANNEL_INTENSITY_TO_RADIUS;
+			return Math.max(r, g, b, .01);
+		} }),
+		gpu: { fragment: (params) => composeBlurredOverSharp(params, (blurred, sharp) => call(channelBlurCompose, "channelBlurCompose", [
+			sharp,
+			blurred,
+			uniformOf(red, params),
+			uniformOf(green, params),
+			uniformOf(blue, params)
+		])) }
+	};
+}
+function progressiveBlur(opts) {
+	const { intensity, angle, center, falloff } = opts;
+	return {
+		compute: (params) => {
+			const { getCpuValue, getMapInfo } = params;
+			const readGeometry = (dims) => {
+				const centerValue = getCpuValue(center.name);
+				return {
+					angle: getCpuValue(angle.name) ?? 0,
+					centerX: typeof centerValue?.x === "number" ? centerValue.x : 0,
+					centerY: typeof centerValue?.y === "number" ? centerValue.y : .5,
+					falloff: getCpuValue(falloff.name) ?? 1,
+					aspect: dims.width / dims.height
+				};
+			};
+			const mapInfo = getMapInfo(intensity.name);
+			if (mapInfo) return withVariableBlurCompute(params, {
+				source: mapInfo,
+				buildFill: (cw, ch) => buildProgressiveBlurFillMapGraph(cw, ch, mapInfo.channel),
+				fillValues: (dims, window) => ({
+					...readGeometry(dims),
+					inputWidth: dims.width,
+					inputHeight: dims.height,
+					...remapWindowValues(window)
+				})
+			});
+			return withVariableBlurCompute(params, {
+				buildFill: buildProgressiveBlurFillGraph,
+				fillValues: (dims) => ({
+					...readGeometry(dims),
+					maxRadius: intensityToRadius(getCpuValue(intensity.name) ?? 0)
+				})
+			});
+		},
+		gpu: { fragment: (params) => composeBlurredOverSharp(params, (blurred, sharp) => vec4(blurred.member("rgb"), sharp.member("a"))) }
+	};
+}
+function tiltShift(opts) {
+	const { intensity, width, falloff, angle, center } = opts;
+	return {
+		compute: (params) => {
+			const { getCpuValue, getMapInfo } = params;
+			const readGeometry = (dims) => {
+				const centerValue = getCpuValue(center.name);
+				return {
+					angle: getCpuValue(angle.name) ?? 0,
+					centerX: typeof centerValue?.x === "number" ? centerValue.x : .5,
+					centerY: typeof centerValue?.y === "number" ? centerValue.y : .5,
+					width: getCpuValue(width.name) ?? .3,
+					falloff: getCpuValue(falloff.name) ?? .3,
+					aspect: dims.width / dims.height
+				};
+			};
+			const mapInfo = getMapInfo(intensity.name);
+			if (mapInfo) return withVariableBlurCompute(params, {
+				halfKernel: 14,
+				source: mapInfo,
+				buildFill: (cw, ch) => buildTiltShiftFillMapGraph(cw, ch, mapInfo.channel),
+				fillValues: (dims, window) => ({
+					...readGeometry(dims),
+					inputWidth: dims.width,
+					inputHeight: dims.height,
+					...remapWindowValues(window)
+				})
+			});
+			return withVariableBlurCompute(params, {
+				halfKernel: 14,
+				buildFill: buildTiltShiftFillGraph,
+				fillValues: (dims) => ({
+					...readGeometry(dims),
+					maxRadius: intensityToRadius(getCpuValue(intensity.name) ?? 0)
+				})
+			});
+		},
+		gpu: { fragment: (params) => composeBlurredOverSharp(params, (blurred, sharp) => {
+			return mixExpr(sharp, blurred, call(tiltShiftBlurAmount, "tiltShiftBlurAmount", [
+				uniformOf(angle, params),
+				uniformOf(center, params),
+				uniformOf(width, params),
+				uniformOf(falloff, params),
+				params.ctx.uv,
+				params.ctx.aspect
+			]));
+		}) }
+	};
+}
+function bloom(opts) {
+	const { intensity, threshold, size } = opts;
+	return {
+		compute: (params) => {
+			const { getCpuValue, getMapInfo } = params;
+			const mapInfo = getMapInfo(size.name);
+			if (!mapInfo && (getCpuValue(size.name) ?? 0) === 0) return null;
+			return withBloomCompute(params, {
+				mapInfo,
+				buildExtract: buildGlowPrepassGraph,
+				buildExtractMap: buildGlowPrepassMapGraph,
+				threshold: () => getCpuValue(threshold.name) ?? .5,
+				radius: () => getCpuValue(size.name) ?? 25
+			});
+		},
+		gpu: { fragment: (params) => composeBlurredOverSharp(params, (bloomSample, original) => call(glowCompose, "glowCompose", [
+			original,
+			bloomSample,
+			uniformOf(intensity, params)
+		])) }
+	};
+}
+function childTap() {
+	return (params) => params.texture.sample(params.ctx.uv);
+}
+function shadowOffset(opts) {
+	return (params) => call(dropShadowUV, "dropShadowUV", [
+		params.ctx.uv,
+		params.ctx.viewportSize,
+		resolveArg(opts.angle, params),
+		resolveArg(opts.distance, params)
+	]);
+}
+function silhouetteCoverage(opts) {
+	return (params) => silhouetteBlur({
+		at: opts.at(params),
+		uv: params.ctx.uv,
+		viewportSize: params.ctx.viewportSize,
+		blurRadius: resolveArg(opts.blur, params),
+		sample: (coord) => params.texture.sample(coord),
+		convertToTexture: params.convertToTexture
+	});
+}
+function shadowComposite(opts) {
+	return (original, params) => {
+		const shadowAlpha = opts.coverage(params).mul(resolveArg(opts.intensity, params));
+		return call(dropShadowComposite, "dropShadowComposite", [
+			original,
+			resolveArg(opts.color, params),
+			shadowAlpha,
+			floatE(params.propValues[opts.cutout.name] === 1 ? 1 : 0)
+		]);
+	};
+}
+var PEEL_CORNERS = {
+	"top-left": {
+		corner: [0, 0],
+		opposite: [1, 1]
+	},
+	"top-right": {
+		corner: [1, 0],
+		opposite: [0, 1]
+	},
+	"bottom-left": {
+		corner: [0, 1],
+		opposite: [1, 0]
+	},
+	"bottom-right": {
+		corner: [1, 1],
+		opposite: [0, 0]
+	}
+};
+function fluteFrame(opts) {
+	return frameOf((params) => {
+		const shapeId = params.propValues[opts.shape.name] ?? 0;
+		const expHi = shapeId === 0 ? 16 : 8;
+		const expLo = shapeId === 0 ? 4 : 3;
+		const wavesFlag = shapeId === 2 ? 1 : 0;
+		const t = animatedTime(params).mul(-1);
+		return asLocal(call(flutedGlassGeom, "flutedGlassGeom", [
+			params.ctx.uv,
+			params.ctx.aspect,
+			t,
+			resolveArg(opts.angle, params),
+			resolveArg(opts.frequency, params),
+			resolveArg(opts.softness, params),
+			resolveArg(opts.waveAmplitude, params),
+			resolveArg(opts.waveFrequency, params),
+			resolveArg(opts.refraction, params),
+			resolveArg(opts.aberration, params),
+			expr(`vec3f(${formatFloat(expHi)}, ${formatFloat(expLo)}, ${formatFloat(wavesFlag)})`)
+		]), "flute");
+	});
+}
+function refractedTaps(frame, opts) {
+	return (params) => {
+		const edgeMode = params.propValues[opts.edges.name] ?? 2;
+		const aberrationEnabled = (params.propValues[opts.aberration.name] ?? .2) > 0;
+		const geom = frame(params);
+		const sampleAt = (uvE) => edgeClipSample((uv) => params.texture.sample(uv), uvE, edgeMode);
+		const refractedUV = geom.member("refractedUV");
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [aberrationEnabled ? rgbSplitTaps(sampleAt, refractedUV, geom.member("chrOff")) : sampleAt(refractedUV)]);
+	};
+}
+function fluteHighlight(frame, opts) {
+	return (color, params) => {
+		const specA = call(blinnHighlight, "blinnHighlight", [
+			frame(params).member("slope"),
+			resolveArg(opts.lightAngle, params),
+			resolveArg(opts.highlight, params),
+			resolveArg(opts.softness, params)
+		]).mul(color.member("a"));
+		return vec4(color.member("rgb").add(resolveArg(opts.color, params).member("rgb").mul(specA)), color.member("a"));
+	};
+}
+function peelFrame(opts) {
+	return frameOf((params) => {
+		const cornerGeom = PEEL_CORNERS[params.propValues[opts.corner.name] ?? "bottom-right"] ?? PEEL_CORNERS["bottom-right"];
+		return asLocal(call(pagePeelGeom, "pagePeelGeom", [
+			params.ctx.uv,
+			params.ctx.aspect,
+			floatE(cornerGeom.corner[0]),
+			floatE(cornerGeom.corner[1]),
+			floatE(cornerGeom.opposite[0]),
+			floatE(cornerGeom.opposite[1]),
+			resolveArg(opts.amount, params),
+			resolveArg(opts.radius, params)
+		]), "peel");
+	});
+}
+function curlShading(frame, opts) {
+	return (params) => call(curlShade, "curlShade", [frame(params).member("theta"), resolveArg(opts.shading, params)]);
+}
+function curlSheen(frame, opts) {
+	return (params) => call(curlSheen$1, "curlSheen", [
+		frame(params).member("theta"),
+		resolveArg(opts.highlight, params),
+		resolveArg(opts.softness, params)
+	]);
+}
+function overhangShadow(frame, opts) {
+	return (params) => {
+		const g = frame(params);
+		return call(overhangShade, "overhangShade", [
+			g.member("distPastCrease"),
+			g.member("flatReach"),
+			resolveArg(opts.amount, params),
+			resolveArg(opts.shadow, params)
+		]);
+	};
+}
+function revealShadow(frame, opts) {
+	return (params) => {
+		const g = frame(params);
+		return call(revealShadow$1, "revealShadow", [
+			g.member("distIntoPeel"),
+			g.member("peelReach"),
+			resolveArg(opts.amount, params),
+			resolveArg(opts.shadow, params)
+		]);
+	};
+}
+function peelCompose(frame, parts) {
+	return (params) => {
+		const g = frame(params);
+		return call(pagePeelCompose, "pagePeelCompose", [
+			params.texture.sample(g.member("curlUV")),
+			params.texture.sample(params.ctx.uv),
+			parts.shade(params),
+			parts.sheen(params),
+			parts.overhang(params),
+			parts.reveal(params),
+			g.member("foldBlend"),
+			g.member("showCurl")
+		]);
+	};
+}
+const mirrorRowUV = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, lineY) => {
+	"use gpu";
+	return vec2f(uv.x, __tsover_sub(__tsover_mul(lineY, 2), uv.y));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}, {
+			"type": "i",
+			"name": "lineY"
+		}],
+		"body": [0, [[10, [
+			6,
+			"d.vec2f",
+			[[
+				7,
+				"uv",
+				"x"
+			], [
+				1,
+				[
+					1,
+					"lineY",
+					"*",
+					[5, "2"]
+				],
+				"-",
+				[
+					7,
+					"uv",
+					"y"
+				]
+			]]
+		]]]]
+	},
+	externals: { "d.vec2f": () => vec2f }
+}) && $.f)({}));
+const planarReflectionCompose = typegpu_default.fn([
+	vec4f,
+	vec4f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((original, refl, uvY, lineY, distance, falloff) => {
+	"use gpu";
+	const distBelow = max(__tsover_sub(uvY, lineY), 0);
+	const distanceMax = max(distance, .001);
+	const fadeWidth = max(__tsover_mul(distanceMax, falloff), 1e-4);
+	const fadeStart = __tsover_sub(distanceMax, fadeWidth);
+	const visibility = __tsover_sub(1, smoothstep(fadeStart, distanceMax, distBelow));
+	const effReflA = __tsover_mul(refl.w, visibility);
+	const oneMinusReflA = __tsover_sub(1, effReflA);
+	return mix(original, vec4f(refl.xyz.mul(visibility).add(original.xyz.mul(oneMinusReflA)), __tsover_add(effReflA, __tsover_mul(original.w, oneMinusReflA))), vec4f(step(lineY, uvY)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "original"
+			},
+			{
+				"type": "i",
+				"name": "refl"
+			},
+			{
+				"type": "i",
+				"name": "uvY"
+			},
+			{
+				"type": "i",
+				"name": "lineY"
+			},
+			{
+				"type": "i",
+				"name": "distance"
+			},
+			{
+				"type": "i",
+				"name": "falloff"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"distBelow",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						"uvY",
+						"-",
+						"lineY"
+					], [5, "0"]]
+				]
+			],
+			[
+				13,
+				"distanceMax",
+				[
+					6,
+					"std.max",
+					["distance", [5, "0.001"]]
+				]
+			],
+			[
+				13,
+				"fadeWidth",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						"distanceMax",
+						"*",
+						"falloff"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"fadeStart",
+				[
+					1,
+					"distanceMax",
+					"-",
+					"fadeWidth"
+				]
+			],
+			[
+				13,
+				"visibility",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						"std.smoothstep",
+						[
+							"fadeStart",
+							"distanceMax",
+							"distBelow"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"effReflA",
+				[
+					1,
+					[
+						7,
+						"refl",
+						"w"
+					],
+					"*",
+					"visibility"
+				]
+			],
+			[
+				13,
+				"oneMinusReflA",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"effReflA"
+				]
+			],
+			[
+				13,
+				"belowRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									7,
+									"refl",
+									"xyz"
+								],
+								"mul"
+							],
+							["visibility"]
+						],
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								7,
+								"original",
+								"xyz"
+							],
+							"mul"
+						],
+						["oneMinusReflA"]
+					]]
+				]
+			],
+			[
+				13,
+				"belowA",
+				[
+					1,
+					"effReflA",
+					"+",
+					[
+						1,
+						[
+							7,
+							"original",
+							"w"
+						],
+						"*",
+						"oneMinusReflA"
+					]
+				]
+			],
+			[
+				13,
+				"belowLine",
+				[
+					6,
+					"d.vec4f",
+					["belowRgb", "belowA"]
+				]
+			],
+			[
+				13,
+				"isBelowLine",
+				[
+					6,
+					"std.step",
+					["lineY", "uvY"]
+				]
+			],
+			[10, [
+				6,
+				"std.mix",
+				[
+					"original",
+					"belowLine",
+					[
+						6,
+						"d.vec4f",
+						["isBelowLine"]
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.smoothstep": () => smoothstep,
+		"d.vec4f": () => vec4f,
+		"std.step": () => step,
+		"std.mix": () => mix
+	}
+}) && $.f)({}));
+var DEPTH_RAMP_RADIUS_PX = 12;
+function depthRampFillParams() {
+	return struct({
+		height: f32,
+		blurAmount: f32,
+		blurDistance: f32
+	});
+}
+function buildDepthRampFillGraph(computeWidth, computeHeight) {
+	const Params = depthRampFillParams();
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+		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 v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
+			const distBelowAtOutput = max(__tsover_sub(p.height, v), 0);
+			const ramp = smoothstep(0, p.blurDistance, distBelowAtOutput);
+			const radius = __tsover_mul(__tsover_mul(p.blurAmount, ramp), DEPTH_RAMP_RADIUS_PX);
+			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,
+						"v",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"d.f32",
+									["cy"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							"computeHeight"
+						]
+					],
+					[
+						13,
+						"distBelowAtOutput",
+						[
+							6,
+							"std.max",
+							[[
+								1,
+								[
+									7,
+									"p",
+									"height"
+								],
+								"-",
+								"v"
+							], [5, "0"]]
+						]
+					],
+					[
+						13,
+						"ramp",
+						[
+							6,
+							"std.smoothstep",
+							[
+								[5, "0"],
+								[
+									7,
+									"p",
+									"blurDistance"
+								],
+								"distBelowAtOutput"
+							]
+						]
+					],
+					[
+						13,
+						"radius",
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"blurAmount"
+								],
+								"*",
+								"ramp"
+							],
+							"*",
+							"DEPTH_RAMP_RADIUS_PX"
+						]
+					],
+					[
+						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,
+				"d.f32": () => f32,
+				"computeHeight": () => computeHeight,
+				"std.max": () => max,
+				"std.smoothstep": () => smoothstep,
+				"DEPTH_RAMP_RADIUS_PX": () => DEPTH_RAMP_RADIUS_PX,
+				"std.textureStore": () => textureStore,
+				"d.vec2u": () => vec2u,
+				"d.vec4f": () => vec4f
+			}
+		}) && $.f)({})).$name("depthRampFillBlurMap"),
+		Params
+	};
+}
+function mirrorAcrossRow(line) {
+	return ({ ctx, uniforms }) => call(mirrorRowUV, "mirrorRowUV", [ctx.uv, uniforms[line.name]]);
+}
+function depthRampBlur(opts) {
+	return { compute: (params) => withVariableBlurCompute(params, {
+		halfKernel: opts.halfKernel,
+		buildFill: buildDepthRampFillGraph,
+		fillValues: () => ({
+			height: params.getCpuValue(opts.line.name) ?? .5,
+			blurAmount: params.getCpuValue(opts.blur.name) ?? 1,
+			blurDistance: Math.max(.01, params.getCpuValue(opts.blurDistance.name) ?? .5)
+		})
+	}) };
+}
+function planarReflection(opts, original, reflection, reflectedUV) {
+	return (params) => {
+		const { ctx, uniforms, propValues } = params;
+		const edgeMode = propValues[opts.edges.name] ?? 0;
+		return call(planarReflectionCompose, "planarReflectionCompose", [
+			original,
+			applyEdgeHandlingExpr(reflectedUV(params), reflection, edgeMode),
+			ctx.uv.member("y"),
+			uniforms[opts.line.name],
+			uniforms[opts.distance.name],
+			uniforms[opts.falloff.name]
+		]);
+	};
+}
+const tintedScreenGlow = typegpu_default.fn([
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, glow, tintStrength) => {
+	"use gpu";
+	const strength = tintStrength.w;
+	const bloomC = clamp(glow.xyz.mul(tintStrength.xyz).mul(strength), vec3f(0, 0, 0), vec3f(1, 1, 1));
+	const one = vec3f(1, 1, 1);
+	const screened = one.sub(one.sub(base.xyz).mul(one.sub(bloomC)));
+	const a = __tsover_add(base.w, __tsover_mul(__tsover_mul(glow.w, strength), __tsover_sub(1, base.w)));
+	return vec4f(screened.x, screened.y, screened.z, clamp(a, 0, 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "base"
+			},
+			{
+				"type": "i",
+				"name": "glow"
+			},
+			{
+				"type": "i",
+				"name": "tintStrength"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"strength",
+				[
+					7,
+					"tintStrength",
+					"w"
+				]
+			],
+			[
+				13,
+				"bloomC",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										[
+											7,
+											"glow",
+											"xyz"
+										],
+										"mul"
+									],
+									[[
+										7,
+										"tintStrength",
+										"xyz"
+									]]
+								],
+								"mul"
+							],
+							["strength"]
+						],
+						[
+							6,
+							"d.vec3f",
+							[
+								[5, "0"],
+								[5, "0"],
+								[5, "0"]
+							]
+						],
+						[
+							6,
+							"d.vec3f",
+							[
+								[5, "1"],
+								[5, "1"],
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"one",
+				[
+					6,
+					"d.vec3f",
+					[
+						[5, "1"],
+						[5, "1"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"screened",
+				[
+					6,
+					[
+						7,
+						"one",
+						"sub"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"one",
+									"sub"
+								],
+								[[
+									7,
+									"base",
+									"xyz"
+								]]
+							],
+							"mul"
+						],
+						[[
+							6,
+							[
+								7,
+								"one",
+								"sub"
+							],
+							["bloomC"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"a",
+				[
+					1,
+					[
+						7,
+						"base",
+						"w"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"glow",
+								"w"
+							],
+							"*",
+							"strength"
+						],
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"base",
+								"w"
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec4f",
+				[
+					[
+						7,
+						"screened",
+						"x"
+					],
+					[
+						7,
+						"screened",
+						"y"
+					],
+					[
+						7,
+						"screened",
+						"z"
+					],
+					[
+						6,
+						"std.clamp",
+						[
+							"a",
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.clamp": () => clamp,
+		"d.vec3f": () => vec3f,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({})).$name("tintedScreenGlow");
+function screenedBloom(slots) {
+	return {
+		compute: (params) => {
+			const { getCpuValue } = params;
+			if ((getCpuValue(slots.strength.name) ?? 0) === 0) return null;
+			return withBloomCompute(params, {
+				outputKey: slots.output,
+				buildExtract: (w, h) => buildBloomExtractGraph(w, h, slots.extractName),
+				threshold: () => slots.threshold,
+				radius: () => getCpuValue(slots.radius.name) ?? 28
+			});
+		},
+		screen: (base, at, params) => {
+			const glowTex = params.computeOutputs?.[slots.output];
+			return call(tintedScreenGlow, "tintedScreenGlow", [
+				base,
+				glowTex ? glowTex.sample(at) : expr("vec4f(0.0, 0.0, 0.0, 0.0)"),
+				vec4(slots.tint[0], slots.tint[1], slots.tint[2], params.uniforms[slots.strength.name])
+			]);
+		}
+	};
+}
+const swayUV = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, amount, t) => {
+	"use gpu";
+	const amp = __tsover_mul(amount, .006);
+	const ox = __tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_mul(t, 1.7)), .5), __tsover_mul(sin(__tsover_add(__tsover_mul(t, .9), 1.3)), .5)), amp);
+	const oy = __tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(t, 1.3), .7)), .5), __tsover_mul(sin(__tsover_mul(t, 2.3)), .5)), amp);
+	const ang = __tsover_mul(__tsover_mul(sin(__tsover_mul(t, .6)), amount), .004);
+	const c = cos(ang);
+	const s = sin(ang);
+	const p = uv.sub(vec2f(.5, .5));
+	const rx = __tsover_sub(__tsover_mul(p.x, c), __tsover_mul(p.y, s));
+	const ry = __tsover_add(__tsover_mul(p.x, s), __tsover_mul(p.y, c));
+	return vec2f(__tsover_add(__tsover_add(rx, .5), ox), __tsover_add(__tsover_add(ry, .5), oy));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "amount"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"amp",
+				[
+					1,
+					"amount",
+					"*",
+					[5, "0.006"]
+				]
+			],
+			[
+				13,
+				"ox",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									"t",
+									"*",
+									[5, "1.7"]
+								]]
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"+",
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										"t",
+										"*",
+										[5, "0.9"]
+									],
+									"+",
+									[5, "1.3"]
+								]]
+							],
+							"*",
+							[5, "0.5"]
+						]
+					],
+					"*",
+					"amp"
+				]
+			],
+			[
+				13,
+				"oy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										"t",
+										"*",
+										[5, "1.3"]
+									],
+									"+",
+									[5, "0.7"]
+								]]
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"+",
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									"t",
+									"*",
+									[5, "2.3"]
+								]]
+							],
+							"*",
+							[5, "0.5"]
+						]
+					],
+					"*",
+					"amp"
+				]
+			],
+			[
+				13,
+				"ang",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.sin",
+							[[
+								1,
+								"t",
+								"*",
+								[5, "0.6"]
+							]]
+						],
+						"*",
+						"amount"
+					],
+					"*",
+					[5, "0.004"]
+				]
+			],
+			[
+				13,
+				"c",
+				[
+					6,
+					"std.cos",
+					["ang"]
+				]
+			],
+			[
+				13,
+				"s",
+				[
+					6,
+					"std.sin",
+					["ang"]
+				]
+			],
+			[
+				13,
+				"p",
+				[
+					6,
+					[
+						7,
+						"uv",
+						"sub"
+					],
+					[[
+						6,
+						"d.vec2f",
+						[[5, "0.5"], [5, "0.5"]]
+					]]
+				]
+			],
+			[
+				13,
+				"rx",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"p",
+							"x"
+						],
+						"*",
+						"c"
+					],
+					"-",
+					[
+						1,
+						[
+							7,
+							"p",
+							"y"
+						],
+						"*",
+						"s"
+					]
+				]
+			],
+			[
+				13,
+				"ry",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"p",
+							"x"
+						],
+						"*",
+						"s"
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"y"
+						],
+						"*",
+						"c"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					1,
+					[
+						1,
+						"rx",
+						"+",
+						[5, "0.5"]
+					],
+					"+",
+					"ox"
+				], [
+					1,
+					[
+						1,
+						"ry",
+						"+",
+						[5, "0.5"]
+					],
+					"+",
+					"oy"
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.sin": () => sin,
+		"std.cos": () => cos,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({})).$name("swayUV");
+function frameSway(slots) {
+	return (params) => {
+		let acc = 0;
+		params.onBeforeRender(({ deltaTime }) => {
+			const w = params.getCpuValue(slots.amount.name) ?? 0;
+			acc += deltaTime * (w > 0 ? 1 : 0);
+			params.setExtraField(slots.field, acc);
+		});
+		return call(swayUV, "swayUV", [
+			params.ctx.uv,
+			params.uniforms[slots.amount.name],
+			params.uniforms[slots.field]
+		]);
+	};
+}
+var BOKEH_DEG_TO_RAD = DEG_TO_RAD;
+var BOKEH_GATHER_FORMAT = "rgba16float";
+function apertureTable(opts, getCpuValue, tapsUniform) {
+	let key = "";
+	return () => {
+		const shape = getCpuValue(opts.shape.name) ?? "blades";
+		const count = getCpuValue(opts.blades.name) ?? 6;
+		const next = `${shape}|${count}`;
+		if (next === key) return;
+		key = next;
+		tapsUniform.write(generateBokehTaps(shape, count, 100).map((tap) => vec4f(tap.x, tap.y, tap.rim, 0)));
+	};
+}
+function bokehDefocus(opts) {
+	return {
+		compute: (params) => {
+			const { childNode, gpu, convertToTexture, registerComputeTexture, getCpuValue, getMapInfo, onCleanup, onResize, dimensions } = params;
+			if (!childNode) return null;
+			const root = gpu?.root;
+			if (!root) return null;
+			const childTexture = convertToTexture(childNode);
+			let curWidth = Math.max(1, Math.round(dimensions.width));
+			let curHeight = Math.max(1, Math.round(dimensions.height));
+			const LONG_EDGE = Math.max(DEFAULT_COMPUTE_WIDTH, 640);
+			const aspect = curHeight > 0 ? curWidth / curHeight : 1;
+			const computeWidth = Math.max(8, aspect >= 1 ? LONG_EDGE : Math.round(LONG_EDGE * aspect));
+			const computeHeight = Math.max(8, aspect >= 1 ? Math.round(LONG_EDGE / aspect) : LONG_EDGE);
+			const outputTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+				size: [computeWidth, computeHeight],
+				format: BOKEH_GATHER_FORMAT
+			}).$usage("storage", "sampled"), "outputTex");
+			onCleanup(() => outputTex.destroy());
+			const blurredTexture = registerComputeTexture(outputTex);
+			onResize(({ width, height }) => {
+				curWidth = Math.max(1, Math.round(width));
+				curHeight = Math.max(1, Math.round(height));
+			});
+			const readLook = () => {
+				const rot = (getCpuValue(opts.rotation.name) ?? 0) * BOKEH_DEG_TO_RAD;
+				return {
+					highlightGain: getCpuValue(opts.gain.name) ?? 4,
+					highlightThreshold: getCpuValue(opts.threshold.name) ?? .6,
+					rotCos: Math.cos(rot),
+					rotSin: Math.sin(rot),
+					chromaticFringe: getCpuValue(opts.fringe.name) ?? .2
+				};
+			};
+			const mapInfo = getMapInfo(opts.radius.name);
+			if (mapInfo) {
+				const graph$1 = buildBokehMapGraph(computeWidth, computeHeight, 100, mapInfo.channel);
+				const kernelParams$1 = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph$1.Params), "kernelParams");
+				const tapsUniform$1 = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph$1.TapArray), "tapsUniform");
+				const ensureTaps$1 = apertureTable({
+					shape: opts.shape,
+					blades: opts.blades
+				}, getCpuValue, tapsUniform$1);
+				let bokehPass$1 = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+					"use gpu";
+					graph$1.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$1.kernel }
+				}) && $.f)({}), { size: [computeWidth, computeHeight] });
+				return {
+					outputs: { blurredTexture },
+					bindInputs: (resolve) => {
+						const src = resolve(childTexture.key);
+						const mapSrc = resolve(mapInfo.sourceTexture.key);
+						if (!src || !mapSrc) return;
+						const bindGroup = root.createBindGroup(graph$1.layout, {
+							input: src.texture,
+							source: mapSrc.texture,
+							output: outputTex,
+							params: kernelParams$1.buffer,
+							taps: tapsUniform$1.buffer
+						});
+						bokehPass$1 = bokehPass$1.with(bindGroup);
+					},
+					getComputeNodes: () => {
+						ensureTaps$1();
+						const w = mapInfo.window();
+						kernelParams$1.write({
+							...readLook(),
+							inputWidth: curWidth,
+							inputHeight: curHeight,
+							inputMin: w.inputMin,
+							inputMax: w.inputMax,
+							outputMin: w.outputMin,
+							outputMax: w.outputMax,
+							curve: w.curve
+						});
+						return [bokehPass$1];
+					}
+				};
+			}
+			const graph = buildBokehGraph(computeWidth, computeHeight, 100);
+			const kernelParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.Params), "kernelParams");
+			const tapsUniform = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.TapArray), "tapsUniform");
+			const ensureTaps = apertureTable({
+				shape: opts.shape,
+				blades: opts.blades
+			}, getCpuValue, tapsUniform);
+			let bokehPass = 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: [computeWidth, computeHeight] });
+			return {
+				outputs: { blurredTexture },
+				bindInputs: (resolve) => {
+					const src = resolve(childTexture.key);
+					if (!src) return;
+					const bindGroup = root.createBindGroup(graph.layout, {
+						input: src.texture,
+						output: outputTex,
+						params: kernelParams.buffer,
+						taps: tapsUniform.buffer
+					});
+					bokehPass = bokehPass.with(bindGroup);
+				},
+				getComputeNodes: () => {
+					ensureTaps();
+					const radius = getCpuValue(opts.radius.name) ?? 50;
+					kernelParams.write({
+						radius: bokehRadiusToPixels(radius),
+						...readLook(),
+						inputWidth: curWidth,
+						inputHeight: curHeight
+					});
+					return [bokehPass];
+				}
+			};
+		},
+		gpu: { fragment: ({ childNode, computeOutputs, ctx, convertToTexture }) => {
+			if (!childNode) return ZERO;
+			const blurred = computeOutputs?.blurredTexture;
+			if (!blurred) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [convertToTexture(childNode).sample(ctx.uv)]);
+			return call(unpremultiplyAlpha, "unpremultiplyAlpha", [blurred.sample(ctx.uv)]);
+		} }
+	};
+}
+export { planarReflection as A, shadowOffset as B, motionBlur as C, peelFrame as D, peelCompose as E, rimLit as F, tiltShift as G, silhouetteCoverage as H, scanlines as I, vignetteOverlay as K, scatter as L, refractedTaps as M, revealShadow as N, phosphorMask as O, rgbSplit as P, screenedBloom as R, mirrorAcrossRow as S, overhangShadow as T, sphereFrame as U, sharpen as V, tapeWarp as W, frameSway as _, bokehDefocus as a, glitchFrame as b, chromaSmearTaps as c, curlShading as d, curlSheen as f, fluteHighlight as g, fluteFrame as h, blurPath as i, progressiveBlur as j, pixelate as k, colorBarFills as l, distortedScanlines as m, beatPulse as n, channelBlur as o, depthRampBlur as p, bloom as r, childTap as s, adjust as t, crispTap as u, gatherStack as v, opaque as w, glitchRgbSplit as x, gaussianBlur as y, shadowComposite as z };