kuinetic 0.1.0

package/dist/esm/chunk-QZIJ7WZI.mjs

@@ -0,0 +1,3312 @@
+import {
+  ABSOLUTE_BASIS,
+  CHANNEL,
+  Registry,
+  clamp01,
+  createAttributeLedger,
+  createMeasureCache,
+  createStyleLedger,
+  deferPrepare,
+  effectDurationMs,
+  inertInstance,
+  isSameOriginPath,
+  toPixels
+} from "./chunk-LWS4OSLX.mjs";
+
+// src/effects/shared.ts
+var COMMON = {
+  duration: { type: "time", default: "600ms", cssProperty: "--kui-duration" },
+  delay: { type: "time", default: "0ms", cssProperty: "--kui-delay" },
+  ease: { type: "easing", default: "ease-out", cssProperty: "--kui-ease" },
+  stagger: { type: "time", default: "0ms", cssProperty: "--kui-stagger" }
+};
+function cssPrimitive(id, channels, options = {}) {
+  return {
+    id,
+    renderer: "css-keyframes",
+    channels,
+    parameters: { ...COMMON, ...options.parameters },
+    supportedTimelines: options.timelines ?? ["time"],
+    supportedActivations: options.activations ?? [
+      "load",
+      "enter",
+      "hover",
+      "focus",
+      "click",
+      "manual"
+    ],
+    perfClass: options.perfClass ?? "compositor",
+    reducedMotion: options.reducedMotion ?? "shorten",
+    ...options.defaultActivation ? { defaultActivation: options.defaultActivation } : {}
+  };
+}
+
+// src/effects/catalog/ambient.ts
+var drift = {
+  duration: { type: "time", default: "10s", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "ease-in-out", cssProperty: "--kui-ease" }
+};
+var float = {
+  duration: { type: "time", default: "4s", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "ease-in-out", cssProperty: "--kui-ease" },
+  distance: { type: "length", default: "14px", cssProperty: "--kui-distance" }
+};
+var pulse = {
+  duration: { type: "time", default: "2.2s", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "ease-in-out", cssProperty: "--kui-ease" }
+};
+var AMBIENT_PRIMITIVES = [
+  cssPrimitive("ambient-gradient", [CHANNEL.background], {
+    parameters: drift,
+    defaultActivation: "load",
+    reducedMotion: "disable",
+    perfClass: "continuous"
+  }),
+  cssPrimitive("ambient-float", [CHANNEL.translate], {
+    parameters: float,
+    defaultActivation: "load",
+    reducedMotion: "disable",
+    perfClass: "continuous"
+  }),
+  cssPrimitive("ambient-pulse", [CHANNEL.scale, CHANNEL.opacity], {
+    parameters: pulse,
+    defaultActivation: "load",
+    reducedMotion: "disable",
+    perfClass: "continuous"
+  })
+];
+var AMBIENT_PRESETS = [
+  { name: "gradient-mesh", primitive: "ambient-gradient", keyframes: "kui-gradient-mesh" },
+  { name: "aurora", primitive: "ambient-gradient", keyframes: "kui-aurora" },
+  {
+    name: "gradient-rotate-border",
+    primitive: "ambient-gradient",
+    keyframes: "kui-gradient-rotate-border",
+    params: { duration: "6s", ease: "linear" }
+  },
+  {
+    name: "noise-overlay",
+    primitive: "ambient-gradient",
+    keyframes: "kui-noise-overlay",
+    params: { duration: "650ms", ease: "steps(6)" }
+  },
+  {
+    name: "scanline",
+    primitive: "ambient-gradient",
+    keyframes: "kui-scanline",
+    params: { duration: "3.5s", ease: "linear" }
+  },
+  {
+    name: "dot-grid-drift",
+    primitive: "ambient-gradient",
+    keyframes: "kui-dot-grid-drift",
+    params: { duration: "16s", ease: "linear" }
+  },
+  {
+    name: "line-grid-drift",
+    primitive: "ambient-gradient",
+    keyframes: "kui-line-grid-drift",
+    params: { duration: "16s", ease: "linear" }
+  },
+  {
+    name: "starfield",
+    primitive: "ambient-gradient",
+    keyframes: "kui-starfield",
+    params: { duration: "40s", ease: "linear" }
+  },
+  {
+    name: "spotlight-follow",
+    primitive: "ambient-gradient",
+    keyframes: "kui-spotlight-follow",
+    params: { duration: "9s" }
+  },
+  {
+    name: "wave-blob",
+    primitive: "ambient-gradient",
+    keyframes: "kui-wave-blob",
+    params: { duration: "12s" }
+  },
+  { name: "float", primitive: "ambient-float", keyframes: "kui-float" },
+  {
+    name: "bob",
+    primitive: "ambient-float",
+    keyframes: "kui-bob",
+    params: { duration: "2s", distance: "8px" }
+  },
+  {
+    name: "floating-shapes",
+    primitive: "ambient-float",
+    keyframes: "kui-floating-shapes",
+    params: { duration: "6s", distance: "10px" }
+  },
+  { name: "glow-pulse", primitive: "ambient-pulse", keyframes: "kui-glow-pulse" }
+];
+function registerAmbient(registry) {
+  return registry.registerPrimitives(AMBIENT_PRIMITIVES).registerPresets(AMBIENT_PRESETS);
+}
+
+// src/effects/catalog/feedback.ts
+var loop = {
+  duration: { type: "time", default: "1.6s", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "linear", cssProperty: "--kui-ease" }
+};
+var spin = {
+  duration: { type: "time", default: "900ms", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "linear", cssProperty: "--kui-ease" }
+};
+var dotPulse = {
+  duration: { type: "time", default: "1.2s", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "ease-in-out", cssProperty: "--kui-ease" }
+};
+var progressTrack = {
+  duration: { type: "time", default: "1.4s", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "ease-in-out", cssProperty: "--kui-ease" }
+};
+var toast = {
+  duration: { type: "time", default: "420ms", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "back-out", cssProperty: "--kui-ease" },
+  distance: { type: "length", default: "24px", cssProperty: "--kui-distance" }
+};
+var shake = {
+  duration: { type: "time", default: "500ms", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "linear", cssProperty: "--kui-ease" }
+};
+var pop = {
+  duration: { type: "time", default: "420ms", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "back-out", cssProperty: "--kui-ease" }
+};
+var ripple = {
+  duration: { type: "time", default: "600ms", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "ease-out", cssProperty: "--kui-ease" },
+  spread: { type: "number", default: "4", cssProperty: "--kui-ripple-scale", finite: true, minimum: 1 }
+};
+var confirm = {
+  duration: { type: "time", default: "1400ms", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "linear", cssProperty: "--kui-ease" }
+};
+var FEEDBACK_PRIMITIVES = [
+  cssPrimitive("feedback-shimmer", [CHANNEL.background], {
+    parameters: loop,
+    defaultActivation: "load",
+    reducedMotion: "disable",
+    perfClass: "continuous"
+  }),
+  cssPrimitive("feedback-fade", [CHANNEL.opacity], {
+    defaultActivation: "manual"
+  }),
+  cssPrimitive("feedback-spin", [CHANNEL.rotate], {
+    parameters: spin,
+    defaultActivation: "load",
+    reducedMotion: "disable",
+    perfClass: "continuous"
+  }),
+  // Declares every channel the preset's CSS actually paints, not just what the shared keyframe
+  // animates: spinner-dots' `[data-kui-fx~='spinner-dots']` rule also sets `background:
+  // currentColor` (the dot itself) and `box-shadow` (the other two dots), entirely outside
+  // `@keyframes kui-spinner-dots`. Declaring only [scale, opacity] let a composed
+  // `background`-writing effect (e.g. gradient-mesh) pass channel-collision detection and then
+  // have its gradient silently overwritten by this rule — see css-invariants.test.ts's "CSS
+  // static rules" describe block, which now catches this class of omission directly.
+  cssPrimitive("feedback-dot-pulse", [CHANNEL.scale, CHANNEL.opacity, CHANNEL.background, "shadow"], {
+    parameters: dotPulse,
+    defaultActivation: "load",
+    reducedMotion: "disable",
+    perfClass: "continuous"
+  }),
+  // Same shape as feedback-dot-pulse above: `[data-kui-fx~='progress-indeterminate']` sets
+  // `background: currentColor` unconditionally for the bar itself, outside the keyframe.
+  cssPrimitive("feedback-progress-track", [CHANNEL.translate, CHANNEL.scale, CHANNEL.background], {
+    parameters: progressTrack,
+    defaultActivation: "load",
+    reducedMotion: "disable",
+    perfClass: "continuous"
+  }),
+  cssPrimitive("feedback-toast", [CHANNEL.opacity, CHANNEL.translate], {
+    parameters: toast,
+    defaultActivation: "manual"
+  }),
+  cssPrimitive("feedback-shake", [CHANNEL.translate], {
+    parameters: shake,
+    defaultActivation: "manual"
+  }),
+  cssPrimitive("feedback-wobble", [CHANNEL.translate, CHANNEL.rotate], {
+    defaultActivation: "click"
+  }),
+  // `[data-kui-fx~='ripple']` sets `background: currentColor` unconditionally for the ripple
+  // disc itself, outside the keyframe — same gap as feedback-dot-pulse/feedback-progress-track.
+  cssPrimitive("feedback-ripple", [CHANNEL.scale, CHANNEL.opacity, CHANNEL.background], {
+    parameters: ripple,
+    defaultActivation: "click"
+  }),
+  cssPrimitive("feedback-pop", [CHANNEL.scale], {
+    parameters: pop,
+    defaultActivation: "manual"
+  }),
+  // Declares every channel any preset built on it actually paints, not just what the shared
+  // keyframes animate: heart-burst's CSS also sets `color`, confetti-burst's also sets
+  // `background-image`. Understating this let a composed `background`-writing effect (e.g.
+  // gradient-mesh) pass channel-collision detection and silently overwrite confetti-burst's dots.
+  cssPrimitive("feedback-burst", [CHANNEL.scale, CHANNEL.opacity, CHANNEL.background, CHANNEL.color], {
+    parameters: pop,
+    defaultActivation: "click"
+  }),
+  cssPrimitive("feedback-confirm", [CHANNEL.opacity], {
+    parameters: confirm,
+    defaultActivation: "click"
+  }),
+  cssPrimitive("feedback-pull", [CHANNEL.translate], {
+    defaultActivation: "manual"
+  })
+];
+var FEEDBACK_PRESETS = [
+  { name: "skeleton-shimmer", primitive: "feedback-shimmer", keyframes: "kui-skeleton-shimmer" },
+  { name: "skeleton-to-content", primitive: "feedback-fade", keyframes: "kui-skeleton-to-content" },
+  { name: "spinner", primitive: "feedback-spin", keyframes: "kui-spinner-spin" },
+  { name: "spinner-dots", primitive: "feedback-dot-pulse", keyframes: "kui-spinner-dots" },
+  { name: "spinner-ring", primitive: "feedback-spin", keyframes: "kui-spinner-ring-spin" },
+  {
+    name: "progress-indeterminate",
+    primitive: "feedback-progress-track",
+    keyframes: "kui-progress-indeterminate"
+  },
+  { name: "toast-slide-in", primitive: "feedback-toast", keyframes: "kui-toast-slide-in" },
+  {
+    name: "toast-slide-out",
+    primitive: "feedback-toast",
+    keyframes: "kui-toast-slide-out",
+    params: { ease: "ease-in" }
+  },
+  { name: "shake-error", primitive: "feedback-shake", keyframes: "kui-shake-error" },
+  {
+    name: "wobble",
+    primitive: "feedback-wobble",
+    keyframes: "kui-wobble",
+    params: { duration: "600ms", ease: "ease-in-out" }
+  },
+  { name: "ripple", primitive: "feedback-ripple", keyframes: "kui-ripple" },
+  { name: "badge-pop", primitive: "feedback-pop", keyframes: "kui-badge-pop" },
+  { name: "count-bump", primitive: "feedback-pop", keyframes: "kui-count-bump", params: { duration: "280ms" } },
+  {
+    name: "heart-burst",
+    primitive: "feedback-burst",
+    keyframes: "kui-heart-burst",
+    params: { duration: "700ms" }
+  },
+  {
+    name: "confetti-burst",
+    primitive: "feedback-burst",
+    keyframes: "kui-confetti-burst",
+    params: { duration: "900ms" }
+  },
+  { name: "copy-confirm", primitive: "feedback-confirm", keyframes: "kui-copy-confirm" },
+  {
+    name: "pull-to-refresh",
+    primitive: "feedback-pull",
+    keyframes: "kui-pull-to-refresh",
+    params: { duration: "900ms", ease: "ease-out" }
+  }
+];
+function registerFeedback(registry) {
+  return registry.registerPrimitives(FEEDBACK_PRIMITIVES).registerPresets(FEEDBACK_PRESETS);
+}
+
+// src/core/spring.ts
+var DEFAULT_SPRING = {
+  stiffness: 180,
+  damping: 24,
+  mass: 1,
+  restVelocity: 0.05,
+  restDisplacement: 0.05
+};
+var SUBSTEP = 1 / 240;
+var MAX_STEP = 0.25;
+function stepSpring(state, target, config, dt) {
+  let { value, velocity } = state;
+  let remaining = Math.min(Math.max(dt, 0), MAX_STEP);
+  while (remaining > 0) {
+    const step = Math.min(SUBSTEP, remaining);
+    const force = -config.stiffness * (value - target) - config.damping * velocity;
+    velocity += force / config.mass * step;
+    value += velocity * step;
+    remaining -= step;
+  }
+  return { value, velocity };
+}
+function isSettled(state, target, config) {
+  return Math.abs(state.velocity) < config.restVelocity && Math.abs(state.value - target) < config.restDisplacement;
+}
+var MAX_SETTLE_MS = 1e4;
+function createSpringRunner(config, onChange, deps) {
+  const safeConfig = validConfig(config) ? config : DEFAULT_SPRING;
+  if (safeConfig !== config) deps.warn?.("invalid spring configuration; using defaults");
+  let state = { value: 0, velocity: 0 };
+  let target = 0;
+  let handle = null;
+  let lastTime = 0;
+  let startedAt = 0;
+  function frame(time) {
+    handle = null;
+    const dt = (time - lastTime) / 1e3;
+    lastTime = time;
+    state = stepSpring(state, target, safeConfig, dt);
+    if (!finiteState(state) || !Number.isFinite(target)) {
+      abortRun("spring produced non-finite state");
+      return;
+    }
+    if (time - startedAt >= MAX_SETTLE_MS) {
+      abortRun(`spring exceeded ${MAX_SETTLE_MS}ms settle budget`);
+      return;
+    }
+    if (isSettled(state, target, safeConfig)) {
+      state = { value: target, velocity: 0 };
+      onChange(state.value, true);
+      return;
+    }
+    onChange(state.value, false);
+    schedule();
+  }
+  function schedule() {
+    if (handle !== null) return;
+    handle = deps.requestFrame(frame);
+  }
+  function start() {
+    lastTime = deps.now();
+    startedAt = lastTime;
+    schedule();
+  }
+  function abortRun(message) {
+    state = { value: Number.isFinite(target) ? target : 0, velocity: 0 };
+    deps.warn?.(message);
+    onChange(state.value, true);
+  }
+  return {
+    to(next, velocity) {
+      target = next;
+      if (velocity !== void 0) state = { ...state, velocity };
+      start();
+    },
+    set(value, velocity = 0) {
+      state = { value, velocity };
+    },
+    current: () => ({ ...state }),
+    stop() {
+      if (handle !== null) deps.cancelFrame(handle);
+      handle = null;
+    }
+  };
+}
+function validConfig(config) {
+  return Object.values(config).every(Number.isFinite) && config.stiffness > 0 && config.damping > 0 && config.mass > 0 && config.restVelocity > 0 && config.restDisplacement > 0;
+}
+function finiteState(state) {
+  return Number.isFinite(state.value) && Number.isFinite(state.velocity);
+}
+function defaultSpringDeps() {
+  const raf = globalThis.requestAnimationFrame;
+  if (typeof raf !== "function") {
+    return {
+      requestFrame: (callback) => globalThis.setTimeout(() => callback(Date.now()), 16),
+      cancelFrame: (handle) => globalThis.clearTimeout(handle),
+      now: () => Date.now()
+    };
+  }
+  return {
+    requestFrame: (callback) => raf(callback),
+    cancelFrame: (handle) => globalThis.cancelAnimationFrame(handle),
+    now: () => performance.now()
+  };
+}
+
+// src/effects/catalog/interaction-shared.ts
+function centeredOffset(point, size) {
+  return {
+    x: size.width > 0 ? point.x / size.width - 0.5 : 0,
+    y: size.height > 0 ? point.y / size.height - 0.5 : 0
+  };
+}
+function tiltAngles(point, size, maxAngleDeg) {
+  const centered = centeredOffset(point, size);
+  return { rotateY: centered.x * maxAngleDeg * 2, rotateX: -centered.y * maxAngleDeg * 2 };
+}
+function parallaxOffset(point, size, strengthPx) {
+  const centered = centeredOffset(point, size);
+  return { x: centered.x * strengthPx * 2, y: centered.y * strengthPx * 2 };
+}
+function supportsFineHover(win) {
+  return win.matchMedia?.("(hover: hover) and (pointer: fine)").matches ?? true;
+}
+
+// src/effects/catalog/interaction.ts
+var hoverTiming = {
+  duration: { type: "time", default: "220ms", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "ease-out", cssProperty: "--kui-ease" }
+};
+function hoverPrimitive(id, channels) {
+  return {
+    id,
+    renderer: "javascript",
+    channels,
+    parameters: hoverTiming,
+    supportedTimelines: ["time"],
+    supportedActivations: ["load"],
+    defaultActivation: "load",
+    perfClass: "compositor",
+    // Not 'disable': a translate/box-shadow/rotate hover micro-interaction at this scale is not a
+    // vestibular trigger the way parallax or continuous ambient motion is. The real motion lives in
+    // CSS transitions and `:hover`-scoped pseudo-element animations rather than this primitive's
+    // (here unused) compiled `animation-*` path, so the policy layer shortens it via the
+    // `transition-duration` and `::before`/`::after` rules in base.css.
+    reducedMotion: "shorten",
+    prepare: () => inertInstance()
+  };
+}
+var HOVER_PRIMITIVES = [
+  hoverPrimitive("lift", ["translate"]),
+  hoverPrimitive("lift-shadow", ["translate", "shadow"]),
+  hoverPrimitive("shine-sweep", ["sweep"]),
+  hoverPrimitive("split-flap", ["rotate"]),
+  hoverPrimitive("border-draw", ["border"]),
+  hoverPrimitive("border-glow", ["shadow"]),
+  hoverPrimitive("beam-border", ["border"]),
+  hoverPrimitive("underline-slide", ["scale"]),
+  hoverPrimitive("underline-center", ["scale"]),
+  hoverPrimitive("icon-wiggle", ["rotate"]),
+  hoverPrimitive("icon-spin", ["rotate"]),
+  hoverPrimitive("icon-bounce", ["translate"])
+];
+var HOVER_PRESETS = HOVER_PRIMITIVES.map((primitive) => ({
+  name: primitive.id,
+  primitive: primitive.id
+}));
+var CONTINUOUS_BORDER_PRIMITIVES = [
+  {
+    id: "beam-border-auto",
+    renderer: "javascript",
+    channels: ["border"],
+    parameters: hoverTiming,
+    supportedTimelines: ["time"],
+    supportedActivations: ["load"],
+    defaultActivation: "load",
+    perfClass: "compositor",
+    reducedMotion: "disable",
+    prepare: () => inertInstance()
+  }
+];
+var CONTINUOUS_BORDER_PRESETS = [
+  { name: "beam-border-auto", primitive: "beam-border-auto" }
+];
+var springParams = {
+  stiffness: {
+    type: "number",
+    default: "260",
+    cssProperty: "--kui-stiffness",
+    finite: true,
+    minimum: 1,
+    maximum: 1e4
+  },
+  damping: {
+    type: "number",
+    default: "26",
+    cssProperty: "--kui-damping",
+    finite: true,
+    minimum: 0.1,
+    maximum: 1e3
+  }
+};
+function pointerPrimitive(id, channels, parameters, prepare) {
+  return {
+    id,
+    renderer: "javascript",
+    channels,
+    parameters,
+    supportedTimelines: ["time", "pointer"],
+    supportedActivations: ["load", "manual"],
+    defaultActivation: "load",
+    perfClass: "continuous",
+    // A tilt or cursor-follow effect only exists while the pointer is present; there is no
+    // meaningful "shortened" version of tracking a position. `prepare` itself checks
+    // `supportsFineHover` and no-ops on touch, which is the coarse-pointer half of this rule.
+    reducedMotion: "disable",
+    prepare
+  };
+}
+function springFrom(params) {
+  return {
+    ...DEFAULT_SPRING,
+    stiffness: params.num("stiffness", DEFAULT_SPRING.stiffness),
+    damping: params.num("damping", DEFAULT_SPRING.damping)
+  };
+}
+function springDepsFor(ctx) {
+  return { ...defaultSpringDeps(), warn: ctx.warn };
+}
+function prepareTilt3d(el, params, ctx) {
+  if (!supportsFineHover(ctx.win)) return () => {
+  };
+  const node = el;
+  const maxAngle = params.num("maxAngle", 14);
+  const perspective = params.text("perspective", "800px");
+  function writeAngles(rotateX, rotateY, transitionMs) {
+    ctx.style.set("transition", `transform ${transitionMs}ms ease-out`);
+    ctx.style.set(
+      "transform",
+      `perspective(${perspective}) rotateX(${rotateX.toFixed(2)}deg) rotateY(${rotateY.toFixed(2)}deg)`
+    );
+  }
+  function onMove(event) {
+    const rect = node.getBoundingClientRect();
+    const point = { x: event.clientX - rect.left, y: event.clientY - rect.top };
+    const { rotateX, rotateY } = tiltAngles(point, rect, maxAngle);
+    writeAngles(rotateX, rotateY, 100);
+  }
+  function reset() {
+    writeAngles(0, 0, 400);
+  }
+  function onFocus() {
+    writeAngles(-maxAngle / 2, maxAngle / 2, 250);
+  }
+  node.addEventListener("pointermove", onMove, { passive: true });
+  node.addEventListener("pointerleave", reset, { passive: true });
+  node.addEventListener("focus", onFocus);
+  node.addEventListener("blur", reset);
+  return () => {
+    node.removeEventListener("pointermove", onMove);
+    node.removeEventListener("pointerleave", reset);
+    node.removeEventListener("focus", onFocus);
+    node.removeEventListener("blur", reset);
+  };
+}
+function collectParallaxLayers(node) {
+  return [...node.querySelectorAll("[data-depth]")].map((layer) => ({
+    ledger: createStyleLedger(layer),
+    depth: Number(layer.dataset.depth) || 0
+  }));
+}
+function writeParallaxLayers(layers, x, y, transitionMs) {
+  for (const layer of layers) {
+    layer.ledger.set("transition", `translate ${transitionMs}ms ease-out`);
+    layer.ledger.set("translate", `${(x * layer.depth).toFixed(2)}px ${(y * layer.depth).toFixed(2)}px`);
+  }
+}
+function prepareTiltParallax(el, params, ctx) {
+  if (!supportsFineHover(ctx.win)) return () => {
+  };
+  const node = el;
+  const strength = params.num("strength", 24);
+  const layers = collectParallaxLayers(node);
+  function onMove(event) {
+    const rect = node.getBoundingClientRect();
+    const point = { x: event.clientX - rect.left, y: event.clientY - rect.top };
+    const offset = parallaxOffset(point, rect, strength);
+    writeParallaxLayers(layers, offset.x, offset.y, 120);
+  }
+  function reset() {
+    writeParallaxLayers(layers, 0, 0, 400);
+  }
+  node.addEventListener("pointermove", onMove, { passive: true });
+  node.addEventListener("pointerleave", reset, { passive: true });
+  node.addEventListener("focus", reset);
+  node.addEventListener("blur", reset);
+  return () => {
+    node.removeEventListener("pointermove", onMove);
+    node.removeEventListener("pointerleave", reset);
+    node.removeEventListener("focus", reset);
+    node.removeEventListener("blur", reset);
+    for (const layer of layers) layer.ledger.restore();
+  };
+}
+function writeDotPosition(dot, x, y) {
+  dot.style.translate = `${x.toFixed(1)}px ${y.toFixed(1)}px`;
+}
+function createCursorDot(doc, dotClass, labelText) {
+  const dot = doc.createElement("span");
+  dot.className = `kui-cursor-dot ${dotClass}`;
+  dot.setAttribute("aria-hidden", "true");
+  if (labelText) dot.textContent = labelText;
+  doc.body.append(dot);
+  return dot;
+}
+function createCursorRunners(dot, config, deps) {
+  const position = { x: 0, y: 0 };
+  const onAxis = (axis) => (value) => {
+    position[axis] = value;
+    writeDotPosition(dot, position.x, position.y);
+  };
+  return {
+    x: createSpringRunner(config, onAxis("x"), deps),
+    y: createSpringRunner(config, onAxis("y"), deps)
+  };
+}
+function prepareCursorDot(el, params, ctx, dotClass) {
+  if (!supportsFineHover(ctx.win)) return () => {
+  };
+  const doc = el.ownerDocument;
+  const node = el;
+  const dot = createCursorDot(doc, dotClass, params.text("label", ""));
+  const runners = createCursorRunners(dot, springFrom(params), springDepsFor(ctx));
+  function show() {
+    dot.classList.add("kui-cursor-dot-active");
+  }
+  function hide() {
+    dot.classList.remove("kui-cursor-dot-active");
+  }
+  function onMove(event) {
+    show();
+    runners.x.to(event.clientX);
+    runners.y.to(event.clientY);
+  }
+  function onFocus() {
+    const rect = node.getBoundingClientRect();
+    const cx = rect.left + rect.width / 2;
+    const cy = rect.top + rect.height / 2;
+    show();
+    runners.x.set(cx);
+    runners.y.set(cy);
+    writeDotPosition(dot, cx, cy);
+  }
+  node.addEventListener("pointermove", onMove, { passive: true });
+  node.addEventListener("pointerleave", hide, { passive: true });
+  node.addEventListener("focus", onFocus);
+  node.addEventListener("blur", hide);
+  return () => {
+    node.removeEventListener("pointermove", onMove);
+    node.removeEventListener("pointerleave", hide);
+    node.removeEventListener("focus", onFocus);
+    node.removeEventListener("blur", hide);
+    runners.x.stop();
+    runners.y.stop();
+    dot.remove();
+  };
+}
+function prepareSpotlight(el, params, ctx) {
+  if (!supportsFineHover(ctx.win)) return () => {
+  };
+  const node = el;
+  if (ctx.win.getComputedStyle(node).position === "static") ctx.style.set("position", "relative");
+  function writeSpot(x, y, on) {
+    ctx.style.set("--kui-x", x);
+    ctx.style.set("--kui-y", y);
+    ctx.style.set("--kui-spotlight-opacity", on ? "1" : "0");
+  }
+  function onMove(event) {
+    const rect = node.getBoundingClientRect();
+    writeSpot(`${(event.clientX - rect.left).toFixed(1)}px`, `${(event.clientY - rect.top).toFixed(1)}px`, true);
+  }
+  function hide() {
+    writeSpot("50%", "50%", false);
+  }
+  function onFocus() {
+    writeSpot("50%", "50%", true);
+  }
+  node.addEventListener("pointermove", onMove, { passive: true });
+  node.addEventListener("pointerleave", hide, { passive: true });
+  node.addEventListener("focus", onFocus);
+  node.addEventListener("blur", hide);
+  return () => {
+    node.removeEventListener("pointermove", onMove);
+    node.removeEventListener("pointerleave", hide);
+    node.removeEventListener("focus", onFocus);
+    node.removeEventListener("blur", hide);
+  };
+}
+var tiltParams = {
+  maxAngle: { type: "number", default: "14", cssProperty: "--kui-max-angle" },
+  perspective: { type: "length", default: "800px", cssProperty: "--kui-perspective" }
+};
+var parallaxParams = {
+  strength: { type: "number", default: "24", cssProperty: "--kui-strength" }
+};
+var cursorDotParams = {
+  ...springParams,
+  label: { type: "text", default: "", cssProperty: "--kui-label" }
+};
+var POINTER_PRIMITIVES = [
+  pointerPrimitive("tilt-3d", ["rotate"], tiltParams, deferPrepare(prepareTilt3d)),
+  pointerPrimitive("tilt-parallax", ["translate"], parallaxParams, deferPrepare(prepareTiltParallax)),
+  pointerPrimitive("cursor-follow", ["translate"], cursorDotParams, deferPrepare(prepareCursorFollow)),
+  pointerPrimitive("cursor-lag", ["translate"], cursorDotParams, deferPrepare(prepareCursorLag)),
+  pointerPrimitive("cursor-label", ["translate"], cursorDotParams, deferPrepare(prepareCursorLabel)),
+  pointerPrimitive("cursor-invert", ["translate"], cursorDotParams, deferPrepare(prepareCursorInvert)),
+  pointerPrimitive("cursor-spotlight", ["spotlight"], {}, deferPrepare(prepareSpotlight))
+];
+function prepareCursorFollow(el, params, ctx) {
+  return prepareCursorDot(el, params, ctx, "kui-cursor-dot-follow");
+}
+function prepareCursorLag(el, params, ctx) {
+  return prepareCursorDot(el, params, ctx, "kui-cursor-dot-lag");
+}
+function prepareCursorLabel(el, params, ctx) {
+  return prepareCursorDot(el, params, ctx, "kui-cursor-dot-label");
+}
+function prepareCursorInvert(el, params, ctx) {
+  return prepareCursorDot(el, params, ctx, "kui-cursor-dot-invert");
+}
+var POINTER_PRESETS = [
+  { name: "tilt-3d", primitive: "tilt-3d" },
+  { name: "tilt-parallax", primitive: "tilt-parallax" },
+  { name: "cursor-follow", primitive: "cursor-follow", params: { stiffness: "300", damping: "30" } },
+  { name: "cursor-lag", primitive: "cursor-lag", params: { stiffness: "80", damping: "14" } },
+  { name: "cursor-label", primitive: "cursor-label", params: { stiffness: "260", damping: "26", label: "View" } },
+  { name: "cursor-spotlight", primitive: "cursor-spotlight" },
+  { name: "cursor-invert", primitive: "cursor-invert", params: { stiffness: "260", damping: "26" } }
+];
+var INTERACTION_PRIMITIVES = [
+  ...HOVER_PRIMITIVES,
+  ...POINTER_PRIMITIVES,
+  ...CONTINUOUS_BORDER_PRIMITIVES
+];
+var INTERACTION_PRESETS = [
+  ...HOVER_PRESETS,
+  ...POINTER_PRESETS,
+  ...CONTINUOUS_BORDER_PRESETS
+];
+function registerInteraction(registry) {
+  return registry.registerPrimitives(INTERACTION_PRIMITIVES).registerPresets(INTERACTION_PRESETS);
+}
+
+// src/effects/catalog/media.ts
+var geometry = {
+  distance: { type: "length", default: "24px", cssProperty: "--kui-distance" },
+  scale: { type: "number", default: "1.12", cssProperty: "--kui-to-scale" }
+};
+var MEDIA_PRIMITIVES = [
+  cssPrimitive("media-wipe", [CHANNEL.clip]),
+  cssPrimitive("media-mask", ["mask"], { perfClass: "paint" }),
+  // Not `reducedMotion: 'disable'` — that policy means "no finite duration would make sense,
+  // because the animation never ends" (see `ambient.ts`/`feedback.ts`), and a Ken Burns pan/zoom
+  // is the opposite of that: a one-shot cinematic move with a real, shortenable duration. The demo
+  // authors it as `ken-burns 9000ms` (a still image, one slow zoom, then it holds) and
+  // `ken-burns 3000ms on:hover` (zooms in while hovered), and its complement `ken-burns-out` is a
+  // second one-shot preset for the reverse move — not a `-loop` variant the way `typewriter-loop`
+  // or `marquee`/`marquee-scroll-linked` are. `kui-ken-burns`'s keyframe (`scale: 1` to `1.12`,
+  // no loop-safe midpoint) is shaped for exactly that: run once, land on the zoomed frame, stay
+  // there. `'disable'` here previously looked like the same missing-`--kui-fx-*-iterations` bug as
+  // `marquee`/`gradient-shimmer`, but the actual defect was this policy — the default `'shorten'`
+  // is correct, so no `--kui-fx-ken-burns-iterations` is needed at all.
+  cssPrimitive("media-ken-burns", [CHANNEL.translate, CHANNEL.scale], {
+    parameters: geometry
+  }),
+  cssPrimitive("media-filter", [CHANNEL.filter], {
+    defaultActivation: "hover",
+    perfClass: "paint"
+  }),
+  cssPrimitive("media-blur-up", [CHANNEL.translate, CHANNEL.filter], {
+    parameters: geometry,
+    perfClass: "paint"
+  }),
+  cssPrimitive("media-parallax-frame", [CHANNEL.translate], {
+    parameters: geometry,
+    timelines: ["view", "scroll"],
+    activations: ["manual"],
+    defaultActivation: "manual",
+    reducedMotion: "disable"
+  }),
+  cssPrimitive("media-lightbox", [CHANNEL.opacity, CHANNEL.scale], {
+    parameters: geometry
+  })
+];
+var MEDIA_PRESETS = [
+  { name: "wipe-up", primitive: "media-wipe", keyframes: "kui-wipe-up" },
+  { name: "wipe-down", primitive: "media-wipe", keyframes: "kui-wipe-down" },
+  { name: "wipe-left", primitive: "media-wipe", keyframes: "kui-wipe-left" },
+  { name: "wipe-right", primitive: "media-wipe", keyframes: "kui-wipe-right" },
+  { name: "wipe-circle", primitive: "media-wipe", keyframes: "kui-wipe-circle" },
+  { name: "wipe-diagonal", primitive: "media-wipe", keyframes: "kui-wipe-diagonal" },
+  { name: "mask-reveal", primitive: "media-mask", keyframes: "kui-mask-reveal" },
+  { name: "curtain-reveal", primitive: "media-wipe", keyframes: "kui-curtain-reveal" },
+  { name: "ken-burns", primitive: "media-ken-burns", keyframes: "kui-ken-burns" },
+  { name: "ken-burns-out", primitive: "media-ken-burns", keyframes: "kui-ken-burns-out" },
+  { name: "blur-up", primitive: "media-blur-up", keyframes: "kui-blur-up" },
+  { name: "duotone-hover", primitive: "media-filter", keyframes: "kui-duotone-hover" },
+  { name: "grayscale-hover", primitive: "media-filter", keyframes: "kui-grayscale-hover" },
+  { name: "saturate-hover", primitive: "media-filter", keyframes: "kui-saturate-hover" },
+  {
+    name: "image-parallax-frame",
+    primitive: "media-parallax-frame",
+    keyframes: "kui-image-parallax-frame"
+  },
+  { name: "before-after-wipe", primitive: "media-wipe", keyframes: "kui-before-after-wipe" },
+  { name: "lightbox-open", primitive: "media-lightbox", keyframes: "kui-lightbox-open" }
+];
+function registerMedia(registry) {
+  return registry.registerPrimitives(MEDIA_PRIMITIVES).registerPresets(MEDIA_PRESETS);
+}
+
+// src/effects/catalog/numbers-shared.ts
+var SR_ONLY_CLASS = "kui-sr-only";
+var DECORATIVE_CLASS = "kui-count-decorative";
+function installCountLayers(el, doc) {
+  const decorative = doc.createElement("span");
+  decorative.setAttribute("aria-hidden", "true");
+  decorative.className = DECORATIVE_CLASS;
+  const srOnly = doc.createElement("span");
+  srOnly.className = SR_ONLY_CLASS;
+  srOnly.setAttribute("aria-live", "polite");
+  el.textContent = "";
+  el.append(decorative, srOnly);
+  return {
+    decorative,
+    srOnly,
+    restore: () => {
+      el.textContent = srOnly.textContent;
+    }
+  };
+}
+function easeOutCubic(t) {
+  const clamped = Math.min(Math.max(t, 0), 1);
+  return 1 - (1 - clamped) ** 3;
+}
+function tweenValue(t, from, to) {
+  return from + (to - from) * t;
+}
+function cubicBezier(x1, y1, x2, y2) {
+  const cx = 3 * x1;
+  const bx = 3 * (x2 - x1) - cx;
+  const ax = 1 - cx - bx;
+  const cy = 3 * y1;
+  const by = 3 * (y2 - y1) - cy;
+  const ay = 1 - cy - by;
+  const sampleX = (t) => ((ax * t + bx) * t + cx) * t;
+  const sampleY = (t) => ((ay * t + by) * t + cy) * t;
+  const slopeX = (t) => (3 * ax * t + 2 * bx) * t + cx;
+  function solveT(x) {
+    let t = x;
+    for (let i = 0; i < 8; i++) {
+      const slope = slopeX(t);
+      if (Math.abs(slope) < 1e-6) break;
+      const next = t - (sampleX(t) - x) / slope;
+      if (Math.abs(sampleX(next) - x) < 1e-6) return next;
+      t = next;
+    }
+    let lo = 0;
+    let hi = 1;
+    t = x;
+    while (hi - lo > 1e-6) {
+      if (sampleX(t) < x) lo = t;
+      else hi = t;
+      t = (lo + hi) / 2;
+    }
+    return t;
+  }
+  return (t) => sampleY(solveT(Math.min(Math.max(t, 0), 1)));
+}
+var EASING_KEYWORDS = {
+  ease: [0.25, 0.1, 0.25, 1],
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1],
+  "expo-in": [0.7, 0, 0.84, 0],
+  "expo-out": [0.16, 1, 0.3, 1],
+  "expo-in-out": [0.87, 0, 0.13, 1],
+  "back-in": [0.36, 0, 0.66, -0.56],
+  "back-out": [0.34, 1.56, 0.64, 1],
+  "back-in-out": [0.68, -0.6, 0.32, 1.6],
+  "quart-out": [0.25, 1, 0.5, 1],
+  "circ-out": [0, 0.55, 0.45, 1]
+};
+var CUBIC_BEZIER_FN = /^cubic-bezier\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)$/i;
+function resolveEasing(easing, warn) {
+  if (easing === void 0) return easeOutCubic;
+  if (easing === "linear") return (t) => Math.min(Math.max(t, 0), 1);
+  const keyword = EASING_KEYWORDS[easing];
+  if (keyword) return cubicBezier(...keyword);
+  const fn = CUBIC_BEZIER_FN.exec(easing);
+  if (fn) return cubicBezier(Number(fn[1]), Number(fn[2]), Number(fn[3]), Number(fn[4]));
+  warn(`easing "${easing}" has no JS equivalent for a counter tween \u2014 using the default ease-out`);
+  return easeOutCubic;
+}
+var COMPACT_OPTIONS = { notation: "compact", maximumFractionDigits: 1 };
+function formatCount(value, options) {
+  const { format, decimals, currency } = options;
+  if (format === "currency") {
+    return new Intl.NumberFormat(void 0, {
+      style: "currency",
+      currency,
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    }).format(value);
+  }
+  if (format === "percent") {
+    return new Intl.NumberFormat(void 0, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    }).format(value);
+  }
+  if (format === "compact") {
+    return new Intl.NumberFormat(void 0, COMPACT_OPTIONS).format(value);
+  }
+  return new Intl.NumberFormat(void 0, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(value);
+}
+function paddedDigits(value, width) {
+  return Math.round(Math.max(0, value)).toString().padStart(width, "0");
+}
+function groupDigits(digits) {
+  const groups = [];
+  for (let end = digits.length; end > 0; end -= 3) {
+    groups.unshift(digits.slice(Math.max(0, end - 3), end));
+  }
+  return groups.join(",");
+}
+function odometerTokens(grouped) {
+  return [...grouped].map((char) => ({ char, digit: char >= "0" && char <= "9" }));
+}
+
+// src/effects/catalog/numbers.ts
+var COUNT_STEP_MS = 16;
+var REDUCED_MOTION_DURATION_MS = 1;
+var countParams = {
+  duration: { type: "time", default: "1600ms", cssProperty: "--kui-duration" },
+  from: { type: "number", default: "0", cssProperty: "--kui-from" },
+  to: { type: "number", default: "100", cssProperty: "--kui-to" },
+  decimals: {
+    type: "number",
+    default: "0",
+    cssProperty: "--kui-decimals",
+    integer: true,
+    minimum: 0,
+    maximum: 6
+  },
+  format: {
+    type: "keyword",
+    default: "number",
+    cssProperty: "--kui-format",
+    values: ["number", "currency", "percent", "compact"]
+  },
+  currency: { type: "text", default: "USD", cssProperty: "--kui-currency" }
+};
+var odometerParams = {
+  duration: { type: "time", default: "1600ms", cssProperty: "--kui-duration" },
+  from: { type: "number", default: "0", cssProperty: "--kui-from" },
+  to: { type: "number", default: "100", cssProperty: "--kui-to" }
+};
+function countPrimitive(id, parameters, prepare) {
+  return {
+    id,
+    renderer: "javascript",
+    channels: ["content"],
+    parameters,
+    supportedTimelines: ["time"],
+    supportedActivations: ["load", "enter", "hover", "focus", "click", "manual"],
+    defaultActivation: "enter",
+    perfClass: "dom-transform",
+    // Not 'disable': the animator would then skip activation entirely under reduced motion,
+    // leaving the counter permanently blank. `prepareTween` reads `ctx.reducedMotion` itself and
+    // collapses the ramp to one effectively-instant tick instead, so the final value still lands.
+    reducedMotion: "shorten",
+    prepare
+  };
+}
+function tweenDurationMs(params, ctx) {
+  return ctx.reducedMotion ? REDUCED_MOTION_DURATION_MS : Math.max(0, effectDurationMs(params, 1600));
+}
+function tweenTimingFor(params, ctx) {
+  return {
+    durationMs: tweenDurationMs(params, ctx),
+    delayMs: Math.max(0, params.timing.delayMs ?? 0),
+    easing: resolveEasing(params.timing.easing, ctx.warn)
+  };
+}
+function tweenNumber(ctx, tween) {
+  const { from, to, durationMs, delayMs, easing, onTick } = tween;
+  let elapsed = 0;
+  let handle;
+  let settle2;
+  const finished = new Promise((resolve) => {
+    settle2 = resolve;
+  });
+  const stop = () => {
+    ctx.win.clearTimeout(start);
+    if (handle !== void 0) ctx.win.clearInterval(handle);
+  };
+  const tick = () => {
+    elapsed += COUNT_STEP_MS;
+    const ratio = durationMs <= 0 ? 1 : Math.min(elapsed / durationMs, 1);
+    const done = ratio >= 1;
+    onTick(tweenValue(easing(ratio), from, to), done);
+    if (done) {
+      stop();
+      settle2();
+    }
+  };
+  const start = ctx.win.setTimeout(() => {
+    handle = ctx.win.setInterval(tick, COUNT_STEP_MS);
+  }, delayMs);
+  return {
+    cleanup: stop,
+    finished,
+    finish: () => {
+      stop();
+      onTick(to, true);
+      settle2();
+    }
+  };
+}
+function prepareCount(el, params, ctx) {
+  const doc = el.ownerDocument;
+  const from = params.num("from", 0);
+  const to = params.num("to", 100);
+  const decimals = Math.max(0, Math.round(params.num("decimals", 0)));
+  const format = params.text("format", "number");
+  const currency = params.text("currency", "USD");
+  const options = { format, decimals, currency };
+  const layers = installCountLayers(el, doc);
+  layers.decorative.textContent = formatCount(from, options);
+  layers.srOnly.textContent = formatCount(from, options);
+  const tween = tweenNumber(ctx, {
+    from,
+    to,
+    ...tweenTimingFor(params, ctx),
+    onTick: (value, done) => {
+      layers.decorative.textContent = formatCount(value, options);
+      if (done) layers.srOnly.textContent = formatCount(to, options);
+    }
+  });
+  return {
+    cleanup: () => {
+      tween.cleanup();
+      layers.restore();
+    },
+    finished: tween.finished,
+    finish: tween.finish
+  };
+}
+function buildOdometerColumns(container, doc, grouped) {
+  const strips = [];
+  for (const token of odometerTokens(grouped)) {
+    if (!token.digit) {
+      container.append(doc.createTextNode(token.char));
+      continue;
+    }
+    const column = doc.createElement("span");
+    column.className = "kui-odometer-col";
+    const strip = doc.createElement("span");
+    strip.className = "kui-odometer-strip";
+    for (let digit = 0; digit <= 9; digit++) {
+      const row = doc.createElement("span");
+      row.textContent = String(digit);
+      strip.append(row);
+    }
+    strip.style.setProperty("--kui-o", token.char);
+    column.append(strip);
+    container.append(column);
+    strips.push(strip);
+  }
+  return strips;
+}
+function updateOdometerColumns(strips, grouped) {
+  let index = 0;
+  for (const token of odometerTokens(grouped)) {
+    if (!token.digit) continue;
+    strips[index]?.style.setProperty("--kui-o", token.char);
+    index++;
+  }
+}
+function prepareOdometer(el, params, ctx) {
+  const doc = el.ownerDocument;
+  const from = Math.max(0, params.num("from", 0));
+  const to = Math.max(0, params.num("to", 100));
+  const width = Math.max(String(Math.round(from)).length, String(Math.round(to)).length);
+  const toGrouped = groupDigits(paddedDigits(to, width));
+  const fromGrouped = groupDigits(paddedDigits(from, width));
+  const layers = installCountLayers(el, doc);
+  layers.srOnly.textContent = fromGrouped;
+  const strips = buildOdometerColumns(layers.decorative, doc, fromGrouped);
+  const tween = tweenNumber(ctx, {
+    from,
+    to,
+    ...tweenTimingFor(params, ctx),
+    onTick: (value, done) => {
+      updateOdometerColumns(strips, groupDigits(paddedDigits(value, width)));
+      if (done) layers.srOnly.textContent = toGrouped;
+    }
+  });
+  return {
+    cleanup: () => {
+      tween.cleanup();
+      layers.restore();
+    },
+    finished: tween.finished,
+    finish: tween.finish
+  };
+}
+var COUNT_PRIMITIVES = [
+  countPrimitive("count", countParams, deferPrepare(prepareCount)),
+  countPrimitive("count-odometer", odometerParams, deferPrepare(prepareOdometer))
+];
+var COUNT_PRESETS = [
+  { name: "count-up", primitive: "count", params: { from: "0", to: "100" } },
+  { name: "count-down", primitive: "count", params: { from: "100", to: "0" } },
+  {
+    name: "count-currency",
+    primitive: "count",
+    params: { from: "0", to: "4820", format: "currency", currency: "USD", decimals: "0" }
+  },
+  {
+    name: "count-percent",
+    primitive: "count",
+    params: { from: "0", to: "0.82", format: "percent", decimals: "0" }
+  },
+  {
+    name: "count-compact",
+    primitive: "count",
+    params: { from: "0", to: "128400", format: "compact" }
+  },
+  { name: "odometer-roll", primitive: "count-odometer", params: { from: "0", to: "4820" } }
+];
+var METER_PRIMITIVES = [
+  cssPrimitive("stroke-sweep", [CHANNEL.stroke]),
+  cssPrimitive("meter-bar", [CHANNEL.scale]),
+  cssPrimitive("meter-segments", [CHANNEL.opacity]),
+  cssPrimitive("meter-stars", [CHANNEL.clip])
+];
+var METER_PRESETS = [
+  { name: "progress-ring", primitive: "stroke-sweep", keyframes: "kui-progress-ring" },
+  { name: "gauge-sweep", primitive: "stroke-sweep", keyframes: "kui-gauge-sweep" },
+  { name: "donut-sweep", primitive: "stroke-sweep", keyframes: "kui-donut-sweep" },
+  { name: "sparkline-draw", primitive: "stroke-sweep", keyframes: "kui-sparkline-draw" },
+  { name: "progress-bar", primitive: "meter-bar", keyframes: "kui-progress-bar" },
+  { name: "progress-segments", primitive: "meter-segments", keyframes: "kui-progress-segments" },
+  { name: "star-rating-fill", primitive: "meter-stars", keyframes: "kui-star-rating-fill" }
+];
+var NUMBERS_PRIMITIVES = [...COUNT_PRIMITIVES, ...METER_PRIMITIVES];
+var NUMBERS_PRESETS = [...COUNT_PRESETS, ...METER_PRESETS];
+function registerNumbers(registry) {
+  return registry.registerPrimitives(NUMBERS_PRIMITIVES).registerPresets(NUMBERS_PRESETS);
+}
+
+// src/effects/catalog/text-shared.ts
+var SR_ONLY_CLASS2 = "kui-sr-only";
+var DECORATIVE_CLASS2 = "kui-split-decorative";
+function installSplitLayers(el, doc) {
+  const originalText = el.textContent.trim();
+  const decorative = doc.createElement("span");
+  decorative.setAttribute("aria-hidden", "true");
+  decorative.className = DECORATIVE_CLASS2;
+  const srOnly = doc.createElement("span");
+  srOnly.className = SR_ONLY_CLASS2;
+  srOnly.textContent = originalText;
+  el.textContent = "";
+  el.append(decorative, srOnly);
+  return {
+    decorative,
+    originalText,
+    restore: () => {
+      el.textContent = originalText;
+    }
+  };
+}
+function segmentGraphemes(text) {
+  const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  return Array.from(segmenter.segment(text), (entry) => entry.segment);
+}
+function segmentWords(text) {
+  const segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+  return Array.from(segmenter.segment(text), (entry) => ({
+    text: entry.segment,
+    isWord: entry.isWordLike === true
+  }));
+}
+function markItem(el, index, extraClass) {
+  el.className = extraClass ? `kui-split-item ${extraClass}` : "kui-split-item";
+  el.style.setProperty("--kui-i", String(index));
+}
+function applyStaggerVars(el, params) {
+  const { durationMs, delayMs, easing } = params.timing;
+  const duration = durationMs === void 0 ? params.text("duration", "500ms") : `${durationMs}ms`;
+  const delay = delayMs === void 0 ? params.text("delay", "0ms") : `${delayMs}ms`;
+  el.style.setProperty("--kui-duration", duration);
+  el.style.setProperty("--kui-delay", delay);
+  el.style.setProperty("--kui-ease", easing ?? params.text("ease", "ease-out"));
+  el.style.setProperty("--kui-stagger", params.text("stagger", "30ms"));
+}
+function stepMsFor(params, ticks, fallback) {
+  const total = params.timing.durationMs;
+  if (total === void 0 || ticks <= 0) return params.ms("step", fallback);
+  return Math.max(1, total / ticks);
+}
+function splitRevealFinishMs(params, itemCount) {
+  if (itemCount === 0) return 0;
+  const durationMs = params.timing.durationMs ?? params.ms("duration", 500);
+  const delayMs = params.timing.delayMs ?? params.ms("delay", 0);
+  const staggerMs = params.ms("stagger", 30);
+  return delayMs + (itemCount - 1) * staggerMs + durationMs;
+}
+function createStepRunner(win, options) {
+  let settle2;
+  const finished = new Promise((resolve) => {
+    settle2 = resolve;
+  });
+  let interval;
+  function stop() {
+    win.clearTimeout(start);
+    if (interval !== void 0) win.clearInterval(interval);
+    settle2?.();
+  }
+  const start = win.setTimeout(() => {
+    interval = win.setInterval(() => {
+      if (options.tick()) stop();
+    }, options.stepMs);
+  }, options.delayMs);
+  return { finished, stop };
+}
+function appendCharSpans(container, doc, text) {
+  const spans = [];
+  let index = 0;
+  for (const grapheme of segmentGraphemes(text)) {
+    if (grapheme.trim() === "") {
+      container.append(doc.createTextNode(grapheme));
+      continue;
+    }
+    const span = doc.createElement("span");
+    markItem(span, index);
+    span.textContent = grapheme;
+    container.append(span);
+    spans.push(span);
+    index++;
+  }
+  return spans;
+}
+function appendWordSpans(container, doc, text) {
+  const spans = [];
+  let index = 0;
+  for (const token of segmentWords(text)) {
+    if (!token.isWord) {
+      container.append(doc.createTextNode(token.text));
+      continue;
+    }
+    const span = doc.createElement("span");
+    markItem(span, index);
+    span.textContent = token.text;
+    container.append(span);
+    spans.push(span);
+    index++;
+  }
+  return spans;
+}
+function bucketByLine(container) {
+  const buckets = [];
+  let currentTop = null;
+  for (const node of Array.from(container.childNodes)) {
+    if (node instanceof HTMLElement) {
+      const top = node.offsetTop;
+      if (currentTop === null || Math.abs(top - currentTop) > 1) {
+        buckets.push([]);
+        currentTop = top;
+      }
+    } else if (buckets.length === 0) {
+      buckets.push([]);
+    }
+    buckets.at(-1).push(node);
+  }
+  return buckets;
+}
+function appendLineSpans(container, doc, text) {
+  appendWordSpans(container, doc, text);
+  const buckets = bucketByLine(container);
+  container.replaceChildren();
+  return buckets.map((nodes, index) => {
+    const line = doc.createElement("span");
+    markItem(line, index, "kui-split-line");
+    for (const node of nodes) line.append(node);
+    container.append(line);
+    return line;
+  });
+}
+function appendSpansFor(unit, container, doc, text) {
+  if (unit === "words") return appendWordSpans(container, doc, text);
+  if (unit === "lines") return appendLineSpans(container, doc, text);
+  return appendCharSpans(container, doc, text);
+}
+function nextTypeState(state, total, loop2) {
+  if (!state.deleting) {
+    const index2 = state.index + 1;
+    if (index2 < total) return { index: index2, deleting: false, done: false };
+    return loop2 ? { index: total, deleting: true, done: false } : { index: total, deleting: false, done: true };
+  }
+  const index = state.index - 1;
+  if (index > 0) return { index, deleting: true, done: false };
+  return { index: 0, deleting: false, done: false };
+}
+var SCRAMBLE_CHARSETS = {
+  upper: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  binary: "01",
+  symbols: "!<>-_\\/[]{}=+*^?#~"
+};
+function scrambledFrame(graphemes, resolved, charset, random) {
+  return graphemes.map((grapheme, index) => {
+    if (index < resolved || grapheme.trim() === "") return grapheme;
+    return charset[Math.floor(random() * charset.length)] ?? charset[0] ?? grapheme;
+  }).join("");
+}
+
+// src/effects/catalog/text.ts
+var fontWeightParams = {
+  from: { type: "number", default: "100", cssProperty: "--kui-from-weight", minimum: 1, maximum: 1e3 },
+  to: { type: "number", default: "800", cssProperty: "--kui-to-weight", minimum: 1, maximum: 1e3 }
+};
+var fontWidthParams = {
+  from: { type: "percentage", default: "75%", cssProperty: "--kui-from-width" },
+  to: { type: "percentage", default: "125%", cssProperty: "--kui-to-width" }
+};
+var fontSlantParams = {
+  from: { type: "angle", default: "0deg", cssProperty: "--kui-from-slant" },
+  to: { type: "angle", default: "-10deg", cssProperty: "--kui-to-slant" }
+};
+var TEXT_CSS_PRIMITIVES = [
+  cssPrimitive("text-shimmer", [CHANNEL.background], { reducedMotion: "disable" }),
+  cssPrimitive("text-sweep", [CHANNEL.background]),
+  cssPrimitive("text-outline-fill", [CHANNEL.stroke, CHANNEL.color]),
+  cssPrimitive("var-weight", ["font"], { parameters: fontWeightParams }),
+  cssPrimitive("var-width", ["font"], { parameters: fontWidthParams }),
+  cssPrimitive("var-slant", ["font"], { parameters: fontSlantParams }),
+  cssPrimitive("text-marquee", [CHANNEL.translate], {
+    timelines: ["time", "scroll"],
+    reducedMotion: "disable"
+  }),
+  cssPrimitive("redaction-reveal", [CHANNEL.clip]),
+  cssPrimitive("text-3d-extrude", [CHANNEL.rotate, CHANNEL.translate])
+];
+var TEXT_CSS_PRESETS = [
+  { name: "gradient-shimmer", primitive: "text-shimmer", keyframes: "kui-gradient-shimmer" },
+  { name: "gradient-sweep", primitive: "text-sweep", keyframes: "kui-gradient-sweep" },
+  { name: "highlight-sweep", primitive: "text-sweep", keyframes: "kui-highlight-sweep" },
+  { name: "underline-draw", primitive: "text-sweep", keyframes: "kui-underline-draw" },
+  { name: "text-outline-fill", primitive: "text-outline-fill", keyframes: "kui-text-outline-fill" },
+  { name: "var-weight", primitive: "var-weight", keyframes: "kui-var-weight" },
+  { name: "var-width", primitive: "var-width", keyframes: "kui-var-width" },
+  { name: "var-slant", primitive: "var-slant", keyframes: "kui-var-slant" },
+  { name: "marquee", primitive: "text-marquee", keyframes: "kui-marquee" },
+  { name: "marquee-scroll-linked", primitive: "text-marquee", keyframes: "kui-marquee" },
+  { name: "redaction-reveal", primitive: "redaction-reveal", keyframes: "kui-redaction-reveal" },
+  { name: "text-3d-extrude", primitive: "text-3d-extrude", keyframes: "kui-text-3d-extrude" }
+];
+function jsTextPrimitive(id, channels, options) {
+  return {
+    id,
+    renderer: "javascript",
+    channels,
+    parameters: options.parameters,
+    supportedTimelines: ["time"],
+    supportedActivations: ["load", "enter", "hover", "focus", "click", "manual"],
+    defaultActivation: "enter",
+    perfClass: options.perfClass ?? "dom-transform",
+    // Every JS-rendered primitive in this catalog is `disable`: none of them declare a CSS
+    // `animation-duration` the reduced-motion policy layer could shorten, so `shorten` would be a
+    // silent no-op. `disable` is enforced upstream — the animator never calls `activate()` at all
+    // — which is the only place that actually works for a timer- or DOM-surgery-driven effect.
+    reducedMotion: "disable",
+    prepare: options.prepare
+  };
+}
+var splitTiming = {
+  duration: { type: "time", default: "500ms", cssProperty: "--kui-duration" },
+  delay: { type: "time", default: "0ms", cssProperty: "--kui-delay" },
+  ease: { type: "easing", default: "ease-out", cssProperty: "--kui-ease" },
+  stagger: { type: "time", default: "30ms", cssProperty: "--kui-stagger" },
+  unit: {
+    type: "keyword",
+    default: "chars",
+    cssProperty: "--kui-unit",
+    values: ["chars", "words", "lines"]
+  },
+  direction: {
+    type: "keyword",
+    default: "fade",
+    cssProperty: "--kui-direction",
+    values: ["fade", "up", "down", "mask"]
+  }
+};
+var motionParams = {
+  stagger: { type: "time", default: "40ms", cssProperty: "--kui-stagger" },
+  motion: {
+    type: "keyword",
+    default: "wave",
+    cssProperty: "--kui-motion",
+    values: ["wave", "jitter"]
+  }
+};
+var typewriterParams = {
+  step: { type: "time", default: "55ms", cssProperty: "--kui-step" },
+  loop: { type: "keyword", default: "false", cssProperty: "--kui-loop", values: ["true", "false"] }
+};
+var scrambleParams = {
+  step: { type: "time", default: "40ms", cssProperty: "--kui-step" },
+  revealEvery: {
+    type: "number",
+    default: "2",
+    cssProperty: "--kui-reveal-every",
+    minimum: 1,
+    integer: true
+  },
+  charset: {
+    type: "keyword",
+    default: "upper",
+    cssProperty: "--kui-charset",
+    values: ["upper", "binary", "symbols"]
+  }
+};
+var wordCyclerParams = {
+  words: { type: "text", default: "", cssProperty: "--kui-words" },
+  interval: { type: "time", default: "2200ms", cssProperty: "--kui-interval" }
+};
+function prepareSplitText(el, params, ctx) {
+  const doc = el.ownerDocument;
+  const unit = params.text("unit", "chars");
+  const direction = params.text("direction", "fade");
+  const layers = installSplitLayers(el, doc);
+  layers.decorative.setAttribute("data-kui-split-fx", direction);
+  applyStaggerVars(layers.decorative, params);
+  const items = appendSpansFor(unit, layers.decorative, doc, layers.originalText);
+  let settle2;
+  const finished = new Promise((resolve) => {
+    settle2 = resolve;
+  });
+  const timer = ctx.win.setTimeout(settle2, splitRevealFinishMs(params, items.length));
+  return {
+    cleanup: () => {
+      ctx.win.clearTimeout(timer);
+      layers.restore();
+    },
+    finished,
+    finish: () => {
+      ctx.win.clearTimeout(timer);
+      settle2();
+    }
+  };
+}
+function prepareSplitMotion(el, params) {
+  const doc = el.ownerDocument;
+  const motion = params.text("motion", "wave");
+  const layers = installSplitLayers(el, doc);
+  layers.decorative.setAttribute("data-kui-split-fx", motion);
+  applyStaggerVars(layers.decorative, params);
+  appendCharSpans(layers.decorative, doc, layers.originalText);
+  return layers.restore;
+}
+function prepareTypewriter(el, params, ctx) {
+  const loop2 = params.is("loop");
+  const layers = installSplitLayers(el, el.ownerDocument);
+  layers.decorative.classList.add("kui-typewriter");
+  const graphemes = segmentGraphemes(layers.originalText);
+  let state = { index: 0, deleting: false };
+  const render = (count) => {
+    layers.decorative.textContent = graphemes.slice(0, count).join("");
+  };
+  const run = createStepRunner(ctx.win, {
+    delayMs: params.timing.delayMs ?? 0,
+    stepMs: stepMsFor(params, graphemes.length, 55),
+    tick: () => {
+      const step = nextTypeState(state, graphemes.length, loop2);
+      state = step;
+      render(step.index);
+      return step.done;
+    }
+  });
+  return {
+    cleanup: () => {
+      run.stop();
+      layers.restore();
+    },
+    finished: run.finished,
+    finish: () => {
+      run.stop();
+      render(graphemes.length);
+    }
+  };
+}
+function prepareScramble(el, params, ctx) {
+  const charset = SCRAMBLE_CHARSETS[params.text("charset", "upper")];
+  const revealEvery = Math.max(1, Math.round(params.num("revealEvery", 2)));
+  const layers = installSplitLayers(el, el.ownerDocument);
+  layers.decorative.classList.add("kui-scramble");
+  const graphemes = segmentGraphemes(layers.originalText);
+  let resolved = 0;
+  let ticks = 0;
+  const render = () => {
+    layers.decorative.textContent = scrambledFrame(graphemes, resolved, charset, Math.random);
+  };
+  render();
+  const run = createStepRunner(ctx.win, {
+    delayMs: params.timing.delayMs ?? 0,
+    stepMs: stepMsFor(params, graphemes.length * revealEvery, 40),
+    tick: () => {
+      ticks++;
+      if (ticks % revealEvery === 0) resolved++;
+      render();
+      return resolved >= graphemes.length;
+    }
+  });
+  return {
+    cleanup: () => {
+      run.stop();
+      layers.restore();
+    },
+    finished: run.finished,
+    finish: () => {
+      run.stop();
+      resolved = graphemes.length;
+      render();
+    }
+  };
+}
+function prepareWordCycler(el, params, ctx) {
+  const words = params.text("words", "").split("|").map((word) => word.trim()).filter(Boolean);
+  if (words.length === 0) return () => {
+  };
+  const original = el.textContent;
+  const swapMs = 150;
+  let index = 0;
+  el.textContent = words[0];
+  const run = createStepRunner(ctx.win, {
+    delayMs: params.timing.delayMs ?? 0,
+    stepMs: params.ms("interval", 2200),
+    tick: () => {
+      el.classList.add("kui-word-cycler-swap");
+      ctx.win.setTimeout(() => {
+        index = (index + 1) % words.length;
+        el.textContent = words[index];
+        el.classList.remove("kui-word-cycler-swap");
+      }, swapMs);
+      return false;
+    }
+  });
+  return {
+    cleanup: () => {
+      run.stop();
+      el.classList.remove("kui-word-cycler-swap");
+      el.textContent = original;
+    },
+    finished: run.finished,
+    finish: () => run.stop()
+  };
+}
+var TEXT_JS_PRIMITIVES = [
+  jsTextPrimitive("split-text", [CHANNEL.opacity, CHANNEL.translate, CHANNEL.clip], {
+    parameters: splitTiming,
+    prepare: deferPrepare(prepareSplitText)
+  }),
+  jsTextPrimitive("split-text-motion", [CHANNEL.translate, CHANNEL.rotate], {
+    parameters: motionParams,
+    prepare: deferPrepare(prepareSplitMotion),
+    perfClass: "continuous"
+  }),
+  jsTextPrimitive("typewriter", [CHANNEL.clip], {
+    parameters: typewriterParams,
+    prepare: deferPrepare(prepareTypewriter),
+    perfClass: "continuous"
+  }),
+  jsTextPrimitive("scramble-text", ["content"], {
+    parameters: scrambleParams,
+    prepare: deferPrepare(prepareScramble),
+    perfClass: "continuous"
+  }),
+  jsTextPrimitive("word-cycler", ["content"], {
+    parameters: wordCyclerParams,
+    prepare: deferPrepare(prepareWordCycler),
+    perfClass: "continuous"
+  })
+];
+var TEXT_JS_PRESETS = [
+  { name: "split-chars", primitive: "split-text", params: { unit: "chars", direction: "fade" } },
+  { name: "split-words", primitive: "split-text", params: { unit: "words", direction: "fade" } },
+  { name: "split-lines", primitive: "split-text", params: { unit: "lines", direction: "fade" } },
+  { name: "text-reveal-up", primitive: "split-text", params: { unit: "words", direction: "up" } },
+  { name: "text-reveal-down", primitive: "split-text", params: { unit: "words", direction: "down" } },
+  { name: "text-reveal-mask", primitive: "split-text", params: { unit: "lines", direction: "mask" } },
+  { name: "text-wave", primitive: "split-text-motion", params: { motion: "wave" } },
+  { name: "text-jitter", primitive: "split-text-motion", params: { motion: "jitter" } },
+  { name: "typewriter", primitive: "typewriter", params: { loop: "false" } },
+  { name: "typewriter-loop", primitive: "typewriter", params: { loop: "true" } },
+  { name: "scramble", primitive: "scramble-text", params: { charset: "upper" } },
+  { name: "decode", primitive: "scramble-text", params: { charset: "binary" } },
+  { name: "glitch", primitive: "scramble-text", params: { charset: "symbols" } },
+  { name: "word-cycler", primitive: "word-cycler" }
+];
+var TEXT_PRIMITIVES = [...TEXT_CSS_PRIMITIVES, ...TEXT_JS_PRIMITIVES];
+var TEXT_PRESETS = [...TEXT_CSS_PRESETS, ...TEXT_JS_PRESETS];
+function registerText(registry) {
+  return registry.registerPrimitives(TEXT_PRIMITIVES).registerPresets(TEXT_PRESETS);
+}
+
+// src/effects/catalog/index.ts
+function registerCatalog(registry) {
+  registerMedia(registry);
+  registerText(registry);
+  registerAmbient(registry);
+  registerFeedback(registry);
+  registerNumbers(registry);
+  registerInteraction(registry);
+  return registry;
+}
+
+// src/effects/catalog/core.ts
+var distance = {
+  distance: { type: "length", default: "24px", cssProperty: "--kui-distance" },
+  opacity: { type: "number", default: "0", cssProperty: "--kui-from-opacity" }
+};
+var PRIMITIVES = [
+  // --- entrance / exit -------------------------------------------------------------------
+  cssPrimitive("reveal", [CHANNEL.opacity, CHANNEL.translate], { parameters: distance }),
+  cssPrimitive("scale", [CHANNEL.scale], {
+    parameters: { scale: { type: "number", default: "0.92", cssProperty: "--kui-from-scale" } }
+  }),
+  // Separate from `scale` because it claims translate as well and so composes differently.
+  cssPrimitive("scale-move", [CHANNEL.scale, CHANNEL.translate], {
+    parameters: {
+      ...distance,
+      scale: { type: "number", default: "0.92", cssProperty: "--kui-from-scale" }
+    }
+  }),
+  cssPrimitive("rotate", [CHANNEL.rotate], {
+    parameters: { angle: { type: "angle", default: "-8deg", cssProperty: "--kui-from-angle" } }
+  }),
+  cssPrimitive("roll", [CHANNEL.rotate, CHANNEL.translate], {
+    parameters: {
+      ...distance,
+      angle: { type: "angle", default: "-120deg", cssProperty: "--kui-from-angle" }
+    }
+  }),
+  cssPrimitive("flip-3d", [CHANNEL.rotate], {
+    parameters: {
+      angle: { type: "angle", default: "90deg", cssProperty: "--kui-from-angle" },
+      perspective: { type: "length", default: "1200px", cssProperty: "--kui-perspective" }
+    }
+  }),
+  cssPrimitive("blur", [CHANNEL.filter], {
+    parameters: { blur: { type: "length", default: "12px", cssProperty: "--kui-blur" } }
+  }),
+  // Purpose-built combination: one keyframe, so opacity is written once instead of twice.
+  cssPrimitive("reveal-blur", [CHANNEL.opacity, CHANNEL.translate, CHANNEL.filter], {
+    parameters: { ...distance, blur: { type: "length", default: "12px", cssProperty: "--kui-blur" } }
+  }),
+  // --- scroll-linked ---------------------------------------------------------------------
+  // These are progress-linked, not time-triggered: they reverse as the user scrolls back.
+  // That is by design and is why `timeline:` is a different axis from `on:`.
+  cssPrimitive("parallax", [CHANNEL.translate], {
+    parameters: distance,
+    timelines: ["view", "scroll"],
+    activations: ["manual"],
+    reducedMotion: "disable",
+    perfClass: "compositor"
+  }),
+  cssPrimitive("parallax-scale", [CHANNEL.scale], {
+    parameters: { scale: { type: "number", default: "1.2", cssProperty: "--kui-to-scale" } },
+    timelines: ["view", "scroll"],
+    activations: ["manual"],
+    reducedMotion: "disable"
+  }),
+  cssPrimitive("parallax-rotate", [CHANNEL.rotate], {
+    parameters: { angle: { type: "angle", default: "12deg", cssProperty: "--kui-to-angle" } },
+    timelines: ["view", "scroll"],
+    activations: ["manual"],
+    reducedMotion: "disable"
+  }),
+  cssPrimitive("scroll-fade", [CHANNEL.opacity], {
+    parameters: { opacity: { type: "number", default: "0", cssProperty: "--kui-from-opacity" } },
+    timelines: ["view", "scroll"],
+    activations: ["manual"],
+    reducedMotion: "disable"
+  }),
+  cssPrimitive("progress", [CHANNEL.scale], {
+    timelines: ["scroll", "view"],
+    activations: ["manual"],
+    reducedMotion: "disable"
+  }),
+  // Separate primitive because it writes `stroke-dashoffset`, not `scale` — declaring the
+  // wrong channel would let it silently compose with an effect it actually collides with.
+  cssPrimitive("progress-stroke", [CHANNEL.stroke], {
+    parameters: { length: { type: "number", default: "100", cssProperty: "--kui-path-length" } },
+    timelines: ["scroll", "view"],
+    activations: ["manual"],
+    reducedMotion: "disable",
+    perfClass: "paint"
+  })
+];
+var p = (name, primitive, keyframes, params) => ({ name, primitive, keyframes, ...params ? { params } : {} });
+var FADE = [
+  p("fade-in", "reveal", "kui-in"),
+  p("fade-out", "reveal", "kui-out"),
+  p("fade-up", "reveal", "kui-in-up"),
+  p("fade-down", "reveal", "kui-in-down"),
+  p("fade-left", "reveal", "kui-in-left"),
+  p("fade-right", "reveal", "kui-in-right"),
+  p("fade-out-up", "reveal", "kui-out-up"),
+  p("fade-out-down", "reveal", "kui-out-down"),
+  p("fade-out-left", "reveal", "kui-out-left"),
+  p("fade-out-right", "reveal", "kui-out-right")
+];
+var SLIDE_PARAMS = { distance: "100px", opacity: "1" };
+var SLIDE = [
+  p("slide-up", "reveal", "kui-in-up", SLIDE_PARAMS),
+  p("slide-down", "reveal", "kui-in-down", SLIDE_PARAMS),
+  p("slide-left", "reveal", "kui-in-left", SLIDE_PARAMS),
+  p("slide-right", "reveal", "kui-in-right", SLIDE_PARAMS),
+  p("slide-out-up", "reveal", "kui-out-up", SLIDE_PARAMS),
+  p("slide-out-down", "reveal", "kui-out-down", SLIDE_PARAMS),
+  p("slide-out-left", "reveal", "kui-out-left", SLIDE_PARAMS),
+  p("slide-out-right", "reveal", "kui-out-right", SLIDE_PARAMS)
+];
+var LOGICAL = [
+  p("slide-inline-start", "reveal", "kui-in-inline-start", SLIDE_PARAMS),
+  p("slide-inline-end", "reveal", "kui-in-inline-end", SLIDE_PARAMS),
+  p("slide-block-start", "reveal", "kui-in-up", SLIDE_PARAMS),
+  p("slide-block-end", "reveal", "kui-in-down", SLIDE_PARAMS)
+];
+var ZOOM = [
+  p("zoom-in", "scale", "kui-zoom-in"),
+  p("zoom-out", "scale", "kui-zoom-out"),
+  p("pop-in", "scale", "kui-zoom-in", { scale: "0.6", ease: "back-out" }),
+  p("pop-out", "scale", "kui-zoom-out", { scale: "0.6", ease: "back-in" }),
+  p("zoom-in-up", "scale-move", "kui-zoom-in-up"),
+  p("zoom-in-down", "scale-move", "kui-zoom-in-down")
+];
+var FLIP = [
+  p("flip-in-x", "flip-3d", "kui-flip-in-x"),
+  p("flip-in-y", "flip-3d", "kui-flip-in-y"),
+  p("flip-out-x", "flip-3d", "kui-flip-out-x"),
+  p("flip-out-y", "flip-3d", "kui-flip-out-y")
+];
+var ROTATE = [
+  p("rotate-in", "rotate", "kui-rotate-in"),
+  p("rotate-out", "rotate", "kui-rotate-out"),
+  p("rotate-in-left", "rotate", "kui-rotate-in", { angle: "-45deg" }),
+  p("rotate-in-right", "rotate", "kui-rotate-in", { angle: "45deg" }),
+  p("roll-in", "roll", "kui-roll-in"),
+  p("roll-out", "roll", "kui-roll-out"),
+  p("swing-in", "rotate", "kui-swing-in", { angle: "-15deg", ease: "back-out" })
+];
+var BLUR = [
+  p("blur-in", "blur", "kui-blur-in"),
+  p("blur-out", "blur", "kui-blur-out"),
+  p("fade-blur-up", "reveal-blur", "kui-fade-blur-up"),
+  p("fade-blur-in", "reveal-blur", "kui-fade-blur-in")
+];
+var CHARACTER = [
+  p("bounce-in", "scale", "kui-zoom-in", { scale: "0.3", ease: "back-out" }),
+  p("bounce-in-up", "reveal", "kui-in-up", { distance: "60px", ease: "back-out" }),
+  p("bounce-in-down", "reveal", "kui-in-down", { distance: "60px", ease: "back-out" }),
+  p("back-in-up", "reveal", "kui-in-up", { distance: "120px", ease: "expo-out" }),
+  p("back-in-down", "reveal", "kui-in-down", { distance: "120px", ease: "expo-out" })
+];
+var SCROLL = [
+  p("parallax-y", "parallax", "kui-parallax-y"),
+  p("parallax-x", "parallax", "kui-parallax-x"),
+  p("parallax-scale", "parallax-scale", "kui-parallax-scale"),
+  p("parallax-rotate", "parallax-rotate", "kui-parallax-rotate"),
+  p("depth-layer", "parallax", "kui-parallax-y", { distance: "200px" }),
+  p("scroll-fade", "scroll-fade", "kui-scroll-fade"),
+  p("scroll-progress-bar", "progress", "kui-progress-x"),
+  p("scroll-progress-ring", "progress-stroke", "kui-progress-ring"),
+  // `reveal-repeat` was removed: it was byte-identical to `reveal-once`, and the activation
+  // binder unobserves after first entry, so a repeating reveal is not implementable yet.
+  p("reveal-once", "reveal", "kui-in-up")
+];
+var PRESETS = [
+  ...FADE,
+  ...SLIDE,
+  ...LOGICAL,
+  ...ZOOM,
+  ...FLIP,
+  ...ROTATE,
+  ...BLUR,
+  ...CHARACTER,
+  ...SCROLL
+];
+var COMBOS = [
+  [["fade-up", "blur-in"], "fade-blur-up"],
+  [["fade-in", "blur-in"], "fade-blur-in"]
+];
+function registerCore(registry) {
+  registry.registerPrimitives(PRIMITIVES).registerPresets(PRESETS);
+  for (const [names, preset] of COMBOS) registry.registerCombo(names, preset);
+  return registry;
+}
+
+// src/effects/forms/primitives.ts
+var timing = {
+  duration: { type: "time", default: "400ms", cssProperty: "--kui-duration" },
+  delay: { type: "time", default: "0ms", cssProperty: "--kui-delay" },
+  ease: { type: "easing", default: "ease-out", cssProperty: "--kui-ease" }
+};
+var NATIVE_STATE_PRIMITIVE = {
+  id: "native-state",
+  renderer: "javascript",
+  channels: [CHANNEL.translate, CHANNEL.scale, CHANNEL.opacity, CHANNEL.stroke, CHANNEL.color],
+  parameters: {},
+  supportedTimelines: ["time"],
+  supportedActivations: ["load"],
+  defaultActivation: "load",
+  perfClass: "compositor",
+  // Native pseudo-classes drive these and the motion lands on a sibling, not on the control that
+  // carries the attribute, so base.css's policy layer enforces this through its sibling
+  // `transition-duration` rules rather than the `animation-*` ones.
+  reducedMotion: "disable",
+  prepare: () => inertInstance()
+};
+var FOCUS_RING_PRIMITIVE = cssPrimitive("focus-ring", ["shadow"], {
+  activations: ["focus", "manual"],
+  defaultActivation: "focus"
+});
+var VALIDATE_SHAKE_PRIMITIVE = cssPrimitive("validate-shake", [CHANNEL.translate], {
+  activations: ["click", "manual"],
+  defaultActivation: "click"
+});
+var VALIDATE_CHECK_PRIMITIVE = cssPrimitive("validate-check", [CHANNEL.stroke], {
+  activations: ["click", "manual"],
+  defaultActivation: "click"
+});
+function jsInputPrimitive(id, channels, parameters, prepare) {
+  return {
+    id,
+    renderer: "javascript",
+    channels,
+    parameters: { ...timing, ...parameters },
+    supportedTimelines: ["time"],
+    supportedActivations: ["load"],
+    defaultActivation: "load",
+    perfClass: "compositor",
+    reducedMotion: "disable",
+    prepare
+  };
+}
+function computeStrength(value) {
+  let score = 0;
+  if (value.length >= 6) score++;
+  if (value.length >= 10) score++;
+  if (/[a-z]/.test(value) && /[A-Z]/.test(value)) score++;
+  if (/\d/.test(value)) score++;
+  if (/[^A-Za-z0-9]/.test(value)) score++;
+  return Math.min(4, score);
+}
+function prepareStrengthMeter(el) {
+  const input = el;
+  const update = () => {
+    el.setAttribute("data-kui-strength-level", String(computeStrength(input.value)));
+  };
+  input.addEventListener("input", update);
+  update();
+  return () => {
+    input.removeEventListener("input", update);
+    el.removeAttribute("data-kui-strength-level");
+  };
+}
+function prepareRangeFill(el, params, ctx) {
+  const input = el;
+  const update = () => {
+    const min = Number(input.min || "0");
+    const max = Number(input.max || "100");
+    const pct = max > min ? (Number(input.value) - min) / (max - min) * 100 : 0;
+    ctx.style.set("--kui-fill", `${pct.toFixed(2)}%`);
+  };
+  input.addEventListener("input", update);
+  update();
+  return () => input.removeEventListener("input", update);
+}
+var STRENGTH_METER_PRIMITIVE = jsInputPrimitive(
+  "strength-meter",
+  ["meter"],
+  {},
+  deferPrepare(prepareStrengthMeter)
+);
+var RANGE_FILL_PRIMITIVE = jsInputPrimitive(
+  "range-fill",
+  [CHANNEL.background],
+  {},
+  deferPrepare(prepareRangeFill)
+);
+function nextStep(step, total) {
+  return total > 0 ? (step + 1) % total : 0;
+}
+function prepareStepProgress(el, params) {
+  const total = Math.max(1, Math.round(params.num("steps", 4)));
+  let step = 0;
+  const render = () => el.setAttribute("data-kui-step", String(step));
+  const advance = () => {
+    step = nextStep(step, total);
+    render();
+  };
+  el.addEventListener("click", advance);
+  render();
+  return () => {
+    el.removeEventListener("click", advance);
+    el.removeAttribute("data-kui-step");
+  };
+}
+var STEP_PROGRESS_PRIMITIVE = jsInputPrimitive(
+  "step-progress",
+  ["state"],
+  { steps: { type: "number", default: "4", cssProperty: "--kui-steps", minimum: 1, integer: true } },
+  deferPrepare(prepareStepProgress)
+);
+function nextSubmitStage(stage) {
+  if (stage === "idle") return "loading";
+  if (stage === "loading") return "done";
+  return "idle";
+}
+function prepareSubmitFlow(el, params, ctx) {
+  const loadMs = params.ms("load", 1200);
+  const holdMs = params.ms("hold", 1500);
+  let stage = "idle";
+  let handle;
+  const render = () => el.setAttribute("data-kui-stage", stage);
+  const toIdle = () => {
+    stage = nextSubmitStage(stage);
+    render();
+  };
+  const toDone = () => {
+    stage = nextSubmitStage(stage);
+    render();
+    handle = ctx.win.setTimeout(toIdle, holdMs);
+  };
+  const advance = () => {
+    if (stage !== "idle") return;
+    stage = nextSubmitStage(stage);
+    render();
+    handle = ctx.win.setTimeout(toDone, loadMs);
+  };
+  el.addEventListener("click", advance);
+  render();
+  return () => {
+    el.removeEventListener("click", advance);
+    if (handle !== void 0) ctx.win.clearTimeout(handle);
+    el.removeAttribute("data-kui-stage");
+  };
+}
+var SUBMIT_FLOW_PRIMITIVE = jsInputPrimitive(
+  "submit-flow",
+  ["state"],
+  {
+    load: { type: "time", default: "1200ms", cssProperty: "--kui-load" },
+    hold: { type: "time", default: "1500ms", cssProperty: "--kui-hold" }
+  },
+  deferPrepare(prepareSubmitFlow)
+);
+
+// src/effects/forms/index.ts
+var FORMS_PRIMITIVES = [
+  NATIVE_STATE_PRIMITIVE,
+  FOCUS_RING_PRIMITIVE,
+  VALIDATE_SHAKE_PRIMITIVE,
+  VALIDATE_CHECK_PRIMITIVE,
+  STRENGTH_METER_PRIMITIVE,
+  RANGE_FILL_PRIMITIVE,
+  STEP_PROGRESS_PRIMITIVE,
+  SUBMIT_FLOW_PRIMITIVE
+];
+var FORMS_PRESETS = [
+  { name: "label-float", primitive: "native-state" },
+  { name: "input-underline-grow", primitive: "native-state" },
+  { name: "focus-ring-grow", primitive: "focus-ring", keyframes: "kui-focus-ring-grow" },
+  { name: "validate-shake", primitive: "validate-shake", keyframes: "kui-validate-shake" },
+  { name: "validate-check", primitive: "validate-check", keyframes: "kui-validate-check" },
+  { name: "strength-meter", primitive: "strength-meter" },
+  { name: "toggle-morph", primitive: "native-state" },
+  { name: "checkbox-draw", primitive: "native-state" },
+  { name: "radio-fill", primitive: "native-state" },
+  { name: "range-fill", primitive: "range-fill" },
+  { name: "submit-to-spinner-to-check", primitive: "submit-flow" },
+  { name: "step-progress", primitive: "step-progress" }
+];
+function registerForms(registry) {
+  return registry.registerPrimitives(FORMS_PRIMITIVES).registerPresets(FORMS_PRESETS);
+}
+
+// src/core/gesture.ts
+var VELOCITY_WINDOW_MS = 100;
+var MAX_SAMPLES = 12;
+function velocityFrom(samples) {
+  const last = samples[samples.length - 1];
+  if (!last || samples.length < 2) return { vx: 0, vy: 0 };
+  const cutoff = last.time - VELOCITY_WINDOW_MS;
+  const first = samples.find((sample) => sample.time >= cutoff) ?? samples[0];
+  const span = (last.time - first.time) / 1e3;
+  if (span <= 0) return { vx: 0, vy: 0 };
+  return { vx: (last.x - first.x) / span, vy: (last.y - first.y) / span };
+}
+function swipeDirection(vector, minVelocity) {
+  const { vx, vy } = vector;
+  if (Math.abs(vx) < minVelocity && Math.abs(vy) < minVelocity) return null;
+  if (Math.abs(vx) >= Math.abs(vy)) return vx > 0 ? "right" : "left";
+  return vy > 0 ? "down" : "up";
+}
+function applyAxis(vector, axis) {
+  if (axis === "x") return { ...vector, dy: 0, vy: 0 };
+  if (axis === "y") return { ...vector, dx: 0, vx: 0 };
+  return vector;
+}
+function recognise(el, handlers, options = {}, deps = defaultGestureDeps()) {
+  const threshold = options.threshold ?? 4;
+  const axis = options.axis ?? "both";
+  const swipeVelocity = options.swipeVelocity ?? 300;
+  const longPressMs = options.longPressMs ?? 0;
+  let samples = [];
+  let origin = null;
+  let active = false;
+  let longPressTimer = null;
+  function sampleOf(event) {
+    return { x: event.clientX, y: event.clientY, time: deps.now() };
+  }
+  function vectorNow(sample) {
+    const start = origin;
+    const { vx, vy } = velocityFrom(samples);
+    return applyAxis({ dx: sample.x - start.x, dy: sample.y - start.y, vx, vy }, axis);
+  }
+  function clearLongPress() {
+    if (longPressTimer !== null) deps.clearTimer(longPressTimer);
+    longPressTimer = null;
+  }
+  function onDown(event) {
+    origin = sampleOf(event);
+    samples = [origin];
+    active = false;
+    el.setPointerCapture?.(event.pointerId);
+    if (longPressMs > 0) {
+      longPressTimer = deps.setTimer(() => handlers.onLongPress?.(origin), longPressMs);
+    }
+  }
+  function onMove(event) {
+    if (!origin) return;
+    const sample = sampleOf(event);
+    samples.push(sample);
+    if (samples.length > MAX_SAMPLES) samples.shift();
+    const vector = vectorNow(sample);
+    if (!active && Math.hypot(vector.dx, vector.dy) < threshold) return;
+    if (!active) {
+      active = true;
+      clearLongPress();
+      handlers.onStart?.(origin);
+    }
+    handlers.onMove?.(vector, sample);
+  }
+  function onUp(event) {
+    clearLongPress();
+    el.releasePointerCapture?.(event.pointerId);
+    if (!origin) return;
+    const sample = sampleOf(event);
+    samples.push(sample);
+    const vector = vectorNow(sample);
+    if (active) {
+      handlers.onEnd?.(vector, sample);
+      const direction = swipeDirection(vector, swipeVelocity);
+      if (direction) handlers.onSwipe?.(direction, vector);
+    }
+    origin = null;
+    active = false;
+    samples = [];
+  }
+  el.addEventListener("pointerdown", onDown);
+  el.addEventListener("pointermove", onMove, { passive: true });
+  el.addEventListener("pointerup", onUp, { passive: true });
+  el.addEventListener("pointercancel", onUp, { passive: true });
+  return () => {
+    clearLongPress();
+    el.removeEventListener("pointerdown", onDown);
+    el.removeEventListener("pointermove", onMove);
+    el.removeEventListener("pointerup", onUp);
+    el.removeEventListener("pointercancel", onUp);
+  };
+}
+function defaultGestureDeps() {
+  return {
+    now: () => typeof performance === "undefined" ? Date.now() : performance.now(),
+    setTimer: (callback, ms) => globalThis.setTimeout(callback, ms),
+    clearTimer: (handle) => globalThis.clearTimeout(handle)
+  };
+}
+function rubberBand(offset, limit, tension = 0.55) {
+  if (limit <= 0) return 0;
+  const sign = Math.sign(offset);
+  const magnitude = Math.abs(offset);
+  return sign * (1 - 1 / (magnitude / limit / tension + 1)) * limit;
+}
+
+// src/effects/gestures/primitives.ts
+var springParams2 = {
+  stiffness: {
+    type: "number",
+    default: "180",
+    cssProperty: "--kui-stiffness",
+    finite: true,
+    minimum: 1,
+    maximum: 1e4
+  },
+  damping: {
+    type: "number",
+    default: "24",
+    cssProperty: "--kui-damping",
+    finite: true,
+    minimum: 0.1,
+    maximum: 1e3
+  }
+};
+function gesturePrimitive(id, channels, parameters, prepare) {
+  return {
+    id,
+    renderer: "javascript",
+    channels,
+    parameters,
+    supportedTimelines: ["time", "pointer"],
+    supportedActivations: ["load", "manual"],
+    defaultActivation: "load",
+    perfClass: "continuous",
+    reducedMotion: "disable",
+    prepare
+  };
+}
+function springFrom2(params) {
+  return {
+    ...DEFAULT_SPRING,
+    stiffness: params.num("stiffness", DEFAULT_SPRING.stiffness),
+    damping: params.num("damping", DEFAULT_SPRING.damping)
+  };
+}
+function springDeps(ctx) {
+  return { ...defaultSpringDeps(), warn: ctx.warn };
+}
+function writeOffset(ctx, x, y) {
+  ctx.style.set("translate", `${x.toFixed(2)}px ${y.toFixed(2)}px`);
+}
+function prepareDraggable(el, params, ctx) {
+  const config = springFrom2(params);
+  const bounds = params.num("bounds", 0);
+  const returns = params.is("return");
+  const inertia = params.is("inertia");
+  const offset = { x: 0, y: 0 };
+  const deps = springDeps(ctx);
+  const runners = {
+    x: createSpringRunner(config, (value) => write({ ...offset, x: value }), deps),
+    y: createSpringRunner(config, (value) => write({ ...offset, y: value }), deps)
+  };
+  function write(next) {
+    offset.x = next.x;
+    offset.y = next.y;
+    writeOffset(ctx, offset.x, offset.y);
+  }
+  const stopRecognising = recognise(
+    el,
+    {
+      onStart() {
+        runners.x.stop();
+        runners.y.stop();
+        el.setAttribute("data-kui-dragging", "true");
+      },
+      onMove(vector) {
+        write({ x: resist(vector.dx, bounds), y: resist(vector.dy, bounds) });
+      },
+      onEnd(vector) {
+        el.setAttribute("data-kui-dragging", "false");
+        settle(runners, offset, vector, { returns, inertia });
+      }
+    },
+    { axis: params.text("axis", "both") }
+  );
+  ctx.invalidate();
+  return () => {
+    stopRecognising();
+    runners.x.stop();
+    runners.y.stop();
+    el.removeAttribute("data-kui-dragging");
+  };
+}
+function resist(delta, bounds) {
+  return bounds > 0 ? rubberBand(delta, bounds) : delta;
+}
+function settle(runners, offset, vector, mode) {
+  runners.x.set(offset.x, mode.inertia ? vector.vx : 0);
+  runners.y.set(offset.y, mode.inertia ? vector.vy : 0);
+  if (mode.returns) {
+    runners.x.to(0);
+    runners.y.to(0);
+    return;
+  }
+  runners.x.to(offset.x + vector.vx * 0.2);
+  runners.y.to(offset.y + vector.vy * 0.2);
+}
+function prepareSwipeable(el, params) {
+  const stop = recognise(
+    el,
+    {
+      onSwipe(direction) {
+        el.setAttribute("data-kui-swipe", direction);
+      }
+    },
+    {
+      axis: params.text("axis", "both"),
+      swipeVelocity: params.num("velocity", 300)
+    }
+  );
+  return () => {
+    stop();
+    el.removeAttribute("data-kui-swipe");
+  };
+}
+function preparePressable(el, params) {
+  const stop = recognise(
+    el,
+    {
+      onLongPress() {
+        el.setAttribute("data-kui-pressed", "true");
+      },
+      onEnd() {
+        el.setAttribute("data-kui-pressed", "false");
+      }
+    },
+    { longPressMs: effectDurationMs(params, 500) }
+  );
+  return () => {
+    stop();
+    el.removeAttribute("data-kui-pressed");
+  };
+}
+function prepareMagnetic(el, params, ctx) {
+  const node = el;
+  const radius = params.num("radius", 120);
+  const strength = params.num("strength", 0.35);
+  const config = springFrom2(params);
+  const deps = springDeps(ctx);
+  const offset = { x: 0, y: 0 };
+  const runnerX = createSpringRunner(config, (value) => {
+    offset.x = value;
+    writeOffset(ctx, offset.x, offset.y);
+  }, deps);
+  const runnerY = createSpringRunner(config, (value) => {
+    offset.y = value;
+    writeOffset(ctx, offset.x, offset.y);
+  }, deps);
+  const onPointerMove = (event) => {
+    const box = node.getBoundingClientRect();
+    const dx = event.clientX - (box.left + box.width / 2);
+    const dy = event.clientY - (box.top + box.height / 2);
+    const inRange = Math.hypot(dx, dy) < radius;
+    runnerX.to(inRange ? dx * strength : 0);
+    runnerY.to(inRange ? dy * strength : 0);
+  };
+  ctx.win.addEventListener("pointermove", onPointerMove, { passive: true });
+  return () => {
+    ctx.win.removeEventListener("pointermove", onPointerMove);
+    runnerX.stop();
+    runnerY.stop();
+  };
+}
+var GESTURE_PRIMITIVES = [
+  gesturePrimitive(
+    "draggable",
+    ["translate"],
+    {
+      ...springParams2,
+      axis: { type: "keyword", default: "both", cssProperty: "--kui-axis", values: ["x", "y", "both"] },
+      bounds: { type: "number", default: "0", cssProperty: "--kui-bounds" },
+      return: {
+        type: "keyword",
+        default: "false",
+        cssProperty: "--kui-return",
+        values: ["true", "false"]
+      },
+      inertia: {
+        type: "keyword",
+        default: "false",
+        cssProperty: "--kui-inertia",
+        values: ["true", "false"]
+      }
+    },
+    deferPrepare(prepareDraggable)
+  ),
+  gesturePrimitive(
+    "swipeable",
+    ["state"],
+    {
+      axis: { type: "keyword", default: "both", cssProperty: "--kui-axis", values: ["x", "y", "both"] },
+      velocity: { type: "number", default: "300", cssProperty: "--kui-velocity" }
+    },
+    deferPrepare(prepareSwipeable)
+  ),
+  gesturePrimitive(
+    "pressable",
+    ["state"],
+    { duration: { type: "time", default: "500ms", cssProperty: "--kui-duration" } },
+    deferPrepare(preparePressable)
+  ),
+  gesturePrimitive(
+    "magnetic",
+    ["translate"],
+    {
+      ...springParams2,
+      radius: { type: "number", default: "120", cssProperty: "--kui-radius" },
+      strength: { type: "number", default: "0.35", cssProperty: "--kui-strength" }
+    },
+    deferPrepare(prepareMagnetic)
+  )
+];
+
+// src/effects/gestures/index.ts
+var GESTURE_PRESETS = [
+  { name: "drag", primitive: "draggable" },
+  { name: "drag-x", primitive: "draggable", params: { axis: "x" } },
+  { name: "drag-y", primitive: "draggable", params: { axis: "y" } },
+  { name: "drag-inertia", primitive: "draggable", params: { inertia: "true" } },
+  { name: "throwable", primitive: "draggable", params: { inertia: "true", damping: "18" } },
+  { name: "elastic-pull", primitive: "draggable", params: { return: "true", bounds: "80" } },
+  { name: "rubber-band", primitive: "draggable", params: { return: "true", bounds: "120" } },
+  { name: "snap-back", primitive: "draggable", params: { return: "true", stiffness: "260" } },
+  { name: "swipe", primitive: "swipeable" },
+  { name: "swipe-x", primitive: "swipeable", params: { axis: "x" } },
+  { name: "long-press", primitive: "pressable" },
+  { name: "magnetic", primitive: "magnetic" },
+  { name: "magnetic-snap", primitive: "magnetic", params: { strength: "0.6", radius: "160" } }
+];
+function registerGestures(registry) {
+  return registry.registerPrimitives(GESTURE_PRIMITIVES).registerPresets(GESTURE_PRESETS);
+}
+
+// src/core/flip.ts
+var EPSILON = 0.5;
+function domMeasure(el) {
+  const rect = el.getBoundingClientRect();
+  return { x: rect.left, y: rect.top, width: rect.width, height: rect.height };
+}
+function domAnimate(el, keyframes, options) {
+  const animate = el.animate;
+  return typeof animate === "function" ? animate.call(el, keyframes, options) : null;
+}
+function createFlipEngine(deps = {}) {
+  const measure = deps.measure ?? domMeasure;
+  const animate = deps.animate ?? domAnimate;
+  return {
+    snapshot(elements) {
+      const boxes = /* @__PURE__ */ new Map();
+      for (const el of elements) boxes.set(el, measure(el));
+      return { boxes };
+    },
+    play(before, elements, options = {}) {
+      const deltas = collectDeltas(before, elements, measure, options.scale ?? false);
+      if (deltas.length === 0) {
+        return { moved: [], finished: Promise.resolve(), cancel: () => {
+        } };
+      }
+      return runDeltas(deltas, animate, options);
+    }
+  };
+}
+function collectDeltas(before, elements, measure, scale) {
+  const deltas = [];
+  for (const el of elements) {
+    const first = before.boxes.get(el);
+    if (!first) continue;
+    const last = measure(el);
+    const delta = deltaFor(el, first, last, scale);
+    if (delta) deltas.push(delta);
+  }
+  return deltas;
+}
+function deltaFor(el, first, last, scale) {
+  const dx = first.x - last.x;
+  const dy = first.y - last.y;
+  const sx = scale && last.width > 0 ? first.width / last.width : 1;
+  const sy = scale && last.height > 0 ? first.height / last.height : 1;
+  const still = Math.abs(dx) < EPSILON && Math.abs(dy) < EPSILON && Math.abs(sx - 1) < 1e-3 && Math.abs(sy - 1) < 1e-3;
+  return still ? null : { el, dx, dy, sx, sy };
+}
+function runDeltas(deltas, animate, options) {
+  const duration = options.durationMs ?? 400;
+  const easing = options.easing ?? "cubic-bezier(0.2, 0, 0, 1)";
+  const animations = [];
+  for (const { el, dx, dy, sx, sy } of deltas) {
+    const animation = animate(
+      el,
+      [
+        { translate: `${dx}px ${dy}px`, scale: `${sx} ${sy}` },
+        { translate: "0px 0px", scale: "1 1" }
+      ],
+      { duration, easing, fill: "none" }
+    );
+    if (animation) animations.push(animation);
+  }
+  const finished = Promise.all(
+    animations.map((animation) => animation.finished.catch(() => void 0))
+  ).then(() => void 0);
+  return {
+    moved: deltas.map((delta) => delta.el),
+    finished,
+    cancel() {
+      for (const animation of animations) animation.cancel();
+    }
+  };
+}
+function observeLayout(container, engine, options, observe) {
+  let before = engine.snapshot(container.children);
+  const cleanup = observe(() => {
+    engine.play(before, container.children, options);
+    before = engine.snapshot(container.children);
+  });
+  return cleanup;
+}
+function mutationWatcher(container) {
+  return (callback) => {
+    if (typeof MutationObserver === "undefined") return () => {
+    };
+    const observer = new MutationObserver(callback);
+    observer.observe(container, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["hidden"]
+    });
+    return () => observer.disconnect();
+  };
+}
+
+// src/effects/layout/primitives.ts
+var timing2 = {
+  duration: { type: "time", default: "400ms", cssProperty: "--kui-duration" },
+  ease: { type: "easing", default: "ease-out", cssProperty: "--kui-ease" }
+};
+function layoutPrimitive(id, channels, parameters, prepare) {
+  return {
+    id,
+    renderer: "javascript",
+    channels,
+    parameters: { ...timing2, ...parameters },
+    supportedTimelines: ["time"],
+    supportedActivations: ["load", "manual", "click"],
+    defaultActivation: "load",
+    perfClass: "layout",
+    // A layout transition that is merely faster is still a layout transition; under reduced
+    // motion the correct behaviour is for elements to appear in place.
+    reducedMotion: "disable",
+    prepare
+  };
+}
+function prepareFlipContainer(el, params) {
+  const engine = createFlipEngine();
+  return observeLayout(
+    el,
+    engine,
+    {
+      durationMs: effectDurationMs(params, 400),
+      easing: params.text("ease"),
+      scale: params.is("scale")
+    },
+    mutationWatcher(el)
+  );
+}
+function prepareAutoHeight(el, params, ctx) {
+  const node = el;
+  ctx.style.set("overflow", "hidden");
+  ctx.style.claim("height");
+  const duration = effectDurationMs(params, 400);
+  let animation = null;
+  const observer = watchAttribute(node, params.text("attribute"), () => {
+    animation?.cancel();
+    animation = animateHeight(node, duration, params.text("ease"));
+  });
+  ctx.invalidate();
+  return () => {
+    observer();
+    animation?.cancel();
+  };
+}
+function animateHeight(node, duration, easing) {
+  const from = `${node.getBoundingClientRect().height}px`;
+  node.style.removeProperty("height");
+  const to = `${node.scrollHeight}px`;
+  const animate = node.animate;
+  if (typeof animate !== "function") return null;
+  return animate.call(node, [{ height: from }, { height: to }], { duration, easing, fill: "none" });
+}
+function prepareIndicator(el, params, ctx) {
+  const node = el;
+  const engine = createFlipEngine();
+  const selector = params.text("follow");
+  let currentShift = 0;
+  const move = () => {
+    if (!selector) return;
+    const target = ctx.doc.querySelector(selector);
+    if (!(target instanceof Element)) return;
+    const before = engine.snapshot([node]);
+    const box = target.getBoundingClientRect();
+    const current = node.getBoundingClientRect();
+    const shift = box.left - current.left + currentShift;
+    currentShift = shift;
+    ctx.style.set("width", `${box.width}px`);
+    ctx.style.set("translate", `${shift}px 0`);
+    engine.play(before, [node], {
+      durationMs: effectDurationMs(params, 400),
+      easing: params.text("ease"),
+      scale: true
+    });
+  };
+  move();
+  return watchAttribute(ctx.doc.documentElement, params.text("attribute"), move);
+}
+function watchAttribute(root, attribute, onChange) {
+  if (typeof MutationObserver === "undefined" || !attribute) return () => {
+  };
+  const observer = new MutationObserver(onChange);
+  observer.observe(root, { subtree: true, attributes: true, attributeFilter: [attribute] });
+  return () => observer.disconnect();
+}
+var LAYOUT_PRIMITIVES = [
+  layoutPrimitive(
+    "flip-container",
+    ["translate", "scale"],
+    {
+      scale: {
+        type: "keyword",
+        default: "false",
+        cssProperty: "--kui-flip-scale",
+        values: ["true", "false"]
+      }
+    },
+    deferPrepare(prepareFlipContainer)
+  ),
+  layoutPrimitive(
+    "auto-height",
+    ["layout"],
+    { attribute: { type: "text", default: "data-open", cssProperty: "--kui-attribute" } },
+    deferPrepare(prepareAutoHeight)
+  ),
+  layoutPrimitive(
+    "flip-indicator",
+    ["translate", "layout"],
+    {
+      follow: { type: "text", default: "", cssProperty: "--kui-follow" },
+      attribute: { type: "text", default: "aria-selected", cssProperty: "--kui-attribute" }
+    },
+    deferPrepare(prepareIndicator)
+  )
+];
+
+// src/effects/layout/presets.ts
+var LAYOUT_PRESETS = [
+  { name: "flip-reorder", primitive: "flip-container" },
+  { name: "flip-filter", primitive: "flip-container" },
+  { name: "flip-sort", primitive: "flip-container" },
+  { name: "flip-shuffle", primitive: "flip-container" },
+  // Cards changing aspect between layouts need their size interpolated, not just their position.
+  { name: "grid-to-list", primitive: "flip-container", params: { scale: "true" } },
+  { name: "masonry-reflow", primitive: "flip-container" },
+  { name: "expand-to-modal", primitive: "flip-container", params: { scale: "true", duration: "500ms" } },
+  { name: "accordion-height", primitive: "auto-height" },
+  { name: "tab-indicator-slide", primitive: "flip-indicator", params: { duration: "300ms" } }
+];
+
+// src/effects/layout/index.ts
+function registerLayout(registry) {
+  return registry.registerPrimitives(LAYOUT_PRIMITIVES).registerPresets(LAYOUT_PRESETS);
+}
+
+// src/effects/navigation/index.ts
+var NAV_CSS_PRIMITIVES = [
+  cssPrimitive("nav-reveal", [CHANNEL.opacity, CHANNEL.translate]),
+  cssPrimitive("menu-fullscreen", [CHANNEL.clip, CHANNEL.opacity]),
+  cssPrimitive("panel-reveal", [CHANNEL.opacity, CHANNEL.translate]),
+  cssPrimitive("drawer-slide", [CHANNEL.translate], {
+    defaultActivation: "click"
+  })
+];
+var NAV_CSS_PRESETS = [
+  { name: "menu-stagger-open", primitive: "nav-reveal", keyframes: "kui-nav-reveal" },
+  { name: "menu-fullscreen", primitive: "menu-fullscreen", keyframes: "kui-menu-fullscreen" },
+  { name: "dropdown-open", primitive: "panel-reveal", keyframes: "kui-panel-reveal" },
+  {
+    name: "mega-menu-drop",
+    primitive: "panel-reveal",
+    keyframes: "kui-panel-reveal",
+    params: { duration: "550ms" }
+  },
+  {
+    name: "drawer-slide",
+    primitive: "drawer-slide",
+    keyframes: "kui-drawer-slide-right"
+  }
+];
+function navPrimitive(id, channels, parameters, prepare) {
+  return {
+    id,
+    renderer: "javascript",
+    channels,
+    parameters,
+    supportedTimelines: ["time"],
+    supportedActivations: ["load"],
+    defaultActivation: "load",
+    perfClass: "compositor",
+    // A scroll-position reaction, like the scroll-mechanics category: shortening its "duration"
+    // is meaningless because the position, not a clock, drives it.
+    reducedMotion: "disable",
+    prepare
+  };
+}
+function subscribeScrollTop(el, ctx, onScrollTop) {
+  return ctx.scheduler.subscribe(ctx.rootFor(el), (frame) => onScrollTop(frame.metrics.scrollTop));
+}
+function prepareHeaderShrink(el, params, ctx) {
+  const offset = params.num("offset", 120);
+  return subscribeScrollTop(el, ctx, (top) => {
+    const progress = offset > 0 ? Math.min(1, Math.max(0, top / offset)) : 1;
+    ctx.style.set("--kui-shrink", progress.toFixed(4));
+    el.setAttribute("data-kui-shrunk", String(progress >= 1));
+  });
+}
+function prepareHeaderHide(el, params, ctx) {
+  const minDelta = params.num("offset", 8);
+  let last = 0;
+  return subscribeScrollTop(el, ctx, (top) => {
+    const delta = top - last;
+    if (Math.abs(delta) < minDelta) return;
+    el.setAttribute("data-kui-hidden", String(delta > 0 && top > minDelta));
+    last = top;
+  });
+}
+function prepareBackToTop(el, params, ctx) {
+  const offset = params.num("offset", 400);
+  return subscribeScrollTop(el, ctx, (top) => {
+    el.setAttribute("data-kui-visible", String(top > offset));
+  });
+}
+var NAV_JS_PRIMITIVES = [
+  navPrimitive(
+    "header-shrink",
+    ["layout"],
+    { offset: { type: "number", default: "120", cssProperty: "--kui-offset" } },
+    deferPrepare(prepareHeaderShrink)
+  ),
+  navPrimitive(
+    "header-hide-on-scroll",
+    [CHANNEL.translate],
+    { offset: { type: "number", default: "8", cssProperty: "--kui-offset" } },
+    deferPrepare(prepareHeaderHide)
+  ),
+  navPrimitive(
+    "back-to-top-fade",
+    [CHANNEL.opacity, CHANNEL.translate],
+    { offset: { type: "number", default: "400", cssProperty: "--kui-offset" } },
+    deferPrepare(prepareBackToTop)
+  )
+];
+var NAV_JS_PRESETS = [
+  { name: "header-shrink", primitive: "header-shrink" },
+  { name: "header-hide-on-scroll", primitive: "header-hide-on-scroll" },
+  { name: "back-to-top-fade", primitive: "back-to-top-fade" }
+];
+var NAVIGATION_PRIMITIVES = [...NAV_CSS_PRIMITIVES, ...NAV_JS_PRIMITIVES];
+var NAVIGATION_PRESETS = [...NAV_CSS_PRESETS, ...NAV_JS_PRESETS];
+function registerNavigation(registry) {
+  return registry.registerPrimitives(NAVIGATION_PRIMITIVES).registerPresets(NAVIGATION_PRESETS);
+}
+
+// src/effects/scroll-mechanics/tracker.ts
+var domGeometry = (el) => {
+  const rect = el.getBoundingClientRect();
+  return { top: rect.top, height: rect.height };
+};
+function trackProgress(el, ctx, options, onProgress) {
+  const measure = options.measure ?? domGeometry;
+  let scrollTop = 0;
+  let scrollportTop = 0;
+  const geometry2 = createMeasureCache(() => {
+    const box = measure(el);
+    return { contentTop: box.top - scrollportTop + scrollTop, height: box.height };
+  });
+  return ctx.scheduler.subscribe(ctx.rootFor(el), (frame) => {
+    scrollTop = frame.metrics.scrollTop;
+    scrollportTop = frame.metrics.viewportTop;
+    const box = geometry2.read(frame.epoch);
+    const span = resolveDistance(options.distance, { top: 0, height: box.height }, frame);
+    onProgress(progressFrom(box.contentTop - scrollTop, span), frame);
+  });
+}
+function resolveDistance(distance2, box, frame) {
+  if (!distance2) return box.height;
+  const basis = {
+    viewportWidth: frame.metrics.viewportWidth,
+    viewportHeight: frame.metrics.viewportHeight,
+    percentBasis: box.height,
+    fontSize: 16,
+    rootFontSize: 16
+  };
+  return toPixels(distance2, basis, box.height);
+}
+function progressFrom(top, span) {
+  if (span <= 0) return 0;
+  return clamp01(-top / span);
+}
+
+// src/effects/scroll-mechanics/primitives.ts
+var PROGRESS_VAR = "--kui-progress";
+var distanceParam = {
+  distance: { type: "length", default: "100vh", cssProperty: "--kui-distance" }
+};
+function scrollPrimitive(spec) {
+  const { id, channels, parameters, prepare, perfClass = "compositor" } = spec;
+  return {
+    id,
+    renderer: "javascript",
+    channels,
+    parameters,
+    supportedTimelines: ["time", "view", "scroll"],
+    supportedActivations: ["manual", "load", "enter"],
+    defaultActivation: "load",
+    perfClass,
+    reducedMotion: "disable",
+    prepare
+  };
+}
+function writeProgress(ctx, progress) {
+  ctx.style.set(PROGRESS_VAR, progress.toFixed(4));
+}
+function preparePin(el, params, ctx) {
+  const node = el;
+  ctx.style.set("position", "sticky");
+  ctx.style.set("top", params.text("offset", "0px"));
+  const removeSpacer = params.is("spacer") ? insertSpacer(node, params.text("distance"), ctx) : null;
+  const tracked = node.parentElement ?? el;
+  const untrack = trackProgress(tracked, ctx, { distance: params.text("distance") }, (progress) => {
+    writeProgress(ctx, progress);
+    el.setAttribute("data-kui-pinned", progress > 0 && progress < 1 ? "true" : "false");
+  });
+  return () => {
+    untrack();
+    removeSpacer?.();
+    el.removeAttribute("data-kui-pinned");
+  };
+}
+function insertSpacer(node, distance2, ctx) {
+  const spacer = ctx.doc.createElement("div");
+  spacer.setAttribute("data-kui-spacer", "");
+  spacer.setAttribute("aria-hidden", "true");
+  spacer.style.height = distance2;
+  spacer.style.pointerEvents = "none";
+  node.after(spacer);
+  ctx.invalidate();
+  return () => {
+    spacer.remove();
+    ctx.invalidate();
+  };
+}
+function prepareProgress(el, params, ctx) {
+  const steps = Math.max(0, Math.round(params.num("steps", 0)));
+  const untrack = trackProgress(el, ctx, { distance: params.text("distance") }, (progress) => {
+    writeProgress(ctx, progress);
+    if (steps > 0) {
+      const index = Math.min(steps - 1, Math.floor(progress * steps));
+      el.setAttribute("data-kui-step", String(index));
+    }
+  });
+  return () => {
+    untrack();
+    el.removeAttribute("data-kui-step");
+  };
+}
+function prepareHorizontal(el, params, ctx) {
+  const node = el;
+  const authored = params.text("travel", "auto");
+  const travel = createMeasureCache(() => trackTravel(node, authored, node.ownerDocument));
+  const untrack = trackProgress(el, ctx, { distance: params.text("distance") }, (progress, frame) => {
+    ctx.style.set("translate", `${-progress * travel.read(frame.epoch)}px 0`);
+    writeProgress(ctx, progress);
+  });
+  return untrack;
+}
+function trackTravel(node, authored, doc) {
+  if (authored && authored !== "auto") return toPixels(authored, ABSOLUTE_BASIS, 0);
+  const selfOverflow = node.scrollWidth - node.clientWidth;
+  if (selfOverflow > 0) return selfOverflow;
+  const viewportWidth = node.parentElement?.clientWidth || doc.documentElement.clientWidth;
+  return Math.max(0, node.scrollWidth - viewportWidth);
+}
+function prepareMediaScrub(el, params, ctx) {
+  const frames = Math.max(1, Math.round(params.num("frames", 1)));
+  const pattern = mediaSrcPattern(params.text("src"), ctx);
+  const media = el;
+  let lastIndex = -1;
+  const untrack = trackProgress(el, ctx, { distance: params.text("distance") }, (progress) => {
+    writeProgress(ctx, progress);
+    const index = Math.min(frames - 1, Math.floor(progress * frames));
+    if (index === lastIndex) return;
+    lastIndex = index;
+    applyFrame(media, { index, frames, progress, pattern });
+  });
+  return untrack;
+}
+function mediaSrcPattern(pattern, ctx) {
+  if (!pattern || isSameOriginPath(pattern)) return pattern;
+  ctx.warn(`media-scrub "src" must be a same-origin path, got "${pattern}" \u2014 ignoring`);
+  return "";
+}
+function applyFrame(media, write) {
+  const { index, frames, progress, pattern } = write;
+  if (media.tagName === "VIDEO") {
+    const duration = Number.isFinite(media.duration) ? media.duration : 0;
+    if (duration > 0) media.currentTime = duration * progress;
+    return;
+  }
+  if (media.tagName !== "IMG") return;
+  if (pattern) media.src = pattern.replace("{i}", String(index).padStart(String(frames).length, "0"));
+}
+function prepareScrollSpy(el, params, ctx) {
+  const selector = spyTarget(params.text("target"), ctx);
+  const links = /* @__PURE__ */ new Map();
+  const self = createAttributeLedger(el);
+  let last;
+  const untrack = trackProgress(el, ctx, { distance: params.text("distance") }, (progress) => {
+    const active = progress > 0 && progress < 1;
+    if (active === last) return;
+    last = active;
+    self.set("data-kui-active", String(active));
+    if (selector) markLinks(ctx.doc, selector, active, links);
+  });
+  return () => {
+    untrack();
+    self.restore();
+    for (const ledger of links.values()) ledger.restore();
+  };
+}
+function spyTarget(selector, ctx) {
+  if (!selector) return selector;
+  const breadth = selectorBreadth(selector, ctx.doc);
+  if (breadth === "invalid") {
+    ctx.warn(`scroll-spy target "${selector}" is not a valid selector and will be ignored`);
+    return "";
+  }
+  if (breadth === "document-wide") {
+    ctx.warn(`scroll-spy target "${selector}" matches the whole document and will be ignored`);
+    return "";
+  }
+  return selector;
+}
+function selectorBreadth(selector, doc) {
+  try {
+    if (doc.documentElement.matches(selector)) return "document-wide";
+    if (doc.body?.matches(selector)) return "document-wide";
+    return "ok";
+  } catch {
+    return "invalid";
+  }
+}
+function markLinks(doc, selector, active, links) {
+  for (const link of doc.querySelectorAll(selector)) {
+    let ledger = links.get(link);
+    if (!ledger) {
+      ledger = createAttributeLedger(link);
+      links.set(link, ledger);
+    }
+    ledger.set("data-kui-active", String(active));
+  }
+}
+function prepareSnap(el, params, ctx) {
+  ctx.style.set(
+    "scroll-snap-type",
+    `${params.is("axis", "x") ? "x" : "y"} ${params.text("strictness", "mandatory")}`
+  );
+  const childLedgers = [...el.children].map((child) => createStyleLedger(child));
+  for (const ledger of childLedgers) ledger.set("scroll-snap-align", params.text("align", "start"));
+  return () => {
+    for (const ledger of childLedgers) ledger.restore();
+  };
+}
+var SCROLL_PRIMITIVES = [
+  scrollPrimitive({
+    id: "pin",
+    channels: ["layout", "progress"],
+    parameters: {
+      ...distanceParam,
+      offset: { type: "length", default: "0px", cssProperty: "--kui-offset" },
+      spacer: {
+        type: "keyword",
+        default: "false",
+        cssProperty: "--kui-spacer",
+        values: ["true", "false"]
+      }
+    },
+    prepare: deferPrepare(preparePin),
+    perfClass: "layout"
+  }),
+  scrollPrimitive({
+    id: "scroll-progress",
+    channels: ["progress"],
+    parameters: {
+      ...distanceParam,
+      steps: { type: "number", default: "0", cssProperty: "--kui-steps" }
+    },
+    prepare: deferPrepare(prepareProgress)
+  }),
+  scrollPrimitive({
+    id: "horizontal-track",
+    channels: ["translate", "progress"],
+    parameters: {
+      ...distanceParam,
+      travel: { type: "text", default: "auto", cssProperty: "--kui-travel" }
+    },
+    prepare: deferPrepare(prepareHorizontal)
+  }),
+  scrollPrimitive({
+    id: "media-scrub",
+    channels: ["media", "progress"],
+    parameters: {
+      ...distanceParam,
+      frames: { type: "number", default: "1", cssProperty: "--kui-frames" },
+      src: { type: "text", default: "", cssProperty: "--kui-src" }
+    },
+    prepare: deferPrepare(prepareMediaScrub),
+    perfClass: "paint"
+  }),
+  scrollPrimitive({
+    id: "scroll-spy",
+    channels: ["state"],
+    parameters: {
+      ...distanceParam,
+      target: { type: "text", default: "", cssProperty: "--kui-target" }
+    },
+    prepare: deferPrepare(prepareScrollSpy)
+  }),
+  scrollPrimitive({
+    id: "scroll-snap",
+    channels: ["layout"],
+    parameters: {
+      axis: { type: "keyword", default: "y", cssProperty: "--kui-axis", values: ["x", "y"] },
+      strictness: {
+        type: "keyword",
+        default: "mandatory",
+        cssProperty: "--kui-snap-strictness",
+        values: ["mandatory", "proximity"]
+      },
+      align: {
+        type: "keyword",
+        default: "start",
+        cssProperty: "--kui-snap-align",
+        values: ["start", "center", "end"]
+      }
+    },
+    prepare: deferPrepare(prepareSnap),
+    perfClass: "layout"
+  })
+];
+
+// src/effects/scroll-mechanics/presets.ts
+var SCROLL_PRESETS = [
+  // --- pinning ---------------------------------------------------------------------------
+  // The default carries a spacer: a pin longer than its containing block silently does nothing,
+  // and that is the single most common way authors get sticky wrong.
+  { name: "pin-section", primitive: "pin", params: { distance: "100vh", spacer: "true" } },
+  { name: "pin-until", primitive: "pin", params: { spacer: "false" } },
+  { name: "pin-spacer", primitive: "pin", params: { spacer: "true" } },
+  // Applied per card; each card sticks at its own offset and the stack builds up naturally.
+  { name: "stacking-cards", primitive: "pin", params: { spacer: "false" } },
+  // --- progress publishing ---------------------------------------------------------------
+  { name: "scroll-progress", primitive: "scroll-progress" },
+  { name: "scrollytelling-step", primitive: "scroll-progress", params: { steps: "4" } },
+  // --- travel ------------------------------------------------------------------------------
+  { name: "horizontal-scroll", primitive: "horizontal-track" },
+  // --- media -------------------------------------------------------------------------------
+  { name: "sequence-scrub", primitive: "media-scrub" },
+  { name: "video-scrub", primitive: "media-scrub" },
+  // --- navigation --------------------------------------------------------------------------
+  { name: "scroll-spy", primitive: "scroll-spy" },
+  // --- native CSS passthroughs ---------------------------------------------------------------
+  { name: "scroll-snap-x", primitive: "scroll-snap", params: { axis: "x" } },
+  { name: "scroll-snap-y", primitive: "scroll-snap", params: { axis: "y" } }
+];
+
+// src/effects/scroll-mechanics/index.ts
+function registerScrollMechanics(registry) {
+  return registry.registerPrimitives(SCROLL_PRIMITIVES).registerPresets(SCROLL_PRESETS);
+}
+
+// src/core/path-morph.ts
+var COMMAND = /([mlhvcz])|(-?(?:\d+(?:\.\d+)?|\.\d+))/gi;
+var UNSUPPORTED = /[AaSsQqTt]/;
+function parsePath(d) {
+  if (UNSUPPORTED.test(d)) {
+    return { segments: [], reason: "arc and shorthand commands (A S Q T) are not supported" };
+  }
+  const tokens = [...d.matchAll(COMMAND)].map((m) => m[1] ?? m[2]);
+  const state = {
+    segments: [],
+    current: { x: 0, y: 0 },
+    start: { x: 0, y: 0 },
+    command: ""
+  };
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (/[a-z]/i.test(token)) {
+      state.command = token;
+      if (token.toLowerCase() === "z") closeSubpath(state);
+      index++;
+      continue;
+    }
+    if (!state.command) return { segments: [], reason: "path must start with a command letter" };
+    index = consume(tokens, index, state);
+  }
+  if (state.segments.length === 0) return { segments: [], reason: "no drawable segments" };
+  return { segments: state.segments };
+}
+var ARITY = { m: 2, l: 2, h: 1, v: 1, c: 6, z: 0 };
+function closeSubpath(state) {
+  const { current, start } = state;
+  if (Math.abs(current.x - start.x) < 1e-6 && Math.abs(current.y - start.y) < 1e-6) return;
+  state.segments.push(lineToCubic(current, start));
+  state.current = { ...start };
+}
+function consume(tokens, index, state) {
+  const key = state.command.toLowerCase();
+  const relative = state.command === key;
+  const arity = ARITY[key];
+  const args = tokens.slice(index, index + arity).map(Number);
+  if (args.length < arity) return tokens.length;
+  const next = endpointFor(key, args, state.current, relative);
+  if (key === "m") {
+    state.current = next;
+    state.start = next;
+    state.command = relative ? "l" : "L";
+    return index + arity;
+  }
+  state.segments.push(straightOrCubic({ key, args, from: state.current, relative }, next));
+  state.current = next;
+  return index + arity;
+}
+function endpointFor(key, args, current, relative) {
+  const base = relative ? current : { x: 0, y: 0 };
+  if (key === "h") return { x: base.x + args[0], y: current.y };
+  if (key === "v") return { x: current.x, y: base.y + args[0] };
+  if (key === "c") return { x: base.x + args[4], y: base.y + args[5] };
+  return { x: base.x + args[0], y: base.y + args[1] };
+}
+function straightOrCubic(command, to) {
+  const { key, args, from, relative } = command;
+  if (key !== "c") return lineToCubic(from, to);
+  const base = relative ? from : { x: 0, y: 0 };
+  return {
+    from,
+    c1: { x: base.x + args[0], y: base.y + args[1] },
+    c2: { x: base.x + args[2], y: base.y + args[3] },
+    to
+  };
+}
+function lineToCubic(from, to) {
+  return {
+    from,
+    c1: lerpPoint(from, to, 1 / 3),
+    c2: lerpPoint(from, to, 2 / 3),
+    to
+  };
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpPoint(a, b, t) {
+  return { x: lerp(a.x, b.x, t), y: lerp(a.y, b.y, t) };
+}
+function splitCubic(segment, t) {
+  const p01 = lerpPoint(segment.from, segment.c1, t);
+  const p12 = lerpPoint(segment.c1, segment.c2, t);
+  const p23 = lerpPoint(segment.c2, segment.to, t);
+  const p012 = lerpPoint(p01, p12, t);
+  const p123 = lerpPoint(p12, p23, t);
+  const mid = lerpPoint(p012, p123, t);
+  return [
+    { from: segment.from, c1: p01, c2: p012, to: mid },
+    { from: mid, c1: p123, c2: p23, to: segment.to }
+  ];
+}
+function normaliseCount(segments, target) {
+  const out = [...segments];
+  while (out.length < target && out.length > 0) {
+    let longest = 0;
+    for (let i = 1; i < out.length; i++) {
+      if (chordLength(out[i]) > chordLength(out[longest])) longest = i;
+    }
+    const [a, b] = splitCubic(out[longest], 0.5);
+    out.splice(longest, 1, a, b);
+  }
+  return out;
+}
+function chordLength(segment) {
+  return Math.hypot(segment.to.x - segment.from.x, segment.to.y - segment.from.y);
+}
+function toPathData(segments) {
+  if (segments.length === 0) return "";
+  const head = segments[0];
+  const parts = [`M${round(head.from.x)},${round(head.from.y)}`];
+  for (const s of segments) {
+    parts.push(
+      `C${round(s.c1.x)},${round(s.c1.y)} ${round(s.c2.x)},${round(s.c2.y)} ${round(s.to.x)},${round(s.to.y)}`
+    );
+  }
+  return parts.join(" ");
+}
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function createMorph(fromPath, toPath) {
+  const a = parsePath(fromPath);
+  const b = parsePath(toPath);
+  if (a.reason) return { reason: `start path: ${a.reason}` };
+  if (b.reason) return { reason: `end path: ${b.reason}` };
+  const count = Math.max(a.segments.length, b.segments.length);
+  const from = normaliseCount(a.segments, count);
+  const to = normaliseCount(b.segments, count);
+  return {
+    morph: {
+      segmentCount: count,
+      at(t) {
+        const clamped = Math.min(1, Math.max(0, t));
+        return toPathData(from.map((segment, i) => lerpCubic(segment, to[i], clamped)));
+      }
+    }
+  };
+}
+function lerpCubic(a, b, t) {
+  return {
+    from: lerpPoint(a.from, b.from, t),
+    c1: lerpPoint(a.c1, b.c1, t),
+    c2: lerpPoint(a.c2, b.c2, t),
+    to: lerpPoint(a.to, b.to, t)
+  };
+}
+
+// src/effects/svg/index.ts
+function prepareMorph(el, params, ctx) {
+  const path = el;
+  const startPath = params.text("from") || path.getAttribute("d") || "";
+  const { morph, reason } = createMorph(startPath, params.text("to"));
+  if (!morph) {
+    ctx.warn(`cannot morph: ${reason}`);
+    return () => {
+    };
+  }
+  const duration = effectDurationMs(params, 300);
+  let frame = 0;
+  let cancelled = false;
+  const drive = (target) => {
+    cancelAnimationFrame(frame);
+    const startedAt = performance.now();
+    const startValue = current;
+    const step = (now) => {
+      if (cancelled) return;
+      const t = duration > 0 ? Math.min(1, (now - startedAt) / duration) : 1;
+      current = startValue + (target - startValue) * t;
+      path.setAttribute("d", morph.at(current));
+      if (t < 1) frame = requestAnimationFrame(step);
+    };
+    frame = requestAnimationFrame(step);
+  };
+  let current = 0;
+  const enter = () => drive(1);
+  const leave = () => drive(0);
+  el.addEventListener("pointerenter", enter, { passive: true });
+  el.addEventListener("focusin", enter, { passive: true });
+  el.addEventListener("pointerleave", leave, { passive: true });
+  el.addEventListener("focusout", leave, { passive: true });
+  return () => {
+    cancelled = true;
+    cancelAnimationFrame(frame);
+    el.removeEventListener("pointerenter", enter);
+    el.removeEventListener("focusin", enter);
+    el.removeEventListener("pointerleave", leave);
+    el.removeEventListener("focusout", leave);
+    path.setAttribute("d", startPath);
+  };
+}
+var SVG_PRIMITIVES = [
+  {
+    id: "path-morph",
+    renderer: "javascript",
+    // `d` is its own channel: nothing else in the catalog writes path geometry, so a morph can
+    // safely compose with a fade or a rotation on the same element.
+    channels: ["path"],
+    parameters: {
+      from: { type: "text", default: "", cssProperty: "--kui-path-from" },
+      to: { type: "text", default: "", cssProperty: "--kui-path-to" },
+      duration: { type: "time", default: "300ms", cssProperty: "--kui-duration" }
+    },
+    supportedTimelines: ["time"],
+    supportedActivations: ["hover", "focus", "manual", "load"],
+    // The morph attaches its own hover listeners, so it must be wired up on load, not on enter.
+    defaultActivation: "load",
+    perfClass: "paint",
+    reducedMotion: "disable",
+    prepare: deferPrepare(prepareMorph)
+  }
+];
+var SVG_PRESETS = [
+  { name: "icon-morph", primitive: "path-morph" },
+  { name: "blob-morph", primitive: "path-morph", params: { duration: "800ms" } }
+];
+function registerSvg(registry) {
+  return registry.registerPrimitives(SVG_PRIMITIVES).registerPresets(SVG_PRESETS);
+}
+
+// src/effects/three-d/index.ts
+var THREE_D_PRIMITIVES = [
+  cssPrimitive("flip-face", [CHANNEL.rotate], {
+    parameters: {
+      angle: { type: "angle", default: "180deg", cssProperty: "--kui-from-angle" },
+      perspective: { type: "length", default: "1200px", cssProperty: "--kui-perspective" }
+    }
+  }),
+  cssPrimitive("page-reveal", [CHANNEL.opacity, CHANNEL.translate], {
+    parameters: { distance: { type: "length", default: "40px", cssProperty: "--kui-distance" } }
+  }),
+  cssPrimitive("wipe", [CHANNEL.clip]),
+  cssPrimitive("bar", [CHANNEL.scale])
+];
+var THREE_D_PRESETS = [
+  // --- 3D & perspective ---
+  { name: "card-flip-y", primitive: "flip-face", keyframes: "kui-card-flip-y" },
+  { name: "card-flip-x", primitive: "flip-face", keyframes: "kui-card-flip-x" },
+  { name: "cube-rotate", primitive: "flip-face", keyframes: "kui-cube-rotate", params: { angle: "90deg" } },
+  {
+    name: "book-page-turn",
+    primitive: "flip-face",
+    keyframes: "kui-book-page-turn",
+    params: { angle: "-160deg", duration: "900ms" }
+  },
+  {
+    name: "fold-panel",
+    primitive: "flip-face",
+    keyframes: "kui-fold-panel",
+    params: { angle: "-90deg" }
+  },
+  // --- page transitions ---
+  { name: "page-fade", primitive: "page-reveal", keyframes: "kui-page-fade" },
+  { name: "page-slide", primitive: "page-reveal", keyframes: "kui-page-slide" },
+  { name: "curtain-wipe", primitive: "wipe", keyframes: "kui-curtain-wipe", params: { duration: "800ms" } },
+  { name: "loading-bar", primitive: "bar", keyframes: "kui-loading-bar" }
+];
+function registerThreeD(registry) {
+  return registry.registerPrimitives(THREE_D_PRIMITIVES).registerPresets(THREE_D_PRESETS);
+}
+
+// src/effects/index.ts
+function createRegistry() {
+  const registry = new Registry();
+  registerCore(registry);
+  registerScrollMechanics(registry);
+  registerLayout(registry);
+  registerSvg(registry);
+  registerGestures(registry);
+  registerThreeD(registry);
+  registerCatalog(registry);
+  registerNavigation(registry);
+  registerForms(registry);
+  return registry;
+}
+
+export {
+  registerCatalog,
+  PRIMITIVES,
+  PRESETS,
+  COMBOS,
+  registerCore,
+  registerGestures,
+  registerLayout,
+  registerScrollMechanics,
+  registerSvg,
+  registerThreeD,
+  createRegistry
+};