shaders 3.1.463 → 3.2.464

package/dist/core/device-DLKcFOd2.js

@@ -0,0 +1,10 @@
+function isMobileGpuViewport() {
+	if (typeof window === "undefined") return false;
+	const coarse = !!(window.matchMedia && window.matchMedia("(pointer: coarse)").matches);
+	const cssLong = Math.max(window.innerWidth || 0, window.innerHeight || 0);
+	return coarse && cssLong > 0 && cssLong <= 1366;
+}
+function maxPixelRatioForDevice() {
+	return isMobileGpuViewport() ? 1.5 : 2;
+}
+export { maxPixelRatioForDevice as n, isMobileGpuViewport as t };

package/dist/core/feedback-ZMsR_fKB.js

@@ -0,0 +1,46 @@
+import { F as createFluidKernelPass, ft as createFeedbackTrailSim } from "./porters-B1UjrM1y.js";
+function feedbackSim(build) {
+	return { compute: (params) => {
+		const { childNode, gpu } = params;
+		if (!childNode) return null;
+		const root = gpu?.root;
+		if (!root) return null;
+		const cfg = build(params, root);
+		const paramsU = root.createUniform(cfg.paramsSchema);
+		const sim = createFeedbackTrailSim(params, {
+			size: cfg.size,
+			format: cfg.format,
+			extraSlots: cfg.extraSlots,
+			textures: cfg.textures,
+			speedProp: cfg.speedProp,
+			maxDeltaTime: cfg.maxDeltaTime,
+			bindGroups: (ctx, read, write) => cfg.bindGroups({
+				...ctx,
+				paramsBuffer: paramsU.buffer
+			}, read, write),
+			staticGroups: cfg.staticGroups ? (ctx) => cfg.staticGroups({
+				...ctx,
+				paramsBuffer: paramsU.buffer
+			}) : void 0
+		});
+		if (!sim) return null;
+		const pipeline = createFluidKernelPass(root, cfg.step, {
+			n: cfg.size,
+			bindGroup: void 0
+		});
+		return {
+			outputs: {
+				childTexture: sim.childTexture,
+				display: sim.display,
+				...cfg.outputs ?? {}
+			},
+			bindInputs: sim.bindInputs,
+			getComputeNodes: (frameParams) => sim.tick(frameParams, (t) => {
+				if (cfg.skip?.(t)) return null;
+				paramsU.write(cfg.values(t));
+				return [pipeline.with(t.groups)];
+			})
+		};
+	} };
+}
+export { feedbackSim as t };

package/dist/core/fields-Cg5kOBDV.js

@@ -0,0 +1,250 @@
+import { Nt as mixColorsLinear, Pt as mixColorsVariants, Ut as domainWarp2, a as uniformOf, at as call, dt as vec4, i as resolveScalar, it as asLocal, lt as floatE, o as Scalar } from "./lower-z2vuXP8M.js";
+import { b as value13, f as mxNoiseFloat3, g as perlin13 } from "./noise-B3Oq1k3_.js";
+import { gt as mixColorStopsRuntime, t as animatedTime } from "./porters-B1UjrM1y.js";
+import { A as volumeDomain, C as radialDist, D as spiralMask, E as shimmerPulse, O as unitNoise3, S as plasmaTone, T as repeatWrap, c as diamondDist, f as gradientClamp01, g as gradientTransparentAlpha, h as gradientRawT, k as unitThreshold, l as flowLayers, m as gradientEdgeWrap, o as conicSweep, p as gradientEdgeMirror, w as repeatRings } from "./gradientPaints-B6-PoDoK.js";
+import { o as transformColorSpace } from "./transformations-CoIwF5JU.js";
+import { N as vec3, _ as local, d as fract, i as clamp, j as sub, t as abs, x as mul } from "./math-BF-GBlb4.js";
+function baseArg(spec, params) {
+	if (typeof spec === "number") return floatE(spec);
+	if (spec instanceof Scalar || spec.kind !== "ctx") return resolveScalar(spec, params);
+	return params.ctx[spec.name];
+}
+function fArg(spec, params) {
+	if (typeof spec === "object" && spec !== null && "base" in spec) {
+		let e = baseArg(spec.base, params);
+		if (spec.add !== void 0) e = e.add(spec.add);
+		if (spec.mul !== void 0) e = e.mul(spec.mul);
+		return e;
+	}
+	return baseArg(spec, params);
+}
+function frame(params) {
+	return {
+		uv: params.uvContext ?? params.ctx.uv,
+		viewport: params.effectiveViewportSize ?? params.ctx.viewportSize
+	};
+}
+function structural(ref, params) {
+	return params.propValues[ref.name];
+}
+function colorSpaceModeOf(raw) {
+	if (typeof raw === "number") return raw;
+	if (typeof raw === "string") return transformColorSpace(raw);
+	return 0;
+}
+function pair(a, b, space) {
+	return (t, params) => {
+		return call(mixColorsVariants[colorSpaceModeOf(structural(space, params))] ?? mixColorsLinear, "mixColors", [
+			uniformOf(a, params),
+			uniformOf(b, params),
+			t
+		]);
+	};
+}
+function stops(space) {
+	return (t, params) => {
+		const spaceMode = colorSpaceModeOf(structural(space, params));
+		if ((params.propValues.stopCount ?? 0) > 1) return mixColorStopsRuntime(t, {
+			colorsArray: params.uniforms.colorsArray,
+			positionsArray: params.uniforms.positionsArray,
+			convertedColorsArray: params.uniforms.convertedColorsArray,
+			stopCount: params.uniforms.stopCount
+		}, spaceMode);
+		return call(mixColorsVariants[spaceMode] ?? mixColorsLinear, "mixColors", [
+			params.uniforms.colorA,
+			params.uniforms.colorB,
+			t
+		]);
+	};
+}
+var TRANSPARENT = 1;
+var MIRROR = 2;
+var WRAP = 3;
+function rampOver(field, palette, opts) {
+	return (params) => {
+		const { uv } = frame(params);
+		const t = field(params, uv);
+		if (!opts?.edges) return palette(t, params);
+		const edgeMode = structural(opts.edges, params) ?? 0;
+		let finalT;
+		if (edgeMode === MIRROR) finalT = call(gradientEdgeMirror, "gradientEdgeMirror", [t]);
+		else if (edgeMode === WRAP) finalT = call(gradientEdgeWrap, "gradientEdgeWrap", [t]);
+		else if (edgeMode === TRANSPARENT) finalT = t;
+		else finalT = call(gradientClamp01, "gradientClamp01", [t]);
+		const color = palette(call(gradientClamp01, "gradientClamp01", [finalT]), params);
+		if (edgeMode === TRANSPARENT) {
+			const cut = call(gradientTransparentAlpha, "gradientTransparentAlpha", [t]);
+			return vec4(color.member("rgb"), color.member("a").mul(cut));
+		}
+		return color;
+	};
+}
+const dist = {
+	linear(slots) {
+		return (params, uv) => {
+			const { viewport } = frame(params);
+			return call(gradientRawT, "gradientRawT", [
+				uniformOf(slots.from, params),
+				uniformOf(slots.to, params),
+				fArg(slots.angle, params),
+				uv,
+				viewport
+			]);
+		};
+	},
+	radial(slots) {
+		return (params, uv) => {
+			const { viewport } = frame(params);
+			return call(radialDist, "radialDist", [
+				uniformOf(slots.center, params),
+				fArg(slots.skew, params),
+				fArg(slots.aspect, params),
+				fArg(slots.radius, params),
+				uv,
+				viewport
+			]);
+		};
+	},
+	conic(slots) {
+		return (params, uv) => {
+			const { viewport } = frame(params);
+			return call(conicSweep, "conicSweep", [
+				uniformOf(slots.center, params),
+				fArg(slots.rotation, params),
+				uv,
+				viewport
+			]);
+		};
+	},
+	diamond(slots) {
+		return (params, uv) => {
+			const { viewport } = frame(params);
+			return call(diamondDist, "diamondDist", [
+				uniformOf(slots.center, params),
+				fArg(slots.size, params),
+				fArg(slots.rotation, params),
+				fArg(slots.roundness, params),
+				uv,
+				viewport
+			]);
+		};
+	},
+	spiral(slots) {
+		return (params, uv) => {
+			const { viewport } = frame(params);
+			return call(spiralMask, "spiralMask", [
+				uniformOf(slots.center, params),
+				fArg(slots.scale, params),
+				fArg(slots.width, params),
+				fArg(slots.falloff, params),
+				fArg(slots.softness, params),
+				animatedTime(params),
+				uv,
+				viewport
+			]);
+		};
+	}
+};
+function rings(field, count) {
+	return (params, coord) => call(repeatRings, "repeatRings", [field(params, coord), fArg(count, params)]);
+}
+function tiles(field, count) {
+	return (params, coord) => call(repeatWrap, "repeatWrap", [field(params, coord), fArg(count, params)]);
+}
+function tone(field, opts) {
+	return (params, coord) => call(plasmaTone, "toneRemap", [
+		field(params, coord),
+		fArg(opts.glow, params),
+		fArg(opts.contrast, params),
+		fArg(opts.balance, params)
+	]);
+}
+function threshold(field, opts) {
+	return (params, coord) => call(unitThreshold, "unitThreshold", [
+		field(params, coord),
+		opts.bias !== void 0 ? fArg(opts.bias, params) : floatE(0),
+		floatE(opts.low),
+		floatE(opts.high)
+	]);
+}
+function share(field) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (params, coord) => {
+		let bound = cache.get(params);
+		if (!bound) {
+			bound = asLocal(field(params, coord), "field");
+			cache.set(params, bound);
+		}
+		return bound;
+	};
+}
+var NOISE_BASES = {
+	mx3: {
+		fn: () => unitNoise3,
+		hint: "unitNoise3"
+	},
+	perlin: {
+		fn: () => perlin13,
+		hint: "perlin13"
+	},
+	value: {
+		fn: () => value13,
+		hint: "value13"
+	},
+	mx3signed: {
+		fn: () => mxNoiseFloat3,
+		hint: "mxNoiseFloat3"
+	}
+};
+function noiseField(basis) {
+	const entry = NOISE_BASES[basis];
+	return (_params, coord) => call(entry.fn(), entry.hint, [coord]);
+}
+function warped(field, opts) {
+	const warpFn = domainWarp2(mxNoiseFloat3, { name: "warpDomain" });
+	return (params, coord) => {
+		let amount = fArg(opts.amount, params);
+		if (opts.amountScale !== void 0) amount = amount.mul(opts.amountScale);
+		let time = animatedTime(params);
+		if (opts.timeScale !== void 0) time = time.mul(opts.timeScale);
+		return field(params, call(warpFn, "warpDomain", [
+			coord,
+			time,
+			amount
+		]));
+	};
+}
+function scaledVolume(field, opts) {
+	return (params, uv) => {
+		const { viewport } = frame(params);
+		return field(params, call(volumeDomain, "volumeDomain", [
+			uv,
+			viewport,
+			fArg(opts.scale, params)
+		]));
+	};
+}
+function flowField(slots) {
+	return (params, coord) => call(flowLayers, "flowLayers", [
+		coord,
+		fArg(slots.detail, params),
+		animatedTime(params)
+	]);
+}
+function pulse(field, opts) {
+	return (params, coord) => call(shimmerPulse, "shimmerPulse", [
+		field(params, coord),
+		animatedTime(params),
+		floatE(opts.speed),
+		floatE(opts.span),
+		floatE(opts.depth)
+	]);
+}
+function hueWheel(h) {
+	const x = local(mul(fract(h), 6), "hue6");
+	return vec3(clamp(sub(abs(sub(x, 3)), 1), 0, 1), clamp(sub(2, abs(sub(x, 2))), 0, 1), clamp(sub(2, abs(sub(x, 4))), 0, 1));
+}
+function shimmered(paint, gain) {
+	return (params) => paint(params).mul(gain(params, params.ctx.uv));
+}
+export { warped as _, noiseField as a, rampOver as c, share as d, shimmered as f, tone as g, tiles as h, hueWheel as i, rings as l, threshold as m, dist as n, pair as o, stops as p, flowField as r, pulse as s, colorSpaceModeOf as t, scaledVolume as u };

package/dist/core/figures-Ca2qPDh7.js

@@ -0,0 +1,116 @@
+import { Nt as mixColorsLinear, Pt as mixColorsVariants, a as uniformOf, at as call, dt as vec4, i as resolveScalar, lt as floatE, o as Scalar } from "./lower-z2vuXP8M.js";
+import { gt as mixColorStopsRuntime, t as animatedTime } from "./porters-B1UjrM1y.js";
+import { d as lineMask, f as sineWaveMask, n as blobField, t as blobCompose } from "./shapePaints-G_Ap8xID.js";
+import { _ as local } from "./math-BF-GBlb4.js";
+function arg(spec, params) {
+	if (typeof spec === "number") return floatE(spec);
+	if (spec instanceof Scalar || spec.kind !== "ctx") return resolveScalar(spec, params);
+	return params.ctx[spec.name];
+}
+function paintFrame(params) {
+	return {
+		uv: params.uvContext ?? params.ctx.uv,
+		viewport: params.effectiveViewportSize ?? params.ctx.viewportSize
+	};
+}
+function maskedColor(color, mask, params) {
+	const c = uniformOf(color, params);
+	return vec4(c.member("rgb"), c.member("a").mul(mask));
+}
+function strokedSegment(slots) {
+	return (params) => {
+		const { uv, viewport } = paintFrame(params);
+		const mask = call(lineMask, "lineMask", [
+			uv,
+			viewport,
+			uniformOf(slots.from, params),
+			uniformOf(slots.to, params),
+			arg(slots.width, params),
+			arg(slots.style, params),
+			arg(slots.dashLength, params),
+			arg(slots.gapLength, params),
+			arg(slots.capStart, params),
+			arg(slots.capEnd, params)
+		]);
+		return maskedColor(slots.color, mask, params);
+	};
+}
+function sineStroke(slots) {
+	return (params) => {
+		const { uv, viewport } = paintFrame(params);
+		const mask = call(sineWaveMask, "sineWaveMask", [
+			uv,
+			viewport,
+			arg(slots.angle, params),
+			uniformOf(slots.position, params),
+			arg(slots.frequency, params),
+			arg(slots.amplitude, params),
+			arg(slots.thickness, params),
+			arg(slots.softness, params),
+			animatedTime(params)
+		]);
+		return maskedColor(slots.color, mask, params);
+	};
+}
+function blob(slots) {
+	return (params) => {
+		const { uniforms, ctx, propValues } = params;
+		const uv = params.uvContext ?? ctx.uv;
+		const viewport = ctx.viewportSize;
+		const animTime = animatedTime(params, slots.seed.name);
+		params.onBeforeRender(() => {
+			const lx = params.getCpuValue(slots.light.x.name);
+			const ly = params.getCpuValue(slots.light.y.name);
+			const lz = params.getCpuValue(slots.light.z.name);
+			const len = Math.sqrt(lx * lx + ly * ly + lz * lz);
+			if (len > 0) {
+				params.setExtraField("normLx", lx / len);
+				params.setExtraField("normLy", ly / len);
+				params.setExtraField("normLz", lz / len);
+			} else {
+				params.setExtraField("normLx", 0);
+				params.setExtraField("normLy", 0);
+				params.setExtraField("normLz", 0);
+			}
+		});
+		const field = local(call(blobField, "blobField", [
+			uv,
+			viewport,
+			uniformOf(slots.center, params),
+			arg(slots.size, params),
+			arg(slots.deformation, params),
+			arg(slots.softness, params),
+			arg(slots.highlightIntensity, params),
+			uniforms.normLx,
+			uniforms.normLy,
+			uniforms.normLz,
+			animTime
+		]), "blobField");
+		const mixFactor = field.member("x");
+		const finalHighlight = field.member("y");
+		const blobMask = field.member("z");
+		const colorSpaceMode = propValues[slots.colorSpace.name] ?? 0;
+		const stopCount = propValues.stopCount ?? 0;
+		let colorMix;
+		if (stopCount > 1) colorMix = mixColorStopsRuntime(mixFactor, {
+			colorsArray: uniforms.colorsArray,
+			positionsArray: uniforms.positionsArray,
+			convertedColorsArray: uniforms.convertedColorsArray,
+			stopCount: uniforms.stopCount
+		}, colorSpaceMode);
+		else colorMix = call(mixColorsVariants[colorSpaceMode] ?? mixColorsLinear, "mixColors", [
+			uniformOf(slots.colors.a, params),
+			uniformOf(slots.colors.b, params),
+			mixFactor
+		]);
+		const avgAlpha = uniformOf(slots.colors.a, params).member("a").add(uniformOf(slots.colors.b, params).member("a")).mul(.5);
+		return call(blobCompose, "blobCompose", [
+			colorMix,
+			uniformOf(slots.highlightColor, params),
+			finalHighlight,
+			avgAlpha,
+			blobMask
+		]);
+	};
+}
+export { sineStroke as n, strokedSegment as r, blob as t };

package/dist/core/filter-Bw8Ogi4T.js

@@ -0,0 +1,23 @@
+function tintToward(color, opts) {
+	return {
+		kind: "tintToward",
+		color,
+		amount: opts.amount
+	};
+}
+function displaceBy(field, opts) {
+	return {
+		kind: "displaceBy",
+		field,
+		strength: opts.strength,
+		chromatic: opts.chromatic,
+		edges: opts.edges
+	};
+}
+function gather(config) {
+	return {
+		kind: "gather",
+		...config
+	};
+}
+export { gather as n, tintToward as r, displaceBy as t };

package/dist/core/fluids-D76EnTFg.js

@@ -0,0 +1,224 @@
+import { $n as vec4f, B as createPointerVelocityTracker, H as pathStampRibbon, K as createStateBuffer, hr as f32, z as createIdleGate } from "./lower-z2vuXP8M.js";
+import { F as createFluidKernelPass, I as createStableFluidsPasses } from "./porters-B1UjrM1y.js";
+const ambientForce = (kernel) => ({
+	stage: "pre",
+	kernel
+});
+const restoreToward = (kernel) => ({
+	stage: "post",
+	kernel
+});
+var STATE_FORMAT = "rgba16float";
+function fluidSim(build) {
+	return { compute: (params) => {
+		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const cfg = build(params, root);
+		const n = cfg.resolution;
+		const count = n * n;
+		const velA = createStateBuffer(root, vec4f, count);
+		const velB = createStateBuffer(root, vec4f, count);
+		const dyeA = createStateBuffer(root, vec4f, count);
+		const dyeB = createStateBuffer(root, vec4f, count);
+		const pressure = createStateBuffer(root, f32, count);
+		const divergence = createStateBuffer(root, f32, count);
+		const maskBuf = cfg.container ? createStateBuffer(root, vec4f, count) : void 0;
+		const outTex = root.createTexture({
+			size: [n, n],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled");
+		onCleanup(() => outTex.destroy());
+		const outputTexture = registerComputeTexture(outTex);
+		const paramsU = root.createUniform(cfg.paramsSchema);
+		const entries = {
+			velA,
+			velB,
+			dyeA,
+			dyeB,
+			pressure,
+			divergence,
+			params: paramsU.buffer
+		};
+		if (maskBuf) entries.maskBuf = maskBuf;
+		const fluidBg = root.createBindGroup(cfg.layout, entries);
+		const outputBg = root.createBindGroup(cfg.outputLayout, {
+			dyeA,
+			outTex
+		});
+		const ctx = {
+			params,
+			root,
+			n,
+			buffers: {
+				velA,
+				velB,
+				dyeA,
+				dyeB,
+				pressure,
+				divergence,
+				maskBuf
+			},
+			paramsBuffer: paramsU.buffer,
+			fluidBindGroup: fluidBg,
+			pass: (kernel, bindGroup = fluidBg) => createFluidKernelPass(root, kernel, {
+				n,
+				bindGroup
+			})
+		};
+		const containerParts = cfg.container?.setup(ctx);
+		cfg.init?.setup?.(ctx);
+		const emitters = cfg.inject ?? [];
+		for (const e of emitters) e.setup?.(ctx);
+		const solvePre = (cfg.solve ?? []).filter((s) => s.stage === "pre").map((s) => ctx.pass(s.kernel));
+		const solvePost = (cfg.solve ?? []).filter((s) => s.stage === "post").map((s) => ctx.pass(s.kernel));
+		const solver = createStableFluidsPasses(root, cfg.solver.kernels, {
+			n,
+			bindGroup: fluidBg
+		});
+		const outputPass = ctx.pass(cfg.output.kernel, outputBg);
+		const solveInto = (nodes, jacobiIters) => {
+			nodes.push(...solvePre, ...solver.solveSteps({ jacobiIters }), ...solvePost);
+		};
+		const tracker = cfg.pointer ? createPointerVelocityTracker(cfg.pointer) : null;
+		const maxDt = cfg.maxDeltaTime ?? .033;
+		let lastTime = Date.now();
+		let elapsed = 0;
+		const num = (key, fallback) => {
+			const v = getCpuValue(key);
+			return typeof v === "number" ? v : fallback;
+		};
+		const writeParams = (v) => paramsU.write(v);
+		return {
+			outputs: {
+				[cfg.output.key]: outputTexture,
+				...containerParts?.outputs ?? {}
+			},
+			getComputeNodes: (frameParams) => {
+				const fp = frameParams;
+				const preNodes = containerParts?.preFrame ? containerParts.preFrame(frameParams) : null;
+				const now = Date.now();
+				const dt = Math.min(fp.deltaTime ?? (now - lastTime) / 1e3, maxDt);
+				lastTime = now;
+				if (dt < .001) return preNodes;
+				elapsed += dt;
+				const f = {
+					dt,
+					now,
+					frameParams: fp,
+					num,
+					getCpuValue,
+					writeParams,
+					ptr: tracker ? tracker.update(fp.pointer, dt) : null,
+					get elapsed() {
+						return elapsed;
+					},
+					setElapsed(t) {
+						elapsed = t;
+					}
+				};
+				const nodes = preNodes ? [...preNodes] : [];
+				let ranInit = false;
+				if (cfg.init?.stale(f)) {
+					ranInit = true;
+					cfg.init.run(f, {
+						nodes,
+						writeParams: (v$1) => () => paramsU.write(v$1),
+						solve: solveInto
+					});
+				}
+				for (const e of emitters) e.tick?.(f);
+				for (const e of emitters) if (e.skip?.(f)) return ranInit ? nodes : null;
+				const v = cfg.values(f);
+				if ((cfg.write ?? "direct") === "thunk") nodes.push(() => paramsU.write(v));
+				else paramsU.write(v);
+				if (containerParts) nodes.push(containerParts.maskPass);
+				for (const e of emitters) e.emit?.(f, nodes, v);
+				solveInto(nodes, cfg.solver.jacobiIters);
+				nodes.push(outputPass);
+				return nodes;
+			}
+		};
+	} };
+}
+function splat(opts) {
+	let pass = null;
+	return {
+		setup(ctx) {
+			pass = "kernel" in opts ? ctx.pass(opts.kernel) : opts.setup(ctx);
+		},
+		emit(_f, nodes) {
+			if (pass) nodes.push(pass);
+		}
+	};
+}
+function cursorRibbon(opts) {
+	const tracker = createPointerVelocityTracker(opts.tracker);
+	const idle = createIdleGate();
+	let pass = null;
+	let ptr = null;
+	let scale = 1;
+	let isActive = false;
+	return {
+		setup(ctx) {
+			scale = ctx.n;
+			pass = "kernel" in opts.pass ? ctx.pass(opts.pass.kernel) : opts.pass.setup(ctx);
+		},
+		tick(f) {
+			ptr = tracker.update(f.frameParams.pointer, f.dt);
+			opts.onFrame?.(f, ptr);
+			isActive = opts.activeWhen(ptr, f);
+			if (isActive) idle.markActive(f.now);
+		},
+		skip(f) {
+			return idle.shouldSkip(f.now, opts.fadeSeconds(f));
+		},
+		emit(f, nodes, values) {
+			if (!isActive || !ptr || !pass) return;
+			const spec = opts.ribbon(f, ptr, values);
+			pathStampRibbon(nodes, {
+				fromX: ptr.prevX,
+				fromY: ptr.prevY,
+				dx: ptr.dx,
+				dy: ptr.dy,
+				dragDist: ptr.dragDist,
+				stepSize: spec.stepSize,
+				maxSteps: spec.maxSteps,
+				scale,
+				prepare: spec.prepare,
+				write: spec.write,
+				pass
+			});
+		},
+		ptr: () => ptr,
+		active: () => isActive
+	};
+}
+function seededFieldInit(opts) {
+	let pass = null;
+	let initialized = false;
+	let lastSeed = -1;
+	return {
+		setup(ctx) {
+			pass = ctx.pass(opts.kernel);
+		},
+		stale(f) {
+			return !initialized || opts.seed(f) !== lastSeed;
+		},
+		run(f, io) {
+			initialized = true;
+			lastSeed = opts.seed(f);
+			io.nodes.push(io.writeParams(opts.warm.values(0, f)));
+			if (pass) io.nodes.push(pass);
+			let warmTime = opts.warm.startTime();
+			for (let w = 0; w < opts.warm.steps; w++) {
+				const wt = warmTime;
+				warmTime += opts.warm.dt;
+				io.nodes.push(io.writeParams(opts.warm.values(wt, f)));
+				io.solve(io.nodes, opts.warm.jacobiIters);
+			}
+			f.setElapsed(warmTime);
+		}
+	};
+}
+export { seededFieldInit as a, restoreToward as i, cursorRibbon as n, splat as o, fluidSim as r, ambientForce as t };