shardlight 0.1.0

package/dist/chunk-ZWPHIC3K.js

@@ -0,0 +1,1786 @@
+// src/core/kinds/registry.ts
+var kinds = /* @__PURE__ */ new Map();
+function defineShardKind(def) {
+  return def;
+}
+function registerShardKind(def) {
+  if (kinds.has(def.kind)) {
+    warn(`overwriting already-registered shard kind "${def.kind}"`);
+  }
+  kinds.set(def.kind, def);
+}
+function getShardKind(kind) {
+  return kinds.get(kind);
+}
+function listShardKinds() {
+  return [...kinds.values()];
+}
+function unregisterShardKind(kind) {
+  kinds.delete(kind);
+}
+function warn(message) {
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") return;
+  console.warn(`[shardlight] ${message}`);
+}
+
+// src/core/kinds/draw.ts
+var GRADIENT_STOPS = 16;
+function applyRayScale(params, schema, rayScale) {
+  if (rayScale === 1) return params;
+  const out = { ...params };
+  for (const [name, def] of Object.entries(schema)) {
+    if (def.ray && typeof out[name] === "number") {
+      out[name] = out[name] * rayScale;
+    }
+  }
+  return out;
+}
+function drawRay(ctx, env, o) {
+  const length = o.tipDist - o.rootDist;
+  if (length <= 0 || o.strength <= 0) return;
+  ctx.save();
+  ctx.rotate(o.angleRad);
+  const gradient = ctx.createLinearGradient(o.rootDist, 0, o.tipDist, 0);
+  for (let i = 0; i <= GRADIENT_STOPS; i++) {
+    const t = i / GRADIENT_STOPS;
+    const along = Math.pow(1 - t, o.falloff);
+    const ramp = o.fadeIn > 0 ? Math.min(1, t * length / o.fadeIn) : 1;
+    gradient.addColorStop(t, env.rgba(o.strength * along * ramp));
+  }
+  ctx.fillStyle = gradient;
+  ctx.beginPath();
+  ctx.moveTo(o.rootDist, -o.rootHalf);
+  ctx.lineTo(o.tipDist, -o.tipHalf);
+  ctx.lineTo(o.tipDist, o.tipHalf);
+  ctx.lineTo(o.rootDist, o.rootHalf);
+  ctx.closePath();
+  ctx.fill();
+  ctx.restore();
+}
+function conicVarianceMask(ctx, params, env, size) {
+  const variance = params.variance ?? 0;
+  if (variance <= 0) return;
+  const createConic = ctx.createConicGradient;
+  if (typeof createConic !== "function") return;
+  const center = size / 2;
+  const gradient = createConic.call(ctx, 0, center, center);
+  const stops = 12;
+  const alphas = [];
+  for (let i = 0; i < stops; i++) alphas.push(1 - variance * env.rng());
+  for (let i = 0; i < stops; i++) {
+    gradient.addColorStop(i / stops, env.rgba(alphas[i]));
+  }
+  gradient.addColorStop(1, env.rgba(alphas[0]));
+  ctx.save();
+  ctx.globalCompositeOperation = "destination-in";
+  ctx.fillStyle = gradient;
+  ctx.fillRect(0, 0, size, size);
+  ctx.restore();
+}
+
+// src/core/kinds/blob.ts
+var blob = defineShardKind({
+  kind: "blob",
+  label: "Glow",
+  params: {
+    strength: { type: "number", default: 1, min: 0, max: 2 },
+    size: { type: "number", default: 0.5, min: 0, max: 2 },
+    hardness: { type: "number", default: 0, min: 0, max: 0.999 },
+    falloff: { type: "number", default: 2, min: 0.1, max: 8 },
+    aspect: { type: "number", default: 1, min: 0.1, max: 10 },
+    angle: { type: "angle", default: 0 },
+    softness: { type: "number", default: 0, min: 0, max: 50, unit: "px" },
+    variance: { type: "number", default: 0, min: 0, max: 1 }
+  },
+  draw(ctx, p, env) {
+    const radius = p.size * env.unit;
+    if (radius <= 0 || p.strength <= 0) return;
+    ctx.save();
+    ctx.rotate(p.angle * Math.PI / 180);
+    ctx.scale(p.aspect, 1);
+    const gradient = ctx.createRadialGradient(0, 0, 0, 0, 0, radius);
+    for (let i = 0; i <= GRADIENT_STOPS; i++) {
+      const t = i / GRADIENT_STOPS;
+      let a;
+      if (p.hardness >= 1) {
+        a = t < 1 ? 1 : 0;
+      } else if (p.hardness > 0 && t <= p.hardness) {
+        a = 1;
+      } else {
+        a = Math.pow((1 - t) / (1 - p.hardness), p.falloff);
+      }
+      gradient.addColorStop(t, env.rgba(Math.max(0, a) * p.strength));
+    }
+    ctx.fillStyle = gradient;
+    ctx.beginPath();
+    ctx.arc(0, 0, radius, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.restore();
+  },
+  mask: conicVarianceMask
+});
+
+// src/core/kinds/fan.ts
+var fan = defineShardKind({
+  kind: "fan",
+  label: "Rays",
+  params: {
+    strength: { type: "number", default: 1, min: 0, max: 2 },
+    size: { type: "number", default: 1, min: 0, max: 2 },
+    count: { type: "number", default: 4, min: 1, max: 256, step: 1 },
+    angle: { type: "angle", default: 0 },
+    jitter: { type: "number", default: 0, min: 0, max: 1 },
+    inner: { type: "number", default: 0, min: 0, max: 1 },
+    variance: { type: "number", default: 0, min: 0, max: 1 },
+    width: { type: "number", default: 4, min: 0, max: 100, unit: "px", ray: true },
+    taper: { type: "number", default: 1, min: 0, max: 1 },
+    falloff: { type: "number", default: 1, min: 0, max: 8 },
+    fadeIn: { type: "number", default: 0, min: 0, max: 1 },
+    softness: { type: "number", default: 1, min: 0, max: 50, unit: "px", ray: true }
+  },
+  draw(ctx, p, env) {
+    const count = Math.max(1, Math.round(p.count));
+    const gap = Math.PI * 2 / count;
+    const rootDist = p.inner * env.unit;
+    const lengthPx = p.size * env.unit;
+    const rootHalf = p.width * env.px / 2;
+    for (let i = 0; i < count; i++) {
+      const jitterR = env.rng();
+      const varianceR = env.rng();
+      const base = p.angle * Math.PI / 180 + i * gap;
+      const angle = base + (jitterR * 2 - 1) * p.jitter * (gap / 2);
+      const lengthMul = 1 - p.variance * varianceR;
+      const brightMul = 1 - p.variance * varianceR;
+      const widthMul = 1 - 0.5 * p.variance * varianceR;
+      const half = rootHalf * widthMul;
+      drawRay(ctx, env, {
+        angleRad: angle,
+        rootDist,
+        tipDist: rootDist + lengthPx * lengthMul,
+        rootHalf: half,
+        tipHalf: half * (1 - p.taper),
+        strength: p.strength * brightMul,
+        falloff: p.falloff,
+        fadeIn: p.fadeIn * env.unit
+      });
+    }
+  }
+});
+
+// src/core/kinds/clusters.ts
+var clusters = defineShardKind({
+  kind: "clusters",
+  label: "Streaks",
+  params: {
+    clusters: { type: "number", default: 4, min: 1, max: 64, step: 1 },
+    perCluster: { type: "number", default: 5, min: 1, max: 64, step: 1 },
+    spread: { type: "number", default: 20, min: 0, max: 360 },
+    inner: { type: "number", default: 0.1, min: 0, max: 1 },
+    strength: { type: "number", default: 0.5, min: 0, max: 2 },
+    size: { type: "number", default: 0.5, min: 0, max: 2 },
+    angle: { type: "angle", default: 0 },
+    variance: { type: "number", default: 0.5, min: 0, max: 1 },
+    width: { type: "number", default: 2, min: 0, max: 100, unit: "px", ray: true },
+    taper: { type: "number", default: 0.5, min: 0, max: 1 },
+    falloff: { type: "number", default: 1, min: 0, max: 8 },
+    fadeIn: { type: "number", default: 0.1, min: 0, max: 1 },
+    softness: { type: "number", default: 1, min: 0, max: 50, unit: "px", ray: true }
+  },
+  draw(ctx, p, env) {
+    const clusterCount = Math.max(1, Math.round(p.clusters));
+    const perCluster = Math.max(1, Math.round(p.perCluster));
+    const gap = Math.PI * 2 / clusterCount;
+    const spreadRad = p.spread * Math.PI / 180;
+    const lengthPx = p.size * env.unit;
+    const rootHalf = p.width * env.px / 2;
+    for (let c = 0; c < clusterCount; c++) {
+      const center = p.angle * Math.PI / 180 + c * gap;
+      for (let i = 0; i < perCluster; i++) {
+        const dirR = env.rng();
+        const innerR = env.rng();
+        const varianceR = env.rng();
+        const angle = center + (dirR - 0.5) * spreadRad;
+        const inner = Math.max(0, p.inner + (innerR - 0.5) * p.variance);
+        const rootDist = inner * env.unit;
+        const lengthMul = 1 - p.variance * varianceR;
+        const brightMul = 1 - p.variance * varianceR;
+        const widthMul = 1 - 0.5 * p.variance * varianceR;
+        const half = rootHalf * widthMul;
+        drawRay(ctx, env, {
+          angleRad: angle,
+          rootDist,
+          tipDist: rootDist + lengthPx * lengthMul,
+          rootHalf: half,
+          tipHalf: half * (1 - p.taper),
+          strength: p.strength * brightMul,
+          falloff: p.falloff,
+          fadeIn: p.fadeIn * env.unit
+        });
+      }
+    }
+  }
+});
+
+// src/core/kinds/halo.ts
+var halo = defineShardKind({
+  kind: "halo",
+  label: "Halo",
+  params: {
+    strength: { type: "number", default: 0.1, min: 0, max: 2 },
+    size: { type: "number", default: 0.5, min: 0, max: 2 },
+    width: { type: "number", default: 0.05, min: 0, max: 2 },
+    falloff: { type: "number", default: 1, min: 0, max: 8 },
+    softness: { type: "number", default: 0, min: 0, max: 50, unit: "px" },
+    variance: { type: "number", default: 0, min: 0, max: 1 }
+  },
+  draw(ctx, p, env) {
+    const inner = Math.max(0, p.size - p.width / 2) * env.unit;
+    const outer = Math.max(inner, (p.size + p.width / 2) * env.unit);
+    if (outer <= 0 || p.strength <= 0) return;
+    const gradient = ctx.createRadialGradient(0, 0, inner, 0, 0, outer);
+    for (let i = 0; i <= GRADIENT_STOPS; i++) {
+      const t = i / GRADIENT_STOPS;
+      const across = 1 - Math.abs(2 * t - 1);
+      gradient.addColorStop(t, env.rgba(Math.pow(across, p.falloff) * p.strength));
+    }
+    ctx.fillStyle = gradient;
+    ctx.beginPath();
+    ctx.arc(0, 0, outer, 0, Math.PI * 2);
+    ctx.fill();
+  },
+  mask: conicVarianceMask
+});
+
+// src/core/kinds/index.ts
+function registerBuiltInKinds() {
+  registerShardKind(blob);
+  registerShardKind(fan);
+  registerShardKind(clusters);
+  registerShardKind(halo);
+}
+registerBuiltInKinds();
+
+// src/core/effects/registry.ts
+var effects = /* @__PURE__ */ new Map();
+function defineEffect(def) {
+  return def;
+}
+function registerEffect(def) {
+  if (effects.has(def.name)) {
+    warn2(`overwriting already-registered effect "${def.name}"`);
+  }
+  effects.set(def.name, def);
+}
+function getEffect(name) {
+  return effects.get(name);
+}
+function listEffects() {
+  return [...effects.values()];
+}
+function unregisterEffect(name) {
+  effects.delete(name);
+}
+function warn2(message) {
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") return;
+  console.warn(`[shardlight] ${message}`);
+}
+
+// src/core/effects/pulse.ts
+var pulse = defineEffect({
+  name: "pulse",
+  label: "Pulse",
+  params: {
+    channels: { type: "channels", default: ["main"] },
+    speed: { type: "number", default: 1, min: 0, max: 10, step: 0.01 },
+    amount: { type: "number", default: 0.1, min: 0, max: 1 }
+  },
+  apply(t, p, out) {
+    const k = 1 + Math.sin(t * p.speed * Math.PI * 2) * p.amount;
+    for (const channel of p.channels) out.channel(channel).scale *= k;
+  }
+});
+
+// src/core/effects/flicker.ts
+var flicker = defineEffect({
+  name: "flicker",
+  label: "Flicker",
+  params: {
+    amount: { type: "number", default: 0.15, min: 0, max: 1 },
+    speed: { type: "number", default: 1, min: 0, max: 10, step: 0.01 },
+    channels: { type: "channels", default: ["*"] }
+  },
+  apply(t, p, out) {
+    const s = t * p.speed;
+    const factor = 1 - p.amount * (0.5 + 0.25 * Math.sin(11.3 * s) + 0.25 * Math.sin(17.9 * s + 1.7));
+    const targets = p.channels.includes("*") ? out.channels() : p.channels;
+    for (const channel of targets) out.channel(channel).opacity *= factor;
+  }
+});
+
+// src/core/effects/spin.ts
+var spin = defineEffect({
+  name: "spin",
+  label: "Spin",
+  params: {
+    channels: { type: "channels", default: ["main"] },
+    speed: { type: "number", default: 0.1, min: -10, max: 10, step: 0.01, unit: "turns/s" },
+    phase: { type: "angle", default: 0 }
+  },
+  apply(t, p, out) {
+    const rotation = p.phase + p.speed * 360 * t;
+    for (const channel of p.channels) out.channel(channel).rotation += rotation;
+  }
+});
+
+// src/core/effects/hover.ts
+var hover = defineEffect({
+  name: "hover",
+  label: "Hover",
+  params: {
+    channels: { type: "channels", default: ["main"] },
+    scale: { type: "number", default: 1.15, min: 0, max: 4, step: 0.01 },
+    opacity: { type: "number", default: 1, min: 0, max: 4, step: 0.01 },
+    rotate: { type: "angle", default: 0 },
+    spin: { type: "number", default: 0, min: -10, max: 10, step: 0.01, unit: "turns/s" }
+  },
+  reducedMotion: "keep",
+  apply(_t, p, out) {
+    const h = out.hover;
+    for (const channel of p.channels) {
+      const values = out.channel(channel);
+      values.scale *= 1 + (p.scale - 1) * h;
+      values.opacity *= 1 + (p.opacity - 1) * h;
+      values.rotation += p.rotate * h + p.spin * 360 * out.hoverTime;
+    }
+  }
+});
+
+// src/core/effects/collapse.ts
+var collapse = defineEffect({
+  name: "collapse",
+  label: "Collapse",
+  params: {
+    channels: { type: "channels", default: ["*"] },
+    scale: { type: "number", default: 0, min: 0, max: 4, step: 0.01 },
+    opacity: { type: "number", default: 1, min: 0, max: 4, step: 0.01 },
+    trigger: { type: "enum", default: "click", values: ["click", "once", "none"] }
+  },
+  reducedMotion: "keep",
+  apply(_t, p, out) {
+    const amount = out.collapse;
+    if (amount <= 0) return;
+    const targets = p.channels.includes("*") ? out.channels() : p.channels;
+    for (const channel of targets) {
+      const values = out.channel(channel);
+      values.scale *= 1 + (p.scale - 1) * amount;
+      values.opacity *= 1 + (p.opacity - 1) * amount;
+    }
+  }
+});
+function collapseTrigger(effects2) {
+  let has = false;
+  let once = false;
+  for (const effect of effects2) {
+    if (effect.type !== "collapse") continue;
+    has = true;
+    if (effect.trigger === "none") return "none";
+    if (effect.trigger === "once") once = true;
+  }
+  if (!has) return "none";
+  return once ? "once" : "click";
+}
+
+// src/core/effects/index.ts
+function registerBuiltInEffects() {
+  registerEffect(pulse);
+  registerEffect(flicker);
+  registerEffect(spin);
+  registerEffect(hover);
+  registerEffect(collapse);
+}
+registerBuiltInEffects();
+
+// src/core/presets/registry.ts
+var presets = /* @__PURE__ */ new Map();
+function definePreset(config) {
+  return config;
+}
+function registerPreset(name, config) {
+  if (presets.has(name)) {
+    warn3(`overwriting already-registered preset "${name}"`);
+  }
+  presets.set(name, config);
+}
+function getPreset(name) {
+  return presets.get(name);
+}
+function listPresets() {
+  return [...presets.keys()];
+}
+function unregisterPreset(name) {
+  presets.delete(name);
+}
+function warn3(message) {
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") return;
+  console.warn(`[shardlight] ${message}`);
+}
+
+// src/core/presets/star.ts
+var star = definePreset({
+  version: 1,
+  color: "#FFF4E0",
+  rotation: 45,
+  seed: 1,
+  shards: [
+    {
+      id: "bloom",
+      kind: "blob",
+      channel: "body",
+      strength: 0.4,
+      size: 0.85,
+      hardness: 0,
+      falloff: 3,
+      softness: 3
+    },
+    {
+      id: "hotspot",
+      kind: "blob",
+      channel: "body",
+      strength: 1,
+      size: 0.13,
+      hardness: 0.4,
+      falloff: 2.2
+    },
+    {
+      id: "beam",
+      kind: "fan",
+      channel: "rays",
+      strength: 0.9,
+      size: 1,
+      count: 4,
+      variance: 0.08,
+      width: 5,
+      taper: 1,
+      falloff: 2,
+      softness: 2
+    },
+    {
+      id: "ring",
+      kind: "halo",
+      channel: "rays",
+      strength: 0.06,
+      size: 0.62,
+      width: 0.05,
+      falloff: 2,
+      softness: 1.5,
+      variance: 0.35
+    }
+  ]
+});
+
+// src/core/presets/sun.ts
+var sun = definePreset({
+  version: 1,
+  color: "#FFE9B8",
+  rotation: 0,
+  seed: 1,
+  shards: [
+    {
+      id: "bloom",
+      kind: "blob",
+      channel: "body",
+      strength: 0.55,
+      size: 1.15,
+      hardness: 0,
+      falloff: 2.6,
+      softness: 5
+    },
+    {
+      id: "hotspot",
+      kind: "blob",
+      channel: "body",
+      strength: 1,
+      size: 0.22,
+      hardness: 0.3,
+      falloff: 2
+    },
+    {
+      id: "rays",
+      kind: "fan",
+      channel: "rays",
+      strength: 0.45,
+      size: 1,
+      count: 32,
+      variance: 0.7,
+      jitter: 0.55,
+      inner: 0.06,
+      width: 2,
+      taper: 1,
+      falloff: 1.6,
+      fadeIn: 0.05,
+      softness: 1.5
+    },
+    {
+      id: "ring",
+      kind: "halo",
+      channel: "rays",
+      strength: 0.04,
+      size: 0.8,
+      width: 0.07,
+      falloff: 2,
+      softness: 2.5,
+      variance: 0.4
+    }
+  ]
+});
+
+// src/core/presets/sparkle.ts
+var sparkle = definePreset({
+  version: 1,
+  color: "#FFFFFF",
+  rotation: 0,
+  seed: 4,
+  shards: [
+    {
+      id: "bloom",
+      kind: "blob",
+      channel: "body",
+      strength: 0.25,
+      size: 0.28,
+      hardness: 0,
+      falloff: 3,
+      softness: 2
+    },
+    {
+      id: "hotspot",
+      kind: "blob",
+      channel: "body",
+      strength: 1,
+      size: 0.08,
+      hardness: 0.5,
+      falloff: 2
+    },
+    {
+      id: "spikes",
+      kind: "fan",
+      channel: "rays",
+      strength: 1,
+      size: 0.42,
+      count: 6,
+      width: 3,
+      taper: 1,
+      falloff: 2,
+      softness: 1
+    },
+    {
+      id: "glint",
+      kind: "fan",
+      channel: "glint",
+      strength: 0.6,
+      size: 0.26,
+      count: 6,
+      angle: 30,
+      width: 2,
+      taper: 1,
+      falloff: 2,
+      softness: 1
+    }
+  ]
+});
+
+// src/core/presets/starburst.ts
+var starburst = definePreset({
+  version: 1,
+  color: "#FFFFFF",
+  rotation: 0,
+  seed: 7,
+  shards: [
+    {
+      id: "glow",
+      kind: "blob",
+      channel: "body",
+      strength: 0.3,
+      size: 0.5,
+      hardness: 0,
+      falloff: 3,
+      softness: 4
+    },
+    {
+      id: "core",
+      kind: "blob",
+      channel: "body",
+      strength: 1,
+      size: 0.1,
+      hardness: 0.5,
+      falloff: 2
+    },
+    {
+      id: "rays",
+      kind: "fan",
+      channel: "rays",
+      strength: 0.7,
+      size: 1.1,
+      count: 24,
+      variance: 0.45,
+      width: 2,
+      taper: 1,
+      falloff: 1.6,
+      fadeIn: 0.02,
+      softness: 1
+    }
+  ]
+});
+
+// src/core/presets/ember.ts
+var ember = definePreset({
+  version: 1,
+  color: "#FF9A4D",
+  rotation: 0,
+  seed: 6,
+  shards: [
+    {
+      id: "bloom",
+      kind: "blob",
+      channel: "body",
+      strength: 0.5,
+      size: 1,
+      hardness: 0,
+      falloff: 2.2,
+      softness: 6
+    },
+    {
+      id: "hotspot",
+      kind: "blob",
+      channel: "body",
+      strength: 1,
+      size: 0.18,
+      hardness: 0.25,
+      falloff: 2.4
+    },
+    {
+      id: "sparks",
+      kind: "fan",
+      channel: "rays",
+      strength: 0.3,
+      size: 0.85,
+      count: 6,
+      variance: 0.8,
+      jitter: 0.4,
+      inner: 0.15,
+      width: 2,
+      taper: 1,
+      falloff: 2,
+      fadeIn: 0.15,
+      softness: 1
+    }
+  ]
+});
+
+// src/core/presets/index.ts
+function registerBuiltInPresets() {
+  registerPreset("star", star);
+  registerPreset("sun", sun);
+  registerPreset("sparkle", sparkle);
+  registerPreset("starburst", starburst);
+  registerPreset("ember", ember);
+}
+registerBuiltInPresets();
+
+// src/core/util/color.ts
+var HEX = /^#?([0-9a-f]{3,8})$/i;
+var RGB_FN = /^rgba?\(\s*([^)]+)\)$/i;
+function clampByte(n) {
+  return Math.max(0, Math.min(255, Math.round(n)));
+}
+function parseColor(input) {
+  const value = (input ?? "").trim();
+  const hex = HEX.exec(value);
+  if (hex) {
+    const h = hex[1];
+    if (h.length === 3 || h.length === 4) {
+      const r = parseInt(h[0] + h[0], 16);
+      const g = parseInt(h[1] + h[1], 16);
+      const b = parseInt(h[2] + h[2], 16);
+      const a = h.length === 4 ? parseInt(h[3] + h[3], 16) / 255 : 1;
+      return { r, g, b, a };
+    }
+    if (h.length === 6 || h.length === 8) {
+      const r = parseInt(h.slice(0, 2), 16);
+      const g = parseInt(h.slice(2, 4), 16);
+      const b = parseInt(h.slice(4, 6), 16);
+      const a = h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : 1;
+      return { r, g, b, a };
+    }
+  }
+  const fn = RGB_FN.exec(value);
+  if (fn) {
+    const parts = fn[1].split(/[\s,/]+/).filter(Boolean).map(Number);
+    if (parts.length >= 3 && parts.every((n) => Number.isFinite(n))) {
+      return {
+        r: clampByte(parts[0]),
+        g: clampByte(parts[1]),
+        b: clampByte(parts[2]),
+        a: parts.length >= 4 ? Math.max(0, Math.min(1, parts[3])) : 1
+      };
+    }
+  }
+  return { r: 255, g: 255, b: 255, a: 1 };
+}
+function makeRgba(color) {
+  const { r, g, b, a } = parseColor(color);
+  return (alpha) => {
+    const clamped = Math.max(0, Math.min(1, alpha)) * a;
+    return `rgba(${r},${g},${b},${clamped})`;
+  };
+}
+function isCssIdentifier(name) {
+  return /^-?[_a-zA-Z][-_a-zA-Z0-9]*$/.test(name);
+}
+
+// src/core/config/resolve.ts
+var DEFAULT_COLOR = "#FFFFFF";
+function resolveConfig(input = {}, options = {}) {
+  const warn4 = makeWarn(options.warn);
+  const presetConfig = resolvePreset(input.preset, options.defaultPreset ?? null, warn4);
+  const config = input.config ?? void 0;
+  const color = input.color ?? config?.color ?? presetConfig?.color ?? DEFAULT_COLOR;
+  const rotation = input.rotation ?? config?.rotation ?? presetConfig?.rotation ?? 0;
+  const seed = input.seed ?? config?.seed ?? presetConfig?.seed ?? 1;
+  let list = presetConfig ? presetConfig.shards.map((s) => ({ ...s })) : [];
+  if (config?.shards) list = mergeShardList(list, config.shards, warn4);
+  if (input.shards) list = mergeShardList(list, input.shards, warn4);
+  const effects2 = input.effects ?? config?.effects ?? presetConfig?.effects ?? [];
+  const shards = [];
+  for (const shard of list) {
+    const resolved = resolveShard(shard, color, seed, warn4);
+    if (resolved) shards.push(resolved);
+  }
+  resolveRelativeAngles(shards);
+  const motionEffects = applyShardMotion(shards, warn4);
+  return {
+    version: 1,
+    color,
+    rotation,
+    seed,
+    shards,
+    effects: [...resolveEffects(effects2, warn4), ...motionEffects]
+  };
+}
+function resolvePreset(preset, defaultName, warn4) {
+  if (preset === void 0) preset = defaultName ?? null;
+  if (preset === null) return void 0;
+  if (typeof preset === "string") {
+    const found = getPreset(preset);
+    if (!found) {
+      warn4(`unknown preset "${preset}"`);
+      return defaultName ? getPreset(defaultName) : void 0;
+    }
+    return found;
+  }
+  return preset;
+}
+function mergeShardList(base, overrides, warn4) {
+  const list = base.map((s) => ({ ...s }));
+  const indexById = new Map(list.map((s, i) => [s.id, i]));
+  for (const override of overrides) {
+    const id = override.id;
+    if (typeof id !== "string") {
+      warn4("a shard override without a string `id` was skipped");
+      continue;
+    }
+    const index = indexById.get(id);
+    if (index === void 0) {
+      if (override.kind === void 0) {
+        warn4(`override for unknown shard "${id}" skipped (no \`kind\` to add it)`);
+        continue;
+      }
+      list.push({ ...override });
+      indexById.set(id, list.length - 1);
+    } else {
+      list[index] = { ...list[index], ...override };
+    }
+  }
+  return list;
+}
+function resolveShard(shard, lightColor, lightSeed, warn4) {
+  const kindDef = getShardKind(shard.kind);
+  if (!kindDef) {
+    warn4(`unknown shard kind "${shard.kind}" (shard "${shard.id}") skipped`);
+    return null;
+  }
+  const params = {};
+  for (const [name, schema] of Object.entries(kindDef.params)) {
+    const raw = shard[name];
+    params[name] = coerce(schema, raw, `${shard.id}.${name}`, warn4);
+  }
+  const relativeTo = shard.relativeTo;
+  if (typeof relativeTo === "string") params.relativeTo = relativeTo;
+  const channel = shard.channel ?? "main";
+  if (!isCssIdentifier(channel)) {
+    warn4(`shard "${shard.id}" channel "${channel}" is not a valid CSS identifier`);
+  }
+  return {
+    id: shard.id,
+    kind: shard.kind,
+    visible: shard.visible ?? true,
+    channel,
+    blend: shard.blend ?? "add",
+    color: shard.color ?? lightColor,
+    seed: shard.seed ?? lightSeed,
+    spin: resolveSpin(shard.spin, shard.id, warn4),
+    hover: resolveHover(shard.hover, shard.id, warn4),
+    collapse: resolveCollapse(shard.collapse, shard.id, warn4),
+    params
+  };
+}
+var DEFAULT_SPIN_SPEED = 0.1;
+var HOVER_DEFAULTS = { scale: 1.15, opacity: 1, rotate: 0, spin: 0 };
+var COLLAPSE_DEFAULTS = { scale: 0, opacity: 1 };
+function resolveSpin(value, id, warn4) {
+  if (value === void 0 || value === null || value === false) return void 0;
+  if (value === true) return { speed: DEFAULT_SPIN_SPEED, phase: 0 };
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value === 0) return void 0;
+    return { speed: value, phase: 0 };
+  }
+  if (typeof value === "object") {
+    const speed = Number(value.speed);
+    if (!Number.isFinite(speed)) {
+      warn4(`shard "${id}" spin.speed is not a number; spin ignored`);
+      return void 0;
+    }
+    if (speed === 0) return void 0;
+    const phase = Number(value.phase ?? 0);
+    return { speed, phase: Number.isFinite(phase) ? phase : 0 };
+  }
+  warn4(`shard "${id}" spin must be a number, boolean or object; spin ignored`);
+  return void 0;
+}
+function resolveHover(value, id, warn4) {
+  if (value === void 0 || value === null || value === false) return void 0;
+  if (value === true) return { ...HOVER_DEFAULTS };
+  if (typeof value === "object") {
+    return {
+      scale: finiteOr(value.scale, HOVER_DEFAULTS.scale),
+      opacity: finiteOr(value.opacity, HOVER_DEFAULTS.opacity),
+      rotate: finiteOr(value.rotate, HOVER_DEFAULTS.rotate),
+      spin: finiteOr(value.spin, HOVER_DEFAULTS.spin)
+    };
+  }
+  warn4(`shard "${id}" hover must be a boolean or object; hover ignored`);
+  return void 0;
+}
+function resolveCollapse(value, id, warn4) {
+  if (value === void 0 || value === null || value === false) return void 0;
+  if (value === true) return { ...COLLAPSE_DEFAULTS };
+  if (typeof value === "object") {
+    return {
+      scale: finiteOr(value.scale, COLLAPSE_DEFAULTS.scale),
+      opacity: finiteOr(value.opacity, COLLAPSE_DEFAULTS.opacity)
+    };
+  }
+  warn4(`shard "${id}" collapse must be a boolean or object; collapse ignored`);
+  return void 0;
+}
+function finiteOr(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+function applyShardMotion(shards, warn4) {
+  const effects2 = [];
+  const originalChannels = shards.map((shard) => shard.channel);
+  const taken = new Set(originalChannels);
+  for (const shard of shards) {
+    if (!shard.spin && !shard.hover && !shard.collapse) continue;
+    const shared = originalChannels.filter((channel) => channel === shard.channel).length > 1;
+    if (shared) {
+      const name = uniqueChannel(shard.id, taken);
+      shard.channel = name;
+      taken.add(name);
+      if (!isCssIdentifier(name)) {
+        warn4(`shard "${shard.id}" got an invalid motion channel "${name}"`);
+      }
+    }
+    if (shard.spin) {
+      effects2.push({
+        type: "spin",
+        channels: [shard.channel],
+        speed: shard.spin.speed,
+        phase: shard.spin.phase
+      });
+    }
+    if (shard.hover) {
+      effects2.push({
+        type: "hover",
+        channels: [shard.channel],
+        scale: shard.hover.scale,
+        opacity: shard.hover.opacity,
+        rotate: shard.hover.rotate,
+        spin: shard.hover.spin
+      });
+    }
+    if (shard.collapse) {
+      effects2.push({
+        type: "collapse",
+        channels: [shard.channel],
+        scale: shard.collapse.scale,
+        opacity: shard.collapse.opacity
+      });
+    }
+  }
+  return effects2;
+}
+function uniqueChannel(id, taken) {
+  const base = isCssIdentifier(id) ? id : `shard-${id.replace(/[^_a-zA-Z0-9-]/g, "-").replace(/^-+/, "")}`;
+  let name = base;
+  let i = 2;
+  while (taken.has(name)) {
+    name = `${base}-${i}`;
+    i += 1;
+  }
+  return name;
+}
+function resolveRelativeAngles(shards) {
+  const byId = new Map(shards.map((s) => [s.id, s]));
+  for (const shard of shards) {
+    const relativeTo = shard.params.relativeTo;
+    if (typeof relativeTo !== "string") continue;
+    const target = byId.get(relativeTo);
+    if (!target) continue;
+    if (typeof target.params.angle === "number" && typeof shard.params.angle === "number") {
+      shard.params.angle += target.params.angle;
+    }
+  }
+}
+function resolveEffects(effects2, warn4) {
+  const out = [];
+  for (const effect of effects2) {
+    const def = getEffect(effect.type);
+    if (!def) {
+      warn4(`unknown effect "${effect.type}" skipped`);
+      continue;
+    }
+    const params = { type: effect.type };
+    for (const [name, schema] of Object.entries(def.params)) {
+      params[name] = coerce(
+        schema,
+        effect[name],
+        `effect ${effect.type}.${name}`,
+        warn4
+      );
+    }
+    out.push(params);
+  }
+  return out;
+}
+function coerce(schema, raw, label, warn4) {
+  switch (schema.type) {
+    case "number":
+    case "angle": {
+      let value = raw === void 0 || raw === null ? schema.default : Number(raw);
+      if (!Number.isFinite(value)) {
+        warn4(`${label} is not a number; using default ${schema.default}`);
+        value = schema.default;
+      }
+      if (schema.min !== void 0 && value < schema.min) {
+        warn4(`${label} (${value}) clamped to min ${schema.min}`);
+        value = schema.min;
+      }
+      if (schema.max !== void 0 && value > schema.max) {
+        warn4(`${label} (${value}) clamped to max ${schema.max}`);
+        value = schema.max;
+      }
+      return value;
+    }
+    case "boolean":
+      return raw === void 0 || raw === null ? schema.default : Boolean(raw);
+    case "color":
+      return raw === void 0 || raw === null ? schema.default : String(raw);
+    case "enum": {
+      const value = raw === void 0 || raw === null ? schema.default : String(raw);
+      if (!schema.values.includes(value)) {
+        warn4(`${label} "${value}" is not one of ${schema.values.join(", ")}; using default`);
+        return schema.default;
+      }
+      return value;
+    }
+    case "channels": {
+      if (raw === void 0 || raw === null) return [...schema.default];
+      if (!Array.isArray(raw)) {
+        warn4(`${label} is not an array; using default`);
+        return [...schema.default];
+      }
+      return raw.map((v) => String(v));
+    }
+    default:
+      return raw;
+  }
+}
+function makeWarn(enabled) {
+  const on = enabled ?? (typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true);
+  if (!on) return () => {
+  };
+  return (message) => {
+    console.warn(`[shardlight] ${message}`);
+  };
+}
+
+// src/core/config/migrate.ts
+var CURRENT_VERSION = 1;
+function migrateConfig(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("shardlight: migrateConfig expected a config object");
+  }
+  let config = { ...input };
+  let version = typeof config.version === "number" ? config.version : CURRENT_VERSION;
+  if (version > CURRENT_VERSION) {
+    return config;
+  }
+  while (version < CURRENT_VERSION) {
+    version += 1;
+    config = { ...config, version };
+  }
+  if (config.version !== CURRENT_VERSION) config = { ...config, version: CURRENT_VERSION };
+  return config;
+}
+
+// src/core/effects/frame-values.ts
+function computeFrame(base, effects2, t, channelNames = []) {
+  const map = /* @__PURE__ */ new Map();
+  for (const name of channelNames) map.set(name, { scale: 1, opacity: 1, rotation: 0 });
+  if (base.channels) {
+    for (const [name, values] of Object.entries(base.channels)) {
+      const current = map.get(name) ?? { scale: 1, opacity: 1, rotation: 0 };
+      map.set(name, {
+        scale: values.scale ?? current.scale,
+        opacity: values.opacity ?? current.opacity,
+        rotation: values.rotation ?? current.rotation
+      });
+    }
+  }
+  const out = {
+    opacity: base.opacity ?? 1,
+    hover: base.hover ?? 0,
+    hoverTime: base.hoverTime ?? 0,
+    collapse: base.collapse ?? 0,
+    channel(name) {
+      let channel = map.get(name);
+      if (!channel) {
+        channel = { scale: 1, opacity: 1, rotation: 0 };
+        map.set(name, channel);
+      }
+      return channel;
+    },
+    channels() {
+      return [...map.keys()];
+    }
+  };
+  for (const effect of effects2) {
+    const def = getEffect(effect.type);
+    if (!def) continue;
+    def.apply(t, effect, out);
+  }
+  return out;
+}
+
+// src/core/bake/baker.ts
+var NullContextError = class extends Error {
+  constructor() {
+    super("shardlight: 2D context unavailable (canvas memory cap?)");
+    this.name = "NullContextError";
+  }
+};
+
+// src/core/util/hash.ts
+function hashString(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
+// src/core/util/rng.ts
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function next() {
+    a = a + 1831565813 | 0;
+    let 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 shardSeed(id, seed) {
+  return (hashString(id) ^ seed >>> 0) >>> 0;
+}
+
+// src/core/util/dom.ts
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function createCanvas(width, height) {
+  if (typeof OffscreenCanvas !== "undefined") {
+    return new OffscreenCanvas(width, height);
+  }
+  if (typeof document !== "undefined") {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+  }
+  throw new Error("shardlight: no canvas implementation available in this environment");
+}
+function get2dContext(canvas) {
+  try {
+    return canvas.getContext("2d");
+  } catch {
+    return null;
+  }
+}
+function freeCanvas(canvas) {
+  try {
+    canvas.width = 0;
+    canvas.height = 0;
+  } catch {
+  }
+}
+function canvasToBlob(canvas) {
+  if (typeof canvas.convertToBlob === "function") {
+    return canvas.convertToBlob({ type: "image/png" });
+  }
+  const el = canvas;
+  return new Promise((resolve, reject) => {
+    el.toBlob((blob2) => {
+      if (blob2) resolve(blob2);
+      else reject(new Error("shardlight: canvas.toBlob returned null"));
+    }, "image/png");
+  });
+}
+function isLowMemoryDevice() {
+  if (typeof navigator === "undefined") return false;
+  const nav = navigator;
+  if (typeof nav.deviceMemory === "number") return nav.deviceMemory <= 2;
+  return false;
+}
+
+// src/core/bake/canvas2d.ts
+var canvas2dBaker = {
+  id: "canvas2d",
+  async bake(layer, opts, signal) {
+    throwIfAborted(signal);
+    const resolution = Math.max(1, Math.floor(opts.resolution));
+    const canvas = createCanvas(resolution, resolution);
+    const ctx = get2dContext(canvas);
+    if (!ctx) {
+      freeCanvas(canvas);
+      throw new NullContextError();
+    }
+    ctx.clearRect(0, 0, resolution, resolution);
+    const unit = resolution / 2;
+    const px = resolution / 1024;
+    for (const shard of layer.shards) {
+      throwIfAborted(signal);
+      if (!shard.visible) continue;
+      const def = getShardKind(shard.kind);
+      if (!def) continue;
+      const scratch = createCanvas(resolution, resolution);
+      const scratchCtx = get2dContext(scratch);
+      if (!scratchCtx) {
+        freeCanvas(scratch);
+        continue;
+      }
+      const params = applyRayScale(
+        shard.params,
+        def.params,
+        opts.rayScale
+      );
+      const env = {
+        unit,
+        px,
+        color: shard.color,
+        rayScale: opts.rayScale,
+        size: resolution,
+        rng: mulberry32(shardSeed(shard.id, shard.seed)),
+        rgba: makeRgba(shard.color)
+      };
+      scratchCtx.save();
+      scratchCtx.translate(unit, unit);
+      scratchCtx.rotate(layer.rotation * Math.PI / 180);
+      try {
+        def.draw(scratchCtx, params, env);
+      } catch {
+      }
+      scratchCtx.restore();
+      if (def.mask) {
+        try {
+          def.mask(scratchCtx, params, env, resolution);
+        } catch {
+        }
+      }
+      let blur = 0;
+      if (def.blur) blur = def.blur(params, env);
+      else if (typeof params.softness === "number") blur = params.softness;
+      ctx.save();
+      ctx.globalCompositeOperation = "lighter";
+      if (blur > 0 && typeof ctx.filter === "string") ctx.filter = `blur(${blur}px)`;
+      ctx.drawImage(scratch, 0, 0);
+      ctx.restore();
+      freeCanvas(scratch);
+    }
+    return encode(canvas, opts, signal);
+  }
+};
+async function encode(canvas, opts, signal) {
+  const accept = opts.accept;
+  if (accept.includes("url")) {
+    const blob3 = await canvasToBlob(canvas);
+    freeCanvas(canvas);
+    throwIfAborted(signal);
+    return { type: "url", url: URL.createObjectURL(blob3) };
+  }
+  if (accept.includes("bitmap") && typeof createImageBitmap === "function") {
+    try {
+      const bitmap = await createImageBitmap(canvas, {
+        premultiplyAlpha: "none",
+        colorSpaceConversion: "none"
+      });
+      throwIfAborted(signal);
+      freeCanvas(canvas);
+      return { type: "bitmap", bitmap };
+    } catch (error) {
+      if (isAbort(error)) throw error;
+    }
+  }
+  if (accept.includes("canvas") || accept.includes("bitmap")) {
+    return { type: "canvas", canvas };
+  }
+  const blob2 = await canvasToBlob(canvas);
+  freeCanvas(canvas);
+  throwIfAborted(signal);
+  return { type: "url", url: URL.createObjectURL(blob2) };
+}
+function throwIfAborted(signal) {
+  if (signal.aborted) {
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    throw error;
+  }
+}
+function isAbort(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+
+// src/core/bake/cache.ts
+var sources = /* @__PURE__ */ new Map();
+var refs = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Map();
+function acquireSource(key, start) {
+  refs.set(key, (refs.get(key) ?? 0) + 1);
+  const existing = sources.get(key);
+  if (existing) return Promise.resolve(existing);
+  const inflight = pending.get(key);
+  if (inflight) return inflight.promise;
+  const controller = new AbortController();
+  const entry = { controller, promise: void 0 };
+  entry.promise = start(controller.signal).then(
+    (source) => {
+      if (pending.get(key) === entry) pending.delete(key);
+      sources.set(key, source);
+      if (!refs.has(key)) {
+        sources.delete(key);
+        disposeSource(source);
+      }
+      return source;
+    },
+    (error) => {
+      if (pending.get(key) === entry) pending.delete(key);
+      throw error;
+    }
+  );
+  pending.set(key, entry);
+  return entry.promise;
+}
+function releaseSource(key) {
+  const next = (refs.get(key) ?? 0) - 1;
+  if (next > 0) {
+    refs.set(key, next);
+    return;
+  }
+  refs.delete(key);
+  const source = sources.get(key);
+  if (source) {
+    sources.delete(key);
+    disposeSource(source);
+    return;
+  }
+  const inflight = pending.get(key);
+  if (inflight) {
+    pending.delete(key);
+    inflight.controller.abort();
+  }
+}
+function disposeSource(source) {
+  if (source.type === "url") {
+    if (typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function") {
+      URL.revokeObjectURL(source.url);
+    }
+  } else if (source.type === "bitmap") {
+    try {
+      source.bitmap.close();
+    } catch {
+    }
+  } else if (source.type === "canvas") {
+    try {
+      source.canvas.width = 0;
+      source.canvas.height = 0;
+    } catch {
+    }
+  }
+}
+function cacheSize() {
+  return sources.size;
+}
+function clearCache() {
+  for (const source of sources.values()) disposeSource(source);
+  sources.clear();
+  refs.clear();
+  for (const inflight of pending.values()) inflight.controller.abort();
+  pending.clear();
+}
+
+// src/core/bake/scheduler.ts
+function createScheduler(options = {}) {
+  const delay = options.yieldDelay ?? 0;
+  const queue = [];
+  let running = false;
+  async function pump() {
+    if (running) return;
+    running = true;
+    try {
+      while (queue.length > 0) {
+        const item = queue.shift();
+        if (item.signal?.aborted) {
+          item.reject(abortError());
+          continue;
+        }
+        try {
+          item.resolve(await item.task());
+        } catch (error) {
+          item.reject(error);
+        }
+        if (queue.length > 0) await sleep(delay);
+      }
+    } finally {
+      running = false;
+    }
+  }
+  return {
+    run(task, signal) {
+      return new Promise((resolve, reject) => {
+        queue.push({
+          task,
+          resolve,
+          reject,
+          signal
+        });
+        void pump();
+      });
+    },
+    clear() {
+      queue.length = 0;
+    }
+  };
+}
+function abortError() {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException("Aborted", "AbortError");
+  }
+  const error = new Error("Aborted");
+  error.name = "AbortError";
+  return error;
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError" || typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/util/stringify.ts
+function stableStringify(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value && typeof value === "object") {
+    const obj = value;
+    const out = {};
+    for (const key of Object.keys(obj).sort()) out[key] = sortValue(obj[key]);
+    return out;
+  }
+  if (typeof value === "number") {
+    if (Object.is(value, -0)) return 0;
+    if (Number.isNaN(value)) return "NaN";
+  }
+  return value;
+}
+
+// src/core/model/layers.ts
+function buildLayers(light, inputs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const shard of light.shards) {
+    if (!shard.visible) continue;
+    const id = layerId(shard.channel, shard.blend);
+    let group = groups.get(id);
+    if (!group) {
+      group = [];
+      groups.set(id, group);
+    }
+    group.push(shard);
+  }
+  const layers = [];
+  for (const [id, shards] of groups) {
+    const [channel, blend] = id.split("|");
+    const content = {
+      shards: shards.map((s) => ({
+        id: s.id,
+        kind: s.kind,
+        params: s.params,
+        color: s.color,
+        seed: s.seed
+      })),
+      color: light.color,
+      rotation: light.rotation,
+      seed: light.seed,
+      resolution: inputs.resolution,
+      rayScale: inputs.rayScale,
+      baker: inputs.baker,
+      accept: inputs.accept
+    };
+    layers.push({
+      key: `sl_${hashString(stableStringify(content)).toString(36)}`,
+      id,
+      channel,
+      blend,
+      shards,
+      color: light.color,
+      rotation: light.rotation,
+      seed: light.seed
+    });
+  }
+  return layers;
+}
+function layerId(channel, blend) {
+  return `${channel}|${blend}`;
+}
+
+// src/core/bake/prewarm.ts
+var prewarmed = [];
+async function prewarm(options = {}) {
+  const baker = options.baker ?? canvas2dBaker;
+  const resolution = options.resolution ?? 1024;
+  const rayScale = options.rayScale ?? 1;
+  const accepts = options.accepts ?? ["url"];
+  const config = options.config ? migrateConfig(options.config) : void 0;
+  const light = resolveConfig(
+    {
+      preset: options.preset,
+      config,
+      shards: options.shards,
+      effects: options.effects,
+      color: options.color,
+      rotation: options.rotation,
+      seed: options.seed
+    },
+    { warn: options.warn }
+  );
+  const layers = buildLayers(light, {
+    resolution,
+    rayScale,
+    baker: baker.id,
+    accept: accepts
+  });
+  const scheduler = createScheduler();
+  await Promise.all(
+    layers.map((layer) => {
+      prewarmed.push(layer.key);
+      return acquireSource(
+        layer.key,
+        (signal) => scheduler.run(
+          () => baker.bake(layer, { resolution, rayScale, accept: accepts }, signal),
+          signal
+        )
+      );
+    })
+  );
+}
+function releasePrewarm() {
+  for (const key of prewarmed) releaseSource(key);
+  prewarmed.length = 0;
+}
+
+// src/core/util/object.ts
+function definedOnly(value) {
+  const out = {};
+  for (const key of Object.keys(value)) {
+    if (value[key] !== void 0) out[key] = value[key];
+  }
+  return out;
+}
+
+// src/core/model/light-model.ts
+var DEFAULT_RESOLUTION = 1024;
+var DEFAULT_ACCEPTS = ["url"];
+var DEFAULT_HOVER_EASE = 0.25;
+var DEFAULT_COLLAPSE_EASE = 0.3;
+function createLightModel(options = {}) {
+  let opts = {
+    resolution: DEFAULT_RESOLUTION,
+    rayScale: 1,
+    baker: canvas2dBaker,
+    accepts: DEFAULT_ACCEPTS,
+    ...definedOnly(options)
+  };
+  const scheduler = createScheduler();
+  const layerListeners = /* @__PURE__ */ new Set();
+  const frameListeners = /* @__PURE__ */ new Set();
+  const acquired = /* @__PURE__ */ new Map();
+  const readyWaiters = [];
+  let resolved = resolve(opts);
+  let layers = [];
+  let manual = {};
+  let time = 0;
+  let hover2 = 0;
+  let hoverTarget = 0;
+  let hoverTime = 0;
+  let collapse2 = 0;
+  let collapseTarget = 0;
+  let disposed = false;
+  function resolve(current) {
+    const config = current.config ? migrateConfig(current.config) : void 0;
+    return resolveConfig(
+      {
+        preset: current.preset,
+        config,
+        shards: current.shards,
+        effects: current.effects,
+        color: current.color,
+        rotation: current.rotation,
+        seed: current.seed
+      },
+      { warn: current.warn }
+    );
+  }
+  function activeEffects() {
+    if (!opts.reducedMotion) return resolved.effects;
+    return resolved.effects.filter((effect) => getEffect(effect.type)?.reducedMotion === "keep");
+  }
+  function channelNames() {
+    return [...new Set(layers.map((layer) => layer.channel))];
+  }
+  function hasEffect(type) {
+    return resolved.effects.some((effect) => effect.type === type);
+  }
+  function emitLayers() {
+    const snapshot = layers.slice();
+    for (const listener of layerListeners) listener(snapshot);
+  }
+  function frame() {
+    return computeFrame(
+      { ...manual, hover: hover2, hoverTime, collapse: collapse2 },
+      activeEffects(),
+      time,
+      channelNames()
+    );
+  }
+  function emitFrame() {
+    const values = frame();
+    for (const listener of frameListeners) listener(values);
+  }
+  function pendingCount() {
+    return layers.reduce((count, layer) => count + (layer.source ? 0 : 1), 0);
+  }
+  function flushReady() {
+    if (pendingCount() !== 0) return;
+    while (readyWaiters.length > 0) readyWaiters.shift()();
+  }
+  function bake(resolvedLayer, view) {
+    acquireSource(
+      view.key,
+      (signal) => scheduler.run(
+        () => opts.baker.bake(
+          resolvedLayer,
+          {
+            resolution: opts.resolution ?? DEFAULT_RESOLUTION,
+            rayScale: opts.rayScale ?? 1,
+            accept: opts.accepts ?? DEFAULT_ACCEPTS
+          },
+          signal
+        ),
+        signal
+      )
+    ).then((source) => {
+      if (disposed) return;
+      const current = currentView(view);
+      if (!current) return;
+      current.source = source;
+      emitLayers();
+      flushReady();
+    }).catch((error) => {
+      if (disposed || isAbortError(error)) return;
+      opts.onError?.(error);
+    });
+  }
+  function currentView(view) {
+    return layers.find((layer) => layer.id === view.id && layer.key === view.key);
+  }
+  function sync() {
+    const desired = buildLayers(resolved, {
+      resolution: opts.resolution ?? DEFAULT_RESOLUTION,
+      rayScale: opts.rayScale ?? 1,
+      baker: opts.baker.id,
+      accept: opts.accepts ?? DEFAULT_ACCEPTS
+    });
+    const desiredKeys = new Set(desired.map((layer) => layer.key));
+    for (const key of [...acquired.keys()]) {
+      if (!desiredKeys.has(key)) {
+        releaseSource(key);
+        acquired.delete(key);
+      }
+    }
+    const previous = new Map(layers.map((layer) => [layer.id, layer]));
+    layers = desired.map((layer) => {
+      const prev = previous.get(layer.id);
+      return {
+        id: layer.id,
+        key: layer.key,
+        channel: layer.channel,
+        blend: layer.blend,
+        source: prev && prev.key === layer.key ? prev.source : null
+      };
+    });
+    emitLayers();
+    for (let i = 0; i < desired.length; i++) {
+      const layer = layers[i];
+      if (acquired.has(layer.key)) continue;
+      acquired.set(layer.key, 1);
+      bake(desired[i], layer);
+    }
+    flushReady();
+  }
+  const model = {
+    subscribe(listener) {
+      layerListeners.add(listener);
+      listener(layers.slice());
+      return () => layerListeners.delete(listener);
+    },
+    onFrame(listener) {
+      frameListeners.add(listener);
+      listener(frame());
+      return () => frameListeners.delete(listener);
+    },
+    update(patch) {
+      if (disposed) return;
+      opts = { ...opts, ...definedOnly(patch) };
+      resolved = resolve(opts);
+      sync();
+      emitFrame();
+    },
+    set(values) {
+      if (values.hover !== void 0) {
+        hover2 = clamp01(values.hover);
+        hoverTarget = hover2;
+      }
+      if (values.collapse !== void 0) {
+        collapse2 = clamp01(values.collapse);
+        collapseTarget = collapse2;
+      }
+      manual = {
+        ...manual,
+        ...values,
+        channels: values.channels ? { ...manual.channels, ...values.channels } : manual.channels
+      };
+      emitFrame();
+    },
+    setChannel(channel, values) {
+      model.set({ channels: { [channel]: values } });
+    },
+    setHover(hovered) {
+      if (disposed) return;
+      if (!hasEffect("hover")) return;
+      hoverTarget = hovered ? 1 : 0;
+      if ((opts.hoverEase ?? DEFAULT_HOVER_EASE) <= 0) {
+        hover2 = hoverTarget;
+        emitFrame();
+      }
+    },
+    setCollapsed(collapsed) {
+      if (disposed) return;
+      if (!hasEffect("collapse")) return;
+      collapseTarget = collapsed ? 1 : 0;
+      if ((opts.collapseEase ?? DEFAULT_COLLAPSE_EASE) <= 0) {
+        collapse2 = collapseTarget;
+        emitFrame();
+      }
+    },
+    toggleCollapsed() {
+      model.setCollapsed(collapseTarget < 0.5);
+    },
+    tick(dt) {
+      if (disposed) return;
+      const idle = activeEffects().length === 0;
+      if (idle && hover2 === hoverTarget && collapse2 === collapseTarget) return;
+      time += dt;
+      if (hover2 !== hoverTarget) {
+        const ease = opts.hoverEase ?? DEFAULT_HOVER_EASE;
+        if (ease <= 0) {
+          hover2 = hoverTarget;
+        } else {
+          hover2 += (hoverTarget - hover2) * (1 - Math.exp(-dt / ease));
+          if (Math.abs(hoverTarget - hover2) < 1e-3) hover2 = hoverTarget;
+        }
+      }
+      if (collapse2 !== collapseTarget) {
+        const ease = opts.collapseEase ?? DEFAULT_COLLAPSE_EASE;
+        if (ease <= 0) {
+          collapse2 = collapseTarget;
+        } else {
+          collapse2 += (collapseTarget - collapse2) * (1 - Math.exp(-dt / ease));
+          if (Math.abs(collapseTarget - collapse2) < 1e-3) collapse2 = collapseTarget;
+        }
+      }
+      hoverTime += hover2 * dt;
+      emitFrame();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      scheduler.clear();
+      for (const key of acquired.keys()) releaseSource(key);
+      acquired.clear();
+      layerListeners.clear();
+      frameListeners.clear();
+      flushReady();
+    },
+    get layers() {
+      return layers;
+    },
+    get resolved() {
+      return resolved;
+    },
+    get ready() {
+      if (pendingCount() === 0) return Promise.resolve();
+      return new Promise((resolveReady) => readyWaiters.push(resolveReady));
+    }
+  };
+  sync();
+  return model;
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+
+export { CURRENT_VERSION, NullContextError, abortError, acquireSource, blob, buildLayers, cacheSize, canvas2dBaker, canvasToBlob, clearCache, clusters, collapse, collapseTrigger, computeFrame, createCanvas, createLightModel, createScheduler, defineEffect, definePreset, defineShardKind, definedOnly, disposeSource, ember, fan, flicker, freeCanvas, get2dContext, getEffect, getPreset, getShardKind, halo, hashString, hover, isAbortError, isBrowser, isCssIdentifier, isLowMemoryDevice, layerId, listEffects, listPresets, listShardKinds, makeRgba, migrateConfig, mulberry32, parseColor, prewarm, pulse, registerBuiltInEffects, registerBuiltInKinds, registerBuiltInPresets, registerEffect, registerPreset, registerShardKind, releasePrewarm, releaseSource, resolveConfig, shardSeed, sparkle, spin, stableStringify, star, starburst, sun, unregisterEffect, unregisterPreset, unregisterShardKind };
+//# sourceMappingURL=chunk-ZWPHIC3K.js.map
+//# sourceMappingURL=chunk-ZWPHIC3K.js.map