shaders 4.0.2 → 4.0.4

package/dist/core/Satin-yYWeplbY.js

@@ -0,0 +1,372 @@
+import { Ac as sub, Fc as defineStd, Fl as uniformOf, Hr as fdSlope, Js as abs, Ki as foldSet, Ll as p, Mc as vec3, Mi as viewRay, Nc as vec4, Oi as tiltNormal, Pi as wardAlphas, Pr as anisoSpecular, Qs as div, Ui as drapedFolds, Vc as animatedTime, Vi as clothCoords, Vr as fdCurvature, Xs as clamp, Ys as add, _c as neg, _d as isMobileGpuViewport, ar as direction, ci as nudgeNormal, dc as local, dr as surfaceOf, gc as mul, hc as mix, jc as vec2, ni as lambert, or as directionFrame, qr as grainNoise, ri as lightVec3, si as neutralTone, vi as sheenLobe } from "./std-DcYKWFSQ.js";
+import { a as transformColor } from "./transformations-P50Uo_Ju.js";
+var MOBILE = isMobileGpuViewport();
+var RIPPLE = [
+	{
+		freq: 3.1,
+		speed: .35,
+		amount: .045
+	},
+	{
+		freq: 6.7,
+		speed: -.22,
+		amount: .018
+	},
+	{
+		freq: 11.3,
+		speed: .5,
+		amount: .007
+	}
+];
+var RIPPLE_WAVES = MOBILE ? RIPPLE.slice(0, 2) : RIPPLE;
+var SWELL = {
+	amount: .3,
+	freq: 2.4,
+	speed: .4
+};
+var BREEZE_SWAY = .08;
+var FOLD_CREASE = .7;
+var FOLD_SHARPNESS = 2;
+var FOLD_JITTER = .8;
+var FOLD_FORESHORTEN = .25;
+var FD_EPS = .004;
+var RELIEF_GAIN = .3;
+var CAVITY_GAIN = .0012;
+var THREADS = {
+	coarse: [14, 420],
+	fine: [26, 900]
+};
+var WEAVE_RELIEF = .1;
+var LIGHT = {
+	ambient: .18,
+	key: .9,
+	fill: .45,
+	elevation: -.65,
+	fillElevation: -.45
+};
+var STREAK_GAIN = [.25, .9];
+var BLOOM = {
+	roughness: .85,
+	anisotropy: .5,
+	gain: .35
+};
+var SHEEN_GAIN = .6;
+const componentDefinition = defineStd({
+	name: "Satin",
+	role: "generator",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Flowing satin — a draped cloth of soft rippling folds lit like real fabric: a highlight streaked along the weave, a velvet sheen on the fold flanks and creases falling into shadow, swaying gently in a breeze",
+	acceptsUVContext: true,
+	animatedTime: { speed: "speed" },
+	props: {
+		color: {
+			default: "#c92c40",
+			transform: transformColor,
+			description: "The dye of the cloth — deep colors show the sheen best",
+			ui: {
+				type: "color",
+				label: "Color",
+				group: "Cloth"
+			}
+		},
+		highlightColor: {
+			default: "#c4667b",
+			transform: transformColor,
+			description: "The color of the light caught by the weave — near white for silk, tinted toward the dye for a matte satin",
+			ui: {
+				type: "color",
+				label: "Highlight",
+				group: "Cloth"
+			}
+		},
+		foldCount: {
+			default: 7,
+			compileTime: true,
+			description: "How many ridges run across the cloth",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 12,
+				step: 1,
+				label: "Folds",
+				group: "Folds"
+			}
+		},
+		foldDirection: {
+			default: 90,
+			description: "Direction the folds run, in degrees — 90 hangs them vertically like a curtain",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Direction",
+				group: "Folds"
+			}
+		},
+		foldDepth: {
+			default: .5,
+			description: "How deep the folds are — 0 is a flat sheet, 1 heavy gathered drapery",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Depth",
+				group: "Folds"
+			}
+		},
+		foldWidth: {
+			default: .14,
+			description: "Width of each ridge, relative to the canvas — narrow for fine pleats, wide for broad soft folds",
+			ui: {
+				type: ["range", "map"],
+				min: .04,
+				max: .4,
+				step: .01,
+				label: "Width",
+				group: "Folds"
+			}
+		},
+		pinning: {
+			default: .6,
+			description: "How much the cloth is gathered at the top edge — 0 is a loose drape, 1 a curtain pinned at the rail with the folds opening as they fall",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Pinning",
+				group: "Folds"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed — a different layout of folds",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Folds"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "How fast the cloth moves. 0 pauses.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .01,
+				label: "Speed",
+				group: "Motion"
+			}
+		},
+		breeze: {
+			default: .4,
+			description: "Strength of the breeze — how far the folds ripple and sway",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Breeze",
+				group: "Motion"
+			}
+		},
+		gloss: {
+			default: .1,
+			description: "How shiny the weave is — 0 soft matte satin, 1 glossy silk with a tight bright streak",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Gloss",
+				group: "Finish"
+			}
+		},
+		anisotropy: {
+			default: .7,
+			description: "How much the highlight stretches along the threads — the long streak real satin shows",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Anisotropy",
+				group: "Finish"
+			}
+		},
+		bloom: {
+			default: .5,
+			description: "The broad soft glow around the highlight — light the weave scatters sideways. 0 leaves the crisp streak alone, 1 a wide satin bloom",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Bloom",
+				group: "Finish"
+			}
+		},
+		sheen: {
+			default: .5,
+			description: "The velvet glow on the flanks of each fold where the fibres catch the light edge-on",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Sheen",
+				group: "Finish"
+			}
+		},
+		weave: {
+			default: .1,
+			description: "Visibility of the thread texture — the fine grain that glints inside the highlight",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Weave",
+				group: "Finish"
+			}
+		},
+		fiberAngle: {
+			default: 90,
+			description: "Direction the threads run, in degrees — the highlight streaks along this axis. Usually the fold direction.",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Thread Angle",
+				group: "Finish"
+			}
+		},
+		lightAngle: {
+			default: 215,
+			description: "Direction of the key light, in degrees",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Light"
+			}
+		},
+		fill: {
+			default: .35,
+			description: "Strength of the fill light from the opposite side — lifts the shadowed flanks",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Fill",
+				group: "Light"
+			}
+		}
+	},
+	paint: (params) => {
+		const { uv, aspect } = surfaceOf(params);
+		const u = (name) => uniformOf(p(name), params);
+		const t = local(animatedTime(params), "satinTime");
+		const q = local(vec2(mul(sub(uv.member("x"), .5), aspect), sub(uv.member("y"), .5)), "q");
+		const drape = directionFrame(u("foldDirection"), "drape");
+		const count = Math.max(1, Math.min(12, Math.round(params.propValues.foldCount ?? 7)));
+		const spread = local(mul(add(mul(abs(drape.perp.member("x")), aspect), abs(drape.perp.member("y"))), 1.1), "spread");
+		const folds = foldSet({
+			count,
+			seed: u("seed"),
+			spread,
+			width: u("foldWidth"),
+			height: u("foldDepth"),
+			jitter: FOLD_JITTER
+		});
+		const breeze = local(u("breeze"), "breeze");
+		const drapeOpts = {
+			time: t,
+			ripple: {
+				waves: RIPPLE_WAVES,
+				gain: mix(.35, 1, breeze)
+			},
+			sway: {
+				amount: mul(breeze, BREEZE_SWAY),
+				rate: .7
+			},
+			swell: SWELL,
+			pinning: local(u("pinning"), "pinning"),
+			sharpness: FOLD_SHARPNESS,
+			crease: FOLD_CREASE
+		};
+		const alongExtent = local(add(mul(abs(drape.tangent.member("x")), aspect), abs(drape.tangent.member("y"))), "alongExtent");
+		const onDrape = (at) => {
+			const c = drape.coordsOf(at);
+			return {
+				along: add(div(c.along, alongExtent), .5),
+				across: c.across
+			};
+		};
+		const cloth = (at) => drapedFolds(onDrape(at), folds, drapeOpts);
+		const curved = MOBILE ? null : fdCurvature(cloth, q, FD_EPS, "cloth");
+		const relief = curved ?? fdSlope(cloth, q, FD_EPS, "cloth");
+		const nFold = nudgeNormal(vec3(0, 0, -1), mul(relief.dx, -RELIEF_GAIN), mul(relief.dy, -RELIEF_GAIN), "nFold");
+		const material = clothCoords(onDrape(q), folds, {
+			...drapeOpts,
+			foreshorten: FOLD_FORESHORTEN
+		});
+		const onCloth = local(add(mul(drape.tangent, material.along), mul(drape.perp, material.across)), "onCloth");
+		const fibre = directionFrame(u("fiberAngle"), "fibre");
+		const fc = fibre.coordsOf(onCloth);
+		const n = tiltNormal(nFold, fibre, { across: mul(local(add(grainNoise(fc, { freq: THREADS.coarse }), mul(grainNoise(fc, {
+			freq: THREADS.fine,
+			offset: [3.1, 7.7]
+		}), .5)), "threads"), mul(u("weave"), WEAVE_RELIEF)) });
+		const view = viewRay(params, { aspect });
+		const keyDir = direction(u("lightAngle"), "key");
+		const L = lightVec3(keyDir, LIGHT.elevation, "L");
+		const Lfill = lightVec3(neg(keyDir), LIGHT.fillElevation, "Lfill");
+		const diffuse = local(add(add(LIGHT.ambient, mul(lambert(n, L, { wrap: .35 }), LIGHT.key)), mul(lambert(n, Lfill, { wrap: .6 }), mul(u("fill"), LIGHT.fill))), "diffuse");
+		const cavity = curved ? local(clamp(sub(1, mul(curved.curvature, CAVITY_GAIN)), .6, 1.1), "cavity") : 1;
+		const gloss = local(u("gloss"), "gloss");
+		const aniso = local(u("anisotropy"), "aniso");
+		const streak = anisoSpecular({
+			normal: n,
+			tangent: fibre.tangent,
+			light: L,
+			view,
+			alphas: wardAlphas(sub(1, gloss), aniso),
+			gain: mix(STREAK_GAIN[0], STREAK_GAIN[1], gloss)
+		});
+		const bloom = anisoSpecular({
+			normal: n,
+			tangent: fibre.tangent,
+			light: L,
+			view,
+			alphas: wardAlphas(BLOOM.roughness, mul(aniso, BLOOM.anisotropy)),
+			gain: mul(u("bloom"), BLOOM.gain)
+		});
+		const velvet = sheenLobe({
+			normal: n,
+			light: L,
+			view,
+			roughness: mix(.7, .3, gloss),
+			gain: mul(u("sheen"), SHEEN_GAIN)
+		});
+		const dye = u("color").member("rgb");
+		const catchlight = u("highlightColor").member("rgb");
+		return vec4(neutralTone(add(mul(dye, mul(diffuse, cavity)), mul(catchlight, mul(add(add(streak, bloom), velvet), cavity)))), 1);
+	}
+});
+var Satin_default = componentDefinition;
+export { componentDefinition as n, Satin_default as t };

package/dist/core/{Saturation-BRkifYWj.js → Saturation-qIjYNU3K.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, Rt as saturate, xs as isValue, ys as crosses } from "./std-ClftfWpF.js";
+import { Es as isValue, Fc as defineStd, Ll as p, Rt as saturate, ws as crosses } from "./std-DcYKWFSQ.js";
 const componentDefinition = defineStd({
 	name: "Saturation",
 	role: "filter",

package/dist/core/{Scratches-D87O5C2K.js → Scratches-C6Xr7JRO.js}

@@ -1,5 +1,5 @@
-import { $i as scratchStreaks, Ac as defineStd, Ki as noiseTone, Ml as p, Wi as linearPair, Xi as rawPlane, zo as rampOver } from "./std-ClftfWpF.js";
-import { n as noiseColorPropsAB, r as noiseSpeedProp } from "./noiseColor-D_bPhJ4m.js";
+import { Fc as defineStd, Ll as p, Wo as rampOver, Yi as linearPair, Zi as noiseTone, ia as scratchStreaks, ta as rawPlane } from "./std-DcYKWFSQ.js";
+import { n as noiseColorPropsAB, r as noiseSpeedProp } from "./noiseColor-B6kUgUln.js";
 const componentDefinition = defineStd({
 	name: "Scratches",
 	role: "generator",

package/dist/core/{Sharpness-BGv613Zw.js → Sharpness-0-Tm5xJh.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, An as sharpen, Ml as p, Ss as isZero, ys as crosses } from "./std-ClftfWpF.js";
+import { An as sharpen, Ds as isZero, Fc as defineStd, Ll as p, ws as crosses } from "./std-DcYKWFSQ.js";
 const componentDefinition = defineStd({
 	name: "Sharpness",
 	role: "filter",

package/dist/core/{Shatter-DuyCFU1f.js → Shatter-BWms5ZCO.js}

@@ -1,4 +1,4 @@
-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 { Bd as applyEdgeHandlingExpr, Fc as defineStd, Gd as ZERO, Zd as floatE, _t as crackRefractUV, gt as crackGeom, ht as cellLaneUVFor, ld as toHalfFloat, lf as unpremultiplyAlpha, qd as call, vt as crackShardCompose, yt as voronoiRegionField } from "./std-DcYKWFSQ.js";
 import { s as transformEdges } from "./transformations-P50Uo_Ju.js";
 var seededRandom = (seed) => {
 	const x = Math.sin(seed) * 1e4;

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

@@ -1,5 +1,5 @@
-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";
+import { Bo as noiseField, Fc as defineStd, Gi as evolving, Ll as p, Qo as stops, Wo as rampOver, aa as seededPlane, oa as signedTone } from "./std-DcYKWFSQ.js";
+import { t as noiseColorProps } from "./noiseColor-B6kUgUln.js";
 const componentDefinition = defineStd({
 	name: "SimplexNoise",
 	role: "generator",

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

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, Sr as sineStroke } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, Sr as sineStroke } from "./std-DcYKWFSQ.js";
 import { a as transformColor, c as transformPosition, r as transformAngle } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "SineWave",

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

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, Qn as slicedSlide } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, Qn as slicedSlide } from "./std-DcYKWFSQ.js";
 const componentDefinition = defineStd({
 	name: "SliceWipe",
 	role: "warp",

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

@@ -1,4 +1,4 @@
-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 { $d as vec4, $f as textureStorage2d, Ef as typegpu_default, Fc as defineStd, Gd as ZERO, Yf as vec4f, du as colorStopsPropConfig, ep as arrayOf, f as fluidSim, h as splat, hl as buildFluidOutputKernel, ip as f32, jd as mixColorStopsRuntime, ml as buildEmitterSplatKernel, qd as call, tp as struct, uf as colorMixing_exports, vl as buildStableFluidsKernels } from "./std-DcYKWFSQ.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;

package/dist/core/{SmokeFill-CPnzQtQv.js → SmokeFill-CPPIQi-V.js}

@@ -1,4 +1,4 @@
-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 { $d as vec4, $f as textureStorage2d, Cl as makeShapeMaskSet, Ef as typegpu_default, Fc as defineStd, Gd as ZERO, Hu as resolveShapeType, Ru as sdf3d_exports, Uu as shapeEffectBoundingBoxDeclaration, Xs as clamp, Yf as vec4f, cd as sdf_exports, ep as arrayOf, f as fluidSim, gc as mul, h as splat, hl as buildFluidOutputKernel, ip as f32, ml as buildEmitterSplatKernel, qd as call, tp as struct, uf as colorMixing_exports, vl as buildStableFluidsKernels, wu as glass_exports } from "./std-DcYKWFSQ.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;

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

@@ -1,4 +1,4 @@
-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 { $d as vec4, $f as textureStorage2d, Ef as typegpu_default, Fc as defineStd, Gd as ZERO, Yf as vec4f, d as cursorRibbon, du as colorStopsPropConfig, ep as arrayOf, f as fluidSim, fd as decayFadeSeconds, hl as buildFluidOutputKernel, ip as f32, jd as mixColorStopsRuntime, ml as buildEmitterSplatKernel, qd as call, tp as struct, uf as colorMixing_exports, vl as buildStableFluidsKernels } from "./std-DcYKWFSQ.js";
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var N = 256;
 var COUNT = N * N;

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

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, Ss as isZero, ys as crosses, zt as solarize } from "./std-ClftfWpF.js";
+import { Ds as isZero, Fc as defineStd, Ll as p, ws as crosses, zt as solarize } from "./std-DcYKWFSQ.js";
 const componentDefinition = defineStd({
 	name: "Solarize",
 	role: "filter",

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

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Do as solidColor, Ml as p } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, Mo as solidColor } from "./std-DcYKWFSQ.js";
 import { a as transformColor } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "SolidColor",

package/dist/core/{Sparkle-BZur6gPW.js → Sparkle-DrXTAu56.js}

@@ -1,4 +1,4 @@
-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";
+import { $s as dot, Dc as splat3, Ds as isZero, Fc as defineStd, In as flashes, Jt as brightestNear, Ka as starGlint, Mc as vec3, Nc as vec4, Oc as sqrt, Qs as div, Tc as smoothstep, Vc as animatedTime, Ys as add, _o as scatterPoints, dc as local, gc as mul, hc as mix, jc as vec2, kc as step, mc as min, pc as max, sn as gatherStack, ws as crosses } from "./std-DcYKWFSQ.js";
 var GRID_SCALES = [1, 2 / 3];
 var THRESHOLD_BAND = .12;
 var GLINT = {

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

@@ -1,4 +1,4 @@
-import { $t as crispTap, Ac as defineStd, Ml as p, Mn as sphereFrame, sn as gatherStack, wn as rimLit } from "./std-ClftfWpF.js";
+import { $t as crispTap, Fc as defineStd, Ll as p, Mn as sphereFrame, sn as gatherStack, wn as rimLit } from "./std-DcYKWFSQ.js";
 import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
 var sphere = sphereFrame({
 	center: p("center"),

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

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Io as pair, Ml as p, ko as dist, zo as rampOver } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, Po as dist, Vo as pair, Wo as rampOver } from "./std-DcYKWFSQ.js";
 import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Spiral",

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

@@ -1,4 +1,4 @@
-import { Ac as defineStd, ms as star } from "./std-ClftfWpF.js";
+import { Fc as defineStd, ys as star } from "./std-DcYKWFSQ.js";
 const componentDefinition = defineStd({
 	role: "shape",
 	name: "Star",

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

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Gi as noiseRelief, Zi as reliefBases, c as reliefStylizeProps } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Xi as noiseRelief, c as reliefStylizeProps, na as reliefBases } from "./std-DcYKWFSQ.js";
 const componentDefinition = defineStd({
 	name: "Stone",
 	role: "filter",

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

@@ -1,4 +1,4 @@
-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 { $i as overRgb, Fc as defineStd, Fi as backToP3, Ll as p, du as colorStopsPropConfig, ra as ribbons, sa as tonePow } from "./std-DcYKWFSQ.js";
 import { c as transformPosition, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Strands",

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

@@ -1,4 +1,4 @@
-import { $n as stretch, Ac as defineStd, Ml as p, Nl as centerPropConfig, Pl as edgesPropConfig } from "./std-ClftfWpF.js";
+import { $n as stretch, Fc as defineStd, Ll as p, Rl as centerPropConfig, zl as edgesPropConfig } from "./std-DcYKWFSQ.js";
 const componentDefinition = defineStd({
 	name: "Stretch",
 	role: "warp",

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

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, mo as strokeOver, po as stripeBands } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, vo as stripeBands, yo as strokeOver } from "./std-DcYKWFSQ.js";
 import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Stripes",

package/dist/core/{StudioBackground-BlzYNAsu.js → StudioBackground-SFRLc09j.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Al as uniformOf, Da as glowAt, Dc as vec3, Gs as clamp, Ha as vignetteMask, Ml as p, Oa as glowSpot, Oc as vec4, Sc as splat3, Tc as sub, Wf as vec4f, Ws as add, Ys as exp, Zs as float, bc as smoothstep, cc as max, dc as mul, dr as surfaceOf, fc as neg, oc as local, qs as div, uc as mix, ws as cpuHash01 } from "./std-ClftfWpF.js";
+import { Ac as sub, Dc as splat3, Fc as defineStd, Fl as uniformOf, Ll as p, Ma as glowAt, Mc as vec3, Na as glowSpot, Nc as vec4, Qs as div, Tc as smoothstep, Xs as clamp, Yf as vec4f, Ys as add, _c as neg, dc as local, dr as surfaceOf, ec as exp, gc as mul, hc as mix, ks as cpuHash01, nc as float, pc as max, qa as vignetteMask } from "./std-DcYKWFSQ.js";
 import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
 var TAU = Math.PI * 2;
 const componentDefinition = defineStd({

package/dist/core/{SunBurst-CmWbI18r.js → SunBurst-DjNvFBRl.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ba as softRayLobes, Ma as modulate, Ml as p, Pa as radialFrame, Ua as withFrame, ha as coverageMix, ya as featherMask } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ga as softRayLobes, Ja as withFrame, La as modulate, Ll as p, ba as coverageMix, wa as featherMask, za as radialFrame } from "./std-DcYKWFSQ.js";
 import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "SunBurst",

package/dist/core/{Surface3D-Dmh98-0V.js → Surface3D-Bqk4Yeop.js}

@@ -1,4 +1,4 @@
-import { $c as WAVE_HALFEXTENT, Ac as defineStd, Bd as ZERO, Cs as recompileWhen, Dc as vec3, Gs as clamp, Hd as call, Jc as CURSOR_WAVE_BOUND, Nd as createPingPongPair, Oc as vec4, Qc as WAVE_GRID, Xc as HEIGHT_SLAB_PAD, Yc as HEIGHT_FIELD_STATE_FORMAT, Zc as WAVE_DECAY, al as makeHeightFieldMarchKernel, dc as mul, el as WAVE_SETTLE_MS, fd as isMobileGpuViewport, if as unpremultiplyAlpha, il as heightFieldMarchLayout, mf as DEG_TO_RAD$1, nl as createKernelPass, oc as local, ol as makeWaveEquationKernel, rl as createWaveStateBuffers, sl as waveEquationLayout, tl as createHeightFieldParamsUniform } from "./std-ClftfWpF.js";
+import { $c as CURSOR_WAVE_BOUND, Fc as defineStd, Gd as ZERO, Mc as vec3, Nc as vec4, Os as recompileWhen, Rd as createPingPongPair, Xs as clamp, _d as isMobileGpuViewport, al as WAVE_SETTLE_MS, cl as createWaveStateBuffers, dc as local, dl as makeWaveEquationKernel, el as HEIGHT_FIELD_STATE_FORMAT, fl as waveEquationLayout, gc as mul, il as WAVE_HALFEXTENT, lf as unpremultiplyAlpha, ll as heightFieldMarchLayout, nl as WAVE_DECAY, ol as createHeightFieldParamsUniform, qd as call, rl as WAVE_GRID, sl as createKernelPass, tl as HEIGHT_SLAB_PAD, ul as makeHeightFieldMarchKernel, yf as DEG_TO_RAD$1 } from "./std-DcYKWFSQ.js";
 import { a as transformColor, s as transformEdges } from "./transformations-P50Uo_Ju.js";
 var COMPUTE_MAX = isMobileGpuViewport() ? 960 : 1600;
 var COMPUTE_FALLBACK_W = 1600;

package/dist/core/{Swirl-CzI1qSVc.js → Swirl-CnMHiJHz.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Go as shimmered, Jo as threshold, Lo as pulse, Ml as p, Wo as share, jo as flowField, ou as colorStopsPropConfig, qo as stops, zo as rampOver } from "./std-ClftfWpF.js";
+import { $o as threshold, Fc as defineStd, Ho as pulse, Io as flowField, Ll as p, Qo as stops, Wo as rampOver, Xo as shimmered, Yo as share, du as colorStopsPropConfig } from "./std-DcYKWFSQ.js";
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var swirlPatternField = share(flowField({ detail: p("detail") }));
 const componentDefinition = defineStd({

package/dist/core/{Teardrop-D24uulL0.js → Teardrop-EmqO3Sx3.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, hs as teardrop } from "./std-ClftfWpF.js";
+import { Fc as defineStd, bs as teardrop } from "./std-DcYKWFSQ.js";
 const componentDefinition = defineStd({
 	role: "shape",
 	name: "Teardrop",

package/dist/core/{Text-CrZKvBw6.js → Text-BJsHmsCm.js}

@@ -1,4 +1,4 @@
-import { $f as f32, Ac as defineStd, G as orientedBoxField, Hd as call, Jd as vec4, Ld as sampleCatmullRomExpr, _d as createFontDependentRaster, gd as createCanvasRasterTarget, hd as loadGoogleFont, md as isFontAvailable, vd as createRasterInvalidator, yd as createSwappableMediaTexture } from "./std-ClftfWpF.js";
+import { $d as vec4, Cd as createRasterInvalidator, Fc as defineStd, G as orientedBoxField, Hd as sampleCatmullRomExpr, Sd as createFontDependentRaster, bd as loadGoogleFont, ip as f32, qd as call, wd as createSwappableMediaTexture, xd as createCanvasRasterTarget, yd as isFontAvailable } from "./std-DcYKWFSQ.js";
 import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
 function applyTextTransform(text, mode) {
 	switch (mode) {

package/dist/core/{ThinFilm-D7R2dt1O.js → ThinFilm-D3vXChVM.js}

@@ -1,4 +1,4 @@
-import { $f as f32, Ac as defineStd, Bf as sqrt, Cd as cosinePalette, Cf as select, Df as cos, Ef as clamp, Ff as mix, Hd as call, Hf as vec2f, Kd as floatE, Lf as pow, Mf as fract, Nf as max, Rf as sin, Ru as shapeEffectBoundingBoxDeclaration, Uf as vec3f, Wf as vec4f, bu as offsetUV, cf as mixColorsVariants, hi as shapedSurface, jf as floor, np as __export, qd as mixExpr, sf as mixColorsLinear, vu as glassGradient, xf as typegpu_default, xu as sdfSpaceUV } from "./std-ClftfWpF.js";
+import { Bf as mix, Cu as glassGradient, Ef as typegpu_default, Eu as sdfSpaceUV, Fc as defineStd, Gf as sqrt, Hf as pow, If as floor, Jf as vec3f, Lf as fract, Mf as cos, Od as cosinePalette, Of as select, Qd as mixExpr, Rf as max, Tu as offsetUV, Uf as sin, Uu as shapeEffectBoundingBoxDeclaration, Yf as vec4f, Zd as floatE, ff as mixColorsLinear, gi as shapedSurface, ip as f32, jf as clamp, pf as mixColorsVariants, qd as call, qf as vec2f, sp as __export } from "./std-DcYKWFSQ.js";
 import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var thinFilm_exports = /* @__PURE__ */ __export({
 	applyThinFilmEffect: () => applyThinFilmEffect$1,

package/dist/core/{TiltShift-AMMDZBvf.js → TiltShift-Domqy4zc.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, Pn as tiltShift } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, Pn as tiltShift, ws as crosses } from "./std-DcYKWFSQ.js";
 import { c as transformPosition, r as transformAngle } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "TiltShift",
@@ -71,6 +71,31 @@ const componentDefinition = defineStd({
 				label: "Center",
 				group: "Position"
 			}
+		},
+		dispersion: {
+			default: 0,
+			description: "Blurs red and blue by different amounts for a lens-like color fringe outside the focus band; negative swaps the colors",
+			recompile: crosses(0),
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Dispersion",
+				group: "Lens"
+			}
+		},
+		jitter: {
+			default: 0,
+			description: "Per-pixel noise on the tap spacing that hides banding at large blur radii",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Jitter",
+				group: "Lens"
+			}
 		}
 	},
 	...tiltShift({
@@ -78,7 +103,11 @@ const componentDefinition = defineStd({
 		width: p("width"),
 		falloff: p("falloff"),
 		angle: p("angle"),
-		center: p("center")
+		center: p("center"),
+		detail: {
+			dispersion: p("dispersion"),
+			jitter: p("jitter")
+		}
 	})
 });
 var TiltShift_default = componentDefinition;