shaders 4.0.1 → 4.0.3

package/dist/core/{PixelThrow-DCJb9Lxd.js → PixelThrow-MoKF4eJQ.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Bd as ZERO, Dc as vec3, Fd as applyEdgeHandlingExpr, Gs as clamp, Hd as call, Id as bSplineTapSetup, Js as dot, Tc as sub, dc as mul, id as toHalfFloat, if as unpremultiplyAlpha, nt as hostGridProgram, oc as local, rt as hostStep, tt as hostFieldTexture, uc as mix } from "./std-ClftfWpF.js";
+import { $s as dot, Ac as sub, Bd as applyEdgeHandlingExpr, Fc as defineStd, Gd as ZERO, Mc as vec3, Vd as bSplineTapSetup, Xs as clamp, dc as local, gc as mul, hc as mix, ld as toHalfFloat, lf as unpremultiplyAlpha, nt as hostGridProgram, qd as call, rt as hostStep, tt as hostFieldTexture } from "./std-ebybEx3c.js";
 import { s as transformEdges } from "./transformations-P50Uo_Ju.js";
 var transformThrowKey = (value) => {
 	return {

package/dist/core/{Pixelate-CZdwB--K.js → Pixelate-Dt3Dvyye.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, vn as pixelate } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, vn as pixelate } from "./std-ebybEx3c.js";
 const componentDefinition = defineStd({
 	name: "Pixelate",
 	role: "filter",

package/dist/core/{Plasma-CTOQJeqy.js → Plasma-BHPsAkrx.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Fo as noiseField, Ml as p, Qo as warped, Vo as scaledVolume, Xo as tone, ou as colorStopsPropConfig, qo as stops, zo as rampOver } from "./std-ClftfWpF.js";
+import { Bo as noiseField, Fc as defineStd, Ko as scaledVolume, Ll as p, Qo as stops, Wo as rampOver, du as colorStopsPropConfig, rs as warped, ts as tone } from "./std-ebybEx3c.js";
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Plasma",

package/dist/core/{Plastic-DvyH9x-4.js → Plastic-8Al38_Uo.js}

@@ -1,4 +1,4 @@
-import { $r as keyLightAt, Ac as defineStd, Bd as ZERO, Cc as sqrt, Ci as surfaceNoiseAt, Dc as vec3, Ec as vec2, Ed as mixColorStopsRuntime, Gs as clamp, Hd as call, Hr as fieldSlope, Ic as animatedTime, Js as dot, Oc as vec4, Ru as shapeEffectBoundingBoxDeclaration, Sc as splat3, Si as surfaceNoise, Tc as sub, Us as abs, Ws as add, Xs as exp2, Yr as guarded, Zr as insideShape, ar as direction, bc as smoothstep, cc as max, cf as mixColorsVariants, dc as mul, hc as reflect, hi as shapedSurface, mc as pow, oc as local, ou as colorStopsPropConfig, pc as normalize, qr as grazingFlat, qs as div, ri as marchedNormal, sf as mixColorsLinear, si as nudgeNormal, uc as mix, vi as silhouette, wi as surfacePattern, xi as surfaceField } from "./std-ClftfWpF.js";
+import { $s as dot, Ac as sub, Ci as surfaceField, Dc as splat3, Ei as surfacePattern, Fc as defineStd, Gd as ZERO, Jr as grazingFlat, Js as abs, Mc as vec3, Nc as vec4, Oc as sqrt, Qr as insideShape, Qs as div, Tc as smoothstep, Ti as surfaceNoiseAt, Ur as fieldSlope, Uu as shapeEffectBoundingBoxDeclaration, Vc as animatedTime, Xr as guarded, Xs as clamp, Ys as add, ar as direction, bc as reflect, bi as silhouette, ci as nudgeNormal, dc as local, du as colorStopsPropConfig, ei as keyLightAt, ff as mixColorsLinear, gc as mul, gi as shapedSurface, hc as mix, ii as marchedNormal, jc as vec2, jd as mixColorStopsRuntime, pc as max, pf as mixColorsVariants, qd as call, tc as exp2, vc as normalize, wi as surfaceNoise, yc as pow } from "./std-ebybEx3c.js";
 import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	type: "sphere3D",

package/dist/core/{PolarCoordinates-XhdDAOD0.js → PolarCoordinates-BuiRt8Ae.js}

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

package/dist/core/{Polygon-CLohB-Ly.js → Polygon-CElChfL_.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, rs as circle, uc as mix, us as polygon } from "./std-ClftfWpF.js";
+import { Fc as defineStd, cs as circle, hc as mix, hs as polygon } from "./std-ebybEx3c.js";
 const componentDefinition = defineStd({
 	role: "shape",
 	name: "Polygon",

package/dist/core/{Posterize-BAQfnvmK.js → Posterize-CkX1ySem.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Lt as posterize, Ml as p } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, Lt as posterize } from "./std-ebybEx3c.js";
 const componentDefinition = defineStd({
 	name: "Posterize",
 	role: "filter",

package/dist/core/{Prism-DJVCVAXX.js → Prism-B_8r_ACa.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Al as uniformOf, Gs as clamp, Ic as animatedTime, Ml as p, No as hueWheel, Oc as vec4, Sc as splat3, Tc as sub, Ws as add, Ys as exp, bc as smoothstep, cc as max, dc as mul, dr as surfaceOf, ec as gaussBell, fc as neg, oc as local, qs as div, uc as mix, ur as segmentFrame, xc as softPlus } from "./std-ClftfWpF.js";
+import { Ac as sub, Dc as splat3, Ec as softPlus, Fc as defineStd, Fl as uniformOf, Ll as p, Nc as vec4, Qs as div, Ro as hueWheel, Tc as smoothstep, Vc as animatedTime, Xs as clamp, Ys as add, _c as neg, ac as gaussBell, dc as local, dr as surfaceOf, ec as exp, gc as mul, hc as mix, pc as max, ur as segmentFrame } from "./std-ebybEx3c.js";
 import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Prism",

package/dist/core/{ProgressiveBlur-Dirva1on.js → ProgressiveBlur-BY9XCK4l.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, bn as progressiveBlur } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, bn as progressiveBlur } from "./std-ebybEx3c.js";
 import { c as transformPosition, r as transformAngle } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "ProgressiveBlur",

package/dist/core/{RadialGradient-DuSKR8Ds.js → RadialGradient-D4ELylxQ.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Bo as rings, Ml as p, ko as dist, ou as colorStopsPropConfig, qo as stops, zo as rampOver } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Go as rings, Ll as p, Po as dist, Qo as stops, Wo as rampOver, du as colorStopsPropConfig } from "./std-ebybEx3c.js";
 import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "RadialGradient",

package/dist/core/{RadialWipe-n8tON7x2.js → RadialWipe-DNvkJb42.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, X as reveal, Y as coverage } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, X as reveal, Y as coverage } from "./std-ebybEx3c.js";
 import { c as transformPosition, i as transformBoolean } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "RadialWipe",

package/dist/core/{RandomBars-BYouiIgQ.js → RandomBars-5D9oIVCD.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, X as reveal, Y as coverage } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, X as reveal, Y as coverage } from "./std-ebybEx3c.js";
 import { i as transformBoolean } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "RandomBars",

package/dist/core/{ReactionDiffusion-CHDd3y2q.js → ReactionDiffusion-BGmksqeC.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Bc as buildGrayScottStep, Bd as ZERO, Dc as vec3, Ec as vec2, Gc as createGridKernelPass, Gs as clamp, Hd as call, Hf as vec2f, Js as dot, Ks as cos, Nd as createPingPongPair, Oc as vec4, Pd as createStateBuffer, Sc as splat3, Tc as sub, Uc as buildPairPublishKernel, Wc as buildScatterSeedKernel, Ws as add, af as colorMixing_exports, bc as smoothstep, cc as max, dc as mul, et as gridSim, fc as neg, it as op, lc as min, mc as pow, mf as DEG_TO_RAD, nc as gt, oc as local, od as createPointerVelocityTracker, pc as normalize, qs as div, uc as mix, ud as createLateBoundChildInput, vc as select, yc as sin } from "./std-ClftfWpF.js";
+import { $s as dot, Ac as sub, Cc as select, Dc as splat3, Fc as defineStd, Gc as buildGrayScottStep, Gd as ZERO, Jc as buildPairPublishKernel, Mc as vec3, Nc as vec4, Qs as div, Rd as createPingPongPair, Tc as smoothstep, Xc as createGridKernelPass, Xs as clamp, Yc as buildScatterSeedKernel, Ys as add, Zs as cos, _c as neg, dc as local, dd as createPointerVelocityTracker, et as gridSim, gc as mul, hc as mix, hd as createLateBoundChildInput, it as op, jc as vec2, mc as min, pc as max, qd as call, qf as vec2f, sc as gt, uf as colorMixing_exports, vc as normalize, wc as sin, yc as pow, yf as DEG_TO_RAD, zd as createStateBuffer } from "./std-ebybEx3c.js";
 import { a as transformColor, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var cm = colorMixing_exports;
 var N = 512;

package/dist/core/{RectangularCoordinates-CYFfCawa.js → RectangularCoordinates-0l5t-2No.js}

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

package/dist/core/{ReflectivePlane-DFTl5U9q.js → ReflectivePlane-BqefdbHK.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Bd as ZERO, Hd as call, Ml as p, dn as mirrorAcrossRow, if as unpremultiplyAlpha, nn as depthRampBlur, yn as planarReflection } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Gd as ZERO, Ll as p, dn as mirrorAcrossRow, lf as unpremultiplyAlpha, nn as depthRampBlur, qd as call, yn as planarReflection } from "./std-ebybEx3c.js";
 import { s as transformEdges } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "ReflectivePlane",

package/dist/core/{Repeater-CnbzXuAe.js → Repeater-CJj0PHTv.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, dt as grid, ft as line, mt as repeatInstances, pt as radial, ut as byMode, ys as crosses } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, dt as grid, ft as line, mt as repeatInstances, pt as radial, ut as byMode, ws as crosses } from "./std-ebybEx3c.js";
 import { i as transformBoolean } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Repeater",

package/dist/core/{Ring-CGkHVSVd.js → Ring-Czf6zylA.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, ds as ring } from "./std-ClftfWpF.js";
+import { Fc as defineStd, gs as ring } from "./std-ebybEx3c.js";
 const componentDefinition = defineStd({
 	role: "shape",
 	name: "Ring",

package/dist/core/{RippleWipe-DLjPzY6u.js → RippleWipe-gk_KAy9N.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, X as reveal, Y as coverage } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, X as reveal, Y as coverage } from "./std-ebybEx3c.js";
 import { c as transformPosition, i as transformBoolean } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "RippleWipe",

package/dist/core/{Ripples-C2tITU62.js → Ripples-DSmJplDh.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, Ml as p, mo as strokeOver, uo as ringWaves } from "./std-ClftfWpF.js";
+import { Fc as defineStd, Ll as p, ho as ringWaves, yo as strokeOver } from "./std-ebybEx3c.js";
 import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Ripples",

package/dist/core/{RoundedRect-sfNTUaCY.js → RoundedRect-DCFq3bhP.js}

@@ -1,4 +1,4 @@
-import { Ac as defineStd, fs as roundedRect } from "./std-ClftfWpF.js";
+import { Fc as defineStd, _s as roundedRect } from "./std-ebybEx3c.js";
 const componentDefinition = defineStd({
 	role: "shape",
 	name: "RoundedRect",

package/dist/core/Satin-BEbTbcTD.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-ebybEx3c.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-D0hjM6vJ.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-ebybEx3c.js";
 const componentDefinition = defineStd({
 	name: "Saturation",
 	role: "filter",

package/dist/core/{Scratches-D87O5C2K.js → Scratches-CBbSvaL9.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-ebybEx3c.js";
+import { n as noiseColorPropsAB, r as noiseSpeedProp } from "./noiseColor-oUufQir9.js";
 const componentDefinition = defineStd({
 	name: "Scratches",
 	role: "generator",

package/dist/core/{Sharpness-BGv613Zw.js → Sharpness-CxNkUCd4.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-ebybEx3c.js";
 const componentDefinition = defineStd({
 	name: "Sharpness",
 	role: "filter",

package/dist/core/{Shatter-DuyCFU1f.js → Shatter-OGsXkOO8.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-ebybEx3c.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-EZ9qyUZl.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-ebybEx3c.js";
+import { t as noiseColorProps } from "./noiseColor-oUufQir9.js";
 const componentDefinition = defineStd({
 	name: "SimplexNoise",
 	role: "generator",

package/dist/core/{SineWave-BfOgSGMP.js → SineWave-jv-D2nek.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-ebybEx3c.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-CyQ8KwJe.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-ebybEx3c.js";
 const componentDefinition = defineStd({
 	name: "SliceWipe",
 	role: "warp",

package/dist/core/{Smoke-BDQYKRP1.js → Smoke-D5t3guA6.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-ebybEx3c.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-DDqH7q9k.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-ebybEx3c.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-dqFWC3nR.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-ebybEx3c.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-DQKm8tad.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-ebybEx3c.js";
 const componentDefinition = defineStd({
 	name: "Solarize",
 	role: "filter",

package/dist/core/{SolidColor-DEKpgy1c.js → SolidColor-AuMQ8wsV.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-ebybEx3c.js";
 import { a as transformColor } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "SolidColor",