shaders 3.2.475 → 4.0.0

package/dist/core/Shatter-DuyCFU1f.js

@@ -0,0 +1,328 @@
+import { Ac as defineStd, Bd as ZERO, Fd as applyEdgeHandlingExpr, Hd as call, Kd as floatE, _t as crackRefractUV, gt as crackGeom, ht as cellLaneUVFor, id as toHalfFloat, if as unpremultiplyAlpha, vt as crackShardCompose, yt as voronoiRegionField } from "./std-ClftfWpF.js";
+import { s as transformEdges } from "./transformations-P50Uo_Ju.js";
+var seededRandom = (seed) => {
+	const x = Math.sin(seed) * 1e4;
+	return x - Math.floor(x);
+};
+var SHARD_COUNT = 16;
+var VORONOI_SIZE = 1024;
+var DATA_WIDTH = SHARD_COUNT * 4;
+var cellLaneUV = cellLaneUVFor(DATA_WIDTH);
+var shardSites = (seed) => {
+	const positions = new Float32Array(SHARD_COUNT * 2);
+	for (let i = 0; i < SHARD_COUNT; i++) {
+		positions[i * 2] = seededRandom(seed + i * 2);
+		positions[i * 2 + 1] = seededRandom(seed + i * 2 + 1);
+	}
+	return positions;
+};
+function shardPhysics(getCpuValue) {
+	const cellData = new Float32Array(SHARD_COUNT * 4);
+	const displacementData = new Float32Array(SHARD_COUNT * 4);
+	const generateCells = (seed) => {
+		const sites = shardSites(seed);
+		for (let i = 0; i < SHARD_COUNT; i++) {
+			cellData[i * 4] = sites[i * 2];
+			cellData[i * 4 + 1] = sites[i * 2 + 1];
+			cellData[i * 4 + 2] = seededRandom(seed + i * 3);
+			cellData[i * 4 + 3] = seededRandom(seed + i * 3 + 1);
+		}
+	};
+	let currentSeed = getCpuValue("seed") ?? 2;
+	generateCells(currentSeed);
+	const FRICTION = 1;
+	let prevX = .5;
+	let prevY = .5;
+	return {
+		cellData,
+		displacementData,
+		step(pointer, deltaTime, aspect) {
+			const dt = Math.min(deltaTime, .016);
+			const newSeed = getCpuValue("seed") ?? 2;
+			if (newSeed !== currentSeed) {
+				currentSeed = newSeed;
+				generateCells(currentSeed);
+				displacementData.fill(0);
+			}
+			const intensity = getCpuValue("intensity") ?? 4;
+			const radius = getCpuValue("radius") ?? .4;
+			const decay = getCpuValue("decay") ?? 1;
+			let velX = dt > 0 ? (pointer.x - prevX) / dt : 0;
+			let velY = dt > 0 ? (pointer.y - prevY) / dt : 0;
+			let speed = Math.sqrt(velX * velX + velY * velY);
+			const maxVelocity = 5 + intensity * 2;
+			if (speed > maxVelocity) {
+				const scale = maxVelocity / speed;
+				velX *= scale;
+				velY *= scale;
+				speed = maxVelocity;
+			}
+			for (let i = 0; i < SHARD_COUNT; i++) {
+				const cellX = cellData[i * 4];
+				const cellY = cellData[i * 4 + 1];
+				const randomDirX = cellData[i * 4 + 2] - .5;
+				const randomDirY = cellData[i * 4 + 3] - .5;
+				const dx = aspect >= 1 ? (cellX - pointer.x) * aspect : cellX - pointer.x;
+				const dy = aspect >= 1 ? cellY - pointer.y : (cellY - pointer.y) / aspect;
+				const dist = Math.sqrt(dx * dx + dy * dy);
+				let currentDx = displacementData[i * 4];
+				let currentDy = displacementData[i * 4 + 1];
+				const decayTime = Math.max(.01, decay);
+				const decayFactor = Math.exp(-dt / decayTime);
+				currentDx *= decayFactor;
+				currentDy *= decayFactor;
+				let velocityDx = 0;
+				let velocityDy = 0;
+				if (dist < radius && speed > .01) {
+					const influence = Math.max(0, 1 - dist / radius);
+					const influenceCurve = influence * influence;
+					const pushForce = influenceCurve * speed * intensity * dt * .5;
+					velocityDx = velX * pushForce;
+					velocityDy = velY * pushForce;
+					const jitterForce = influenceCurve * speed * intensity * dt * .1;
+					velocityDx += randomDirX * jitterForce;
+					velocityDy += randomDirY * jitterForce;
+				}
+				const lerpFactor = Math.min(1, FRICTION * dt);
+				displacementData[i * 4] = currentDx + velocityDx * lerpFactor;
+				displacementData[i * 4 + 1] = currentDy + velocityDy * lerpFactor;
+			}
+			prevX = pointer.x;
+			prevY = pointer.y;
+		}
+	};
+}
+function shardDataTexture(params, physics) {
+	const { createDataTexture, registerMediaTexture, onCleanup } = params;
+	const dataMirror = new Float32Array(DATA_WIDTH);
+	const texData = new Uint16Array(DATA_WIDTH);
+	const packMirror = () => {
+		for (let i = 0; i < SHARD_COUNT; i++) {
+			dataMirror[i * 4] = physics.cellData[i * 4];
+			dataMirror[i * 4 + 1] = physics.cellData[i * 4 + 1];
+			dataMirror[i * 4 + 2] = physics.displacementData[i * 4];
+			dataMirror[i * 4 + 3] = physics.displacementData[i * 4 + 1];
+		}
+		for (let i = 0; i < DATA_WIDTH; i++) texData[i] = toHalfFloat(dataMirror[i]);
+	};
+	packMirror();
+	const dataTex = createDataTexture({
+		width: DATA_WIDTH,
+		height: 1,
+		format: "r16float",
+		data: texData,
+		label: "shatter-cells"
+	});
+	onCleanup(() => dataTex.destroy());
+	return {
+		dataKit: registerMediaTexture(() => dataTex.texture),
+		upload() {
+			packMirror();
+			dataTex.write(texData);
+		}
+	};
+}
+const componentDefinition = defineStd({
+	name: "Shatter",
+	role: "simulation",
+	species: "custom",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "Broken glass effect with tectonic plate displacement",
+	requiresRTT: true,
+	requiresChild: true,
+	usesPointer: true,
+	props: {
+		crackWidth: {
+			default: 1,
+			description: "Thickness of crack lines",
+			ui: {
+				type: ["range", "map"],
+				min: .5,
+				max: 5,
+				step: .1,
+				label: "Crack Width",
+				group: "Effect"
+			}
+		},
+		intensity: {
+			default: 4,
+			description: "How much shards shift",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 20,
+				step: 1,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		radius: {
+			default: .4,
+			description: "Cursor influence radius",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 1,
+				step: .1,
+				label: "Radius",
+				group: "Effect"
+			}
+		},
+		decay: {
+			default: 1,
+			description: "How fast shards return to rest",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 10,
+				step: .1,
+				label: "Decay",
+				group: "Effect"
+			}
+		},
+		seed: {
+			default: 2,
+			description: "Random seed for pattern",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 50,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		},
+		chromaticSplit: {
+			default: 1,
+			description: "RGB separation for prismatic glass effect",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Chromatic Split",
+				group: "Effect"
+			}
+		},
+		refractionStrength: {
+			default: 5,
+			description: "How much cracks bend/distort the underlying image",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 10,
+				step: .1,
+				label: "Refraction",
+				group: "Effect"
+			}
+		},
+		shardLighting: {
+			default: .1,
+			description: "Subtle lighting on tilted shards for 3D depth",
+			ui: {
+				type: "range",
+				min: 0,
+				max: .5,
+				step: .1,
+				label: "Shard Lighting",
+				group: "Effect"
+			}
+		},
+		edges: {
+			default: "mirror",
+			description: "How to handle edges when displacement pushes content out of bounds",
+			transform: transformEdges,
+			compileTime: true,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges",
+				group: "Effect"
+			}
+		}
+	},
+	compute: voronoiRegionField({
+		count: SHARD_COUNT,
+		size: VORONOI_SIZE,
+		sites: shardSites,
+		seedProp: "seed",
+		seedDefault: 2,
+		output: "voronoiField"
+	}),
+	gpu: { fragment: (params) => {
+		const { childNode, ctx, computeOutputs, propValues, convertToTexture } = params;
+		if (!childNode) return ZERO;
+		const child = convertToTexture(childNode);
+		const voronoiField = computeOutputs?.voronoiField;
+		if (!voronoiField) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [child.sample(ctx.uv)]);
+		const { onBeforeRender, getCpuValue, dimensions } = params;
+		const edgeMode = propValues.edges ?? 0;
+		const physics = shardPhysics(getCpuValue);
+		const cells = shardDataTexture(params, physics);
+		const dataKit = cells.dataKit;
+		onBeforeRender((fp) => {
+			const { pointer, deltaTime } = fp;
+			const aspect = dimensions.width / Math.max(1, dimensions.height);
+			physics.step(pointer, deltaTime, aspect);
+			cells.upload();
+		});
+		const vSample = voronoiField.sample(ctx.uv, "nearestClamp");
+		const nearestI = vSample.member("r");
+		const secondI = vSample.member("g");
+		const nearestClamp = "nearestClamp";
+		const dataAt = (idx, field) => dataKit.sample(call(cellLaneUV, "cellLaneUV", [idx, floatE(field)]), nearestClamp).member("r");
+		const geom = call(crackGeom, "crackGeom", [
+			ctx.uv,
+			dataAt(nearestI, 0),
+			dataAt(nearestI, 1),
+			dataAt(secondI, 0),
+			dataAt(secondI, 1),
+			dataAt(nearestI, 2),
+			dataAt(nearestI, 3),
+			params.uniforms.crackWidth
+		]);
+		const crackIntensity = geom.member("crackIntensity");
+		const edgeNormal = geom.member("edgeNormal");
+		const displacedUV = geom.member("displacedUV");
+		const disp = geom.member("disp");
+		const sample = (uv) => applyEdgeHandlingExpr(uv, (u) => child.sample(u), edgeMode);
+		const normalColor = sample(displacedUV);
+		const refractUV = (channel) => call(crackRefractUV, "crackRefractUV", [
+			displacedUV,
+			edgeNormal,
+			crackIntensity,
+			params.uniforms.refractionStrength,
+			params.uniforms.chromaticSplit,
+			floatE(channel)
+		]);
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [call(crackShardCompose, "crackShardCompose", [
+			normalColor,
+			sample(refractUV(1)),
+			sample(refractUV(0)),
+			sample(refractUV(-1)),
+			crackIntensity,
+			disp,
+			params.uniforms.shardLighting
+		])]);
+	} }
+});
+var Shatter_default = componentDefinition;
+export { componentDefinition as n, Shatter_default as t };

package/dist/core/{SimplexNoise-CZf812YP.js → SimplexNoise-CQJvmqd-.js}

@@ -1,7 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { b as stops, c as noiseField, f as rampOver } from "./fields-CXwmEUsd.js";
-import { S as signedTone, l as evolving, x as seededPlane } from "./noise-G7a5U0ar.js";
-import { t as noiseColorProps } from "./noiseColor-_P7nIu_L.js";
+import { Ac as defineStd, Fo as noiseField, Ml as p, Vi as evolving, ea as seededPlane, qo as stops, ta as signedTone, zo as rampOver } from "./std-ClftfWpF.js";
+import { t as noiseColorProps } from "./noiseColor-D_bPhJ4m.js";
 const componentDefinition = defineStd({
 	name: "SimplexNoise",
 	role: "generator",

package/dist/core/{SineWave-CVHPlsdX.js → SineWave-BfOgSGMP.js}

@@ -1,6 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { a as transformColor, c as transformPosition, r as transformAngle } from "./transformations-CzFmhZww.js";
-import { t as sineStroke } from "./figures-BRYcB-p2.js";
+import { Ac as defineStd, Ml as p, Sr as sineStroke } from "./std-ClftfWpF.js";
+import { a as transformColor, c as transformPosition, r as transformAngle } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "SineWave",
 	role: "generator",

package/dist/core/{SliceWipe-4Y_DLO0N.js → SliceWipe-CD_D99sl.js}

@@ -1,5 +1,4 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { h as slicedSlide } from "./warps-gIr3RmZV.js";
+import { Ac as defineStd, Ml as p, Qn as slicedSlide } from "./std-ClftfWpF.js";
 const componentDefinition = defineStd({
 	name: "SliceWipe",
 	role: "warp",

package/dist/core/{Smoke-CzjvGgBl.js → Smoke-BDQYKRP1.js}

@@ -1,7 +1,5 @@
-import { At as colorMixing_exports, Br as struct, Gn as typegpu_default, Mr as vec4f, Rr as textureStorage2d, at as ZERO, ct as call, mt as vec4, qr as f32, t as defineStd, zr as arrayOf } from "./lower-DtoDQ7hV.js";
-import { Dt as mixColorStopsRuntime, M as buildStableFluidsKernels, O as buildEmitterSplatKernel, k as buildFluidOutputKernel, vt as colorStopsPropConfig } from "./porters-CQwDd2t4.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
-import { o as splat, r as fluidSim } from "./fluids-CBhAiGAx.js";
+import { $f as f32, Ac as defineStd, Bd as ZERO, Ed as mixColorStopsRuntime, Hd as call, Jd as vec4, Jf as textureStorage2d, Wf as vec4f, Xf as struct, Yf as arrayOf, af as colorMixing_exports, f as fluidSim, h as splat, ll as buildEmitterSplatKernel, ou as colorStopsPropConfig, pl as buildStableFluidsKernels, ul as buildFluidOutputKernel, xf as typegpu_default } from "./std-ClftfWpF.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var N = 256;
 var COUNT = N * N;
 var JACOBI_ITERS = 10;

package/dist/core/{SmokeFill-DkMjXE-D.js → SmokeFill-CPnzQtQv.js}

@@ -1,15 +1,10 @@
-import { At as colorMixing_exports, Br as struct, Gn as typegpu_default, I as sdf_exports, Mr as vec4f, Rr as textureStorage2d, at as ZERO, ct as call, mt as vec4, qr as f32, t as defineStd, zr as arrayOf } from "./lower-DtoDQ7hV.js";
-import { L as makeShapeMaskSet, M as buildStableFluidsKernels, O as buildEmitterSplatKernel, k as buildFluidOutputKernel } from "./porters-CQwDd2t4.js";
-import { O as resolveShapeType, k as shapeEffectBoundingBoxDeclaration, w as sdf3d_exports } from "./sdf3d-BMqCSSPB.js";
-import { n as glass_exports } from "./glass-DIEus1UY.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
-import { i as clamp, w as mul } from "./math-7PlusTFx.js";
-import { o as splat, r as fluidSim } from "./fluids-CBhAiGAx.js";
+import { $f as f32, Ac as defineStd, Bd as ZERO, Gs as clamp, Hd as call, Jd as vec4, Jf as textureStorage2d, Lu as resolveShapeType, Nu as sdf3d_exports, Ru as shapeEffectBoundingBoxDeclaration, Wf as vec4f, Xf as struct, Yf as arrayOf, af as colorMixing_exports, dc as mul, f as fluidSim, h as splat, ll as buildEmitterSplatKernel, pl as buildStableFluidsKernels, rd as sdf_exports, ul as buildFluidOutputKernel, vl as makeShapeMaskSet, xf as typegpu_default, yu as glass_exports } from "./std-ClftfWpF.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var { sdfSpaceUV } = glass_exports;
 var { createSvgSdfSampler, createSdfDataTexture, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS } = sdf3d_exports;
 var DEFAULT_SHAPE_CONFIG = JSON.stringify({
-	type: "circleSDF",
+	type: "sphere3D",
 	radius: .35
 });
 var N = 256;

package/dist/core/{SmokeFlow-DQMNHV2s.js → SmokeFlow-BkPMjZq8.js}

@@ -1,7 +1,5 @@
-import { At as colorMixing_exports, Br as struct, Gn as typegpu_default, Mr as vec4f, Rr as textureStorage2d, W as decayFadeSeconds, at as ZERO, ct as call, mt as vec4, qr as f32, t as defineStd, zr as arrayOf } from "./lower-DtoDQ7hV.js";
-import { Dt as mixColorStopsRuntime, M as buildStableFluidsKernels, O as buildEmitterSplatKernel, k as buildFluidOutputKernel, vt as colorStopsPropConfig } from "./porters-CQwDd2t4.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
-import { n as cursorRibbon, r as fluidSim } from "./fluids-CBhAiGAx.js";
+import { $f as f32, Ac as defineStd, Bd as ZERO, Ed as mixColorStopsRuntime, Hd as call, Jd as vec4, Jf as textureStorage2d, Wf as vec4f, Xf as struct, Yf as arrayOf, af as colorMixing_exports, d as cursorRibbon, f as fluidSim, ll as buildEmitterSplatKernel, ou as colorStopsPropConfig, pl as buildStableFluidsKernels, sd as decayFadeSeconds, ul as buildFluidOutputKernel, xf as typegpu_default } from "./std-ClftfWpF.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var N = 256;
 var COUNT = N * N;
 var JACOBI_ITERS = 10;

package/dist/core/{Solarize-DmhOkKoO.js → Solarize-DSiS32QS.js}

@@ -1,6 +1,4 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { p as solarize } from "./color-CY5teMWa.js";
-import { i as isZero, n as crosses } from "./slots-BqIef2iV.js";
+import { Ac as defineStd, Ml as p, Ss as isZero, ys as crosses, zt as solarize } from "./std-ClftfWpF.js";
 const componentDefinition = defineStd({
 	name: "Solarize",
 	role: "filter",

package/dist/core/{SolidColor-CyYoqgG3.js → SolidColor-DEKpgy1c.js}

@@ -1,6 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { a as transformColor } from "./transformations-CzFmhZww.js";
-import { a as solidColor } from "./gradients-C15o7_xy.js";
+import { Ac as defineStd, Do as solidColor, Ml as p } from "./std-ClftfWpF.js";
+import { a as transformColor } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "SolidColor",
 	role: "generator",

package/dist/core/Sparkle-BZur6gPW.js

@@ -0,0 +1,178 @@
+import { Ac as defineStd, Cc as sqrt, Dc as vec3, Ec as vec2, Ic as animatedTime, In as flashes, Js as dot, Jt as brightestNear, Oc as vec4, Sc as splat3, Ss as isZero, Va as starGlint, Ws as add, bc as smoothstep, cc as max, dc as mul, fo as scatterPoints, lc as min, oc as local, qs as div, sn as gatherStack, uc as mix, wc as step, ys as crosses } from "./std-ClftfWpF.js";
+var GRID_SCALES = [1, 2 / 3];
+var THRESHOLD_BAND = .12;
+var GLINT = {
+	core: .9,
+	rayWidth: 1.6,
+	rayLength: .45,
+	rays: .25
+};
+var BLINK = {
+	minRate: .8,
+	rateSpread: 1.2,
+	sharpness: 8
+};
+var BRIGHT_SHARE = .45;
+var DIM_LEVEL = .35;
+var HUE_GAIN = .6;
+var LUMA = [
+	.2126,
+	.7152,
+	.0722
+];
+var EXPAND_TAPS = 4;
+function glintLayer(params, px, gridScale, layer, t) {
+	const u = params.uniforms;
+	const cellSize = local(mul(u.size, gridScale), `sparkleCell${layer}`);
+	const expanding = (params.propValues.expand ?? 0) > 0;
+	const expandUV = local(div(vec2(u.expand, u.expand), params.ctx.logicalViewportSize), `sparkleExpand${layer}`);
+	const rayRate = local(div(GLINT.rayLength, max(u.rayLength, .01)), `sparkleRays${layer}`);
+	return scatterPoints(px, {
+		cellSize,
+		jitter: .6,
+		seed: add(u.seed, layer * .31)
+	}).map(({ point, offset, random }) => {
+		const source = brightestNear(params.sampleStraight, div(point, params.ctx.logicalViewportSize), {
+			radius: expandUV,
+			taps: expanding ? EXPAND_TAPS : 0,
+			angle: layer * 45
+		});
+		const presence = smoothstep(u.threshold, add(u.threshold, THRESHOLD_BAND), sqrt(source.luma));
+		const blink = flashes(t, {
+			rate: add(BLINK.minRate, mul(random.member("z"), BLINK.rateSpread)),
+			offset: mul(random.member("x"), 6.283185307179586),
+			sharpness: BLINK.sharpness
+		});
+		const level = add(DIM_LEVEL, mul(1 - DIM_LEVEL, step(BRIGHT_SHARE, random.member("z"))));
+		const star = starGlint(offset, {
+			core: GLINT.core,
+			rayWidth: GLINT.rayWidth,
+			rayLength: rayRate,
+			rays: GLINT.rays,
+			reach: mul(cellSize, .5)
+		});
+		const rgb = local(source.color.member("rgb"), "sparkleRgb");
+		const hue = mul(div(rgb, max(dot(rgb, vec3(...LUMA)), .001)), HUE_GAIN);
+		return mul(mix(splat3(1), hue, u.colorize), mul(mul(mul(star, blink), presence), mul(level, u.intensity)));
+	}).reduce((a, b) => add(a, b));
+}
+const componentDefinition = defineStd({
+	name: "Sparkle",
+	role: "filter",
+	species: "gather",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Twinkling star glints over the bright parts of the layer inside",
+	animatedTime: { speed: "speed" },
+	props: {
+		size: {
+			default: 100,
+			description: "Spacing between glints, in CSS pixels (smaller means more glints)",
+			ui: {
+				type: ["range", "map"],
+				min: 10,
+				max: 200,
+				step: 1,
+				label: "Spacing",
+				group: "Effect"
+			}
+		},
+		intensity: {
+			default: 10,
+			description: "Brightness of the glints",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 20,
+				step: .1,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		threshold: {
+			default: .2,
+			description: "How bright the layer must be before glints appear: 0 allows all but black, 0.5 is mid-grey and up, 1 only pure white",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Threshold",
+				group: "Effect"
+			}
+		},
+		expand: {
+			default: 0,
+			description: "Lets glints appear up to this many CSS pixels outside the bright areas",
+			recompile: crosses(0),
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Expand",
+				group: "Effect"
+			}
+		},
+		rayLength: {
+			default: 5,
+			description: "Length of the four rays around each glint (they fade out by half the spacing)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 20,
+				step: .1,
+				label: "Ray Length",
+				group: "Effect"
+			}
+		},
+		colorize: {
+			default: .45,
+			description: "How much each glint takes on the colour beneath it (0 is pure white)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Colorize",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "How fast the glints twinkle",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .05,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Re-rolls where the glints sit and when they blink",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Animation"
+			}
+		}
+	},
+	identityWhen: isZero("intensity"),
+	effect: gatherStack((params) => {
+		const px = local(mul(params.ctx.uv, params.ctx.logicalViewportSize), "sparklePx");
+		const t = local(animatedTime(params), "sparkleT");
+		const glow = local(GRID_SCALES.map((scale, layer) => glintLayer(params, px, scale, layer, t)).reduce((a, b) => add(a, b)), "sparkleGlow");
+		const child = local(params.texture.sample(params.ctx.uv), "sparkleChild");
+		const spill = max(max(glow.member("r"), glow.member("g")), glow.member("b"));
+		return vec4(add(child.member("rgb"), glow), min(add(child.member("a"), spill), 1));
+	}, []),
+	missingChildMessage: "You must pass a child component into the Sparkle shader."
+});
+var Sparkle_default = componentDefinition;
+export { componentDefinition as n, Sparkle_default as t };

package/dist/core/{Spherize-D2gNetxE.js → Spherize-D9Yg4n6O.js}

@@ -1,6 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { a as transformColor, c as transformPosition } from "./transformations-CzFmhZww.js";
-import { F as rimLit, U as sphereFrame, u as crispTap, v as gatherStack } from "./blurs-D5a6ad3o.js";
+import { $t as crispTap, Ac as defineStd, Ml as p, Mn as sphereFrame, sn as gatherStack, wn as rimLit } from "./std-ClftfWpF.js";
+import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
 var sphere = sphereFrame({
 	center: p("center"),
 	radius: p("radius"),

package/dist/core/{Spiral-BCO6OJXU.js → Spiral-BCacfEpT.js}

@@ -1,6 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { f as rampOver, l as pair, r as dist } from "./fields-CXwmEUsd.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
+import { Ac as defineStd, Io as pair, Ml as p, ko as dist, zo as rampOver } from "./std-ClftfWpF.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Spiral",
 	role: "generator",

package/dist/core/{Star-9JERbdHT.js → Star-Dnw1ihk7.js}

@@ -1,5 +1,4 @@
-import { t as defineStd } from "./lower-DtoDQ7hV.js";
-import { p as star } from "./shape-B2CoDi6l.js";
+import { Ac as defineStd, ms as star } from "./std-ClftfWpF.js";
 const componentDefinition = defineStd({
 	role: "shape",
 	name: "Star",

package/dist/core/{Stone-92McvPwz.js → Stone-Cje-_vAg.js}

@@ -1,6 +1,4 @@
-import { t as defineStd } from "./lower-DtoDQ7hV.js";
-import { p as noiseRelief, v as reliefBases } from "./noise-G7a5U0ar.js";
-import { t as reliefStylizeProps } from "./noiseStylize-CUrW_HiC.js";
+import { Ac as defineStd, Gi as noiseRelief, Zi as reliefBases, c as reliefStylizeProps } from "./std-ClftfWpF.js";
 const componentDefinition = defineStd({
 	name: "Stone",
 	role: "filter",

package/dist/core/{Strands-B6NfRExJ.js → Strands-CFRxS1G_.js}

@@ -1,7 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { vt as colorStopsPropConfig } from "./porters-CQwDd2t4.js";
-import { C as tonePow, h as overRgb, t as backToP3, y as ribbons } from "./noise-G7a5U0ar.js";
-import { c as transformPosition, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
+import { Ac as defineStd, Ji as overRgb, Ml as p, Ni as backToP3, Qi as ribbons, na as tonePow, ou as colorStopsPropConfig } from "./std-ClftfWpF.js";
+import { c as transformPosition, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Strands",
 	role: "generator",

package/dist/core/{Stretch-DbUOkCav.js → Stretch-DXVhfIqO.js}

@@ -1,5 +1,4 @@
-import { c as p, l as centerPropConfig, t as defineStd, u as edgesPropConfig } from "./lower-DtoDQ7hV.js";
-import { g as stretch } from "./warps-gIr3RmZV.js";
+import { $n as stretch, Ac as defineStd, Ml as p, Nl as centerPropConfig, Pl as edgesPropConfig } from "./std-ClftfWpF.js";
 const componentDefinition = defineStd({
 	name: "Stretch",
 	role: "warp",

package/dist/core/{Stripes-BG2zbwGV.js → Stripes-CCADWwyq.js}

@@ -1,6 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { C as strokeOver, S as stripeBands } from "./patterns-RTt6Fek8.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
+import { Ac as defineStd, Ml as p, mo as strokeOver, po as stripeBands } from "./std-ClftfWpF.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Stripes",
 	role: "generator",