shaders 3.2.474 → 4.0.0

package/dist/core/blurs-d4B9aUyx.js

@@ -1,1751 +0,0 @@
-import { Ar as vec2u, Br as struct, Cr as sin, Er as step, Gn as typegpu_default, Mr as vec4f, Or as vec2f, Ot as unpremultiplyAlpha, Pn as DEG_TO_RAD, Rr as textureStorage2d, X as applyEdgeHandlingExpr, Yn as textureStore, Yr as u32, _r as mix, ar as clamp, at as ZERO, ct as call, dt as expr, ft as floatE, gt as formatFloat, hr as max, i as resolveArg, jr as vec3f, mt as vec4, o as uniformOf, or as cos, pt as mixExpr, q as createGuardedCompute, qr as f32, rt as sampleCatmullRomExpr, st as asLocal, wr as smoothstep } from "./lower-Bd2jez_2.js";
-import { t as animatedTime } from "./porters-OTkIMOyl.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-Y8xSo-QJ.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-7yjVyMvI.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-g_WSi2iq.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 };