stickyflow 0.7.0 → 0.9.0

package/dist/{chunk-MUKIGLR5.js → chunk-ZCGZJBAT.js}

@@ -1,6 +1,6 @@
-import { render } from './chunk-SDMQRSRW.js';
-import { parseContractVersion, isContractCompatible, Emitter, resolveOwner, CHANGE_COLOR, findOwnerNode, isPrimary, linkSelectionOverlay, pathSelectionOverlay, isometricSelectionOverlay, shapeSelectionOverlay, DERIVED_HEIGHT_ROLES, quickDuplicateBubbles, isCameraGesture, linkChangeOverlay, shapeChangeOverlay, startChangeFade, REDUCED_MOTION_DURATION_MS, FLASH_DURATION_MS } from './chunk-ZNHYW47T.js';
-import { getComponentDescriptor, formatRollingNumber, DEFAULT_ROLLING_NUMBER_STYLE } from './chunk-JQK4IGXJ.js';
+import { render } from './chunk-FS6L462E.js';
+import { parseContractVersion, isContractCompatible, Emitter, resolveOwner, CHANGE_COLOR, findOwnerNode, isPrimary, linkSelectionOverlay, pathSelectionOverlay, isometricSelectionOverlay, shapeSelectionOverlay, DERIVED_HEIGHT_ROLES, quickDuplicateBubbles, isCameraGesture, linkChangeOverlay, shapeChangeOverlay, startChangeFade, REDUCED_MOTION_DURATION_MS, FLASH_DURATION_MS } from './chunk-CM35H45Z.js';
+import { getComponentDescriptor, formatRollingNumber, DEFAULT_ROLLING_NUMBER_STYLE } from './chunk-D2266VBZ.js';
 
 // src/runtime/viewer/components/rollingNumberDom.ts
 var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
@@ -1655,10 +1655,191 @@ var emberSlitsProgram = {
   fragmentSource: fragmentSource6
 };
 
-// src/runtime/viewer/shaders/builtins/glassRefraction.ts
+// src/runtime/viewer/shaders/builtins/glassDots.ts
 var fragmentSource7 = `
 precision highp float;
 
+uniform vec2 uResolution;
+uniform float uTime;
+uniform float uSpeed;
+uniform float uIntensity;
+uniform float uDots;
+uniform float uDotSize;
+uniform float uStagger;
+uniform float uSphere;
+uniform float uAngle;
+uniform float uSpread;
+uniform float uWarp;
+uniform float uGlow;
+uniform float uRound;
+uniform float uScatter;
+uniform float uLens;
+uniform float uGrain;
+uniform vec3 uBaseColor;
+uniform vec3 uColorA;
+uniform vec3 uColorB;
+uniform vec3 uColorC;
+uniform vec3 uColorD;
+uniform vec3 uRimColor;
+varying vec2 vUv;
+
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+
+float noise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hash(i), hash(i + vec2(1.0, 0.0)), u.x), mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), u.x), u.y);
+}
+
+float fbm(vec2 p) {
+  return 0.5 * noise(p) + 0.25 * noise(p * 2.03 + 3.1) + 0.125 * noise(p * 4.01 + 7.7);
+}
+
+vec2 turn(vec2 point, float angle) {
+  float c = cos(angle);
+  float s = sin(angle);
+  return vec2(c * point.x - s * point.y, s * point.x + c * point.y);
+}
+
+// How far the grid is stretched at a distance r from the middle; with sphere the dots follow the surface of a ball.
+float stretch(float r, float sphere) {
+  float rr = clamp(r, 0.0001, 0.9999);
+  return mix(1.0, asin(rr) / rr, sphere);
+}
+
+// The color under the dots: an uneven cloud of color whose edge bleeds out into the dark, with a red glow around it.
+// body is how much of the cloud is there, from 1 inside to 0 far outside.
+vec3 field(vec2 q, float angle, float t, out float body, out float distance) {
+  vec2 p = turn(q, -angle);
+  vec2 bend = vec2(fbm(p * 2.2 + vec2(t * 0.3, 1.7)), fbm(p * 2.2 + vec2(8.3, -t * 0.25))) - 0.35;
+  vec2 w = p + bend * max(uWarp, 0.0) * 0.4;
+  float rr = length(w) / max(uSpread, 0.2);
+  distance = rr;
+  body = 1.0 - smoothstep(0.78, 1.22, rr);
+
+  vec3 c = uColorB;
+  c = mix(c, uColorA, smoothstep(-0.1, 0.95, dot(w, normalize(vec2(-0.6, 0.7)))) * 0.95);
+  c = mix(c, uColorC, smoothstep(-0.05, 0.6, dot(w, normalize(vec2(0.7, -0.45)))) * 0.9);
+  c = mix(c, uColorD, smoothstep(0.18, 0.85, dot(w, normalize(vec2(0.85, -0.55)))) * 0.97);
+  float ring = smoothstep(0.8, 1.05, rr) * max(uGlow, 0.0);
+  c = mix(c, uRimColor, clamp(ring, 0.0, 1.0));
+  return mix(uBaseColor, c, body);
+}
+
+void main() {
+  float side = min(uResolution.x, uResolution.y);
+  vec2 q = (vUv * uResolution - uResolution * 0.5) / (side * 0.5);
+  float r = length(q);
+  // On a circle the picture ends at its edge; on a rectangle the dots run on over the whole surface and may lie beyond the cloud.
+  float edge = uRound > 0.5 ? 1.0 - smoothstep(0.985, 1.0, r) : 1.0;
+  if (edge <= 0.0) discard;
+
+  float t = uTime * max(uSpeed, 0.0);
+  float angle = radians(uAngle);
+  float cells = max(uDots, 2.0) * 0.5;
+  vec2 g = q * stretch(r, uSphere) * cells;
+
+  // The dot that is nearest wins, so dots that lie close cut each other along a straight line.
+  float stagger = clamp(uStagger, 0.0, 1.0);
+  vec2 cell = floor(g);
+  float best = 1e9;
+  vec2 centre = vec2(0.0);
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vec2 c = cell + vec2(float(i), float(j));
+      float shift = stagger * 0.5 * mod(c.y, 2.0);
+      vec2 mid = vec2(c.x + 0.5 + shift, c.y + 0.5);
+      float d = length(g - mid);
+      if (d < best) {
+        best = d;
+        centre = mid;
+      }
+    }
+  }
+
+  // Where the middle of that dot lies on the screen, found by running the stretch backwards.
+  vec2 gc = centre / cells;
+  float gl = length(gc);
+  float rc = gl;
+  for (int k = 0; k < 5; k++) {
+    rc = gl / stretch(rc, uSphere);
+  }
+  rc = clamp(rc, 0.0, 1.0);
+  vec2 qc = gl > 0.0001 ? gc / gl * rc : vec2(0.0);
+
+  float radius = clamp(uDotSize, 0.2, 0.9);
+  float aa = 1.6 / side * cells * 2.0;
+  float inside = 1.0 - smoothstep(radius - aa, radius + aa, best);
+
+  float bodyHere;
+  float bodyDot;
+  float farHere;
+  float farDot;
+  vec3 colorHere = field(q, angle, t, bodyHere, farHere);
+  field(qc, angle, t, bodyDot, farDot);
+
+  // Between the dots the cloud is darker, so the dots read as glass lying on it.
+  vec3 gap = colorHere * mix(0.3, 0.9, bodyHere);
+
+  // Every dot is a lens with a gradient of its own: lighter on the side that faces the middle, dark on the side that faces out.
+  // The darker side grows toward the edge of the cloud, until the dots there are nearly black.
+  vec2 e = (g - centre) / max(radius, 0.001);
+  vec2 outward = length(qc) > 0.0001 ? normalize(qc) : vec2(0.0, 1.0);
+  vec2 outwardGrid = outward;
+  float along = clamp(dot(e, outwardGrid), -1.0, 1.0);
+  float edgeness = 1.0 - smoothstep(0.1, 0.9, bodyDot);
+  float lens = clamp(uLens, 0.0, 1.5);
+  float darken = lens * (0.1 + 0.9 * edgeness) * smoothstep(-0.55, 1.0, along);
+  float lift = lens * 0.09 * (1.0 - edgeness) * (-along);
+  vec3 glass = colorHere * (1.0 + lift) * (1.0 - clamp(darken, 0.0, 0.96));
+
+  // A dot beyond the cloud is drawn in the dark glow color when the dice fall that way, more of them close to the cloud than far from it.
+  float luck = hash(centre + 17.0);
+  float shown = step(luck, clamp(uScatter, 0.0, 1.0) * (1.0 - smoothstep(1.0, 2.0, farDot))) * (1.0 - bodyDot);
+  vec3 outer = mix(uRimColor, mix(uColorD, uColorC, hash(centre + 5.0)), 0.35 * hash(centre + 9.0)) * (0.25 + 0.4 * hash(centre + 3.0));
+  outer *= 1.0 - 0.8 * smoothstep(-0.55, 1.0, along);
+  glass = mix(glass, outer, shown);
+
+  vec3 color = mix(gap, glass, inside);
+  color *= max(uIntensity, 0.0);
+  color += (hash(gl_FragCoord.xy + t) - 0.5) * max(uGrain, 0.0);
+  gl_FragColor = vec4(clamp(color, 0.0, 1.0), edge);
+}
+`;
+var glassDotsProgram = {
+  name: "glassDots",
+  fragmentSource: fragmentSource7,
+  defaultParameters: {
+    speed: 0,
+    intensity: 1,
+    dots: 13,
+    dotSize: 0.5,
+    stagger: 0,
+    sphere: 0,
+    angle: 0,
+    spread: 0.86,
+    warp: 1,
+    glow: 0.75,
+    round: 0,
+    scatter: 0.45,
+    lens: 0.75,
+    grain: 0.06,
+    baseColor: "#121212",
+    colorA: "#f4b49c",
+    colorB: "#4a9c93",
+    colorC: "#34559c",
+    colorD: "#ec3f93",
+    rimColor: "#d93a24"
+  }
+};
+
+// src/runtime/viewer/shaders/builtins/glassRefraction.ts
+var fragmentSource8 = `
+precision highp float;
+
 uniform sampler2D uBackdrop;
 uniform vec2 uBackdropOrigin;
 uniform vec2 uBackdropScale;
@@ -1761,12 +1942,138 @@ void main() {
 `;
 var glassRefractionProgram = {
   name: "glassRefraction",
-  fragmentSource: fragmentSource7,
+  fragmentSource: fragmentSource8,
   usesBackdrop: true
 };
 
+// src/runtime/viewer/shaders/builtins/glowCard.ts
+var fragmentSource9 = `
+precision highp float;
+
+uniform vec2 uResolution;
+uniform float uTime;
+uniform float uSpeed;
+uniform float uIntensity;
+uniform float uGlowHeight;
+uniform float uGlowSpread;
+uniform float uCore;
+uniform float uRim;
+uniform float uGrain;
+uniform float uWarp;
+uniform float uAngle;
+uniform float uCornerRadius;
+uniform vec3 uBaseColor;
+uniform vec3 uColorA;
+uniform vec3 uColorB;
+uniform vec3 uColorC;
+varying vec2 vUv;
+
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+
+float blob(vec2 p, vec2 center, vec2 size) {
+  vec2 d = (p - center) / size;
+  return exp(-dot(d, d));
+}
+
+float noise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hash(i), hash(i + vec2(1.0, 0.0)), u.x), mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), u.x), u.y);
+}
+
+float fbm(vec2 p) {
+  return 0.5 * noise(p) + 0.25 * noise(p * 2.03 + 3.1) + 0.125 * noise(p * 4.01 + 7.7);
+}
+
+void main() {
+  vec2 size = max(uResolution, vec2(1.0));
+  float radius = uCornerRadius * min(size.x, size.y);
+  vec2 q = abs(vUv * size - size * 0.5) - size * 0.5 + radius;
+  float distance = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - radius;
+  float shape = 1.0 - smoothstep(-1.0, 1.0, distance);
+  if (shape <= 0.0) discard;
+
+  // The light comes from one side. Angle 0 is the bottom edge, and it turns clockwise: 90 is the left, 180 the top, 270 the right.
+  // depth is 0 at the edge the light comes from and 1 at the far side, side runs along that edge.
+  float turn = radians(uAngle);
+  vec2 toward = vec2(-sin(turn), -cos(turn));
+  vec2 across = vec2(-toward.y, toward.x);
+  vec2 offset = (vUv - 0.5) * size;
+  float reachAlong = 0.5 * (abs(toward.x) * size.x + abs(toward.y) * size.y);
+  float reachAcross = 0.5 * (abs(across.x) * size.x + abs(across.y) * size.y);
+  float depth = clamp(0.5 - dot(offset, toward) / (2.0 * reachAlong), 0.0, 1.0);
+  float side = clamp(0.5 + dot(offset, across) / (2.0 * reachAcross), 0.0, 1.0);
+  float aspect = reachAcross / reachAlong;
+
+  float t = uTime * max(uSpeed, 0.0);
+  float height = clamp(uGlowHeight, 0.05, 1.0);
+  float spread = max(uGlowSpread, 0.05);
+  // The body is the base color with a faint lift toward the far side, like glass that catches the light.
+  vec3 color = uBaseColor + vec3(0.035) * smoothstep(0.55, 1.0, 1.0 - depth);
+
+  // Three soft lights sit low in the card and drift slowly; the middle one is the broadest.
+  vec2 p = vec2(side * aspect, depth);
+  // The lights are bent by slow noise, so their edges curl like smoke instead of staying round.
+  vec2 bend = vec2(fbm(p * 2.6 + vec2(t * 0.6, 0.0)), fbm(p * 2.6 + vec2(5.2, -t * 0.5))) - 0.35;
+  p += bend * max(uWarp, 0.0) * 0.45;
+  float wander = 0.05 * sin(t);
+  float a = blob(p, vec2((0.18 + wander) * aspect, 0.0), vec2(0.5 * spread * aspect, 0.42 * height));
+  float b = blob(p, vec2((0.52 - wander) * aspect, -0.04), vec2(0.62 * spread * aspect, 0.5 * height));
+  float c = blob(p, vec2((0.86 + wander * 0.6) * aspect, 0.02), vec2(0.5 * spread * aspect, 0.44 * height));
+  // Each light is thicker in some places than in others, so the colors mix unevenly.
+  float patchy = fbm(p * 4.0 + 11.0);
+  a *= 0.55 + 0.9 * patchy;
+  b *= 0.55 + 0.9 * (1.0 - patchy);
+  c *= 0.55 + 0.9 * fbm(p * 4.0 + 23.0);
+  vec3 glow = uColorA * a + uColorB * b + uColorC * c;
+
+  // A haze reaches higher than the lights, so the color fades out into the body.
+  float haze = smoothstep(height, 0.0, depth);
+  glow += mix(uColorB, uColorA, side) * haze * haze * 0.35;
+  color += glow * max(uIntensity, 0.0);
+
+  // Near the exit edge the lights are so strong that they turn white.
+  float hot = smoothstep(height * 0.38, 0.0, depth) * (a + b + c) * clamp(uCore, 0.0, 1.0);
+  color = mix(color, vec3(0.93, 0.95, 1.0), clamp(hot, 0.0, 1.0));
+
+  // A thin rim along the edge, strongest on the side away from the light.
+  float rim = (1.0 - smoothstep(0.0, 1.6, -distance)) * smoothstep(0.0, 1.0, -distance + 1.0);
+  color += vec3(0.62, 0.66, 0.78) * rim * max(uRim, 0.0) * (0.35 + 0.65 * smoothstep(0.2, 1.0, 1.0 - depth));
+
+  // The grit sits in the lit parts and fades in the dark body, as on film.
+  float lit = clamp(dot(glow, vec3(0.45)) * max(uIntensity, 0.0) + hot, 0.0, 1.0);
+  float grit = hash(gl_FragCoord.xy) - 0.5;
+  grit += 0.5 * (hash(floor(gl_FragCoord.xy * 0.5) + 17.0) - 0.5);
+  color += grit * max(uGrain, 0.0) * (0.3 + 2.2 * lit * (1.0 - 0.5 * lit));
+  gl_FragColor = vec4(clamp(color, 0.0, 1.0), shape);
+}
+`;
+var glowCardProgram = {
+  name: "glowCard",
+  fragmentSource: fragmentSource9,
+  defaultParameters: {
+    speed: 0.12,
+    intensity: 1,
+    glowHeight: 0.55,
+    glowSpread: 1,
+    core: 0.7,
+    rim: 0.55,
+    grain: 0.12,
+    warp: 1,
+    angle: 0,
+    cornerRadius: 0.08,
+    baseColor: "#0b0b12",
+    colorA: "#2f6bff",
+    colorB: "#9d5cff",
+    colorC: "#34d3c4"
+  }
+};
+
 // src/runtime/viewer/shaders/builtins/halftoneHalo.ts
-var fragmentSource8 = `
+var fragmentSource10 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -1845,11 +2152,11 @@ void main() {
 `;
 var halftoneHaloProgram = {
   name: "halftoneHalo",
-  fragmentSource: fragmentSource8
+  fragmentSource: fragmentSource10
 };
 
 // src/runtime/viewer/shaders/builtins/halo.ts
-var fragmentSource9 = `
+var fragmentSource11 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -1924,11 +2231,11 @@ void main() {
 `;
 var haloProgram = {
   name: "halo",
-  fragmentSource: fragmentSource9
+  fragmentSource: fragmentSource11
 };
 
 // src/runtime/viewer/shaders/builtins/ledMatrix.ts
-var fragmentSource10 = `
+var fragmentSource12 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -2044,7 +2351,7 @@ void main() {
 `;
 var ledMatrixProgram = {
   name: "ledMatrix",
-  fragmentSource: fragmentSource10,
+  fragmentSource: fragmentSource12,
   defaultParameters: {
     speed: 0.25,
     intensity: 1,
@@ -2075,7 +2382,7 @@ var ledMatrixProgram = {
 };
 
 // src/runtime/viewer/shaders/builtins/lightBand.ts
-var fragmentSource11 = `
+var fragmentSource13 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -2135,7 +2442,7 @@ void main() {
 `;
 var lightBandProgram = {
   name: "lightBand",
-  fragmentSource: fragmentSource11,
+  fragmentSource: fragmentSource13,
   defaultParameters: {
     speed: 0.3,
     intensity: 1,
@@ -2152,7 +2459,7 @@ var lightBandProgram = {
 };
 
 // src/runtime/viewer/shaders/builtins/lumenPortal.ts
-var fragmentSource12 = `
+var fragmentSource14 = `
 precision highp float;
 
 uniform float uTime;
@@ -2210,11 +2517,11 @@ void main() {
 `;
 var lumenPortalProgram = {
   name: "lumenPortal",
-  fragmentSource: fragmentSource12
+  fragmentSource: fragmentSource14
 };
 
 // src/runtime/viewer/shaders/builtins/lumenPortalLight.ts
-var fragmentSource13 = `
+var fragmentSource15 = `
 precision highp float;
 
 uniform float uTime;
@@ -2273,11 +2580,11 @@ void main() {
 `;
 var lumenPortalLightProgram = {
   name: "lumenPortalLight",
-  fragmentSource: fragmentSource13
+  fragmentSource: fragmentSource15
 };
 
 // src/runtime/viewer/shaders/builtins/orb.ts
-var fragmentSource14 = `
+var fragmentSource16 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -2313,11 +2620,11 @@ void main() {
 `;
 var orbProgram = {
   name: "orb",
-  fragmentSource: fragmentSource14
+  fragmentSource: fragmentSource16
 };
 
 // src/runtime/viewer/shaders/builtins/pixelConstellation.ts
-var fragmentSource15 = `
+var fragmentSource17 = `
 precision highp float;
 
 uniform float uTime;
@@ -2417,11 +2724,11 @@ void main() {
 `;
 var pixelConstellationProgram = {
   name: "pixelConstellation",
-  fragmentSource: fragmentSource15
+  fragmentSource: fragmentSource17
 };
 
 // src/runtime/viewer/shaders/builtins/plasmaGauge.ts
-var fragmentSource16 = `
+var fragmentSource18 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -2523,12 +2830,12 @@ void main() {
 `;
 var plasmaGaugeProgram = {
   name: "plasmaGauge",
-  fragmentSource: fragmentSource16,
+  fragmentSource: fragmentSource18,
   replacesBaseFill: true
 };
 
 // src/runtime/viewer/shaders/builtins/prismSlats.ts
-var fragmentSource17 = `
+var fragmentSource19 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -2603,11 +2910,11 @@ void main() {
 `;
 var prismSlatsProgram = {
   name: "prismSlats",
-  fragmentSource: fragmentSource17
+  fragmentSource: fragmentSource19
 };
 
 // src/runtime/viewer/shaders/builtins/reactivePanel.ts
-var fragmentSource18 = `
+var fragmentSource20 = `
 precision highp float;
 
 uniform float uTime;
@@ -2709,7 +3016,7 @@ void main() {
 `;
 var reactivePanelProgram = {
   name: "reactivePanel",
-  fragmentSource: fragmentSource18,
+  fragmentSource: fragmentSource20,
   defaultParameters: {
     intensity: 0.5,
     speed: 0.18,
@@ -2732,7 +3039,7 @@ var reactivePanelProgram = {
 };
 
 // src/runtime/viewer/shaders/builtins/ruler.ts
-var fragmentSource19 = `
+var fragmentSource21 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -2837,12 +3144,12 @@ void main() {
 `;
 var rulerProgram = {
   name: "ruler",
-  fragmentSource: fragmentSource19,
+  fragmentSource: fragmentSource21,
   replacesBaseFill: true
 };
 
 // src/runtime/viewer/shaders/builtins/silkFolds.ts
-var fragmentSource20 = `
+var fragmentSource22 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -2927,7 +3234,7 @@ void main() {
 `;
 var silkFoldsProgram = {
   name: "silkFolds",
-  fragmentSource: fragmentSource20,
+  fragmentSource: fragmentSource22,
   defaultParameters: {
     speed: 0.2,
     intensity: 1,
@@ -2950,7 +3257,7 @@ var silkFoldsProgram = {
 };
 
 // src/runtime/viewer/shaders/builtins/smearOrb.ts
-var fragmentSource21 = `
+var fragmentSource23 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -3026,12 +3333,12 @@ void main() {
 `;
 var smearOrbProgram = {
   name: "smearOrb",
-  fragmentSource: fragmentSource21,
+  fragmentSource: fragmentSource23,
   replacesBaseFill: true
 };
 
 // src/runtime/viewer/shaders/builtins/tickScale.ts
-var fragmentSource22 = `
+var fragmentSource24 = `
 precision highp float;
 
 uniform vec2 uResolution;
@@ -3090,12 +3397,12 @@ void main() {
 `;
 var tickScaleProgram = {
   name: "tickScale",
-  fragmentSource: fragmentSource22,
+  fragmentSource: fragmentSource24,
   replacesBaseFill: true
 };
 
 // src/runtime/viewer/shaders/builtins/violetGlass.ts
-var fragmentSource23 = `
+var fragmentSource25 = `
 precision highp float;
 
 uniform float uTime;
@@ -3175,11 +3482,11 @@ void main() {
 `;
 var violetGlassProgram = {
   name: "violetGlass",
-  fragmentSource: fragmentSource23
+  fragmentSource: fragmentSource25
 };
 
 // src/runtime/viewer/shaders/builtins/violetGlassLight.ts
-var fragmentSource24 = `
+var fragmentSource26 = `
 precision highp float;
 
 uniform float uTime;
@@ -3249,7 +3556,7 @@ void main() {
 `;
 var violetGlassLightProgram = {
   name: "violetGlassLight",
-  fragmentSource: fragmentSource24
+  fragmentSource: fragmentSource26
 };
 
 // src/runtime/viewer/shaders/programs.ts
@@ -3277,7 +3584,9 @@ var builtins = [
   reactivePanelProgram,
   ledMatrixProgram,
   lightBandProgram,
-  silkFoldsProgram
+  silkFoldsProgram,
+  glowCardProgram,
+  glassDotsProgram
 ];
 var programs = new Map(builtins.map((program) => [program.name, program]));
 function registerShaderProgram(program) {
@@ -3458,9 +3767,9 @@ function compile(gl, type, source) {
   }
   return shader;
 }
-function linkProgram(gl, fragmentSource25) {
+function linkProgram(gl, fragmentSource27) {
   const vertex = compile(gl, gl.VERTEX_SHADER, VERTEX_SOURCE);
-  const fragment = compile(gl, gl.FRAGMENT_SHADER, fragmentSource25);
+  const fragment = compile(gl, gl.FRAGMENT_SHADER, fragmentSource27);
   if (!vertex || !fragment) {
     if (vertex) {
       gl.deleteShader(vertex);
@@ -4404,5 +4713,5 @@ function createViewer(options) {
 }
 
 export { SHADER_DEFAULTS, connectInteraction, createViewer, registerShaderProgram, shaderProgram };
-//# sourceMappingURL=chunk-MUKIGLR5.js.map
-//# sourceMappingURL=chunk-MUKIGLR5.js.map
+//# sourceMappingURL=chunk-ZCGZJBAT.js.map
+//# sourceMappingURL=chunk-ZCGZJBAT.js.map