@genart-dev/components 0.1.0

package/dist/index.js

@@ -0,0 +1,3963 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/components/js/index.ts
+var js_exports = {};
+__export(js_exports, {
+  animation: () => animation_default,
+  boids: () => boids_default,
+  canvasUtils: () => canvas_utils_default,
+  color: () => color_default,
+  colorAdvanced: () => color_advanced_default,
+  curl: () => curl_default,
+  distribution: () => distribution_default,
+  distributionAdvanced: () => distribution_advanced_default,
+  dla: () => dla_default,
+  easing: () => easing_default,
+  flowField: () => flow_field_default,
+  grid: () => grid_default,
+  gridAdvanced: () => grid_advanced_default,
+  lSystem: () => l_system_default,
+  math: () => math_default,
+  mathAdvanced: () => math_advanced_default,
+  matrix: () => matrix_default,
+  noise2d: () => noise_2d_default,
+  noise3d: () => noise_3d_default,
+  noise4d: () => noise_4d_default,
+  particle: () => particle_default,
+  particleForces: () => particle_forces_default,
+  physicsRk4: () => physics_rk4_default,
+  physicsSpring: () => physics_spring_default,
+  physicsVerlet: () => physics_verlet_default,
+  prng: () => prng_default,
+  prngUtils: () => prng_utils_default,
+  quadtree: () => quadtree_default,
+  reactionDiffusion: () => reaction_diffusion_default,
+  shape: () => shape_default,
+  shapeAdvanced: () => shape_advanced_default,
+  spatialHash: () => spatial_hash_default,
+  svgPath: () => svg_path_default,
+  turtle: () => turtle_default,
+  vector: () => vector_default,
+  wave: () => wave_default,
+  worley: () => worley_default
+});
+
+// src/components/js/prng.ts
+var prng = {
+  name: "prng",
+  version: "1.0.0",
+  category: "randomness",
+  target: "js",
+  renderers: [],
+  code: `function mulberry32(a) {
+  return function() {
+    a |= 0; a = a + 0x6D2B79F5 | 0;
+    var t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+function sfc32(a, b, c, d) {
+  return function() {
+    a |= 0; b |= 0; c |= 0; d |= 0;
+    var t = (a + b | 0) + d | 0;
+    d = d + 1 | 0; a = b ^ (b >>> 9);
+    b = c + (c << 3) | 0; c = (c << 21 | c >>> 11);
+    c = c + t | 0;
+    return (t >>> 0) / 4294967296;
+  };
+}
+`,
+  exports: ["mulberry32", "sfc32"],
+  dependencies: [],
+  description: "Seeded pseudo-random number generators (mulberry32, sfc32).",
+  usage: `### prng \u2014 Seeded PRNGs
+
+\`\`\`js
+const rng = mulberry32(state.SEED);
+rng(); // \u2192 0.0\u20131.0
+\`\`\`
+
+- **mulberry32(seed)** \u2014 fast 32-bit PRNG, good for most use cases
+- **sfc32(a, b, c, d)** \u2014 higher quality, 4 seeds, passes PractRand
+`
+};
+var prng_default = prng;
+
+// src/components/js/prng-utils.ts
+var prngUtils = {
+  name: "prng-utils",
+  version: "1.0.0",
+  category: "randomness",
+  target: "js",
+  renderers: [],
+  code: `function randomInt(rng, min, max) {
+  return Math.floor(rng() * (max - min + 1)) + min;
+}
+
+function randomFloat(rng, min, max) {
+  return rng() * (max - min) + min;
+}
+
+function randomGaussian(rng) {
+  var u = 0, v = 0;
+  while (u === 0) u = rng();
+  while (v === 0) v = rng();
+  return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+}
+
+function randomChoice(rng, arr) {
+  return arr[Math.floor(rng() * arr.length)];
+}
+
+function shuffle(rng, arr) {
+  var a = arr.slice();
+  for (var i = a.length - 1; i > 0; i--) {
+    var j = Math.floor(rng() * (i + 1));
+    var tmp = a[i]; a[i] = a[j]; a[j] = tmp;
+  }
+  return a;
+}
+
+function weightedChoice(rng, items, weights) {
+  var total = 0;
+  for (var i = 0; i < weights.length; i++) total += weights[i];
+  var r = rng() * total;
+  for (var i = 0; i < items.length; i++) {
+    r -= weights[i];
+    if (r <= 0) return items[i];
+  }
+  return items[items.length - 1];
+}
+`,
+  exports: ["randomInt", "randomFloat", "randomGaussian", "randomChoice", "shuffle", "weightedChoice"],
+  dependencies: ["prng"],
+  description: "RNG convenience wrappers (randomInt, randomFloat, shuffle, etc.).",
+  usage: `### prng-utils \u2014 RNG Convenience Wrappers
+
+\`\`\`js
+const rng = mulberry32(state.SEED);
+randomInt(rng, 1, 10);       // \u2192 integer in [1, 10]
+randomFloat(rng, -1, 1);     // \u2192 float in [-1, 1)
+randomGaussian(rng);          // \u2192 normally distributed float
+randomChoice(rng, ['a','b']); // \u2192 random element
+shuffle(rng, [1,2,3,4]);     // \u2192 shuffled copy
+\`\`\`
+`
+};
+var prng_utils_default = prngUtils;
+
+// src/components/js/noise-2d.ts
+var noise2d = {
+  name: "noise-2d",
+  version: "1.0.0",
+  category: "noise",
+  target: "js",
+  renderers: [],
+  code: `function perlin2D(rng) {
+  var perm = new Uint8Array(512);
+  for (var i = 0; i < 256; i++) perm[i] = i;
+  for (var i = 255; i > 0; i--) {
+    var j = Math.floor(rng() * (i + 1));
+    var tmp = perm[i]; perm[i] = perm[j]; perm[j] = tmp;
+  }
+  for (var i = 0; i < 256; i++) perm[256 + i] = perm[i];
+  function fade(t) { return t * t * t * (t * (t * 6 - 15) + 10); }
+  function grad(hash, x, y) {
+    var h = hash & 3;
+    return ((h & 1) ? -x : x) + ((h & 2) ? -y : y);
+  }
+  return function(x, y) {
+    var xi = Math.floor(x) & 255, yi = Math.floor(y) & 255;
+    var xf = x - Math.floor(x), yf = y - Math.floor(y);
+    var u = fade(xf), v = fade(yf);
+    var a0 = perm[xi] + yi, a1 = perm[xi + 1] + yi;
+    var aa = grad(perm[a0], xf, yf), ba = grad(perm[a1], xf - 1, yf);
+    var ab = grad(perm[a0 + 1], xf, yf - 1), bb = grad(perm[a1 + 1], xf - 1, yf - 1);
+    var x1 = aa + u * (ba - aa), x2 = ab + u * (bb - ab);
+    return (x1 + v * (x2 - x1) + 1) / 2;
+  };
+}
+
+function simplex2D(rng) {
+  var perm = new Uint8Array(512);
+  for (var i = 0; i < 256; i++) perm[i] = i;
+  for (var i = 255; i > 0; i--) {
+    var j = Math.floor(rng() * (i + 1));
+    var tmp = perm[i]; perm[i] = perm[j]; perm[j] = tmp;
+  }
+  for (var i = 0; i < 256; i++) perm[256 + i] = perm[i];
+  var grad2 = [[1,1],[-1,1],[1,-1],[-1,-1],[1,0],[-1,0],[0,1],[0,-1]];
+  var F2 = 0.5 * (Math.sqrt(3) - 1), G2 = (3 - Math.sqrt(3)) / 6;
+  return function(x, y) {
+    var s = (x + y) * F2;
+    var i = Math.floor(x + s), j = Math.floor(y + s);
+    var t = (i + j) * G2;
+    var x0 = x - (i - t), y0 = y - (j - t);
+    var i1 = x0 > y0 ? 1 : 0, j1 = x0 > y0 ? 0 : 1;
+    var x1 = x0 - i1 + G2, y1 = y0 - j1 + G2;
+    var x2 = x0 - 1 + 2 * G2, y2 = y0 - 1 + 2 * G2;
+    var ii = i & 255, jj = j & 255;
+    function contrib(gx, gy, px, py) {
+      var t2 = 0.5 - px * px - py * py;
+      if (t2 < 0) return 0;
+      t2 *= t2;
+      return t2 * t2 * (gx * px + gy * py);
+    }
+    var g0 = grad2[perm[ii + perm[jj]] & 7];
+    var g1 = grad2[perm[ii + i1 + perm[jj + j1]] & 7];
+    var g2 = grad2[perm[ii + 1 + perm[jj + 1]] & 7];
+    return 0.5 + 35 * (contrib(g0[0], g0[1], x0, y0) + contrib(g1[0], g1[1], x1, y1) + contrib(g2[0], g2[1], x2, y2));
+  };
+}
+
+function valueNoise2D(rng) {
+  var values = new Float64Array(256);
+  for (var i = 0; i < 256; i++) values[i] = rng();
+  function hash(x, y) {
+    return values[((x * 374761393 + y * 668265263) & 0x7fffffff) % 256];
+  }
+  return function(x, y) {
+    var ix = Math.floor(x), iy = Math.floor(y);
+    var fx = x - ix, fy = y - iy;
+    fx = fx * fx * (3 - 2 * fx);
+    fy = fy * fy * (3 - 2 * fy);
+    var a = hash(ix, iy), b = hash(ix + 1, iy);
+    var c = hash(ix, iy + 1), d = hash(ix + 1, iy + 1);
+    return a + fx * (b - a) + fy * (c - a) + fx * fy * (a - b - c + d);
+  };
+}
+
+function fbm2D(noiseFn, octaves, lacunarity, gain) {
+  octaves = octaves || 6; lacunarity = lacunarity || 2; gain = gain || 0.5;
+  return function(x, y) {
+    var val = 0, amp = 1, freq = 1, mx = 0;
+    for (var o = 0; o < octaves; o++) {
+      val += amp * noiseFn(x * freq, y * freq);
+      mx += amp;
+      amp *= gain;
+      freq *= lacunarity;
+    }
+    return val / mx;
+  };
+}
+`,
+  exports: ["perlin2D", "simplex2D", "valueNoise2D", "fbm2D"],
+  dependencies: ["prng"],
+  description: "2D noise functions (Perlin, simplex, value) and fBm.",
+  usage: `### noise-2d \u2014 2D Noise Functions
+
+\`\`\`js
+var rng = mulberry32(state.SEED);
+var noise = perlin2D(rng);
+noise(x * 0.01, y * 0.01); // \u2192 0.0\u20131.0
+
+var fbm = fbm2D(noise, 6, 2, 0.5);
+fbm(x * 0.01, y * 0.01);   // \u2192 fractal noise
+\`\`\`
+`
+};
+var noise_2d_default = noise2d;
+
+// src/components/js/noise-3d.ts
+var noise3d = {
+  name: "noise-3d",
+  version: "1.0.0",
+  category: "noise",
+  target: "js",
+  renderers: [],
+  code: `function perlin3D(rng) {
+  var perm = new Uint8Array(512);
+  for (var i = 0; i < 256; i++) perm[i] = i;
+  for (var i = 255; i > 0; i--) {
+    var j = Math.floor(rng() * (i + 1));
+    var tmp = perm[i]; perm[i] = perm[j]; perm[j] = tmp;
+  }
+  for (var i = 0; i < 256; i++) perm[256 + i] = perm[i];
+  function fade(t) { return t * t * t * (t * (t * 6 - 15) + 10); }
+  function grad(hash, x, y, z) {
+    var h = hash & 15;
+    var u = h < 8 ? x : y;
+    var v = h < 4 ? y : (h === 12 || h === 14 ? x : z);
+    return ((h & 1) ? -u : u) + ((h & 2) ? -v : v);
+  }
+  return function(x, y, z) {
+    var xi = Math.floor(x) & 255, yi = Math.floor(y) & 255, zi = Math.floor(z) & 255;
+    var xf = x - Math.floor(x), yf = y - Math.floor(y), zf = z - Math.floor(z);
+    var u = fade(xf), v = fade(yf), w = fade(zf);
+    var a = perm[xi]+yi, aa = perm[a]+zi, ab = perm[a+1]+zi;
+    var b = perm[xi+1]+yi, ba = perm[b]+zi, bb = perm[b+1]+zi;
+    return (
+      lerp(
+        lerp(lerp(grad(perm[aa],xf,yf,zf), grad(perm[ba],xf-1,yf,zf),u),
+             lerp(grad(perm[ab],xf,yf-1,zf), grad(perm[bb],xf-1,yf-1,zf),u),v),
+        lerp(lerp(grad(perm[aa+1],xf,yf,zf-1), grad(perm[ba+1],xf-1,yf,zf-1),u),
+             lerp(grad(perm[ab+1],xf,yf-1,zf-1), grad(perm[bb+1],xf-1,yf-1,zf-1),u),v),
+        w) + 1) / 2;
+  };
+  function lerp(a, b, t) { return a + t * (b - a); }
+}
+
+function simplex3D(rng) {
+  var perm = new Uint8Array(512);
+  for (var i = 0; i < 256; i++) perm[i] = i;
+  for (var i = 255; i > 0; i--) {
+    var j = Math.floor(rng() * (i + 1));
+    var tmp = perm[i]; perm[i] = perm[j]; perm[j] = tmp;
+  }
+  for (var i = 0; i < 256; i++) perm[256 + i] = perm[i];
+  var grad3 = [[1,1,0],[-1,1,0],[1,-1,0],[-1,-1,0],[1,0,1],[-1,0,1],[1,0,-1],[-1,0,-1],[0,1,1],[0,-1,1],[0,1,-1],[0,-1,-1]];
+  var F3 = 1/3, G3 = 1/6;
+  return function(x, y, z) {
+    var s = (x+y+z)*F3;
+    var i=Math.floor(x+s), j=Math.floor(y+s), k=Math.floor(z+s);
+    var t = (i+j+k)*G3;
+    var x0=x-(i-t), y0=y-(j-t), z0=z-(k-t);
+    var i1,j1,k1,i2,j2,k2;
+    if (x0>=y0) { if (y0>=z0) {i1=1;j1=0;k1=0;i2=1;j2=1;k2=0;} else if (x0>=z0) {i1=1;j1=0;k1=0;i2=1;j2=0;k2=1;} else {i1=0;j1=0;k1=1;i2=1;j2=0;k2=1;} }
+    else { if (y0<z0) {i1=0;j1=0;k1=1;i2=0;j2=1;k2=1;} else if (x0<z0) {i1=0;j1=1;k1=0;i2=0;j2=1;k2=1;} else {i1=0;j1=1;k1=0;i2=1;j2=1;k2=0;} }
+    var x1=x0-i1+G3, y1=y0-j1+G3, z1=z0-k1+G3;
+    var x2=x0-i2+2*G3, y2=y0-j2+2*G3, z2=z0-k2+2*G3;
+    var x3=x0-1+3*G3, y3=y0-1+3*G3, z3=z0-1+3*G3;
+    var ii=i&255, jj=j&255, kk=k&255;
+    function c(g, px, py, pz) { var t2=0.6-px*px-py*py-pz*pz; return t2<0?0:(t2*=t2, t2*t2*(g[0]*px+g[1]*py+g[2]*pz)); }
+    var n = c(grad3[perm[ii+perm[jj+perm[kk]]]%12], x0,y0,z0) + c(grad3[perm[ii+i1+perm[jj+j1+perm[kk+k1]]]%12], x1,y1,z1) + c(grad3[perm[ii+i2+perm[jj+j2+perm[kk+k2]]]%12], x2,y2,z2) + c(grad3[perm[ii+1+perm[jj+1+perm[kk+1]]]%12], x3,y3,z3);
+    return 0.5 + 16 * n;
+  };
+}
+
+function fbm3D(noiseFn, octaves, lacunarity, gain) {
+  octaves = octaves || 6; lacunarity = lacunarity || 2; gain = gain || 0.5;
+  return function(x, y, z) {
+    var val = 0, amp = 1, freq = 1, mx = 0;
+    for (var o = 0; o < octaves; o++) {
+      val += amp * noiseFn(x * freq, y * freq, z * freq);
+      mx += amp; amp *= gain; freq *= lacunarity;
+    }
+    return val / mx;
+  };
+}
+`,
+  exports: ["perlin3D", "simplex3D", "fbm3D"],
+  dependencies: ["prng"],
+  description: "3D noise functions (Perlin, simplex) and fBm.",
+  usage: `### noise-3d \u2014 3D Noise Functions
+
+\`\`\`js
+var noise = perlin3D(rng);
+noise(x, y, z); // \u2192 0.0\u20131.0
+var fbm = fbm3D(noise, 6);
+\`\`\`
+`
+};
+var noise_3d_default = noise3d;
+
+// src/components/js/noise-4d.ts
+var noise4d = {
+  name: "noise-4d",
+  version: "1.0.0",
+  category: "noise",
+  target: "js",
+  renderers: [],
+  code: `function simplex4D(rng) {
+  var perm = new Uint8Array(512);
+  for (var i = 0; i < 256; i++) perm[i] = i;
+  for (var i = 255; i > 0; i--) {
+    var j = Math.floor(rng() * (i + 1));
+    var tmp = perm[i]; perm[i] = perm[j]; perm[j] = tmp;
+  }
+  for (var i = 0; i < 256; i++) perm[256 + i] = perm[i];
+  var grad4 = [[0,1,1,1],[0,1,1,-1],[0,1,-1,1],[0,1,-1,-1],[0,-1,1,1],[0,-1,1,-1],[0,-1,-1,1],[0,-1,-1,-1],
+               [1,0,1,1],[1,0,1,-1],[1,0,-1,1],[1,0,-1,-1],[-1,0,1,1],[-1,0,1,-1],[-1,0,-1,1],[-1,0,-1,-1],
+               [1,1,0,1],[1,1,0,-1],[1,-1,0,1],[1,-1,0,-1],[-1,1,0,1],[-1,1,0,-1],[-1,-1,0,1],[-1,-1,0,-1],
+               [1,1,1,0],[1,1,-1,0],[1,-1,1,0],[1,-1,-1,0],[-1,1,1,0],[-1,1,-1,0],[-1,-1,1,0],[-1,-1,-1,0]];
+  var F4 = (Math.sqrt(5) - 1) / 4, G4 = (5 - Math.sqrt(5)) / 20;
+  return function(x, y, z, w) {
+    var s = (x+y+z+w) * F4;
+    var i=Math.floor(x+s), j=Math.floor(y+s), k=Math.floor(z+s), l=Math.floor(w+s);
+    var t = (i+j+k+l) * G4;
+    var x0=x-(i-t), y0=y-(j-t), z0=z-(k-t), w0=w-(l-t);
+    var rankx=0,ranky=0,rankz=0,rankw=0;
+    if(x0>y0)rankx++;else ranky++;
+    if(x0>z0)rankx++;else rankz++;
+    if(x0>w0)rankx++;else rankw++;
+    if(y0>z0)ranky++;else rankz++;
+    if(y0>w0)ranky++;else rankw++;
+    if(z0>w0)rankz++;else rankw++;
+    var i1=rankx>=3?1:0,j1=ranky>=3?1:0,k1=rankz>=3?1:0,l1=rankw>=3?1:0;
+    var i2=rankx>=2?1:0,j2=ranky>=2?1:0,k2=rankz>=2?1:0,l2=rankw>=2?1:0;
+    var i3=rankx>=1?1:0,j3=ranky>=1?1:0,k3=rankz>=1?1:0,l3=rankw>=1?1:0;
+    var x1=x0-i1+G4,y1=y0-j1+G4,z1=z0-k1+G4,w1=w0-l1+G4;
+    var x2=x0-i2+2*G4,y2=y0-j2+2*G4,z2=z0-k2+2*G4,w2=w0-l2+2*G4;
+    var x3=x0-i3+3*G4,y3=y0-j3+3*G4,z3=z0-k3+3*G4,w3=w0-l3+3*G4;
+    var x4=x0-1+4*G4,y4=y0-1+4*G4,z4=z0-1+4*G4,w4=w0-1+4*G4;
+    var ii=i&255,jj=j&255,kk=k&255,ll=l&255;
+    function c(g,px,py,pz,pw){var t2=0.6-px*px-py*py-pz*pz-pw*pw;return t2<0?0:(t2*=t2,t2*t2*(g[0]*px+g[1]*py+g[2]*pz+g[3]*pw));}
+    var n = c(grad4[perm[ii+perm[jj+perm[kk+perm[ll]]]]&31],x0,y0,z0,w0)
+          + c(grad4[perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]]&31],x1,y1,z1,w1)
+          + c(grad4[perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]]&31],x2,y2,z2,w2)
+          + c(grad4[perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]]&31],x3,y3,z3,w3)
+          + c(grad4[perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]]&31],x4,y4,z4,w4);
+    return 0.5 + 13.5 * n;
+  };
+}
+`,
+  exports: ["simplex4D"],
+  dependencies: ["prng"],
+  description: "4D simplex noise for loopable animations.",
+  usage: `### noise-4d \u2014 4D Simplex Noise
+
+\`\`\`js
+var noise = simplex4D(rng);
+// Loopable: map time to a circle in 4D
+var nx = noise(x, y, Math.cos(t) * r, Math.sin(t) * r);
+\`\`\`
+`
+};
+var noise_4d_default = noise4d;
+
+// src/components/js/worley.ts
+var worley = {
+  name: "worley",
+  version: "1.0.0",
+  category: "noise",
+  target: "js",
+  renderers: [],
+  code: `function worley2D(rng) {
+  var cache = {};
+  function cellPoint(ix, iy) {
+    var key = ix + ',' + iy;
+    if (!cache[key]) {
+      var a = ix * 374761393 + iy * 668265263;
+      a = (a ^ (a >> 13)) * 1274126177;
+      var seed = ((a ^ (a >> 16)) >>> 0);
+      var r = mulberry32(seed ^ Math.floor(rng() * 0x7fffffff));
+      cache[key] = [ix + r(), iy + r()];
+    }
+    return cache[key];
+  }
+  return function(x, y) {
+    var ix = Math.floor(x), iy = Math.floor(y);
+    var minDist = 1e10;
+    for (var dx = -1; dx <= 1; dx++) {
+      for (var dy = -1; dy <= 1; dy++) {
+        var p = cellPoint(ix + dx, iy + dy);
+        var d = (x - p[0]) * (x - p[0]) + (y - p[1]) * (y - p[1]);
+        if (d < minDist) minDist = d;
+      }
+    }
+    return Math.sqrt(minDist);
+  };
+}
+
+function worley3D(rng) {
+  var cache = {};
+  function cellPoint(ix, iy, iz) {
+    var key = ix + ',' + iy + ',' + iz;
+    if (!cache[key]) {
+      var a = ix * 374761393 + iy * 668265263 + iz * 1274126177;
+      a = (a ^ (a >> 13)) * 1103515245;
+      var seed = ((a ^ (a >> 16)) >>> 0);
+      var r = mulberry32(seed ^ Math.floor(rng() * 0x7fffffff));
+      cache[key] = [ix + r(), iy + r(), iz + r()];
+    }
+    return cache[key];
+  }
+  return function(x, y, z) {
+    var ix = Math.floor(x), iy = Math.floor(y), iz = Math.floor(z);
+    var minDist = 1e10;
+    for (var dx = -1; dx <= 1; dx++)
+      for (var dy = -1; dy <= 1; dy++)
+        for (var dz = -1; dz <= 1; dz++) {
+          var p = cellPoint(ix + dx, iy + dy, iz + dz);
+          var d = (x-p[0])*(x-p[0]) + (y-p[1])*(y-p[1]) + (z-p[2])*(z-p[2]);
+          if (d < minDist) minDist = d;
+        }
+    return Math.sqrt(minDist);
+  };
+}
+`,
+  exports: ["worley2D", "worley3D"],
+  dependencies: ["prng"],
+  description: "Worley/cellular noise (2D and 3D).",
+  usage: `### worley \u2014 Cellular Noise
+
+\`\`\`js
+var w = worley2D(rng);
+w(x * 5, y * 5); // \u2192 distance to nearest cell point
+\`\`\`
+`
+};
+var worley_default = worley;
+
+// src/components/js/curl.ts
+var curl = {
+  name: "curl",
+  version: "1.0.0",
+  category: "noise",
+  target: "js",
+  renderers: [],
+  code: `function curlNoise2D(noiseFn, eps) {
+  eps = eps || 0.001;
+  return function(x, y) {
+    var dndx = (noiseFn(x + eps, y) - noiseFn(x - eps, y)) / (2 * eps);
+    var dndy = (noiseFn(x, y + eps) - noiseFn(x, y - eps)) / (2 * eps);
+    return [dndy, -dndx];
+  };
+}
+
+function curlNoise3D(noiseFnX, noiseFnY, noiseFnZ, eps) {
+  eps = eps || 0.001;
+  return function(x, y, z) {
+    var dzdy = (noiseFnZ(x, y + eps, z) - noiseFnZ(x, y - eps, z)) / (2 * eps);
+    var dydz = (noiseFnY(x, y, z + eps) - noiseFnY(x, y, z - eps)) / (2 * eps);
+    var dxdz = (noiseFnX(x, y, z + eps) - noiseFnX(x, y, z - eps)) / (2 * eps);
+    var dzdx = (noiseFnZ(x + eps, y, z) - noiseFnZ(x - eps, y, z)) / (2 * eps);
+    var dydx = (noiseFnY(x + eps, y, z) - noiseFnY(x - eps, y, z)) / (2 * eps);
+    var dxdy = (noiseFnX(x, y + eps, z) - noiseFnX(x, y - eps, z)) / (2 * eps);
+    return [dzdy - dydz, dxdz - dzdx, dydx - dxdy];
+  };
+}
+`,
+  exports: ["curlNoise2D", "curlNoise3D"],
+  dependencies: ["noise-2d", "noise-3d"],
+  description: "Curl noise for divergence-free flow fields.",
+  usage: `### curl \u2014 Curl Noise
+
+\`\`\`js
+var noise = perlin2D(rng);
+var curl = curlNoise2D(noise);
+var [vx, vy] = curl(x, y); // divergence-free velocity
+\`\`\`
+`
+};
+var curl_default = curl;
+
+// src/components/js/math.ts
+var math = {
+  name: "math",
+  version: "1.0.0",
+  category: "math",
+  target: "js",
+  renderers: [],
+  code: `function lerp(a, b, t) { return a + t * (b - a); }
+function clamp(v, lo, hi) { return v < lo ? lo : v > hi ? hi : v; }
+function clamp01(v) { return v < 0 ? 0 : v > 1 ? 1 : v; }
+function remap(v, inLo, inHi, outLo, outHi) {
+  return outLo + (v - inLo) / (inHi - inLo) * (outHi - outLo);
+}
+function smoothstep(edge0, edge1, x) {
+  var t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
+  return t * t * (3 - 2 * t);
+}
+function inverseLerp(a, b, v) { return (v - a) / (b - a); }
+function mod(a, n) { return ((a % n) + n) % n; }
+function fract(x) { return x - Math.floor(x); }
+function sign0(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
+function step(edge, x) { return x < edge ? 0 : 1; }
+`,
+  exports: ["lerp", "clamp", "clamp01", "remap", "smoothstep", "inverseLerp", "mod", "fract", "sign0", "step"],
+  dependencies: [],
+  description: "Core math utilities (lerp, clamp, smoothstep, remap, etc.).",
+  usage: `### math \u2014 Core Math Utilities
+
+\`\`\`js
+lerp(0, 100, 0.5);          // \u2192 50
+clamp(1.5, 0, 1);           // \u2192 1
+smoothstep(0, 1, 0.5);      // \u2192 0.5 (S-curve)
+remap(0.5, 0, 1, -10, 10);  // \u2192 0
+\`\`\`
+`
+};
+var math_default = math;
+
+// src/components/js/math-advanced.ts
+var mathAdvanced = {
+  name: "math-advanced",
+  version: "1.0.0",
+  category: "math",
+  target: "js",
+  renderers: [],
+  code: `var PHI = (1 + Math.sqrt(5)) / 2;
+var goldenRatio = PHI;
+
+function bezierPoint(a, b, c, d, t) {
+  var t2 = t * t, t3 = t2 * t;
+  var mt = 1 - t, mt2 = mt * mt, mt3 = mt2 * mt;
+  return mt3 * a + 3 * mt2 * t * b + 3 * mt * t2 * c + t3 * d;
+}
+
+function catmullRom(p0, p1, p2, p3, t) {
+  var t2 = t * t, t3 = t2 * t;
+  return 0.5 * ((2 * p1) + (-p0 + p2) * t +
+    (2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 +
+    (-p0 + 3 * p1 - 3 * p2 + p3) * t3);
+}
+
+function springDamper(current, target, velocity, stiffness, damping, dt) {
+  var force = -stiffness * (current - target) - damping * velocity;
+  velocity += force * dt;
+  current += velocity * dt;
+  return { value: current, velocity: velocity };
+}
+
+function exponentialDecay(value, target, rate, dt) {
+  return target + (value - target) * Math.exp(-rate * dt);
+}
+`,
+  exports: ["bezierPoint", "catmullRom", "springDamper", "exponentialDecay", "goldenRatio", "PHI"],
+  dependencies: ["math"],
+  description: "Advanced interpolation and constants (Bezier, Catmull-Rom, spring, PHI).",
+  usage: `### math-advanced \u2014 Advanced Interpolation
+
+\`\`\`js
+bezierPoint(0, 0.5, 0.5, 1, t);    // cubic Bezier
+catmullRom(p0, p1, p2, p3, t);     // Catmull-Rom spline
+springDamper(pos, target, vel, 100, 10, dt);
+exponentialDecay(current, target, 5, dt);
+PHI; // \u2192 1.618...
+\`\`\`
+`
+};
+var math_advanced_default = mathAdvanced;
+
+// src/components/js/easing.ts
+var easing = {
+  name: "easing",
+  version: "1.0.0",
+  category: "easing",
+  target: "js",
+  renderers: [],
+  code: `function easeInQuad(t) { return t * t; }
+function easeOutQuad(t) { return t * (2 - t); }
+function easeInOutQuad(t) { return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t; }
+function easeInCubic(t) { return t * t * t; }
+function easeOutCubic(t) { var u = 1 - t; return 1 - u * u * u; }
+function easeInOutCubic(t) {
+  return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+}
+function easeInOutSine(t) { return -(Math.cos(Math.PI * t) - 1) / 2; }
+function easeInExpo(t) { return t === 0 ? 0 : Math.pow(2, 10 * t - 10); }
+function easeOutExpo(t) { return t === 1 ? 1 : 1 - Math.pow(2, -10 * t); }
+function easeOutElastic(t) {
+  if (t === 0 || t === 1) return t;
+  return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * (2 * Math.PI / 3)) + 1;
+}
+function easeOutBounce(t) {
+  if (t < 1 / 2.75) return 7.5625 * t * t;
+  if (t < 2 / 2.75) { t -= 1.5 / 2.75; return 7.5625 * t * t + 0.75; }
+  if (t < 2.5 / 2.75) { t -= 2.25 / 2.75; return 7.5625 * t * t + 0.9375; }
+  t -= 2.625 / 2.75; return 7.5625 * t * t + 0.984375;
+}
+function spring(t, freq, decay) {
+  freq = freq || 4; decay = decay || 4;
+  return 1 - Math.exp(-decay * t) * Math.cos(freq * Math.PI * t);
+}
+`,
+  exports: [
+    "easeInQuad",
+    "easeOutQuad",
+    "easeInOutQuad",
+    "easeInCubic",
+    "easeOutCubic",
+    "easeInOutCubic",
+    "easeInOutSine",
+    "easeInExpo",
+    "easeOutExpo",
+    "easeOutElastic",
+    "easeOutBounce",
+    "spring"
+  ],
+  dependencies: [],
+  description: "Easing functions for smooth animations (0\u21921 domain).",
+  usage: `### easing \u2014 Easing Functions
+
+\`\`\`js
+easeInOutCubic(t); // smooth S-curve
+easeOutElastic(t); // springy overshoot
+easeOutBounce(t);  // bouncing effect
+spring(t, 4, 4);   // damped spring
+\`\`\`
+`
+};
+var easing_default = easing;
+
+// src/components/js/color.ts
+var color = {
+  name: "color",
+  version: "1.0.0",
+  category: "color",
+  target: "js",
+  renderers: [],
+  code: `function hexToRgb(hex) {
+  var n = parseInt(hex.charAt(0) === '#' ? hex.slice(1) : hex, 16);
+  return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+
+function rgbToHex(r, g, b) {
+  return '#' + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+}
+
+function hslToRgb(h, s, l) {
+  h = h / 360; s = s / 100; l = l / 100;
+  if (s === 0) { var v = Math.round(l * 255); return [v, v, v]; }
+  function hue2rgb(p, q, t) {
+    if (t < 0) t += 1; if (t > 1) t -= 1;
+    if (t < 1/6) return p + (q - p) * 6 * t;
+    if (t < 1/2) return q;
+    if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+    return p;
+  }
+  var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  var p = 2 * l - q;
+  return [
+    Math.round(hue2rgb(p, q, h + 1/3) * 255),
+    Math.round(hue2rgb(p, q, h) * 255),
+    Math.round(hue2rgb(p, q, h - 1/3) * 255)
+  ];
+}
+
+function rgbToHsl(r, g, b) {
+  r /= 255; g /= 255; b /= 255;
+  var max = Math.max(r, g, b), min = Math.min(r, g, b);
+  var h = 0, s = 0, l = (max + min) / 2;
+  if (max !== min) {
+    var d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+    else if (max === g) h = ((b - r) / d + 2) / 6;
+    else h = ((r - g) / d + 4) / 6;
+  }
+  return [Math.round(h * 360), Math.round(s * 100), Math.round(l * 100)];
+}
+
+function lerpColor(c1, c2, t) {
+  var a = hexToRgb(c1), b = hexToRgb(c2);
+  return rgbToHex(
+    Math.round(a[0] + (b[0] - a[0]) * t),
+    Math.round(a[1] + (b[1] - a[1]) * t),
+    Math.round(a[2] + (b[2] - a[2]) * t)
+  );
+}
+
+function contrastRatio(hex1, hex2) {
+  function luminance(hex) {
+    var rgb = hexToRgb(hex).map(function(c) {
+      c = c / 255;
+      return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    });
+    return 0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2];
+  }
+  var l1 = luminance(hex1), l2 = luminance(hex2);
+  var lighter = Math.max(l1, l2), darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+`,
+  exports: ["hexToRgb", "rgbToHex", "hslToRgb", "rgbToHsl", "lerpColor", "contrastRatio"],
+  dependencies: [],
+  description: "Color space conversion (hex, RGB, HSL) and utilities.",
+  usage: `### color \u2014 Color Space Conversion
+
+\`\`\`js
+hexToRgb('#ff0000');       // \u2192 [255, 0, 0]
+rgbToHex(255, 128, 0);    // \u2192 '#ff8000'
+hslToRgb(200, 80, 50);    // \u2192 [r, g, b]
+lerpColor('#000', '#fff', 0.5);
+contrastRatio('#000', '#fff'); // \u2192 21
+\`\`\`
+`
+};
+var color_default = color;
+
+// src/components/js/color-advanced.ts
+var colorAdvanced = {
+  name: "color-advanced",
+  version: "1.0.0",
+  category: "color",
+  target: "js",
+  renderers: [],
+  code: `function rgbToOklab(r, g, b) {
+  r /= 255; g /= 255; b /= 255;
+  var lr = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+  var lg = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+  var lb = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+  var l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  var m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  var s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return [
+    0.2104542553 * l + 0.7936177850 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.4285922050 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.8086757660 * s
+  ];
+}
+
+function oklabToRgb(L, a, b) {
+  var l = L + 0.3963377774 * a + 0.2158037573 * b;
+  var m = L - 0.1055613458 * a - 0.0638541728 * b;
+  var s = L - 0.0894841775 * a - 1.2914855480 * b;
+  l = l * l * l; m = m * m * m; s = s * s * s;
+  var r = +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+  var g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+  var bl = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s;
+  function toSrgb(c) {
+    c = c > 0.0031308 ? 1.055 * Math.pow(c, 1 / 2.4) - 0.055 : 12.92 * c;
+    return Math.max(0, Math.min(255, Math.round(c * 255)));
+  }
+  return [toSrgb(r), toSrgb(g), toSrgb(bl)];
+}
+
+function rgbToOklch(r, g, b) {
+  var lab = rgbToOklab(r, g, b);
+  var C = Math.sqrt(lab[1] * lab[1] + lab[2] * lab[2]);
+  var h = Math.atan2(lab[2], lab[1]) * 180 / Math.PI;
+  if (h < 0) h += 360;
+  return [lab[0], C, h];
+}
+
+function oklchToRgb(L, C, h) {
+  var rad = h * Math.PI / 180;
+  return oklabToRgb(L, C * Math.cos(rad), C * Math.sin(rad));
+}
+
+function lerpOklab(c1, c2, t) {
+  var a = rgbToOklab(c1[0], c1[1], c1[2]);
+  var b = rgbToOklab(c2[0], c2[1], c2[2]);
+  return oklabToRgb(
+    a[0] + (b[0] - a[0]) * t,
+    a[1] + (b[1] - a[1]) * t,
+    a[2] + (b[2] - a[2]) * t
+  );
+}
+
+function palette(colors, t) {
+  t = Math.max(0, Math.min(1, t)) * (colors.length - 1);
+  var i = Math.floor(t);
+  var f = t - i;
+  if (i >= colors.length - 1) return colors[colors.length - 1];
+  return lerpOklab(colors[i], colors[i + 1], f);
+}
+
+function complementary(r, g, b) {
+  return [255 - r, 255 - g, 255 - b];
+}
+
+function triadic(h, s, l) {
+  return [
+    [h, s, l],
+    [(h + 120) % 360, s, l],
+    [(h + 240) % 360, s, l]
+  ];
+}
+
+function analogous(h, s, l, angle) {
+  angle = angle || 30;
+  return [
+    [(h - angle + 360) % 360, s, l],
+    [h, s, l],
+    [(h + angle) % 360, s, l]
+  ];
+}
+`,
+  exports: ["oklabToRgb", "rgbToOklab", "oklchToRgb", "rgbToOklch", "lerpOklab", "palette", "complementary", "triadic", "analogous"],
+  dependencies: ["color"],
+  description: "Perceptual color spaces (OKLab, OKLCh) and color harmony.",
+  usage: `### color-advanced \u2014 Perceptual Color & Harmony
+
+\`\`\`js
+var lab = rgbToOklab(255, 128, 0);
+var rgb = oklabToRgb(lab[0], lab[1], lab[2]);
+lerpOklab([255,0,0], [0,0,255], 0.5); // perceptually uniform blend
+palette([[255,0,0],[0,255,0],[0,0,255]], 0.5); // palette sampling
+triadic(200, 80, 50); // three equidistant hues
+\`\`\`
+`
+};
+var color_advanced_default = colorAdvanced;
+
+// src/components/js/vector.ts
+var vector = {
+  name: "vector",
+  version: "1.0.0",
+  category: "vector",
+  target: "js",
+  renderers: [],
+  code: `function vec2(x, y) { return [x, y]; }
+function vec3(x, y, z) { return [x, y, z]; }
+
+function add(a, b) {
+  var r = new Array(a.length);
+  for (var i = 0; i < a.length; i++) r[i] = a[i] + b[i];
+  return r;
+}
+
+function sub(a, b) {
+  var r = new Array(a.length);
+  for (var i = 0; i < a.length; i++) r[i] = a[i] - b[i];
+  return r;
+}
+
+function mul(a, s) {
+  var r = new Array(a.length);
+  for (var i = 0; i < a.length; i++) r[i] = a[i] * s;
+  return r;
+}
+
+function div(a, s) {
+  var r = new Array(a.length);
+  for (var i = 0; i < a.length; i++) r[i] = a[i] / s;
+  return r;
+}
+
+function dot(a, b) {
+  var s = 0;
+  for (var i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+
+function length(a) {
+  var s = 0;
+  for (var i = 0; i < a.length; i++) s += a[i] * a[i];
+  return Math.sqrt(s);
+}
+
+function normalize(a) {
+  var len = length(a);
+  return len === 0 ? a : div(a, len);
+}
+
+function distance(a, b) { return length(sub(a, b)); }
+
+function reflect(v, n) {
+  var d = 2 * dot(v, n);
+  return sub(v, mul(n, d));
+}
+
+function rotate2D(v, angle) {
+  var c = Math.cos(angle), s = Math.sin(angle);
+  return [v[0] * c - v[1] * s, v[0] * s + v[1] * c];
+}
+`,
+  exports: ["vec2", "vec3", "add", "sub", "mul", "div", "dot", "cross", "normalize", "length", "distance", "reflect", "rotate2D"],
+  dependencies: [],
+  description: "Lightweight vector math using plain arrays.",
+  usage: `### vector \u2014 Vector Math
+
+\`\`\`js
+var a = vec2(1, 0), b = vec2(0, 1);
+add(a, b);        // \u2192 [1, 1]
+normalize(a);     // \u2192 [1, 0]
+distance(a, b);   // \u2192 1.414...
+rotate2D(a, Math.PI / 2);
+\`\`\`
+`
+};
+var vector_default = vector;
+
+// src/components/js/matrix.ts
+var matrix = {
+  name: "matrix",
+  version: "1.0.0",
+  category: "vector",
+  target: "js",
+  renderers: [],
+  code: `function mat2(a, b, c, d) { return [a, b, c, d]; }
+function mat3(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
+  return [m00, m01, m02, m10, m11, m12, m20, m21, m22];
+}
+function mat4(m00,m01,m02,m03,m10,m11,m12,m13,m20,m21,m22,m23,m30,m31,m32,m33) {
+  return [m00,m01,m02,m03,m10,m11,m12,m13,m20,m21,m22,m23,m30,m31,m32,m33];
+}
+
+function multiply(a, b, n) {
+  var r = new Array(n * n);
+  for (var i = 0; i < n; i++)
+    for (var j = 0; j < n; j++) {
+      var s = 0;
+      for (var k = 0; k < n; k++) s += a[i * n + k] * b[k * n + j];
+      r[i * n + j] = s;
+    }
+  return r;
+}
+
+function transpose(m, n) {
+  var r = new Array(n * n);
+  for (var i = 0; i < n; i++)
+    for (var j = 0; j < n; j++) r[j * n + i] = m[i * n + j];
+  return r;
+}
+
+function inverse(m) {
+  var a=m[0],b=m[1],c=m[2],d=m[3],e=m[4],f=m[5],g=m[6],h=m[7],i=m[8],j=m[9],k=m[10],l=m[11],n=m[12],o=m[13],p=m[14],q=m[15];
+  var kpol=k*q-l*p, jpom=j*q-l*o, jpon=j*p-k*o, ipol=i*q-l*n, ipon=i*p-k*n, iomn=i*o-j*n;
+  var det = a*(f*kpol-g*jpom+h*jpon) - b*(e*kpol-g*ipol+h*ipon) + c*(e*jpom-f*ipol+h*iomn) - d*(e*jpon-f*ipon+g*iomn);
+  if (det === 0) return null;
+  var id = 1/det;
+  return [
+    (f*kpol-g*jpom+h*jpon)*id, -(b*kpol-c*jpom+d*jpon)*id, (b*(g*q-h*p)-c*(f*q-h*o)+d*(f*p-g*o))*id, -(b*(g*l-h*k)-c*(f*l-h*j)+d*(f*k-g*j))*id,
+    -(e*kpol-g*ipol+h*ipon)*id, (a*kpol-c*ipol+d*ipon)*id, -(a*(g*q-h*p)-c*(e*q-h*n)+d*(e*p-g*n))*id, (a*(g*l-h*k)-c*(e*l-h*i)+d*(e*k-g*i))*id,
+    (e*jpom-f*ipol+h*iomn)*id, -(a*jpom-b*ipol+d*iomn)*id, (a*(f*q-h*o)-b*(e*q-h*n)+d*(e*o-f*n))*id, -(a*(f*l-h*j)-b*(e*l-h*i)+d*(e*j-f*i))*id,
+    -(e*jpon-f*ipon+g*iomn)*id, (a*jpon-b*ipon+c*iomn)*id, -(a*(f*p-g*o)-b*(e*p-g*n)+c*(e*o-f*n))*id, (a*(f*k-g*j)-b*(e*k-g*i)+c*(e*j-f*i))*id
+  ];
+}
+
+function rotationMatrix(axis, angle) {
+  var c = Math.cos(angle), s = Math.sin(angle), t = 1 - c;
+  var x = axis[0], y = axis[1], z = axis[2];
+  return [
+    t*x*x+c,   t*x*y-s*z, t*x*z+s*y, 0,
+    t*x*y+s*z, t*y*y+c,   t*y*z-s*x, 0,
+    t*x*z-s*y, t*y*z+s*x, t*z*z+c,   0,
+    0, 0, 0, 1
+  ];
+}
+
+function projectionMatrix(fov, aspect, near, far) {
+  var f = 1 / Math.tan(fov / 2);
+  var nf = 1 / (near - far);
+  return [
+    f/aspect, 0, 0, 0,
+    0, f, 0, 0,
+    0, 0, (far+near)*nf, -1,
+    0, 0, 2*far*near*nf, 0
+  ];
+}
+`,
+  exports: ["mat2", "mat3", "mat4", "multiply", "inverse", "transpose", "rotationMatrix", "projectionMatrix"],
+  dependencies: ["vector"],
+  description: "Matrix math for 2D/3D transforms and projections.",
+  usage: `### matrix \u2014 Matrix Math
+
+\`\`\`js
+var rot = rotationMatrix([0,1,0], Math.PI/4);
+var proj = projectionMatrix(Math.PI/3, 16/9, 0.1, 100);
+var result = multiply(proj, rot, 4);
+\`\`\`
+`
+};
+var matrix_default = matrix;
+
+// src/components/js/grid.ts
+var grid = {
+  name: "grid",
+  version: "1.0.0",
+  category: "grid",
+  target: "js",
+  renderers: [],
+  code: `function marchingSquares(field, cols, rows, threshold) {
+  var segments = [];
+  function val(x, y) { return field[y * cols + x] >= threshold ? 1 : 0; }
+  function interp(a, b, va, vb) {
+    var dv = vb - va;
+    return dv === 0 ? 0.5 : (threshold - va) / dv;
+  }
+  for (var y = 0; y < rows - 1; y++) {
+    for (var x = 0; x < cols - 1; x++) {
+      var v00 = field[y * cols + x], v10 = field[y * cols + x + 1];
+      var v01 = field[(y+1) * cols + x], v11 = field[(y+1) * cols + x + 1];
+      var code = val(x,y) | (val(x+1,y)<<1) | (val(x,y+1)<<2) | (val(x+1,y+1)<<3);
+      if (code === 0 || code === 15) continue;
+      var top = [x + interp(v00, v10, v00, v10), y];
+      var bottom = [x + interp(v01, v11, v01, v11), y + 1];
+      var left = [x, y + interp(v00, v01, v00, v01)];
+      var right = [x + 1, y + interp(v10, v11, v10, v11)];
+      if (code===1||code===14) segments.push([top, left]);
+      else if (code===2||code===13) segments.push([top, right]);
+      else if (code===3||code===12) segments.push([left, right]);
+      else if (code===4||code===11) segments.push([left, bottom]);
+      else if (code===6||code===9) segments.push([top, bottom]);
+      else if (code===7||code===8) segments.push([right, bottom]);
+      else if (code===5) { segments.push([top, left]); segments.push([right, bottom]); }
+      else if (code===10) { segments.push([top, right]); segments.push([left, bottom]); }
+    }
+  }
+  return segments;
+}
+
+function floodFill(grid, cols, rows, startX, startY, fillVal) {
+  var target = grid[startY * cols + startX];
+  if (target === fillVal) return grid;
+  var result = grid.slice();
+  var stack = [[startX, startY]];
+  while (stack.length > 0) {
+    var p = stack.pop();
+    var px = p[0], py = p[1];
+    if (px < 0 || px >= cols || py < 0 || py >= rows) continue;
+    if (result[py * cols + px] !== target) continue;
+    result[py * cols + px] = fillVal;
+    stack.push([px+1,py],[px-1,py],[px,py+1],[px,py-1]);
+  }
+  return result;
+}
+
+function bresenhamLine(x0, y0, x1, y1) {
+  var points = [];
+  var dx = Math.abs(x1 - x0), dy = Math.abs(y1 - y0);
+  var sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1;
+  var err = dx - dy;
+  while (true) {
+    points.push([x0, y0]);
+    if (x0 === x1 && y0 === y1) break;
+    var e2 = 2 * err;
+    if (e2 > -dy) { err -= dy; x0 += sx; }
+    if (e2 < dx) { err += dx; y0 += sy; }
+  }
+  return points;
+}
+
+function cellularAutomaton(grid, cols, rows, ruleFn) {
+  var next = new Array(cols * rows);
+  for (var y = 0; y < rows; y++) {
+    for (var x = 0; x < cols; x++) {
+      var neighbors = 0;
+      for (var dy = -1; dy <= 1; dy++)
+        for (var dx = -1; dx <= 1; dx++) {
+          if (dx === 0 && dy === 0) continue;
+          var nx = (x + dx + cols) % cols, ny = (y + dy + rows) % rows;
+          neighbors += grid[ny * cols + nx] ? 1 : 0;
+        }
+      next[y * cols + x] = ruleFn(grid[y * cols + x], neighbors);
+    }
+  }
+  return next;
+}
+`,
+  exports: ["marchingSquares", "floodFill", "bresenhamLine", "cellularAutomaton"],
+  dependencies: [],
+  description: "Grid/heightmap algorithms (marching squares, flood fill, Bresenham).",
+  usage: `### grid \u2014 Grid Algorithms
+
+\`\`\`js
+var segs = marchingSquares(heightmap, 100, 100, 0.5);
+var filled = floodFill(grid, w, h, 0, 0, 1);
+var line = bresenhamLine(0, 0, 10, 7);
+var next = cellularAutomaton(grid, w, h, function(cell, n) {
+  return n === 3 || (cell && n === 2) ? 1 : 0; // Game of Life
+});
+\`\`\`
+`
+};
+var grid_default = grid;
+
+// src/components/js/grid-advanced.ts
+var gridAdvanced = {
+  name: "grid-advanced",
+  version: "1.0.0",
+  category: "grid",
+  target: "js",
+  renderers: [],
+  code: `function marchingCubes(field, nx, ny, nz, threshold) {
+  var vertices = [];
+  function val(x, y, z) { return field[z * ny * nx + y * nx + x]; }
+  function interp3(p1, p2, v1, v2) {
+    if (Math.abs(v1 - v2) < 1e-6) return p1;
+    var t = (threshold - v1) / (v2 - v1);
+    return [p1[0]+(p2[0]-p1[0])*t, p1[1]+(p2[1]-p1[1])*t, p1[2]+(p2[2]-p1[2])*t];
+  }
+  for (var z = 0; z < nz-1; z++)
+    for (var y = 0; y < ny-1; y++)
+      for (var x = 0; x < nx-1; x++) {
+        var v = [val(x,y,z),val(x+1,y,z),val(x+1,y+1,z),val(x,y+1,z),
+                 val(x,y,z+1),val(x+1,y,z+1),val(x+1,y+1,z+1),val(x,y+1,z+1)];
+        var code = 0;
+        for (var i = 0; i < 8; i++) if (v[i] >= threshold) code |= (1 << i);
+        if (code === 0 || code === 255) continue;
+        var corners = [[x,y,z],[x+1,y,z],[x+1,y+1,z],[x,y+1,z],[x,y,z+1],[x+1,y,z+1],[x+1,y+1,z+1],[x,y+1,z+1]];
+        var edges = [[0,1],[1,2],[2,3],[3,0],[4,5],[5,6],[6,7],[7,4],[0,4],[1,5],[2,6],[3,7]];
+        for (var i = 0; i < edges.length; i++) {
+          var e = edges[i];
+          if ((code & (1<<e[0])) !== (code & (1<<e[1])))
+            vertices.push(interp3(corners[e[0]], corners[e[1]], v[e[0]], v[e[1]]));
+        }
+      }
+  return vertices;
+}
+
+function diamondSquare(size, rng, roughness) {
+  var n = size;
+  var grid = new Float64Array(n * n);
+  grid[0] = rng(); grid[n-1] = rng(); grid[(n-1)*n] = rng(); grid[(n-1)*n+n-1] = rng();
+  var step = n - 1, scale = roughness;
+  while (step > 1) {
+    var half = step / 2;
+    for (var y = 0; y < n-1; y += step)
+      for (var x = 0; x < n-1; x += step) {
+        var avg = (grid[y*n+x]+grid[y*n+x+step]+grid[(y+step)*n+x]+grid[(y+step)*n+x+step])/4;
+        grid[(y+half)*n+x+half] = avg + (rng()-0.5)*scale;
+      }
+    for (var y = 0; y < n; y += half)
+      for (var x = (y % step === 0 ? half : 0); x < n; x += step) {
+        var sum = 0, cnt = 0;
+        if (y-half>=0){sum+=grid[(y-half)*n+x];cnt++;}
+        if (y+half<n){sum+=grid[(y+half)*n+x];cnt++;}
+        if (x-half>=0){sum+=grid[y*n+x-half];cnt++;}
+        if (x+half<n){sum+=grid[y*n+x+half];cnt++;}
+        grid[y*n+x] = sum/cnt + (rng()-0.5)*scale;
+      }
+    step = half; scale *= 0.5;
+  }
+  return grid;
+}
+
+function waveCollapse(tileCount, cols, rows, adjacency, rng) {
+  var grid = new Array(cols * rows);
+  for (var i = 0; i < grid.length; i++) {
+    grid[i] = new Array(tileCount);
+    for (var t = 0; t < tileCount; t++) grid[i][t] = true;
+  }
+  function entropy(cell) {
+    var c = 0;
+    for (var t = 0; t < tileCount; t++) if (cell[t]) c++;
+    return c;
+  }
+  function collapse() {
+    var minE = tileCount + 1, idx = -1;
+    for (var i = 0; i < grid.length; i++) {
+      var e = entropy(grid[i]);
+      if (e > 1 && e < minE) { minE = e; idx = i; }
+    }
+    if (idx === -1) return false;
+    var options = [];
+    for (var t = 0; t < tileCount; t++) if (grid[idx][t]) options.push(t);
+    var pick = options[Math.floor(rng() * options.length)];
+    for (var t = 0; t < tileCount; t++) grid[idx][t] = (t === pick);
+    propagate(idx);
+    return true;
+  }
+  function propagate(idx) {
+    var stack = [idx];
+    while (stack.length > 0) {
+      var ci = stack.pop();
+      var cx = ci % cols, cy = Math.floor(ci / cols);
+      var dirs = [[1,0],[-1,0],[0,1],[0,-1]];
+      for (var d = 0; d < 4; d++) {
+        var nx = cx+dirs[d][0], ny = cy+dirs[d][1];
+        if (nx<0||nx>=cols||ny<0||ny>=rows) continue;
+        var ni = ny*cols+nx;
+        var changed = false;
+        for (var t = 0; t < tileCount; t++) {
+          if (!grid[ni][t]) continue;
+          var valid = false;
+          for (var s = 0; s < tileCount; s++) {
+            if (grid[ci][s] && adjacency[s] && adjacency[s][d] && adjacency[s][d].indexOf(t) >= 0) { valid = true; break; }
+          }
+          if (!valid) { grid[ni][t] = false; changed = true; }
+        }
+        if (changed) stack.push(ni);
+      }
+    }
+  }
+  while (collapse()) {}
+  var result = new Array(cols * rows);
+  for (var i = 0; i < grid.length; i++) {
+    for (var t = 0; t < tileCount; t++) if (grid[i][t]) { result[i] = t; break; }
+  }
+  return result;
+}
+`,
+  exports: ["marchingCubes", "diamondSquare", "waveCollapse"],
+  dependencies: ["prng", "grid"],
+  description: "Advanced grid generation (marching cubes, diamond-square, WFC).",
+  usage: `### grid-advanced \u2014 Advanced Grid Generation
+
+\`\`\`js
+var terrain = diamondSquare(129, rng, 1.0);
+var verts = marchingCubes(field, 32, 32, 32, 0.5);
+var tiles = waveCollapse(4, 20, 20, adjacencyRules, rng);
+\`\`\`
+`
+};
+var grid_advanced_default = gridAdvanced;
+
+// src/components/js/particle.ts
+var particle = {
+  name: "particle",
+  version: "1.0.0",
+  category: "particle",
+  target: "js",
+  renderers: [],
+  code: `function createParticleSystem(maxParticles) {
+  return {
+    particles: [],
+    maxParticles: maxParticles || 1000,
+    time: 0
+  };
+}
+
+function emitParticle(system, x, y, vx, vy, life) {
+  if (system.particles.length >= system.maxParticles) return null;
+  var p = { x: x, y: y, vx: vx || 0, vy: vy || 0, ax: 0, ay: 0, life: life || 1, maxLife: life || 1, age: 0 };
+  system.particles.push(p);
+  return p;
+}
+
+function updateParticles(system, dt) {
+  dt = dt || 1/60;
+  system.time += dt;
+  for (var i = system.particles.length - 1; i >= 0; i--) {
+    var p = system.particles[i];
+    p.vx += p.ax * dt; p.vy += p.ay * dt;
+    p.x += p.vx * dt; p.y += p.vy * dt;
+    p.ax = 0; p.ay = 0;
+    p.age += dt; p.life -= dt;
+    if (p.life <= 0) system.particles.splice(i, 1);
+  }
+  return system;
+}
+
+function applyForce(particle, fx, fy) {
+  particle.ax += fx;
+  particle.ay += fy;
+}
+
+function particleAge(particle) {
+  return particle.age / particle.maxLife;
+}
+`,
+  exports: ["createParticleSystem", "updateParticles", "emitParticle", "applyForce", "particleAge"],
+  dependencies: ["vector"],
+  description: "Renderer-agnostic particle system state management.",
+  usage: `### particle \u2014 Particle System
+
+\`\`\`js
+var sys = createParticleSystem(500);
+emitParticle(sys, x, y, vx, vy, 2.0);
+updateParticles(sys, dt);
+sys.particles.forEach(function(p) {
+  applyForce(p, 0, 9.8); // gravity
+  var t = particleAge(p); // 0\u21921 normalized age
+});
+\`\`\`
+`
+};
+var particle_default = particle;
+
+// src/components/js/particle-forces.ts
+var particleForces = {
+  name: "particle-forces",
+  version: "1.0.0",
+  category: "particle",
+  target: "js",
+  renderers: [],
+  code: `function gravityForce(p, gx, gy) {
+  p.ax += gx || 0;
+  p.ay += gy || 9.8;
+}
+
+function attractorForce(p, ax, ay, strength) {
+  var dx = ax - p.x, dy = ay - p.y;
+  var d = Math.sqrt(dx * dx + dy * dy) + 0.01;
+  var f = strength / (d * d);
+  p.ax += dx / d * f;
+  p.ay += dy / d * f;
+}
+
+function vortexForce(p, cx, cy, strength) {
+  var dx = p.x - cx, dy = p.y - cy;
+  var d = Math.sqrt(dx * dx + dy * dy) + 0.01;
+  var f = strength / d;
+  p.ax += -dy / d * f;
+  p.ay += dx / d * f;
+}
+
+function dragForce(p, coefficient) {
+  coefficient = coefficient || 0.01;
+  var speed = Math.sqrt(p.vx * p.vx + p.vy * p.vy);
+  if (speed > 0) {
+    var drag = coefficient * speed;
+    p.ax -= p.vx / speed * drag;
+    p.ay -= p.vy / speed * drag;
+  }
+}
+
+function turbulenceForce(p, noiseFn, scale, strength) {
+  var angle = noiseFn(p.x * scale, p.y * scale) * Math.PI * 4;
+  p.ax += Math.cos(angle) * strength;
+  p.ay += Math.sin(angle) * strength;
+}
+
+function boundaryForce(p, minX, minY, maxX, maxY, strength) {
+  strength = strength || 10;
+  var margin = 20;
+  if (p.x < minX + margin) p.ax += strength * (1 - (p.x - minX) / margin);
+  if (p.x > maxX - margin) p.ax -= strength * (1 - (maxX - p.x) / margin);
+  if (p.y < minY + margin) p.ay += strength * (1 - (p.y - minY) / margin);
+  if (p.y > maxY - margin) p.ay -= strength * (1 - (maxY - p.y) / margin);
+}
+`,
+  exports: ["gravityForce", "attractorForce", "vortexForce", "dragForce", "turbulenceForce", "boundaryForce"],
+  dependencies: ["particle", "vector"],
+  description: "Common particle force functions (gravity, attractor, vortex, drag).",
+  usage: `### particle-forces \u2014 Force Functions
+
+\`\`\`js
+sys.particles.forEach(function(p) {
+  gravityForce(p, 0, 9.8);
+  attractorForce(p, cx, cy, 100);
+  dragForce(p, 0.02);
+  boundaryForce(p, 0, 0, width, height);
+});
+\`\`\`
+`
+};
+var particle_forces_default = particleForces;
+
+// src/components/js/shape.ts
+var shape = {
+  name: "shape",
+  version: "1.0.0",
+  category: "geometry",
+  target: "js",
+  renderers: [],
+  code: `function regularPolygon(cx, cy, radius, sides) {
+  var pts = [];
+  for (var i = 0; i < sides; i++) {
+    var a = (i / sides) * Math.PI * 2 - Math.PI / 2;
+    pts.push([cx + Math.cos(a) * radius, cy + Math.sin(a) * radius]);
+  }
+  return pts;
+}
+
+function star(cx, cy, outerR, innerR, points) {
+  var pts = [];
+  for (var i = 0; i < points * 2; i++) {
+    var a = (i / (points * 2)) * Math.PI * 2 - Math.PI / 2;
+    var r = i % 2 === 0 ? outerR : innerR;
+    pts.push([cx + Math.cos(a) * r, cy + Math.sin(a) * r]);
+  }
+  return pts;
+}
+
+function spiral(cx, cy, startR, endR, turns, segments) {
+  var pts = [];
+  for (var i = 0; i <= segments; i++) {
+    var t = i / segments;
+    var angle = t * turns * Math.PI * 2;
+    var r = startR + (endR - startR) * t;
+    pts.push([cx + Math.cos(angle) * r, cy + Math.sin(angle) * r]);
+  }
+  return pts;
+}
+
+function lissajous(cx, cy, a, b, kx, ky, delta, segments) {
+  var pts = [];
+  for (var i = 0; i <= segments; i++) {
+    var t = (i / segments) * Math.PI * 2;
+    pts.push([cx + a * Math.sin(kx * t + delta), cy + b * Math.sin(ky * t)]);
+  }
+  return pts;
+}
+
+function superellipse(cx, cy, rx, ry, n, segments) {
+  var pts = [];
+  for (var i = 0; i <= segments; i++) {
+    var a = (i / segments) * Math.PI * 2;
+    var ca = Math.cos(a), sa = Math.sin(a);
+    var x = Math.pow(Math.abs(ca), 2/n) * rx * (ca >= 0 ? 1 : -1);
+    var y = Math.pow(Math.abs(sa), 2/n) * ry * (sa >= 0 ? 1 : -1);
+    pts.push([cx + x, cy + y]);
+  }
+  return pts;
+}
+
+function heart(cx, cy, size, segments) {
+  var pts = [];
+  for (var i = 0; i <= segments; i++) {
+    var t = (i / segments) * Math.PI * 2;
+    var x = 16 * Math.pow(Math.sin(t), 3);
+    var y = -(13 * Math.cos(t) - 5 * Math.cos(2*t) - 2 * Math.cos(3*t) - Math.cos(4*t));
+    pts.push([cx + x * size / 16, cy + y * size / 16]);
+  }
+  return pts;
+}
+`,
+  exports: ["regularPolygon", "star", "spiral", "lissajous", "superellipse", "heart"],
+  dependencies: ["math"],
+  description: "Parametric shape generators returning point arrays.",
+  usage: `### shape \u2014 Parametric Shapes
+
+\`\`\`js
+regularPolygon(cx, cy, 50, 6);  // hexagon
+star(cx, cy, 50, 25, 5);        // 5-point star
+spiral(cx, cy, 10, 100, 5, 200);
+heart(cx, cy, 40, 100);
+\`\`\`
+`
+};
+var shape_default = shape;
+
+// src/components/js/shape-advanced.ts
+var shapeAdvanced = {
+  name: "shape-advanced",
+  version: "1.0.0",
+  category: "geometry",
+  target: "js",
+  renderers: [],
+  code: `function chaikinSmooth(points, iterations) {
+  iterations = iterations || 3;
+  var pts = points;
+  for (var iter = 0; iter < iterations; iter++) {
+    var next = [];
+    for (var i = 0; i < pts.length - 1; i++) {
+      var a = pts[i], b = pts[i+1];
+      next.push([a[0]*0.75 + b[0]*0.25, a[1]*0.75 + b[1]*0.25]);
+      next.push([a[0]*0.25 + b[0]*0.75, a[1]*0.25 + b[1]*0.75]);
+    }
+    pts = next;
+  }
+  return pts;
+}
+
+function subdivideCurve(points, iterations) {
+  iterations = iterations || 1;
+  var pts = points;
+  for (var iter = 0; iter < iterations; iter++) {
+    var next = [pts[0]];
+    for (var i = 0; i < pts.length - 1; i++) {
+      var mid = [(pts[i][0]+pts[i+1][0])/2, (pts[i][1]+pts[i+1][1])/2];
+      next.push(mid);
+      next.push(pts[i+1]);
+    }
+    pts = next;
+  }
+  return pts;
+}
+
+function offsetPath(points, dist) {
+  var result = [];
+  for (var i = 0; i < points.length; i++) {
+    var prev = points[(i-1+points.length)%points.length];
+    var curr = points[i];
+    var next = points[(i+1)%points.length];
+    var dx1 = curr[0]-prev[0], dy1 = curr[1]-prev[1];
+    var dx2 = next[0]-curr[0], dy2 = next[1]-curr[1];
+    var len1 = Math.sqrt(dx1*dx1+dy1*dy1) || 1;
+    var len2 = Math.sqrt(dx2*dx2+dy2*dy2) || 1;
+    var nx = (-(dy1/len1 + dy2/len2))/2, ny = ((dx1/len1 + dx2/len2))/2;
+    var nl = Math.sqrt(nx*nx+ny*ny) || 1;
+    result.push([curr[0]+nx/nl*dist, curr[1]+ny/nl*dist]);
+  }
+  return result;
+}
+
+function convexHull(points) {
+  var pts = points.slice().sort(function(a,b) { return a[0]-b[0] || a[1]-b[1]; });
+  function cross(O,A,B) { return (A[0]-O[0])*(B[1]-O[1])-(A[1]-O[1])*(B[0]-O[0]); }
+  var lower = [];
+  for (var i = 0; i < pts.length; i++) {
+    while (lower.length >= 2 && cross(lower[lower.length-2], lower[lower.length-1], pts[i]) <= 0) lower.pop();
+    lower.push(pts[i]);
+  }
+  var upper = [];
+  for (var i = pts.length - 1; i >= 0; i--) {
+    while (upper.length >= 2 && cross(upper[upper.length-2], upper[upper.length-1], pts[i]) <= 0) upper.pop();
+    upper.push(pts[i]);
+  }
+  return lower.slice(0, -1).concat(upper.slice(0, -1));
+}
+
+function delaunay(points) {
+  var n = points.length;
+  if (n < 3) return [];
+  var ids = new Array(n);
+  for (var i = 0; i < n; i++) ids[i] = i;
+  ids.sort(function(a,b) { return points[a][0]-points[b][0] || points[a][1]-points[b][1]; });
+  var triangles = [];
+  function circumscribed(ax,ay,bx,by,cx,cy,px,py) {
+    var dx=ax-px,dy=ay-py,ex=bx-px,ey=by-py,fx=cx-px,fy=cy-py;
+    var ap=dx*dx+dy*dy,bp=ex*ex+ey*ey,cp=fx*fx+fy*fy;
+    return dx*(ey*cp-bp*fy)-dy*(ex*cp-bp*fx)+ap*(ex*fy-ey*fx) > 0;
+  }
+  var st = [[-1e6,-1e6],[1e6,-1e6],[0,1e6]];
+  triangles.push([n,n+1,n+2]);
+  var all = points.concat(st);
+  for (var i = 0; i < n; i++) {
+    var pi = ids[i], px = all[pi][0], py = all[pi][1];
+    var edges = [], bad = [];
+    for (var j = 0; j < triangles.length; j++) {
+      var t = triangles[j];
+      if (circumscribed(all[t[0]][0],all[t[0]][1],all[t[1]][0],all[t[1]][1],all[t[2]][0],all[t[2]][1],px,py)) {
+        bad.push(j);
+        edges.push([t[0],t[1]],[t[1],t[2]],[t[2],t[0]]);
+      }
+    }
+    for (var j = bad.length-1; j >= 0; j--) triangles.splice(bad[j],1);
+    var unique = [];
+    for (var j = 0; j < edges.length; j++) {
+      var dup = false;
+      for (var k = 0; k < edges.length; k++) {
+        if (j !== k && edges[j][0]===edges[k][1] && edges[j][1]===edges[k][0]) { dup = true; break; }
+      }
+      if (!dup) unique.push(edges[j]);
+    }
+    for (var j = 0; j < unique.length; j++) triangles.push([unique[j][0], unique[j][1], pi]);
+  }
+  return triangles.filter(function(t) { return t[0] < n && t[1] < n && t[2] < n; });
+}
+
+function voronoi(points, width, height, resolution) {
+  resolution = resolution || 1;
+  var cols = Math.ceil(width/resolution), rows = Math.ceil(height/resolution);
+  var cells = new Int32Array(cols * rows);
+  for (var y = 0; y < rows; y++)
+    for (var x = 0; x < cols; x++) {
+      var px = x * resolution, py = y * resolution;
+      var minD = Infinity, minI = 0;
+      for (var i = 0; i < points.length; i++) {
+        var dx = px - points[i][0], dy = py - points[i][1];
+        var d = dx*dx + dy*dy;
+        if (d < minD) { minD = d; minI = i; }
+      }
+      cells[y * cols + x] = minI;
+    }
+  return { cells: cells, cols: cols, rows: rows };
+}
+`,
+  exports: ["chaikinSmooth", "subdivideCurve", "offsetPath", "convexHull", "delaunay", "voronoi"],
+  dependencies: ["vector", "shape"],
+  description: "Computational geometry (Chaikin, convex hull, Delaunay, Voronoi).",
+  usage: `### shape-advanced \u2014 Computational Geometry
+
+\`\`\`js
+var smooth = chaikinSmooth(points, 3);
+var hull = convexHull(points);
+var tris = delaunay(points);
+var v = voronoi(points, 800, 600);
+\`\`\`
+`
+};
+var shape_advanced_default = shapeAdvanced;
+
+// src/components/js/distribution.ts
+var distribution = {
+  name: "distribution",
+  version: "1.0.0",
+  category: "distribution",
+  target: "js",
+  renderers: [],
+  code: `function poissonDisk(rng, width, height, minDist, maxAttempts) {
+  maxAttempts = maxAttempts || 30;
+  var cellSize = minDist / Math.SQRT2;
+  var cols = Math.ceil(width / cellSize), rows = Math.ceil(height / cellSize);
+  var grid = new Array(cols * rows).fill(-1);
+  var points = [], active = [];
+  function addPoint(x, y) {
+    var i = points.length;
+    points.push([x, y]);
+    active.push(i);
+    var gx = Math.floor(x / cellSize), gy = Math.floor(y / cellSize);
+    grid[gy * cols + gx] = i;
+  }
+  addPoint(rng() * width, rng() * height);
+  while (active.length > 0) {
+    var ri = Math.floor(rng() * active.length);
+    var pi = active[ri], p = points[pi];
+    var found = false;
+    for (var attempt = 0; attempt < maxAttempts; attempt++) {
+      var angle = rng() * Math.PI * 2;
+      var dist = minDist + rng() * minDist;
+      var nx = p[0] + Math.cos(angle) * dist, ny = p[1] + Math.sin(angle) * dist;
+      if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+      var gx = Math.floor(nx / cellSize), gy = Math.floor(ny / cellSize);
+      var ok = true;
+      for (var dy = -2; dy <= 2 && ok; dy++)
+        for (var dx = -2; dx <= 2 && ok; dx++) {
+          var cx = gx + dx, cy = gy + dy;
+          if (cx < 0 || cx >= cols || cy < 0 || cy >= rows) continue;
+          var ci = grid[cy * cols + cx];
+          if (ci >= 0) {
+            var cp = points[ci];
+            var d2 = (nx-cp[0])*(nx-cp[0]) + (ny-cp[1])*(ny-cp[1]);
+            if (d2 < minDist * minDist) ok = false;
+          }
+        }
+      if (ok) { addPoint(nx, ny); found = true; break; }
+    }
+    if (!found) active.splice(ri, 1);
+  }
+  return points;
+}
+
+function jitteredGrid(rng, width, height, cellSize, jitter) {
+  jitter = jitter || 0.5;
+  var pts = [];
+  for (var y = cellSize/2; y < height; y += cellSize)
+    for (var x = cellSize/2; x < width; x += cellSize)
+      pts.push([x + (rng()-0.5)*cellSize*jitter, y + (rng()-0.5)*cellSize*jitter]);
+  return pts;
+}
+
+function haltonSequence(n, base1, base2) {
+  base1 = base1 || 2; base2 = base2 || 3;
+  function halton(i, base) {
+    var f = 1, r = 0;
+    while (i > 0) { f /= base; r += f * (i % base); i = Math.floor(i / base); }
+    return r;
+  }
+  var pts = [];
+  for (var i = 0; i < n; i++) pts.push([halton(i+1, base1), halton(i+1, base2)]);
+  return pts;
+}
+
+function uniformOnSphere(rng) {
+  var u = rng(), v = rng();
+  var theta = 2 * Math.PI * u;
+  var phi = Math.acos(2 * v - 1);
+  return [Math.sin(phi)*Math.cos(theta), Math.sin(phi)*Math.sin(theta), Math.cos(phi)];
+}
+
+function gaussianCluster(rng, cx, cy, stddev, count) {
+  var pts = [];
+  for (var i = 0; i < count; i++) {
+    var u1 = rng(), u2 = rng();
+    var r = Math.sqrt(-2 * Math.log(u1 || 1e-10));
+    var theta = 2 * Math.PI * u2;
+    pts.push([cx + r * Math.cos(theta) * stddev, cy + r * Math.sin(theta) * stddev]);
+  }
+  return pts;
+}
+`,
+  exports: ["poissonDisk", "jitteredGrid", "haltonSequence", "uniformOnSphere", "gaussianCluster"],
+  dependencies: ["prng"],
+  description: "Point distribution algorithms (Poisson disk, Halton, jittered grid).",
+  usage: `### distribution \u2014 Point Distributions
+
+\`\`\`js
+var pts = poissonDisk(rng, 800, 600, 20);
+var grid = jitteredGrid(rng, 800, 600, 40, 0.5);
+var halton = haltonSequence(100, 2, 3);
+var sphere = uniformOnSphere(rng);
+\`\`\`
+`
+};
+var distribution_default = distribution;
+
+// src/components/js/distribution-advanced.ts
+var distributionAdvanced = {
+  name: "distribution-advanced",
+  version: "1.0.0",
+  category: "distribution",
+  target: "js",
+  renderers: [],
+  code: `function blueNoise(rng, width, height, count) {
+  var pts = poissonDisk(rng, width, height, Math.sqrt(width * height / count));
+  return pts.slice(0, count);
+}
+
+function lloydRelaxation(points, width, height, iterations) {
+  var pts = points.map(function(p) { return [p[0], p[1]]; });
+  for (var iter = 0; iter < iterations; iter++) {
+    var v = voronoi(pts, width, height, 2);
+    var sums = new Array(pts.length);
+    var counts = new Array(pts.length);
+    for (var i = 0; i < pts.length; i++) { sums[i] = [0, 0]; counts[i] = 0; }
+    for (var y = 0; y < v.rows; y++)
+      for (var x = 0; x < v.cols; x++) {
+        var ci = v.cells[y * v.cols + x];
+        sums[ci][0] += x * 2; sums[ci][1] += y * 2;
+        counts[ci]++;
+      }
+    for (var i = 0; i < pts.length; i++) {
+      if (counts[i] > 0) {
+        pts[i] = [sums[i][0] / counts[i], sums[i][1] / counts[i]];
+      }
+    }
+  }
+  return pts;
+}
+
+function fibonacciSphere(n) {
+  var pts = [];
+  var goldenAngle = Math.PI * (3 - Math.sqrt(5));
+  for (var i = 0; i < n; i++) {
+    var y = 1 - (i / (n - 1)) * 2;
+    var radius = Math.sqrt(1 - y * y);
+    var theta = goldenAngle * i;
+    pts.push([Math.cos(theta) * radius, y, Math.sin(theta) * radius]);
+  }
+  return pts;
+}
+
+function uniformOnDisk(rng, count) {
+  var pts = [];
+  for (var i = 0; i < count; i++) {
+    var r = Math.sqrt(rng());
+    var theta = rng() * Math.PI * 2;
+    pts.push([r * Math.cos(theta), r * Math.sin(theta)]);
+  }
+  return pts;
+}
+
+function stratifiedSample(rng, width, height, nx, ny) {
+  var pts = [];
+  var cw = width / nx, ch = height / ny;
+  for (var y = 0; y < ny; y++)
+    for (var x = 0; x < nx; x++)
+      pts.push([x * cw + rng() * cw, y * ch + rng() * ch]);
+  return pts;
+}
+`,
+  exports: ["blueNoise", "lloydRelaxation", "fibonacciSphere", "uniformOnDisk", "stratifiedSample"],
+  dependencies: ["prng", "distribution"],
+  description: "Advanced spatial sampling (blue noise, Lloyd, Fibonacci sphere).",
+  usage: `### distribution-advanced \u2014 Advanced Sampling
+
+\`\`\`js
+var pts = blueNoise(rng, 800, 600, 200);
+var relaxed = lloydRelaxation(pts, 800, 600, 5);
+var sphere = fibonacciSphere(100);
+var disk = uniformOnDisk(rng, 50);
+\`\`\`
+`
+};
+var distribution_advanced_default = distributionAdvanced;
+
+// src/components/js/physics-spring.ts
+var physicsSpring = {
+  name: "physics-spring",
+  version: "1.0.0",
+  category: "physics",
+  target: "js",
+  renderers: [],
+  code: `function createSpring(restLength, stiffness, damping) {
+  return { restLength: restLength, stiffness: stiffness || 100, damping: damping || 5 };
+}
+
+function springSystem(points, springs) {
+  return { points: points, springs: springs };
+}
+
+function springStep(system, dt) {
+  dt = dt || 1/60;
+  for (var i = 0; i < system.springs.length; i++) {
+    var s = system.springs[i];
+    var a = system.points[s.a], b = system.points[s.b];
+    var dx = b.x - a.x, dy = b.y - a.y;
+    var dist = Math.sqrt(dx * dx + dy * dy) || 0.001;
+    var force = s.stiffness * (dist - s.restLength);
+    var dvx = b.vx - a.vx, dvy = b.vy - a.vy;
+    var dampF = s.damping * (dvx * dx + dvy * dy) / dist;
+    var fx = (force + dampF) * dx / dist;
+    var fy = (force + dampF) * dy / dist;
+    a.vx += fx * dt; a.vy += fy * dt;
+    b.vx -= fx * dt; b.vy -= fy * dt;
+  }
+  for (var i = 0; i < system.points.length; i++) {
+    var p = system.points[i];
+    if (p.fixed) continue;
+    p.x += p.vx * dt; p.y += p.vy * dt;
+  }
+}
+
+function dampedHarmonic(x, v, target, stiffness, damping, dt) {
+  var force = -stiffness * (x - target) - damping * v;
+  v += force * dt;
+  x += v * dt;
+  return { x: x, v: v };
+}
+`,
+  exports: ["springSystem", "springStep", "createSpring", "dampedHarmonic"],
+  dependencies: ["vector"],
+  description: "Spring-based physics simulation.",
+  usage: `### physics-spring \u2014 Spring Physics
+
+\`\`\`js
+var points = [{x:0,y:0,vx:0,vy:0,fixed:true}, {x:100,y:0,vx:0,vy:0}];
+var springs = [{a:0, b:1, restLength:50, stiffness:100, damping:5}];
+var sys = springSystem(points, springs);
+springStep(sys, 1/60);
+\`\`\`
+`
+};
+var physics_spring_default = physicsSpring;
+
+// src/components/js/physics-verlet.ts
+var physicsVerlet = {
+  name: "physics-verlet",
+  version: "1.0.0",
+  category: "physics",
+  target: "js",
+  renderers: [],
+  code: `function verletSystem(points) {
+  return {
+    points: points.map(function(p) {
+      return { x: p.x, y: p.y, px: p.x, py: p.y, ax: 0, ay: 0, fixed: p.fixed || false };
+    }),
+    constraints: []
+  };
+}
+
+function verletStep(system, dt) {
+  dt = dt || 1/60;
+  var dt2 = dt * dt;
+  for (var i = 0; i < system.points.length; i++) {
+    var p = system.points[i];
+    if (p.fixed) continue;
+    var nx = 2 * p.x - p.px + p.ax * dt2;
+    var ny = 2 * p.y - p.py + p.ay * dt2;
+    p.px = p.x; p.py = p.y;
+    p.x = nx; p.y = ny;
+    p.ax = 0; p.ay = 0;
+  }
+  solveConstraints(system, 3);
+}
+
+function addConstraint(system, a, b, restLength) {
+  system.constraints.push({
+    a: a, b: b,
+    restLength: restLength !== undefined ? restLength :
+      Math.sqrt(Math.pow(system.points[a].x - system.points[b].x, 2) + Math.pow(system.points[a].y - system.points[b].y, 2))
+  });
+}
+
+function solveConstraints(system, iterations) {
+  iterations = iterations || 3;
+  for (var iter = 0; iter < iterations; iter++) {
+    for (var i = 0; i < system.constraints.length; i++) {
+      var c = system.constraints[i];
+      var a = system.points[c.a], b = system.points[c.b];
+      var dx = b.x - a.x, dy = b.y - a.y;
+      var dist = Math.sqrt(dx * dx + dy * dy) || 0.001;
+      var diff = (c.restLength - dist) / dist * 0.5;
+      var ox = dx * diff, oy = dy * diff;
+      if (!a.fixed) { a.x -= ox; a.y -= oy; }
+      if (!b.fixed) { b.x += ox; b.y += oy; }
+    }
+  }
+}
+`,
+  exports: ["verletSystem", "verletStep", "addConstraint", "solveConstraints"],
+  dependencies: ["vector"],
+  description: "Verlet integration with distance constraints.",
+  usage: `### physics-verlet \u2014 Verlet Integration
+
+\`\`\`js
+var sys = verletSystem([{x:0,y:0,fixed:true},{x:50,y:0},{x:100,y:0}]);
+addConstraint(sys, 0, 1); addConstraint(sys, 1, 2);
+sys.points[2].ay = 98; // gravity
+verletStep(sys, 1/60);
+\`\`\`
+`
+};
+var physics_verlet_default = physicsVerlet;
+
+// src/components/js/physics-rk4.ts
+var physicsRk4 = {
+  name: "physics-rk4",
+  version: "1.0.0",
+  category: "physics",
+  target: "js",
+  renderers: [],
+  code: `function rk4Step(state, derivsFn, dt) {
+  var n = state.length;
+  var k1 = derivsFn(state);
+  var s2 = new Array(n);
+  for (var i = 0; i < n; i++) s2[i] = state[i] + k1[i] * dt / 2;
+  var k2 = derivsFn(s2);
+  var s3 = new Array(n);
+  for (var i = 0; i < n; i++) s3[i] = state[i] + k2[i] * dt / 2;
+  var k3 = derivsFn(s3);
+  var s4 = new Array(n);
+  for (var i = 0; i < n; i++) s4[i] = state[i] + k3[i] * dt;
+  var k4 = derivsFn(s4);
+  var result = new Array(n);
+  for (var i = 0; i < n; i++)
+    result[i] = state[i] + (k1[i] + 2*k2[i] + 2*k3[i] + k4[i]) * dt / 6;
+  return result;
+}
+
+function rk4System(initialState, derivsFn, dt, steps) {
+  var state = initialState.slice();
+  var trajectory = [state.slice()];
+  for (var s = 0; s < steps; s++) {
+    state = rk4Step(state, derivsFn, dt);
+    trajectory.push(state.slice());
+  }
+  return trajectory;
+}
+
+function lorenzAttractor(sigma, rho, beta) {
+  sigma = sigma || 10; rho = rho || 28; beta = beta || 8/3;
+  return function(state) {
+    return [
+      sigma * (state[1] - state[0]),
+      state[0] * (rho - state[2]) - state[1],
+      state[0] * state[1] - beta * state[2]
+    ];
+  };
+}
+
+function phasePortrait(derivsFn, xRange, yRange, gridSize) {
+  var arrows = [];
+  var dx = (xRange[1] - xRange[0]) / gridSize;
+  var dy = (yRange[1] - yRange[0]) / gridSize;
+  for (var i = 0; i <= gridSize; i++) {
+    for (var j = 0; j <= gridSize; j++) {
+      var x = xRange[0] + i * dx, y = yRange[0] + j * dy;
+      var d = derivsFn([x, y]);
+      arrows.push({ x: x, y: y, dx: d[0], dy: d[1] });
+    }
+  }
+  return arrows;
+}
+`,
+  exports: ["rk4Step", "rk4System", "lorenzAttractor", "phasePortrait"],
+  dependencies: ["vector"],
+  description: "Runge-Kutta integration and common ODEs (Lorenz attractor).",
+  usage: `### physics-rk4 \u2014 RK4 Integration
+
+\`\`\`js
+var lorenz = lorenzAttractor(10, 28, 8/3);
+var traj = rk4System([1,1,1], lorenz, 0.01, 5000);
+\`\`\`
+`
+};
+var physics_rk4_default = physicsRk4;
+
+// src/components/js/flow-field.ts
+var flowField = {
+  name: "flow-field",
+  version: "1.0.0",
+  category: "pattern",
+  target: "js",
+  renderers: [],
+  code: `function createFlowField(cols, rows, angleFn) {
+  var field = new Float64Array(cols * rows);
+  for (var y = 0; y < rows; y++)
+    for (var x = 0; x < cols; x++)
+      field[y * cols + x] = angleFn(x, y);
+  return { field: field, cols: cols, rows: rows };
+}
+
+function flowFromNoise(noiseFn, cols, rows, scale) {
+  return createFlowField(cols, rows, function(x, y) {
+    return noiseFn(x * scale, y * scale) * Math.PI * 4;
+  });
+}
+
+function flowFromFunction(fn, cols, rows) {
+  return createFlowField(cols, rows, fn);
+}
+
+function traceStreamline(field, startX, startY, cellSize, steps, stepSize) {
+  stepSize = stepSize || 1;
+  var pts = [[startX, startY]];
+  var x = startX, y = startY;
+  for (var i = 0; i < steps; i++) {
+    var gx = Math.floor(x / cellSize), gy = Math.floor(y / cellSize);
+    if (gx < 0 || gx >= field.cols || gy < 0 || gy >= field.rows) break;
+    var angle = field.field[gy * field.cols + gx];
+    x += Math.cos(angle) * stepSize;
+    y += Math.sin(angle) * stepSize;
+    pts.push([x, y]);
+  }
+  return pts;
+}
+`,
+  exports: ["createFlowField", "traceStreamline", "flowFromNoise", "flowFromFunction"],
+  dependencies: ["noise-2d", "vector"],
+  description: "Flow field generation and streamline tracing.",
+  usage: `### flow-field \u2014 Flow Fields
+
+\`\`\`js
+var field = flowFromNoise(perlin2D(rng), 80, 60, 0.03);
+var line = traceStreamline(field, startX, startY, 10, 200, 1);
+\`\`\`
+`
+};
+var flow_field_default = flowField;
+
+// src/components/js/l-system.ts
+var lSystem = {
+  name: "l-system",
+  version: "1.0.0",
+  category: "pattern",
+  target: "js",
+  renderers: [],
+  code: `function createLSystem(axiom, rules) {
+  return { axiom: axiom, rules: rules, current: axiom };
+}
+
+function iterateLSystem(system, iterations) {
+  var str = system.current;
+  for (var iter = 0; iter < iterations; iter++) {
+    var next = '';
+    for (var i = 0; i < str.length; i++) {
+      var ch = str[i];
+      next += system.rules[ch] !== undefined ? system.rules[ch] : ch;
+    }
+    str = next;
+  }
+  system.current = str;
+  return str;
+}
+
+function turtleInterpret(str, stepLength, angleDeg) {
+  var x = 0, y = 0, angle = -90;
+  var rad = angleDeg * Math.PI / 180;
+  var path = [[x, y]];
+  var stack = [];
+  for (var i = 0; i < str.length; i++) {
+    var ch = str[i];
+    if (ch === 'F' || ch === 'G') {
+      x += Math.cos(angle * Math.PI / 180) * stepLength;
+      y += Math.sin(angle * Math.PI / 180) * stepLength;
+      path.push([x, y]);
+    } else if (ch === 'f') {
+      x += Math.cos(angle * Math.PI / 180) * stepLength;
+      y += Math.sin(angle * Math.PI / 180) * stepLength;
+      path.push(null);
+      path.push([x, y]);
+    } else if (ch === '+') { angle += angleDeg; }
+    else if (ch === '-') { angle -= angleDeg; }
+    else if (ch === '[') { stack.push({ x: x, y: y, angle: angle }); }
+    else if (ch === ']') {
+      var s = stack.pop();
+      x = s.x; y = s.y; angle = s.angle;
+      path.push(null);
+      path.push([x, y]);
+    }
+  }
+  return path;
+}
+`,
+  exports: ["createLSystem", "iterateLSystem", "turtleInterpret"],
+  dependencies: ["math"],
+  description: "L-system grammar iteration and turtle graphics interpretation.",
+  usage: `### l-system \u2014 L-Systems
+
+\`\`\`js
+var sys = createLSystem('F', { 'F': 'F[+F]F[-F]F' });
+var str = iterateLSystem(sys, 4);
+var path = turtleInterpret(str, 5, 25.7);
+\`\`\`
+`
+};
+var l_system_default = lSystem;
+
+// src/components/js/reaction-diffusion.ts
+var reactionDiffusion = {
+  name: "reaction-diffusion",
+  version: "1.0.0",
+  category: "pattern",
+  target: "js",
+  renderers: [],
+  code: `function createGrayScottGrid(cols, rows) {
+  var a = new Float64Array(cols * rows).fill(1);
+  var b = new Float64Array(cols * rows).fill(0);
+  return { a: a, b: b, cols: cols, rows: rows };
+}
+
+function grayScottStep(grid, feed, kill, dA, dB, dt) {
+  feed = feed || 0.037; kill = kill || 0.06;
+  dA = dA || 1.0; dB = dB || 0.5; dt = dt || 1.0;
+  var cols = grid.cols, rows = grid.rows;
+  var a = grid.a, b = grid.b;
+  var na = new Float64Array(cols * rows);
+  var nb = new Float64Array(cols * rows);
+  for (var y = 0; y < rows; y++) {
+    for (var x = 0; x < cols; x++) {
+      var i = y * cols + x;
+      var up = ((y-1+rows)%rows)*cols+x, dn = ((y+1)%rows)*cols+x;
+      var lt = y*cols+(x-1+cols)%cols, rt = y*cols+(x+1)%cols;
+      var lapA = a[up]+a[dn]+a[lt]+a[rt]-4*a[i];
+      var lapB = b[up]+b[dn]+b[lt]+b[rt]-4*b[i];
+      var abb = a[i] * b[i] * b[i];
+      na[i] = a[i] + (dA * lapA - abb + feed * (1 - a[i])) * dt;
+      nb[i] = b[i] + (dB * lapB + abb - (kill + feed) * b[i]) * dt;
+    }
+  }
+  grid.a = na; grid.b = nb;
+  return grid;
+}
+
+function turingPattern(cols, rows, steps, feed, kill, rng) {
+  var grid = createGrayScottGrid(cols, rows);
+  var cx = cols/2, cy = rows/2, r = Math.min(cols, rows)/6;
+  for (var y = Math.floor(cy-r); y <= Math.ceil(cy+r); y++)
+    for (var x = Math.floor(cx-r); x <= Math.ceil(cx+r); x++)
+      if ((x-cx)*(x-cx)+(y-cy)*(y-cy) < r*r) {
+        var i = y * cols + x;
+        grid.b[i] = 1;
+        if (rng) { grid.a[i] += (rng()-0.5)*0.01; grid.b[i] += (rng()-0.5)*0.01; }
+      }
+  for (var s = 0; s < steps; s++) grayScottStep(grid, feed, kill);
+  return grid;
+}
+`,
+  exports: ["grayScottStep", "createGrayScottGrid", "turingPattern"],
+  dependencies: [],
+  description: "Reaction-diffusion simulation (Gray-Scott model).",
+  usage: `### reaction-diffusion \u2014 Gray-Scott
+
+\`\`\`js
+var grid = createGrayScottGrid(200, 200);
+// seed center region with chemical B
+for (var s = 0; s < 5000; s++) grayScottStep(grid, 0.037, 0.06);
+// grid.b contains the pattern
+\`\`\`
+`
+};
+var reaction_diffusion_default = reactionDiffusion;
+
+// src/components/js/dla.ts
+var dla = {
+  name: "dla",
+  version: "1.0.0",
+  category: "pattern",
+  target: "js",
+  renderers: [],
+  code: `function diffusionLimitedAggregation(rng, width, height, seedCount, walkerCount, stickiness) {
+  stickiness = stickiness || 1;
+  var grid = new Uint8Array(width * height);
+  for (var i = 0; i < seedCount; i++) {
+    var sx = Math.floor(width / 2 + (rng() - 0.5) * 10);
+    var sy = Math.floor(height / 2 + (rng() - 0.5) * 10);
+    if (sx >= 0 && sx < width && sy >= 0 && sy < height) grid[sy * width + sx] = 1;
+  }
+  var attached = [];
+  for (var y = 0; y < height; y++)
+    for (var x = 0; x < width; x++)
+      if (grid[y * width + x]) attached.push([x, y]);
+
+  for (var w = 0; w < walkerCount; w++) {
+    var wx = Math.floor(rng() * width), wy = Math.floor(rng() * height);
+    var stuck = false;
+    for (var step = 0; step < 10000 && !stuck; step++) {
+      wx += Math.round(rng() * 2 - 1);
+      wy += Math.round(rng() * 2 - 1);
+      if (wx < 0 || wx >= width || wy < 0 || wy >= height) {
+        wx = Math.floor(rng() * width);
+        wy = Math.floor(rng() * height);
+        continue;
+      }
+      for (var dx = -1; dx <= 1 && !stuck; dx++)
+        for (var dy = -1; dy <= 1 && !stuck; dy++) {
+          var nx = wx + dx, ny = wy + dy;
+          if (nx >= 0 && nx < width && ny >= 0 && ny < height && grid[ny * width + nx]) {
+            if (rng() < stickiness) {
+              grid[wy * width + wx] = 1;
+              attached.push([wx, wy]);
+              stuck = true;
+            }
+          }
+        }
+    }
+  }
+  return { grid: grid, points: attached, width: width, height: height };
+}
+
+function dlaStep(state, rng, walkers, stickiness) {
+  walkers = walkers || 100;
+  stickiness = stickiness || 1;
+  var w = state.width, h = state.height, grid = state.grid;
+  for (var i = 0; i < walkers; i++) {
+    var wx = Math.floor(rng() * w), wy = Math.floor(rng() * h);
+    for (var step = 0; step < 500; step++) {
+      wx += Math.round(rng() * 2 - 1);
+      wy += Math.round(rng() * 2 - 1);
+      if (wx < 0 || wx >= w || wy < 0 || wy >= h) break;
+      var hasN = false;
+      for (var dx = -1; dx <= 1 && !hasN; dx++)
+        for (var dy = -1; dy <= 1 && !hasN; dy++) {
+          var nx = wx + dx, ny = wy + dy;
+          if (nx >= 0 && nx < w && ny >= 0 && ny < h && grid[ny * w + nx]) hasN = true;
+        }
+      if (hasN && rng() < stickiness) {
+        grid[wy * w + wx] = 1;
+        state.points.push([wx, wy]);
+        break;
+      }
+    }
+  }
+  return state;
+}
+`,
+  exports: ["diffusionLimitedAggregation", "dlaStep"],
+  dependencies: ["prng"],
+  description: "Diffusion-limited aggregation (DLA) pattern generation.",
+  usage: `### dla \u2014 Diffusion-Limited Aggregation
+
+\`\`\`js
+var state = diffusionLimitedAggregation(rng, 400, 400, 1, 5000, 0.8);
+// state.grid \u2014 occupancy grid
+// state.points \u2014 attached point coordinates
+\`\`\`
+`
+};
+var dla_default = dla;
+
+// src/components/js/boids.ts
+var boids = {
+  name: "boids",
+  version: "1.0.0",
+  category: "particle",
+  target: "js",
+  renderers: [],
+  code: `function createBoidSystem(count, rng, width, height) {
+  var boids = [];
+  for (var i = 0; i < count; i++) {
+    var angle = rng() * Math.PI * 2;
+    var speed = 1 + rng() * 2;
+    boids.push({
+      x: rng() * width, y: rng() * height,
+      vx: Math.cos(angle) * speed, vy: Math.sin(angle) * speed
+    });
+  }
+  return { boids: boids, width: width, height: height };
+}
+
+function separationForce(boid, neighbors, sepDist) {
+  var sx = 0, sy = 0;
+  for (var i = 0; i < neighbors.length; i++) {
+    var dx = boid.x - neighbors[i].x, dy = boid.y - neighbors[i].y;
+    var d = Math.sqrt(dx*dx + dy*dy);
+    if (d > 0 && d < sepDist) { sx += dx / d; sy += dy / d; }
+  }
+  return [sx, sy];
+}
+
+function alignmentForce(boid, neighbors) {
+  if (neighbors.length === 0) return [0, 0];
+  var ax = 0, ay = 0;
+  for (var i = 0; i < neighbors.length; i++) {
+    ax += neighbors[i].vx; ay += neighbors[i].vy;
+  }
+  return [(ax / neighbors.length - boid.vx) * 0.1, (ay / neighbors.length - boid.vy) * 0.1];
+}
+
+function cohesionForce(boid, neighbors) {
+  if (neighbors.length === 0) return [0, 0];
+  var cx = 0, cy = 0;
+  for (var i = 0; i < neighbors.length; i++) {
+    cx += neighbors[i].x; cy += neighbors[i].y;
+  }
+  return [(cx / neighbors.length - boid.x) * 0.005, (cy / neighbors.length - boid.y) * 0.005];
+}
+
+function updateBoids(system, perception, sepDist, maxSpeed) {
+  perception = perception || 50; sepDist = sepDist || 25; maxSpeed = maxSpeed || 4;
+  for (var i = 0; i < system.boids.length; i++) {
+    var b = system.boids[i];
+    var neighbors = [];
+    for (var j = 0; j < system.boids.length; j++) {
+      if (i === j) continue;
+      var dx = system.boids[j].x - b.x, dy = system.boids[j].y - b.y;
+      if (dx*dx + dy*dy < perception * perception) neighbors.push(system.boids[j]);
+    }
+    var sep = separationForce(b, neighbors, sepDist);
+    var ali = alignmentForce(b, neighbors);
+    var coh = cohesionForce(b, neighbors);
+    b.vx += sep[0] * 0.15 + ali[0] + coh[0];
+    b.vy += sep[1] * 0.15 + ali[1] + coh[1];
+    var spd = Math.sqrt(b.vx*b.vx + b.vy*b.vy);
+    if (spd > maxSpeed) { b.vx = b.vx/spd*maxSpeed; b.vy = b.vy/spd*maxSpeed; }
+    b.x += b.vx; b.y += b.vy;
+    if (b.x < 0) b.x += system.width;
+    if (b.x > system.width) b.x -= system.width;
+    if (b.y < 0) b.y += system.height;
+    if (b.y > system.height) b.y -= system.height;
+  }
+}
+`,
+  exports: ["createBoidSystem", "updateBoids", "separationForce", "alignmentForce", "cohesionForce"],
+  dependencies: ["vector"],
+  description: "Boid flocking algorithm (separation, alignment, cohesion).",
+  usage: `### boids \u2014 Flocking Algorithm
+
+\`\`\`js
+var sys = createBoidSystem(200, rng, width, height);
+updateBoids(sys, 50, 25, 4);
+sys.boids.forEach(function(b) { drawBoid(b); });
+\`\`\`
+`
+};
+var boids_default = boids;
+
+// src/components/js/wave.ts
+var wave = {
+  name: "wave",
+  version: "1.0.0",
+  category: "animation",
+  target: "js",
+  renderers: [],
+  code: `function sineWave(t, freq, amp, phase) {
+  return (amp || 1) * Math.sin(2 * Math.PI * (freq || 1) * t + (phase || 0));
+}
+
+function squareWave(t, freq) {
+  return Math.sin(2 * Math.PI * (freq || 1) * t) >= 0 ? 1 : -1;
+}
+
+function sawtoothWave(t, freq) {
+  var p = t * (freq || 1);
+  return 2 * (p - Math.floor(p + 0.5));
+}
+
+function triangleWave(t, freq) {
+  var p = t * (freq || 1);
+  return 4 * Math.abs(p - Math.floor(p + 0.75) + 0.25) - 1;
+}
+
+function waveSum(waveFns, t) {
+  var sum = 0;
+  for (var i = 0; i < waveFns.length; i++) sum += waveFns[i](t);
+  return sum;
+}
+
+function standingWave(x, t, freq, wavelength) {
+  return Math.sin(2 * Math.PI * x / (wavelength || 1)) * Math.cos(2 * Math.PI * (freq || 1) * t);
+}
+`,
+  exports: ["sineWave", "squareWave", "sawtoothWave", "triangleWave", "waveSum", "standingWave"],
+  dependencies: ["math"],
+  description: "Periodic wave functions (sine, square, sawtooth, triangle).",
+  usage: `### wave \u2014 Wave Functions
+
+\`\`\`js
+sineWave(t, 2, 1, 0);    // 2 Hz sine
+squareWave(t, 1);         // 1 Hz square
+triangleWave(t, 0.5);     // 0.5 Hz triangle
+standingWave(x, t, 1, 100);
+\`\`\`
+`
+};
+var wave_default = wave;
+
+// src/components/js/animation.ts
+var animation = {
+  name: "animation",
+  version: "1.0.0",
+  category: "animation",
+  target: "js",
+  renderers: [],
+  code: `function pingPong(t) {
+  t = t % 2;
+  return t <= 1 ? t : 2 - t;
+}
+
+function loop(t, duration) {
+  return (t % duration) / duration;
+}
+
+function oscillate(t, min, max, freq) {
+  return min + (max - min) * 0.5 * (1 + Math.sin(2 * Math.PI * (freq || 1) * t));
+}
+
+function stagger(index, total, duration, offset) {
+  offset = offset || 0.1;
+  return Math.max(0, Math.min(1, (duration - index * offset) / (duration - (total-1) * offset)));
+}
+
+function timeline(t, keyframes) {
+  for (var i = 0; i < keyframes.length - 1; i++) {
+    var a = keyframes[i], b = keyframes[i+1];
+    if (t >= a.t && t <= b.t) {
+      var p = (t - a.t) / (b.t - a.t);
+      if (b.ease) p = b.ease(p);
+      return a.value + (b.value - a.value) * p;
+    }
+  }
+  return keyframes[keyframes.length - 1].value;
+}
+
+function sequence(t, segments) {
+  var totalDuration = 0;
+  for (var i = 0; i < segments.length; i++) totalDuration += segments[i].duration;
+  t = t % totalDuration;
+  var elapsed = 0;
+  for (var i = 0; i < segments.length; i++) {
+    if (t < elapsed + segments[i].duration) {
+      var local = (t - elapsed) / segments[i].duration;
+      return segments[i].fn(local);
+    }
+    elapsed += segments[i].duration;
+  }
+  return segments[segments.length - 1].fn(1);
+}
+`,
+  exports: ["pingPong", "loop", "oscillate", "stagger", "timeline", "sequence"],
+  dependencies: ["math", "easing"],
+  description: "Animation timing utilities (ping-pong, stagger, timeline, sequence).",
+  usage: `### animation \u2014 Timing Utilities
+
+\`\`\`js
+pingPong(t);              // 0\u21921\u21920\u21921...
+loop(t, 5);               // repeats every 5 seconds
+oscillate(t, 0, 100, 2);  // bounces 0\u2194100 at 2 Hz
+timeline(t, [
+  { t: 0, value: 0 },
+  { t: 1, value: 100, ease: easeInOutCubic },
+  { t: 2, value: 50 }
+]);
+\`\`\`
+`
+};
+var animation_default = animation;
+
+// src/components/js/quadtree.ts
+var quadtree = {
+  name: "quadtree",
+  version: "1.0.0",
+  category: "data-structure",
+  target: "js",
+  renderers: [],
+  code: `function createQuadTree(x, y, w, h, capacity) {
+  return { x: x, y: y, w: w, h: h, capacity: capacity || 4, points: [], children: null };
+}
+
+function insertPoint(qt, px, py, data) {
+  if (px < qt.x || px >= qt.x + qt.w || py < qt.y || py >= qt.y + qt.h) return false;
+  if (qt.points.length < qt.capacity && !qt.children) {
+    qt.points.push({ x: px, y: py, data: data });
+    return true;
+  }
+  if (!qt.children) {
+    var hw = qt.w/2, hh = qt.h/2;
+    qt.children = [
+      createQuadTree(qt.x, qt.y, hw, hh, qt.capacity),
+      createQuadTree(qt.x+hw, qt.y, hw, hh, qt.capacity),
+      createQuadTree(qt.x, qt.y+hh, hw, hh, qt.capacity),
+      createQuadTree(qt.x+hw, qt.y+hh, hw, hh, qt.capacity)
+    ];
+    for (var i = 0; i < qt.points.length; i++) {
+      var p = qt.points[i];
+      for (var c = 0; c < 4; c++) if (insertPoint(qt.children[c], p.x, p.y, p.data)) break;
+    }
+    qt.points = [];
+  }
+  for (var c = 0; c < 4; c++) if (insertPoint(qt.children[c], px, py, data)) return true;
+  return false;
+}
+
+function queryRange(qt, rx, ry, rw, rh) {
+  var found = [];
+  if (qt.x + qt.w < rx || qt.x > rx + rw || qt.y + qt.h < ry || qt.y > ry + rh) return found;
+  for (var i = 0; i < qt.points.length; i++) {
+    var p = qt.points[i];
+    if (p.x >= rx && p.x <= rx + rw && p.y >= ry && p.y <= ry + rh) found.push(p);
+  }
+  if (qt.children) {
+    for (var c = 0; c < 4; c++) found = found.concat(queryRange(qt.children[c], rx, ry, rw, rh));
+  }
+  return found;
+}
+
+function queryRadius(qt, cx, cy, r) {
+  var found = [];
+  var r2 = r * r;
+  function search(node) {
+    if (cx - r > node.x + node.w || cx + r < node.x || cy - r > node.y + node.h || cy + r < node.y) return;
+    for (var i = 0; i < node.points.length; i++) {
+      var p = node.points[i];
+      var dx = p.x - cx, dy = p.y - cy;
+      if (dx*dx + dy*dy <= r2) found.push(p);
+    }
+    if (node.children) for (var c = 0; c < 4; c++) search(node.children[c]);
+  }
+  search(qt);
+  return found;
+}
+`,
+  exports: ["createQuadTree", "insertPoint", "queryRange", "queryRadius"],
+  dependencies: [],
+  description: "Quadtree spatial index for efficient neighbor queries.",
+  usage: `### quadtree \u2014 Spatial Index
+
+\`\`\`js
+var qt = createQuadTree(0, 0, 800, 600, 8);
+points.forEach(function(p) { insertPoint(qt, p.x, p.y, p); });
+var nearby = queryRadius(qt, mouseX, mouseY, 50);
+\`\`\`
+`
+};
+var quadtree_default = quadtree;
+
+// src/components/js/spatial-hash.ts
+var spatialHash = {
+  name: "spatial-hash",
+  version: "1.0.0",
+  category: "data-structure",
+  target: "js",
+  renderers: [],
+  code: `function createSpatialHash(cellSize) {
+  return { cellSize: cellSize, cells: {} };
+}
+
+function insertCell(hash, x, y, data) {
+  var cx = Math.floor(x / hash.cellSize);
+  var cy = Math.floor(y / hash.cellSize);
+  var key = cx + ',' + cy;
+  if (!hash.cells[key]) hash.cells[key] = [];
+  hash.cells[key].push({ x: x, y: y, data: data });
+}
+
+function queryNearby(hash, x, y, radius) {
+  var cs = hash.cellSize;
+  var minCx = Math.floor((x - radius) / cs);
+  var maxCx = Math.floor((x + radius) / cs);
+  var minCy = Math.floor((y - radius) / cs);
+  var maxCy = Math.floor((y + radius) / cs);
+  var r2 = radius * radius;
+  var results = [];
+  for (var cy = minCy; cy <= maxCy; cy++) {
+    for (var cx = minCx; cx <= maxCx; cx++) {
+      var cell = hash.cells[cx + ',' + cy];
+      if (!cell) continue;
+      for (var i = 0; i < cell.length; i++) {
+        var p = cell[i];
+        var dx = p.x - x, dy = p.y - y;
+        if (dx * dx + dy * dy <= r2) results.push(p);
+      }
+    }
+  }
+  return results;
+}
+`,
+  exports: ["createSpatialHash", "insertCell", "queryNearby"],
+  dependencies: [],
+  description: "Grid-based spatial hashing for fast neighbor lookups.",
+  usage: `### spatial-hash \u2014 Spatial Hashing
+
+\`\`\`js
+var hash = createSpatialHash(50);
+points.forEach(function(p) { insertCell(hash, p.x, p.y, p); });
+var nearby = queryNearby(hash, x, y, 100);
+\`\`\`
+`
+};
+var spatial_hash_default = spatialHash;
+
+// src/components/js/turtle.ts
+var turtle = {
+  name: "turtle",
+  version: "1.0.0",
+  category: "geometry",
+  target: "js",
+  renderers: [],
+  code: `function createTurtle(x, y, angle) {
+  return { x: x || 0, y: y || 0, angle: angle || 0, pen: true, path: [[x || 0, y || 0]] };
+}
+
+function forward(t, dist) {
+  var rad = t.angle * Math.PI / 180;
+  t.x += Math.cos(rad) * dist;
+  t.y += Math.sin(rad) * dist;
+  if (t.pen) t.path.push([t.x, t.y]);
+  return t;
+}
+
+function turn(t, degrees) {
+  t.angle += degrees;
+  return t;
+}
+
+function penUp(t) {
+  t.pen = false;
+  return t;
+}
+
+function penDown(t) {
+  t.pen = true;
+  t.path.push(null);
+  t.path.push([t.x, t.y]);
+  return t;
+}
+
+function getPath(t) {
+  return t.path;
+}
+`,
+  exports: ["createTurtle", "forward", "turn", "penUp", "penDown", "getPath"],
+  dependencies: ["vector"],
+  description: "Turtle graphics state machine for path generation.",
+  usage: `### turtle \u2014 Turtle Graphics
+
+\`\`\`js
+var t = createTurtle(400, 300, 0);
+for (var i = 0; i < 360; i++) { forward(t, 2); turn(t, 1); }
+var path = getPath(t); // circle-like path
+\`\`\`
+`
+};
+var turtle_default = turtle;
+
+// src/components/js/svg-path.ts
+var svgPath = {
+  name: "svg-path",
+  version: "1.0.0",
+  category: "geometry",
+  target: "js",
+  renderers: [],
+  code: `function pathFromPoints(points, closed) {
+  if (!points.length) return '';
+  var d = 'M ' + points[0][0] + ' ' + points[0][1];
+  for (var i = 1; i < points.length; i++) {
+    if (points[i] === null) {
+      if (i + 1 < points.length && points[i + 1]) {
+        d += ' M ' + points[i + 1][0] + ' ' + points[i + 1][1];
+        i++;
+      }
+    } else {
+      d += ' L ' + points[i][0] + ' ' + points[i][1];
+    }
+  }
+  if (closed) d += ' Z';
+  return d;
+}
+
+function arcPath(cx, cy, r, startAngle, endAngle) {
+  var x1 = cx + r * Math.cos(startAngle), y1 = cy + r * Math.sin(startAngle);
+  var x2 = cx + r * Math.cos(endAngle), y2 = cy + r * Math.sin(endAngle);
+  var largeArc = Math.abs(endAngle - startAngle) > Math.PI ? 1 : 0;
+  return 'M ' + x1 + ' ' + y1 + ' A ' + r + ' ' + r + ' 0 ' + largeArc + ' 1 ' + x2 + ' ' + y2;
+}
+
+function bezierPath(points) {
+  if (points.length < 4) return pathFromPoints(points);
+  var d = 'M ' + points[0][0] + ' ' + points[0][1];
+  for (var i = 1; i + 2 < points.length; i += 3) {
+    d += ' C ' + points[i][0] + ' ' + points[i][1] + ', ' +
+      points[i+1][0] + ' ' + points[i+1][1] + ', ' +
+      points[i+2][0] + ' ' + points[i+2][1];
+  }
+  return d;
+}
+
+function closePath(d) { return d + ' Z'; }
+
+function pathToString(segments) {
+  return segments.join(' ');
+}
+`,
+  exports: ["pathFromPoints", "arcPath", "bezierPath", "closePath", "pathToString"],
+  dependencies: [],
+  description: "SVG path string builders (points to path, arcs, bezier curves).",
+  usage: `### svg-path \u2014 SVG Path Builders
+
+\`\`\`js
+var d = pathFromPoints(points, true); // closed polygon
+var arc = arcPath(100, 100, 50, 0, Math.PI);
+var curve = bezierPath(controlPoints);
+\`\`\`
+`
+};
+var svg_path_default = svgPath;
+
+// src/components/js/canvas-utils.ts
+var canvasUtils = {
+  name: "canvas-utils",
+  version: "1.0.0",
+  category: "imaging",
+  target: "js",
+  renderers: [],
+  code: `function pixelAt(imageData, x, y) {
+  var i = (y * imageData.width + x) * 4;
+  return [imageData.data[i], imageData.data[i+1], imageData.data[i+2], imageData.data[i+3]];
+}
+
+function setPixelAt(imageData, x, y, r, g, b, a) {
+  var i = (y * imageData.width + x) * 4;
+  imageData.data[i] = r; imageData.data[i+1] = g;
+  imageData.data[i+2] = b; imageData.data[i+3] = a !== undefined ? a : 255;
+}
+
+function forEachPixel(imageData, fn) {
+  for (var y = 0; y < imageData.height; y++)
+    for (var x = 0; x < imageData.width; x++) {
+      var i = (y * imageData.width + x) * 4;
+      fn(x, y, imageData.data[i], imageData.data[i+1], imageData.data[i+2], imageData.data[i+3], i);
+    }
+}
+
+function convolve3x3(imageData, kernel) {
+  var w = imageData.width, h = imageData.height;
+  var src = new Uint8ClampedArray(imageData.data);
+  for (var y = 1; y < h-1; y++)
+    for (var x = 1; x < w-1; x++) {
+      var r=0,g=0,b=0;
+      for (var ky = -1; ky <= 1; ky++)
+        for (var kx = -1; kx <= 1; kx++) {
+          var i = ((y+ky)*w+(x+kx))*4;
+          var k = kernel[(ky+1)*3+(kx+1)];
+          r += src[i]*k; g += src[i+1]*k; b += src[i+2]*k;
+        }
+      var oi = (y*w+x)*4;
+      imageData.data[oi] = Math.max(0,Math.min(255,r));
+      imageData.data[oi+1] = Math.max(0,Math.min(255,g));
+      imageData.data[oi+2] = Math.max(0,Math.min(255,b));
+    }
+}
+
+function threshold(imageData, level) {
+  for (var i = 0; i < imageData.data.length; i += 4) {
+    var v = (imageData.data[i]*0.299 + imageData.data[i+1]*0.587 + imageData.data[i+2]*0.114) >= level ? 255 : 0;
+    imageData.data[i] = imageData.data[i+1] = imageData.data[i+2] = v;
+  }
+}
+
+function dither(imageData) {
+  var w = imageData.width, h = imageData.height;
+  var buf = new Float64Array(w * h);
+  for (var i = 0; i < buf.length; i++)
+    buf[i] = imageData.data[i*4]*0.299 + imageData.data[i*4+1]*0.587 + imageData.data[i*4+2]*0.114;
+  for (var y = 0; y < h; y++)
+    for (var x = 0; x < w; x++) {
+      var old = buf[y*w+x];
+      var nw = old < 128 ? 0 : 255;
+      buf[y*w+x] = nw;
+      var err = old - nw;
+      if (x+1<w) buf[y*w+x+1] += err*7/16;
+      if (y+1<h) {
+        if (x>0) buf[(y+1)*w+x-1] += err*3/16;
+        buf[(y+1)*w+x] += err*5/16;
+        if (x+1<w) buf[(y+1)*w+x+1] += err/16;
+      }
+    }
+  for (var i = 0; i < buf.length; i++) {
+    var v = Math.max(0, Math.min(255, Math.round(buf[i])));
+    imageData.data[i*4] = imageData.data[i*4+1] = imageData.data[i*4+2] = v;
+  }
+}
+`,
+  exports: ["pixelAt", "setPixelAt", "forEachPixel", "convolve3x3", "threshold", "dither"],
+  dependencies: [],
+  description: "ImageData pixel manipulation (read, write, convolve, dither).",
+  usage: `### canvas-utils \u2014 Pixel Manipulation
+
+\`\`\`js
+var px = pixelAt(imageData, x, y); // [r, g, b, a]
+setPixelAt(imageData, x, y, 255, 0, 0);
+convolve3x3(imageData, [0,-1,0,-1,5,-1,0,-1,0]); // sharpen
+threshold(imageData, 128);
+dither(imageData); // Floyd-Steinberg
+\`\`\`
+`
+};
+var canvas_utils_default = canvasUtils;
+
+// src/components/glsl/index.ts
+var glsl_exports = {};
+__export(glsl_exports, {
+  glslBlend: () => blend_default,
+  glslColor: () => color_default2,
+  glslCurl: () => curl_default2,
+  glslDomain: () => domain_default,
+  glslEasing: () => easing_default2,
+  glslGradient: () => gradient_default,
+  glslLighting: () => lighting_default,
+  glslMath: () => math_default2,
+  glslNoise: () => noise_default,
+  glslNoise3d: () => noise_3d_default2,
+  glslNoise4d: () => noise_4d_default2,
+  glslPattern: () => pattern_default,
+  glslPost: () => post_default,
+  glslRay: () => ray_default,
+  glslSdf: () => sdf_default,
+  glslSdf3d: () => sdf_3d_default,
+  glslShape: () => shape_default2,
+  glslTransform: () => transform_default
+});
+
+// src/components/glsl/noise.ts
+var glslNoise = {
+  name: "glsl-noise",
+  version: "1.0.0",
+  category: "noise",
+  target: "glsl",
+  renderers: [],
+  code: `float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+float noise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  float a = hash(i);
+  float b = hash(i + vec2(1.0, 0.0));
+  float c = hash(i + vec2(0.0, 1.0));
+  float d = hash(i + vec2(1.0, 1.0));
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+
+float fbm(vec2 p, int octaves) {
+  float val = 0.0, amp = 0.5;
+  for (int i = 0; i < 8; i++) {
+    if (i >= octaves) break;
+    val += amp * noise(p);
+    p *= 2.0;
+    amp *= 0.5;
+  }
+  return val;
+}
+
+float voronoi(vec2 p) {
+  vec2 n = floor(p);
+  vec2 f = fract(p);
+  float minDist = 1.0;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vec2 g = vec2(float(i), float(j));
+      vec2 o = vec2(hash(n + g), hash(n + g + vec2(37.0, 17.0)));
+      vec2 diff = g + o - f;
+      minDist = min(minDist, dot(diff, diff));
+    }
+  }
+  return sqrt(minDist);
+}
+`,
+  exports: ["hash", "noise", "fbm", "voronoi"],
+  dependencies: [],
+  description: "Standard GLSL noise stack (hash, value noise, fBm, Voronoi).",
+  usage: `### glsl-noise \u2014 GLSL Noise
+
+\`\`\`glsl
+float n = noise(uv * 10.0);
+float f = fbm(uv * 5.0, 6);
+float v = voronoi(uv * 8.0);
+\`\`\`
+`
+};
+var noise_default = glslNoise;
+
+// src/components/glsl/noise-3d.ts
+var glslNoise3d = {
+  name: "glsl-noise-3d",
+  version: "1.0.0",
+  category: "noise",
+  target: "glsl",
+  renderers: [],
+  code: `float hash3(vec3 p) {
+  p = fract(p * vec3(443.897, 441.423, 437.195));
+  p += dot(p, p.yzx + 19.19);
+  return fract((p.x + p.y) * p.z);
+}
+
+float noise3(vec3 p) {
+  vec3 i = floor(p);
+  vec3 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  float a = hash3(i);
+  float b = hash3(i + vec3(1.0, 0.0, 0.0));
+  float c = hash3(i + vec3(0.0, 1.0, 0.0));
+  float d = hash3(i + vec3(1.0, 1.0, 0.0));
+  float e = hash3(i + vec3(0.0, 0.0, 1.0));
+  float f2 = hash3(i + vec3(1.0, 0.0, 1.0));
+  float g = hash3(i + vec3(0.0, 1.0, 1.0));
+  float h = hash3(i + vec3(1.0, 1.0, 1.0));
+  float x1 = mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+  float x2 = mix(mix(e, f2, f.x), mix(g, h, f.x), f.y);
+  return mix(x1, x2, f.z);
+}
+
+float fbm3(vec3 p, int octaves) {
+  float val = 0.0, amp = 0.5;
+  for (int i = 0; i < 8; i++) {
+    if (i >= octaves) break;
+    val += amp * noise3(p);
+    p *= 2.0;
+    amp *= 0.5;
+  }
+  return val;
+}
+`,
+  exports: ["hash3", "noise3", "fbm3"],
+  dependencies: [],
+  description: "3D GLSL noise (hash, value noise, fBm).",
+  usage: `### glsl-noise-3d \u2014 3D Noise
+
+\`\`\`glsl
+float n = noise3(vec3(uv * 5.0, u_time));
+float f = fbm3(vec3(uv * 3.0, u_time * 0.5), 6);
+\`\`\`
+`
+};
+var noise_3d_default2 = glslNoise3d;
+
+// src/components/glsl/noise-4d.ts
+var glslNoise4d = {
+  name: "glsl-noise-4d",
+  version: "1.0.0",
+  category: "noise",
+  target: "glsl",
+  renderers: [],
+  code: `float noise4(vec4 p) {
+  vec4 i = floor(p);
+  vec4 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  float h1 = fract(sin(dot(i, vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h2 = fract(sin(dot(i + vec4(1,0,0,0), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h3 = fract(sin(dot(i + vec4(0,1,0,0), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h4 = fract(sin(dot(i + vec4(1,1,0,0), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h5 = fract(sin(dot(i + vec4(0,0,1,0), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h6 = fract(sin(dot(i + vec4(1,0,1,0), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h7 = fract(sin(dot(i + vec4(0,1,1,0), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h8 = fract(sin(dot(i + vec4(1,1,1,0), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h9 = fract(sin(dot(i + vec4(0,0,0,1), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h10 = fract(sin(dot(i + vec4(1,0,0,1), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h11 = fract(sin(dot(i + vec4(0,1,0,1), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h12 = fract(sin(dot(i + vec4(1,1,0,1), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h13 = fract(sin(dot(i + vec4(0,0,1,1), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h14 = fract(sin(dot(i + vec4(1,0,1,1), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h15 = fract(sin(dot(i + vec4(0,1,1,1), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float h16 = fract(sin(dot(i + vec4(1,1,1,1), vec4(127.1,311.7,269.5,183.3))) * 43758.5453);
+  float x1 = mix(mix(h1,h2,f.x), mix(h3,h4,f.x), f.y);
+  float x2 = mix(mix(h5,h6,f.x), mix(h7,h8,f.x), f.y);
+  float x3 = mix(mix(h9,h10,f.x), mix(h11,h12,f.x), f.y);
+  float x4 = mix(mix(h13,h14,f.x), mix(h15,h16,f.x), f.y);
+  return mix(mix(x1,x2,f.z), mix(x3,x4,f.z), f.w);
+}
+
+float fbm4(vec4 p, int octaves) {
+  float val = 0.0, amp = 0.5;
+  for (int i = 0; i < 8; i++) {
+    if (i >= octaves) break;
+    val += amp * noise4(p);
+    p *= 2.0;
+    amp *= 0.5;
+  }
+  return val;
+}
+`,
+  exports: ["noise4", "fbm4"],
+  dependencies: [],
+  description: "4D GLSL noise for loopable animations.",
+  usage: `### glsl-noise-4d \u2014 4D Noise
+
+\`\`\`glsl
+float n = noise4(vec4(uv * 5.0, cos(t) * r, sin(t) * r));
+\`\`\`
+`
+};
+var noise_4d_default2 = glslNoise4d;
+
+// src/components/glsl/curl.ts
+var glslCurl = {
+  name: "glsl-curl",
+  version: "1.0.0",
+  category: "noise",
+  target: "glsl",
+  renderers: [],
+  code: `vec2 curlNoise(vec2 p) {
+  float eps = 0.001;
+  float n1 = noise(p + vec2(eps, 0.0));
+  float n2 = noise(p - vec2(eps, 0.0));
+  float n3 = noise(p + vec2(0.0, eps));
+  float n4 = noise(p - vec2(0.0, eps));
+  float dndx = (n1 - n2) / (2.0 * eps);
+  float dndy = (n3 - n4) / (2.0 * eps);
+  return vec2(dndy, -dndx);
+}
+`,
+  exports: ["curlNoise"],
+  dependencies: ["glsl-noise"],
+  description: "GLSL curl noise for divergence-free flow.",
+  usage: `### glsl-curl \u2014 Curl Noise
+
+\`\`\`glsl
+vec2 flow = curlNoise(uv * 5.0);
+\`\`\`
+`
+};
+var curl_default2 = glslCurl;
+
+// src/components/glsl/sdf.ts
+var glslSdf = {
+  name: "glsl-sdf",
+  version: "1.0.0",
+  category: "sdf",
+  target: "glsl",
+  renderers: [],
+  code: `float sdCircle(vec2 p, float r) {
+  return length(p) - r;
+}
+
+float sdBox(vec2 p, vec2 b) {
+  vec2 d = abs(p) - b;
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+float sdLine(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a, ba = b - a;
+  float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+
+float sdPolygon(vec2 p, vec2 v[8], int n) {
+  float d = dot(p - v[0], p - v[0]);
+  float s = 1.0;
+  for (int i = 0, j = n - 1; i < 8; j = i, i++) {
+    if (i >= n) break;
+    vec2 e = v[j] - v[i];
+    vec2 w = p - v[i];
+    vec2 b = w - e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);
+    d = min(d, dot(b, b));
+    bvec3 cond = bvec3(p.y >= v[i].y, p.y < v[j].y, e.x * w.y > e.y * w.x);
+    if (all(cond) || all(not(cond))) s *= -1.0;
+  }
+  return s * sqrt(d);
+}
+
+float sdRing(vec2 p, float r, float thickness) {
+  return abs(length(p) - r) - thickness;
+}
+
+float opUnion(float d1, float d2) { return min(d1, d2); }
+float opSubtract(float d1, float d2) { return max(-d1, d2); }
+float opIntersect(float d1, float d2) { return max(d1, d2); }
+float opSmooth(float d1, float d2, float k) {
+  float h = clamp(0.5 + 0.5 * (d2 - d1) / k, 0.0, 1.0);
+  return mix(d2, d1, h) - k * h * (1.0 - h);
+}
+`,
+  exports: ["sdCircle", "sdBox", "sdLine", "sdPolygon", "sdRing", "opUnion", "opSubtract", "opIntersect", "opSmooth"],
+  dependencies: [],
+  description: "2D signed distance functions and CSG operations.",
+  usage: `### glsl-sdf \u2014 2D SDF
+
+\`\`\`glsl
+float d = sdCircle(uv - 0.5, 0.2);
+d = opSmooth(d, sdBox(uv - vec2(0.7), vec2(0.1)), 0.05);
+vec3 col = mix(vec3(1), vec3(0), smoothstep(0.0, 0.01, d));
+\`\`\`
+`
+};
+var sdf_default = glslSdf;
+
+// src/components/glsl/sdf-3d.ts
+var glslSdf3d = {
+  name: "glsl-sdf-3d",
+  version: "1.0.0",
+  category: "sdf",
+  target: "glsl",
+  renderers: [],
+  code: `float sdSphere(vec3 p, float r) { return length(p) - r; }
+
+float sdBox3(vec3 p, vec3 b) {
+  vec3 d = abs(p) - b;
+  return length(max(d, 0.0)) + min(max(d.x, max(d.y, d.z)), 0.0);
+}
+
+float sdCylinder(vec3 p, float h, float r) {
+  vec2 d = abs(vec2(length(p.xz), p.y)) - vec2(r, h);
+  return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
+}
+
+float sdTorus(vec3 p, vec2 t) {
+  vec2 q = vec2(length(p.xz) - t.x, p.y);
+  return length(q) - t.y;
+}
+
+float opUnion3(float d1, float d2) { return min(d1, d2); }
+float opSmooth3(float d1, float d2, float k) {
+  float h = clamp(0.5 + 0.5 * (d2 - d1) / k, 0.0, 1.0);
+  return mix(d2, d1, h) - k * h * (1.0 - h);
+}
+
+vec3 opRepeat(vec3 p, vec3 c) {
+  return mod(p + 0.5 * c, c) - 0.5 * c;
+}
+`,
+  exports: ["sdSphere", "sdBox3", "sdCylinder", "sdTorus", "opUnion3", "opSmooth3", "opRepeat"],
+  dependencies: [],
+  description: "3D SDF primitives (sphere, box, cylinder, torus) and operations.",
+  usage: `### glsl-sdf-3d \u2014 3D SDF
+
+\`\`\`glsl
+float d = sdSphere(p, 1.0);
+d = opSmooth3(d, sdBox3(p - vec3(1.5, 0, 0), vec3(0.5)), 0.2);
+\`\`\`
+`
+};
+var sdf_3d_default = glslSdf3d;
+
+// src/components/glsl/color.ts
+var glslColor = {
+  name: "glsl-color",
+  version: "1.0.0",
+  category: "color",
+  target: "glsl",
+  renderers: [],
+  code: `vec3 rgb2hsv(vec3 c) {
+  vec4 K = vec4(0.0, -1.0/3.0, 2.0/3.0, -1.0);
+  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+  float d = q.x - min(q.w, q.y);
+  float e = 1.0e-10;
+  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+vec3 hsv2rgb(vec3 c) {
+  vec4 K = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
+  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+vec3 rgb2hsl(vec3 c) {
+  float maxC = max(c.r, max(c.g, c.b));
+  float minC = min(c.r, min(c.g, c.b));
+  float l = (maxC + minC) * 0.5;
+  if (maxC == minC) return vec3(0.0, 0.0, l);
+  float d = maxC - minC;
+  float s = l > 0.5 ? d / (2.0 - maxC - minC) : d / (maxC + minC);
+  float h;
+  if (maxC == c.r) h = (c.g - c.b) / d + (c.g < c.b ? 6.0 : 0.0);
+  else if (maxC == c.g) h = (c.b - c.r) / d + 2.0;
+  else h = (c.r - c.g) / d + 4.0;
+  h /= 6.0;
+  return vec3(h, s, l);
+}
+
+vec3 hsl2rgb(vec3 c) {
+  if (c.y == 0.0) return vec3(c.z);
+  float q = c.z < 0.5 ? c.z * (1.0 + c.y) : c.z + c.y - c.z * c.y;
+  float p = 2.0 * c.z - q;
+  vec3 t = vec3(c.x + 1.0/3.0, c.x, c.x - 1.0/3.0);
+  t = fract(t);
+  vec3 r;
+  for (int i = 0; i < 3; i++) {
+    float ti = i == 0 ? t.x : (i == 1 ? t.y : t.z);
+    float v;
+    if (ti < 1.0/6.0) v = p + (q - p) * 6.0 * ti;
+    else if (ti < 0.5) v = q;
+    else if (ti < 2.0/3.0) v = p + (q - p) * (2.0/3.0 - ti) * 6.0;
+    else v = p;
+    if (i == 0) r.x = v;
+    else if (i == 1) r.y = v;
+    else r.z = v;
+  }
+  return r;
+}
+
+vec3 rgb2oklab(vec3 c) {
+  float l = 0.4122214708 * c.r + 0.5363325363 * c.g + 0.0514459929 * c.b;
+  float m = 0.2119034982 * c.r + 0.6806995451 * c.g + 0.1073969566 * c.b;
+  float s = 0.0883024619 * c.r + 0.2817188376 * c.g + 0.6299787005 * c.b;
+  l = pow(l, 1.0/3.0); m = pow(m, 1.0/3.0); s = pow(s, 1.0/3.0);
+  return vec3(
+    0.2104542553*l + 0.7936177850*m - 0.0040720468*s,
+    1.9779984951*l - 2.4285922050*m + 0.4505937099*s,
+    0.0259040371*l + 0.7827717662*m - 0.8086757660*s
+  );
+}
+
+vec3 oklab2rgb(vec3 lab) {
+  float l = lab.x + 0.3963377774*lab.y + 0.2158037573*lab.z;
+  float m = lab.x - 0.1055613458*lab.y - 0.0638541728*lab.z;
+  float s = lab.x - 0.0894841775*lab.y - 1.2914855480*lab.z;
+  l=l*l*l; m=m*m*m; s=s*s*s;
+  return vec3(
+    4.0767416621*l - 3.3077115913*m + 0.2309699292*s,
+    -1.2684380046*l + 2.6097574011*m - 0.3413193965*s,
+    -0.0041960863*l - 0.7034186147*m + 1.7076147010*s
+  );
+}
+
+vec3 posterize(vec3 c, float levels) {
+  return floor(c * levels + 0.5) / levels;
+}
+
+vec3 quantize(vec3 c, float steps) {
+  return floor(c * steps) / steps;
+}
+`,
+  exports: ["rgb2hsv", "hsv2rgb", "rgb2hsl", "hsl2rgb", "rgb2oklab", "oklab2rgb", "posterize", "quantize"],
+  dependencies: [],
+  description: "GLSL color space conversions (HSV, HSL, OKLab) and quantization.",
+  usage: `### glsl-color \u2014 Color Spaces
+
+\`\`\`glsl
+vec3 hsv = rgb2hsv(color);
+hsv.x += 0.1; // hue shift
+color = hsv2rgb(hsv);
+color = posterize(color, 4.0);
+\`\`\`
+`
+};
+var color_default2 = glslColor;
+
+// src/components/glsl/pattern.ts
+var glslPattern = {
+  name: "glsl-pattern",
+  version: "1.0.0",
+  category: "pattern",
+  target: "glsl",
+  renderers: [],
+  code: `float truchet(vec2 uv, float scale) {
+  vec2 id = floor(uv * scale);
+  vec2 f = fract(uv * scale);
+  float r = hash(id);
+  if (r > 0.5) f.x = 1.0 - f.x;
+  float d1 = length(f) - 0.5;
+  float d2 = length(f - 1.0) - 0.5;
+  return min(abs(d1), abs(d2));
+}
+
+float checkerboard(vec2 uv, float scale) {
+  vec2 c = floor(uv * scale);
+  return mod(c.x + c.y, 2.0);
+}
+
+vec2 hexGrid(vec2 uv) {
+  vec2 s = vec2(1.0, 1.7320508);
+  vec2 a = mod(uv, s) - s * 0.5;
+  vec2 b = mod(uv - s * 0.5, s) - s * 0.5;
+  return dot(a, a) < dot(b, b) ? a : b;
+}
+
+float voronoiEdges(vec2 uv, float scale) {
+  vec2 p = uv * scale;
+  vec2 n = floor(p);
+  vec2 f = fract(p);
+  float md = 8.0;
+  for (int j = -1; j <= 1; j++)
+    for (int i = -1; i <= 1; i++) {
+      vec2 g = vec2(float(i), float(j));
+      vec2 o = vec2(hash(n + g), hash(n + g + vec2(37.0)));
+      vec2 r = g + o - f;
+      md = min(md, dot(r, r));
+    }
+  return sqrt(md);
+}
+
+float stripes(vec2 uv, float freq, float angle) {
+  float c = cos(angle), s = sin(angle);
+  float t = uv.x * c + uv.y * s;
+  return 0.5 + 0.5 * sin(t * freq * 6.28318);
+}
+
+float dots(vec2 uv, float scale, float radius) {
+  vec2 f = fract(uv * scale) - 0.5;
+  return smoothstep(radius, radius - 0.01, length(f));
+}
+`,
+  exports: ["truchet", "checkerboard", "hexGrid", "voronoiEdges", "stripes", "dots"],
+  dependencies: ["glsl-noise"],
+  description: "Tiling and pattern functions (truchet, hex grid, stripes, dots).",
+  usage: `### glsl-pattern \u2014 Patterns
+
+\`\`\`glsl
+float t = truchet(uv, 10.0);
+float c = checkerboard(uv, 8.0);
+float s = stripes(uv, 20.0, 0.785);
+\`\`\`
+`
+};
+var pattern_default = glslPattern;
+
+// src/components/glsl/transform.ts
+var glslTransform = {
+  name: "glsl-transform",
+  version: "1.0.0",
+  category: "transform",
+  target: "glsl",
+  renderers: [],
+  code: `vec2 rotate2D(vec2 p, float angle) {
+  float c = cos(angle), s = sin(angle);
+  return vec2(p.x * c - p.y * s, p.x * s + p.y * c);
+}
+
+vec2 scale2D(vec2 p, vec2 s) { return p / s; }
+vec2 translate2D(vec2 p, vec2 t) { return p - t; }
+
+vec2 kaleidoscope(vec2 p, float segments) {
+  float angle = atan(p.y, p.x);
+  float r = length(p);
+  float seg = 6.28318 / segments;
+  angle = mod(angle, seg);
+  if (angle > seg * 0.5) angle = seg - angle;
+  return vec2(cos(angle), sin(angle)) * r;
+}
+
+vec2 polarCoords(vec2 p) {
+  return vec2(length(p), atan(p.y, p.x));
+}
+
+vec2 fishEye(vec2 uv, float strength) {
+  vec2 c = uv - 0.5;
+  float r = length(c);
+  float bind = sqrt(dot(vec2(0.5), vec2(0.5)));
+  vec2 nuv = c / bind;
+  nuv *= 1.0 - strength + strength * r;
+  return nuv * bind + 0.5;
+}
+
+vec2 ripple(vec2 uv, vec2 center, float freq, float amp, float time) {
+  vec2 d = uv - center;
+  float r = length(d);
+  float offset = sin(r * freq - time) * amp;
+  return uv + normalize(d) * offset;
+}
+`,
+  exports: ["rotate2D", "scale2D", "translate2D", "kaleidoscope", "polarCoords", "fishEye", "ripple"],
+  dependencies: [],
+  description: "UV coordinate transformations (rotate, kaleidoscope, fisheye, ripple).",
+  usage: `### glsl-transform \u2014 UV Transforms
+
+\`\`\`glsl
+vec2 p = rotate2D(uv - 0.5, u_time) + 0.5;
+p = kaleidoscope(p - 0.5, 6.0);
+p = fishEye(uv, 0.5);
+\`\`\`
+`
+};
+var transform_default = glslTransform;
+
+// src/components/glsl/math.ts
+var glslMath = {
+  name: "glsl-math",
+  version: "1.0.0",
+  category: "math",
+  target: "glsl",
+  renderers: [],
+  code: `float remap(float value, float inMin, float inMax, float outMin, float outMax) {
+  return outMin + (value - inMin) / (inMax - inMin) * (outMax - outMin);
+}
+
+float mod289(float x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+
+float inverseLerp(float a, float b, float v) { return (v - a) / (b - a); }
+
+float smoothmin(float a, float b, float k) {
+  float h = max(k - abs(a - b), 0.0) / k;
+  return min(a, b) - h * h * h * k * (1.0 / 6.0);
+}
+
+float bias(float x, float b) {
+  return x / ((1.0 / b - 2.0) * (1.0 - x) + 1.0);
+}
+
+float gain(float x, float g) {
+  if (x < 0.5) return bias(x * 2.0, g) * 0.5;
+  return bias(x * 2.0 - 1.0, 1.0 - g) * 0.5 + 0.5;
+}
+`,
+  exports: ["remap", "mod289", "inverseLerp", "smoothmin", "bias", "gain"],
+  dependencies: [],
+  description: "GLSL math utilities (remap, smoothmin, bias, gain).",
+  usage: `### glsl-math \u2014 GLSL Math
+
+\`\`\`glsl
+float v = remap(x, 0.0, 1.0, -1.0, 1.0);
+float s = smoothmin(d1, d2, 0.1);
+float b = bias(x, 0.3);
+\`\`\`
+`
+};
+var math_default2 = glslMath;
+
+// src/components/glsl/easing.ts
+var glslEasing = {
+  name: "glsl-easing",
+  version: "1.0.0",
+  category: "easing",
+  target: "glsl",
+  renderers: [],
+  code: `float easeInQuad(float t) { return t * t; }
+float easeOutQuad(float t) { return t * (2.0 - t); }
+float easeInOutCubic(float t) {
+  return t < 0.5 ? 4.0 * t * t * t : 1.0 - pow(-2.0 * t + 2.0, 3.0) / 2.0;
+}
+float easeOutElastic(float t) {
+  if (t == 0.0 || t == 1.0) return t;
+  return pow(2.0, -10.0 * t) * sin((t * 10.0 - 0.75) * (6.28318 / 3.0)) + 1.0;
+}
+float easeOutBounce(float t) {
+  if (t < 1.0 / 2.75) return 7.5625 * t * t;
+  if (t < 2.0 / 2.75) { t -= 1.5 / 2.75; return 7.5625 * t * t + 0.75; }
+  if (t < 2.5 / 2.75) { t -= 2.25 / 2.75; return 7.5625 * t * t + 0.9375; }
+  t -= 2.625 / 2.75; return 7.5625 * t * t + 0.984375;
+}
+`,
+  exports: ["easeInQuad", "easeOutQuad", "easeInOutCubic", "easeOutElastic", "easeOutBounce"],
+  dependencies: [],
+  description: "Easing functions in GLSL.",
+  usage: `### glsl-easing \u2014 GLSL Easing
+
+\`\`\`glsl
+float t = easeInOutCubic(progress);
+float e = easeOutElastic(progress);
+\`\`\`
+`
+};
+var easing_default2 = glslEasing;
+
+// src/components/glsl/blend.ts
+var glslBlend = {
+  name: "glsl-blend",
+  version: "1.0.0",
+  category: "color",
+  target: "glsl",
+  renderers: [],
+  code: `vec3 blendMultiply(vec3 base, vec3 blend) { return base * blend; }
+vec3 blendScreen(vec3 base, vec3 blend) { return 1.0 - (1.0 - base) * (1.0 - blend); }
+vec3 blendOverlay(vec3 base, vec3 blend) {
+  return vec3(
+    base.r < 0.5 ? 2.0 * base.r * blend.r : 1.0 - 2.0 * (1.0 - base.r) * (1.0 - blend.r),
+    base.g < 0.5 ? 2.0 * base.g * blend.g : 1.0 - 2.0 * (1.0 - base.g) * (1.0 - blend.g),
+    base.b < 0.5 ? 2.0 * base.b * blend.b : 1.0 - 2.0 * (1.0 - base.b) * (1.0 - blend.b)
+  );
+}
+vec3 blendSoftLight(vec3 base, vec3 blend) {
+  return mix(
+    sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend),
+    2.0 * base * blend + base * base * (1.0 - 2.0 * blend),
+    step(vec3(0.5), blend)
+  );
+}
+vec3 blendAdd(vec3 base, vec3 blend) { return min(base + blend, vec3(1.0)); }
+`,
+  exports: ["blendMultiply", "blendScreen", "blendOverlay", "blendSoftLight", "blendAdd"],
+  dependencies: [],
+  description: "Photoshop-style blend modes in GLSL.",
+  usage: `### glsl-blend \u2014 Blend Modes
+
+\`\`\`glsl
+vec3 result = blendOverlay(base, overlay);
+result = blendScreen(result, glow);
+\`\`\`
+`
+};
+var blend_default = glslBlend;
+
+// src/components/glsl/lighting.ts
+var glslLighting = {
+  name: "glsl-lighting",
+  version: "1.0.0",
+  category: "pattern",
+  target: "glsl",
+  renderers: [],
+  code: `float lambertian(vec3 normal, vec3 lightDir) {
+  return max(dot(normalize(normal), normalize(lightDir)), 0.0);
+}
+
+float phong(vec3 normal, vec3 lightDir, vec3 viewDir, float shininess) {
+  vec3 n = normalize(normal);
+  vec3 l = normalize(lightDir);
+  vec3 r = reflect(-l, n);
+  float diff = max(dot(n, l), 0.0);
+  float spec = pow(max(dot(normalize(viewDir), r), 0.0), shininess);
+  return diff + spec;
+}
+
+vec3 normalFromHeight(sampler2D tex, vec2 uv, float strength) {
+  float eps = 1.0 / 512.0;
+  float h = texture2D(tex, uv).r;
+  float hx = texture2D(tex, uv + vec2(eps, 0.0)).r;
+  float hy = texture2D(tex, uv + vec2(0.0, eps)).r;
+  return normalize(vec3((h - hx) * strength, (h - hy) * strength, 1.0));
+}
+
+float ambientOcclusion(vec2 uv, float radius, float intensity) {
+  float ao = 0.0;
+  for (int i = 0; i < 4; i++) {
+    float angle = float(i) * 1.5708;
+    vec2 offset = vec2(cos(angle), sin(angle)) * radius;
+    ao += smoothstep(0.0, 1.0, length(offset));
+  }
+  return 1.0 - (ao / 4.0) * intensity;
+}
+`,
+  exports: ["phong", "lambertian", "normalFromHeight", "ambientOcclusion"],
+  dependencies: [],
+  description: "Basic GLSL lighting models (Phong, Lambertian, normal mapping).",
+  usage: `### glsl-lighting \u2014 Lighting
+
+\`\`\`glsl
+float diff = lambertian(normal, lightPos - fragPos);
+float lit = phong(normal, lightDir, viewDir, 32.0);
+vec3 n = normalFromHeight(heightMap, uv, 2.0);
+\`\`\`
+`
+};
+var lighting_default = glslLighting;
+
+// src/components/glsl/ray.ts
+var glslRay = {
+  name: "glsl-ray",
+  version: "1.0.0",
+  category: "sdf",
+  target: "glsl",
+  renderers: [],
+  code: `float rayMarch(vec3 ro, vec3 rd, float maxDist, int maxSteps) {
+  float t = 0.0;
+  for (int i = 0; i < 256; i++) {
+    if (i >= maxSteps) break;
+    vec3 p = ro + rd * t;
+    float d = sdSphere(p, 1.0);
+    if (d < 0.001 || t > maxDist) break;
+    t += d;
+  }
+  return t;
+}
+
+vec3 estimateNormal(vec3 p) {
+  float eps = 0.001;
+  return normalize(vec3(
+    sdSphere(p + vec3(eps,0,0), 1.0) - sdSphere(p - vec3(eps,0,0), 1.0),
+    sdSphere(p + vec3(0,eps,0), 1.0) - sdSphere(p - vec3(0,eps,0), 1.0),
+    sdSphere(p + vec3(0,0,eps), 1.0) - sdSphere(p - vec3(0,0,eps), 1.0)
+  ));
+}
+
+float softShadow(vec3 ro, vec3 rd, float mint, float maxt, float k) {
+  float res = 1.0;
+  float t = mint;
+  for (int i = 0; i < 64; i++) {
+    float h = sdSphere(ro + rd * t, 1.0);
+    res = min(res, k * h / t);
+    t += clamp(h, 0.02, 0.1);
+    if (h < 0.001 || t > maxt) break;
+  }
+  return clamp(res, 0.0, 1.0);
+}
+
+float ambientOcclusion3D(vec3 p, vec3 n) {
+  float occ = 0.0;
+  float sca = 1.0;
+  for (int i = 0; i < 5; i++) {
+    float h = 0.01 + 0.12 * float(i);
+    float d = sdSphere(p + n * h, 1.0);
+    occ += (h - d) * sca;
+    sca *= 0.95;
+  }
+  return clamp(1.0 - 3.0 * occ, 0.0, 1.0);
+}
+`,
+  exports: ["rayMarch", "estimateNormal", "softShadow", "ambientOcclusion3D"],
+  dependencies: ["glsl-sdf-3d"],
+  description: "Raymarching utilities (march, normals, soft shadows, AO).",
+  usage: `### glsl-ray \u2014 Raymarching
+
+\`\`\`glsl
+float t = rayMarch(ro, rd, 100.0, 128);
+if (t < 100.0) {
+  vec3 p = ro + rd * t;
+  vec3 n = estimateNormal(p);
+  float shadow = softShadow(p, lightDir, 0.02, 10.0, 8.0);
+}
+\`\`\`
+`
+};
+var ray_default = glslRay;
+
+// src/components/glsl/post.ts
+var glslPost = {
+  name: "glsl-post",
+  version: "1.0.0",
+  category: "imaging",
+  target: "glsl",
+  renderers: [],
+  code: `float vignette(vec2 uv, float intensity) {
+  vec2 d = uv - 0.5;
+  return 1.0 - dot(d, d) * intensity;
+}
+
+vec3 chromaticAberration(sampler2D tex, vec2 uv, float offset) {
+  float r = texture2D(tex, uv + vec2(offset, 0.0)).r;
+  float g = texture2D(tex, uv).g;
+  float b = texture2D(tex, uv - vec2(offset, 0.0)).b;
+  return vec3(r, g, b);
+}
+
+float filmGrain(vec2 uv, float time, float intensity) {
+  return (hash(uv * 1000.0 + time) - 0.5) * intensity;
+}
+
+vec3 bloom(sampler2D tex, vec2 uv, float threshold, float intensity) {
+  vec3 col = texture2D(tex, uv).rgb;
+  vec3 bright = max(col - vec3(threshold), vec3(0.0));
+  vec3 blur = vec3(0.0);
+  for (int i = -2; i <= 2; i++)
+    for (int j = -2; j <= 2; j++)
+      blur += max(texture2D(tex, uv + vec2(float(i), float(j)) * 0.003).rgb - vec3(threshold), vec3(0.0));
+  blur /= 25.0;
+  return col + blur * intensity;
+}
+
+vec3 sharpen(sampler2D tex, vec2 uv, float strength) {
+  vec2 px = vec2(1.0) / vec2(textureSize(tex, 0));
+  vec3 col = texture2D(tex, uv).rgb * (1.0 + 4.0 * strength);
+  col -= texture2D(tex, uv + vec2(px.x, 0.0)).rgb * strength;
+  col -= texture2D(tex, uv - vec2(px.x, 0.0)).rgb * strength;
+  col -= texture2D(tex, uv + vec2(0.0, px.y)).rgb * strength;
+  col -= texture2D(tex, uv - vec2(0.0, px.y)).rgb * strength;
+  return col;
+}
+`,
+  exports: ["vignette", "chromaticAberration", "filmGrain", "bloom", "sharpen"],
+  dependencies: ["glsl-noise"],
+  description: "Post-processing effects (vignette, chromatic aberration, grain, bloom).",
+  usage: `### glsl-post \u2014 Post Processing
+
+\`\`\`glsl
+color *= vignette(uv, 2.0);
+color += filmGrain(uv, u_time, 0.05);
+color = bloom(tex, uv, 0.8, 1.5);
+\`\`\`
+`
+};
+var post_default = glslPost;
+
+// src/components/glsl/shape.ts
+var glslShape = {
+  name: "glsl-shape",
+  version: "1.0.0",
+  category: "geometry",
+  target: "glsl",
+  renderers: [],
+  code: `float polygon(vec2 p, int sides, float radius) {
+  float a = atan(p.y, p.x);
+  float seg = 6.28318 / float(sides);
+  float d = cos(floor(0.5 + a / seg) * seg - a) * length(p);
+  return d - radius;
+}
+
+float star(vec2 p, int points, float outer, float inner) {
+  float a = atan(p.y, p.x);
+  float seg = 3.14159 / float(points);
+  a = mod(a, 2.0 * seg) - seg;
+  float r = length(p);
+  float d1 = r * cos(a) - outer;
+  float d2 = r * cos(a - seg) - inner;
+  return max(d1, d2);
+}
+
+float roundedRect(vec2 p, vec2 size, float radius) {
+  vec2 d = abs(p) - size + radius;
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0) - radius;
+}
+
+float ring(vec2 p, float radius, float thickness) {
+  return abs(length(p) - radius) - thickness;
+}
+
+float arc(vec2 p, float radius, float angle, float thickness) {
+  float a = atan(p.y, p.x);
+  float ha = angle * 0.5;
+  float d = abs(length(p) - radius) - thickness;
+  float angDist = abs(mod(a + 3.14159, 6.28318) - 3.14159);
+  return max(d, angDist - ha);
+}
+
+float line(vec2 p, vec2 a, vec2 b, float thickness) {
+  vec2 pa = p - a, ba = b - a;
+  float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+  return length(pa - ba * h) - thickness;
+}
+`,
+  exports: ["polygon", "star", "roundedRect", "ring", "arc", "line"],
+  dependencies: ["glsl-sdf"],
+  description: "2D shape rendering via SDF (polygon, star, rounded rect, ring).",
+  usage: `### glsl-shape \u2014 2D Shapes
+
+\`\`\`glsl
+float d = polygon(uv - 0.5, 6, 0.3);
+d = min(d, star(uv - vec2(0.7, 0.5), 5, 0.2, 0.1));
+d = min(d, roundedRect(uv - vec2(0.3, 0.7), vec2(0.1), 0.02));
+vec3 col = mix(vec3(1), vec3(0), smoothstep(0.0, 0.01, d));
+\`\`\`
+`
+};
+var shape_default2 = glslShape;
+
+// src/components/glsl/domain.ts
+var glslDomain = {
+  name: "glsl-domain",
+  version: "1.0.0",
+  category: "transform",
+  target: "glsl",
+  renderers: [],
+  code: `vec2 domainWarp(vec2 p, float strength) {
+  float n1 = noise(p);
+  float n2 = noise(p + vec2(5.2, 1.3));
+  return p + vec2(n1, n2) * strength;
+}
+
+vec2 domainRepeat(vec2 p, vec2 period) {
+  return mod(p + period * 0.5, period) - period * 0.5;
+}
+
+vec2 domainTwist(vec2 p, float amount) {
+  float angle = p.y * amount;
+  float c = cos(angle), s = sin(angle);
+  return vec2(p.x * c - p.y * s, p.x * s + p.y * c);
+}
+
+vec2 domainFold(vec2 p, vec2 axis) {
+  float d = dot(p, normalize(axis));
+  if (d < 0.0) p -= 2.0 * d * normalize(axis);
+  return p;
+}
+`,
+  exports: ["domainWarp", "domainRepeat", "domainTwist", "domainFold"],
+  dependencies: ["glsl-noise"],
+  description: "Domain manipulation (warp, repeat, twist, fold).",
+  usage: `### glsl-domain \u2014 Domain Manipulation
+
+\`\`\`glsl
+vec2 p = domainWarp(uv * 5.0, 0.3);
+p = domainRepeat(p, vec2(2.0));
+p = domainTwist(p, 1.5);
+\`\`\`
+`
+};
+var domain_default = glslDomain;
+
+// src/components/glsl/gradient.ts
+var glslGradient = {
+  name: "glsl-gradient",
+  version: "1.0.0",
+  category: "color",
+  target: "glsl",
+  renderers: [],
+  code: `vec3 linearGradient(vec2 uv, vec3 c1, vec3 c2, float angle) {
+  float c = cos(angle), s = sin(angle);
+  float t = clamp(uv.x * c + uv.y * s, 0.0, 1.0);
+  return mix(c1, c2, t);
+}
+
+vec3 radialGradient(vec2 uv, vec3 c1, vec3 c2, vec2 center, float radius) {
+  float t = clamp(length(uv - center) / radius, 0.0, 1.0);
+  return mix(c1, c2, t);
+}
+
+vec3 angularGradient(vec2 uv, vec3 c1, vec3 c2, vec2 center) {
+  float angle = atan(uv.y - center.y, uv.x - center.x);
+  float t = (angle + 3.14159) / 6.28318;
+  return mix(c1, c2, t);
+}
+
+vec3 conicGradient(vec2 uv, vec3 colors[4], vec2 center) {
+  float angle = atan(uv.y - center.y, uv.x - center.x);
+  float t = (angle + 3.14159) / 6.28318;
+  float segment = t * 4.0;
+  int i = int(floor(segment));
+  float f = fract(segment);
+  if (i >= 3) return mix(colors[3], colors[0], f);
+  return mix(colors[i], colors[i + 1], f);
+}
+
+vec3 paletteGradient(float t, vec3 a, vec3 b, vec3 c, vec3 d) {
+  return a + b * cos(6.28318 * (c * t + d));
+}
+`,
+  exports: ["linearGradient", "radialGradient", "angularGradient", "conicGradient", "paletteGradient"],
+  dependencies: [],
+  description: "Gradient generation (linear, radial, angular, palette).",
+  usage: `### glsl-gradient \u2014 Gradients
+
+\`\`\`glsl
+vec3 g = linearGradient(uv, vec3(1,0,0), vec3(0,0,1), 0.0);
+vec3 r = radialGradient(uv, vec3(1), vec3(0), vec2(0.5), 0.5);
+// Iq-style cosine palette
+vec3 p = paletteGradient(t, vec3(0.5), vec3(0.5), vec3(1), vec3(0,0.33,0.67));
+\`\`\`
+`
+};
+var gradient_default = glslGradient;
+
+// src/registry.ts
+var COMPONENT_REGISTRY = Object.fromEntries(
+  [...Object.values(js_exports), ...Object.values(glsl_exports)].map((c) => [c.name, c])
+);
+
+// src/resolver.ts
+var RENDERER_TARGET = {
+  p5: "js",
+  three: "js",
+  canvas2d: "js",
+  svg: "js",
+  glsl: "glsl"
+};
+function resolveComponents(components, renderer) {
+  const target = RENDERER_TARGET[renderer];
+  const allNames = /* @__PURE__ */ new Set();
+  const stack = Object.keys(components);
+  while (stack.length > 0) {
+    const name = stack.pop();
+    if (allNames.has(name)) continue;
+    const entry = COMPONENT_REGISTRY[name];
+    if (!entry) {
+      throw new Error(`Unknown component: "${name}"`);
+    }
+    if (entry.target !== target) {
+      throw new Error(
+        `Component "${name}" has target "${entry.target}" but renderer "${renderer}" requires target "${target}"`
+      );
+    }
+    if (entry.renderers.length > 0 && !entry.renderers.includes(renderer)) {
+      throw new Error(
+        `Component "${name}" is not compatible with renderer "${renderer}". Compatible: ${entry.renderers.join(", ")}`
+      );
+    }
+    allNames.add(name);
+    for (const dep of entry.dependencies) {
+      if (!allNames.has(dep)) {
+        stack.push(dep);
+      }
+    }
+  }
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected involving component "${name}"`);
+    }
+    visiting.add(name);
+    const entry = COMPONENT_REGISTRY[name];
+    for (const dep of entry.dependencies) {
+      if (allNames.has(dep)) {
+        visit(dep);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    sorted.push(name);
+  }
+  for (const name of allNames) {
+    visit(name);
+  }
+  const exportNames = /* @__PURE__ */ new Map();
+  for (const name of sorted) {
+    const entry = COMPONENT_REGISTRY[name];
+    for (const exp of entry.exports) {
+      const existing = exportNames.get(exp);
+      if (existing) {
+        throw new Error(
+          `Export collision: "${exp}" is exported by both "${existing}" and "${name}"`
+        );
+      }
+      exportNames.set(exp, name);
+    }
+  }
+  return sorted.map((name) => {
+    const entry = COMPONENT_REGISTRY[name];
+    return {
+      name: entry.name,
+      version: entry.version,
+      code: entry.code,
+      exports: entry.exports
+    };
+  });
+}
+export {
+  COMPONENT_REGISTRY,
+  resolveComponents
+};
+//# sourceMappingURL=index.js.map