kuinetic 0.1.3 → 0.2.0

package/dist/esm/chunk-5DON3UFQ.mjs

@@ -1,4380 +0,0 @@
-import {
-  ABSOLUTE_BASIS,
-  CHANNEL,
-  Registry,
-  clamp01,
-  continuousSetup,
-  createAttributeLedger,
-  createMeasureCache,
-  createStyleLedger,
-  deferPrepare,
-  effectDurationMs,
-  inertInstance,
-  isSameOriginPath,
-  toPixels
-} from "./chunk-JT4PZL3A.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 orbit = {
-  duration: { type: "time", default: "3.5s", cssProperty: "--kui-duration" },
-  // `linear` by default, unlike every other ambient primitive: a continuous rotation that eases
-  // visibly stutters once per revolution, because the ease restarts at each iteration boundary.
-  ease: { type: "easing", default: "linear", cssProperty: "--kui-ease" },
-  angle: { type: "angle", default: "360deg", cssProperty: "--kui-to-angle" }
-};
-var pulse = {
-  duration: { type: "time", default: "2.2s", cssProperty: "--kui-duration" },
-  ease: { type: "easing", default: "ease-in-out", cssProperty: "--kui-ease" },
-  scale: { type: "number", default: "1.15", cssProperty: "--kui-pulse-scale", finite: true, minimum: 1 }
-};
-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-orbit", [CHANNEL.rotate], {
-    parameters: orbit,
-    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: "orbit", primitive: "ambient-orbit", keyframes: "kui-orbit" },
-  { 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" },
-  dotSize: { type: "length", default: "8px", cssProperty: "--kui-dot-size" }
-};
-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" },
-  scale: { type: "number", default: "1.18", cssProperty: "--kui-pop-scale", finite: true, minimum: 1 }
-};
-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 pull = {
-  distance: { type: "length", default: "36px", cssProperty: "--kui-pull-distance" }
-};
-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], {
-    parameters: pull,
-    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", scale: "1.3" }
-  },
-  {
-    name: "heart-burst",
-    primitive: "feedback-burst",
-    keyframes: "kui-heart-burst",
-    params: { duration: "700ms", scale: "1.4" }
-  },
-  {
-    name: "confetti-burst",
-    primitive: "feedback-burst",
-    keyframes: "kui-confetti-burst",
-    params: { duration: "900ms", scale: "1.15" }
-  },
-  { 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" }
-};
-var liftParams = {
-  distance: { type: "length", default: "6px", cssProperty: "--kui-lift-distance" }
-};
-var popParams = {
-  scale: { type: "number", default: "1.06", cssProperty: "--kui-pop-scale", finite: true, minimum: 0 }
-};
-function hoverPrimitive(id, channels, extraParams = {}) {
-  return {
-    id,
-    renderer: "javascript",
-    channels,
-    parameters: { ...hoverTiming, ...extraParams },
-    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"], liftParams),
-  hoverPrimitive("pop", ["scale"], popParams),
-  hoverPrimitive("lift-shadow", ["translate", "shadow"], liftParams),
-  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
-  },
-  mass: {
-    type: "number",
-    default: "1",
-    cssProperty: "--kui-mass",
-    finite: true,
-    minimum: 0.1
-  }
-};
-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),
-    mass: params.num("mass", DEFAULT_SPRING.mass)
-  };
-}
-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-shared.ts
-var AXIS_DEGREES = { vertical: 0, horizontal: 90 };
-var UNIT_DEGREES = { deg: 1, grad: 0.9, rad: 180 / Math.PI, turn: 360 };
-var BAND_OVERLAP_PX = 1;
-var STAGE_CLASS = "kui-slat-stage";
-var SLAT_CLASS = "kui-slat-item";
-var GOLDEN_RATIO_CONJUGATE = 0.6180339887498949;
-function slatOrder(index, count, from) {
-  if (count <= 1) return 0;
-  switch (from) {
-    case "start":
-      return index;
-    case "end":
-      return count - 1 - index;
-    case "edges":
-      return Math.min(index, count - 1 - index);
-    case "random-ish":
-      return Math.floor(index * GOLDEN_RATIO_CONJUGATE % 1 * count);
-    case "alternate":
-    default:
-      return zigzagRank(index, count);
-  }
-}
-function zigzagRank(index, count) {
-  const fromStart = index;
-  const fromEnd = count - 1 - index;
-  const pair = Math.min(fromStart, fromEnd);
-  return fromStart <= fromEnd ? pair * 2 : pair * 2 + 1;
-}
-function slatAngleDegrees(authored, axis) {
-  const trimmed = authored.trim();
-  if (!trimmed) return AXIS_DEGREES[axis];
-  const match = /^(-?(?:\d+(?:\.\d+)?|\.\d+))(deg|rad|grad|turn)?$/.exec(trimmed);
-  if (!match) return AXIS_DEGREES[axis];
-  const value = Number(match[1]);
-  if (!Number.isFinite(value)) return AXIS_DEGREES[axis];
-  const unit = match[2] ?? "deg";
-  const degrees = value * UNIT_DEGREES[unit];
-  return (degrees % 180 + 180) % 180;
-}
-function slatTravelVector(angleDegrees) {
-  const theta = angleDegrees * Math.PI / 180;
-  return { x: -Math.sin(theta), y: Math.cos(theta) };
-}
-function slatBandClip(index, count, angleDegrees, box) {
-  const { width, height } = box;
-  const theta = angleDegrees * Math.PI / 180;
-  const nx = Math.cos(theta);
-  const ny = Math.sin(theta);
-  const { x: dx, y: dy } = slatTravelVector(angleDegrees);
-  const span = Math.abs(nx) * width + Math.abs(ny) * height;
-  const centreX = width / 2;
-  const centreY = height / 2;
-  const step = span / count;
-  const near = index * step - span / 2 - BAND_OVERLAP_PX;
-  const far = (index + 1) * step - span / 2 + BAND_OVERLAP_PX;
-  const reach = width + height;
-  const corner = (along, across) => `${(centreX + along * nx + across * dx).toFixed(2)}px ${(centreY + along * ny + across * dy).toFixed(2)}px`;
-  return `polygon(${corner(near, reach)}, ${corner(near, -reach)}, ${corner(far, -reach)}, ${corner(far, reach)})`;
-}
-function axisLabel(angleDegrees) {
-  if (angleDegrees === 0) return "vertical";
-  if (angleDegrees === 90) return "horizontal";
-  return "diagonal";
-}
-function syncStageToImage(stage, img, bands) {
-  const { slats, angleDegrees } = bands;
-  const width = img.offsetWidth;
-  const height = img.offsetHeight;
-  stage.style.top = `${img.offsetTop}px`;
-  stage.style.left = `${img.offsetLeft}px`;
-  stage.style.width = `${width}px`;
-  stage.style.height = `${height}px`;
-  slats.forEach((slat, index) => {
-    slat.style.clipPath = slatBandClip(index, slats.length, angleDegrees, { width, height });
-  });
-}
-function watchImageBox(stage, img, win, bands) {
-  const handler = () => syncStageToImage(stage, img, bands);
-  win.addEventListener("resize", handler, { passive: true });
-  const stopWindow = () => win.removeEventListener("resize", handler);
-  const ResizeObserverCtor = win.ResizeObserver;
-  if (!ResizeObserverCtor) return stopWindow;
-  const observer = new ResizeObserverCtor(handler);
-  observer.observe(img);
-  return () => {
-    stopWindow();
-    observer.disconnect();
-  };
-}
-function imagePaintStyle(img, win) {
-  const computed = win.getComputedStyle(img);
-  const position = computed.objectPosition || "50% 50%";
-  const fit = computed.objectFit;
-  if (fit === "cover") return { size: "cover", position };
-  if (fit === "contain" || fit === "scale-down") return { size: "contain", position };
-  if (fit === "none") return { size: "auto", position };
-  return { size: "100% 100%", position };
-}
-function installSlatStage(el, doc, win, options) {
-  const img = el.querySelector("img");
-  if (!img) return null;
-  const url = img.currentSrc || img.getAttribute("src") || "";
-  if (!url) return null;
-  const { count, angleDegrees, from, fold } = options;
-  const travel = slatTravelVector(angleDegrees);
-  const stage = doc.createElement("div");
-  stage.className = STAGE_CLASS;
-  stage.setAttribute("aria-hidden", "true");
-  stage.dataset.kuiSlatAxis = axisLabel(angleDegrees);
-  stage.dataset.kuiSlatAngle = String(angleDegrees);
-  stage.dataset.kuiSlatFold = String(fold);
-  stage.style.setProperty("--kui-slat-count", String(count));
-  stage.style.setProperty("--kui-slat-dx", travel.x.toFixed(4));
-  stage.style.setProperty("--kui-slat-dy", travel.y.toFixed(4));
-  const paint = imagePaintStyle(img, win);
-  const slats = [];
-  for (let index = 0; index < count; index++) {
-    const slat = doc.createElement("div");
-    slat.className = SLAT_CLASS;
-    slat.style.setProperty("--kui-slat-index", String(index));
-    slat.style.setProperty("--kui-i", String(slatOrder(index, count, from)));
-    slat.style.backgroundImage = `url("${url}")`;
-    slat.style.backgroundSize = paint.size;
-    slat.style.backgroundPosition = paint.position;
-    stage.append(slat);
-    slats.push(slat);
-  }
-  el.append(stage);
-  const bands = { slats, angleDegrees };
-  syncStageToImage(stage, img, bands);
-  const stopWatching = watchImageBox(stage, img, win, bands);
-  const imageStyles = createStyleLedger(img);
-  imageStyles.set("visibility", "hidden");
-  return {
-    stage,
-    slats,
-    restore: () => {
-      stopWatching();
-      imageStyles.restore();
-      stage.remove();
-    }
-  };
-}
-function applySlatTimingVars(stage, 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`;
-  stage.style.setProperty("--kui-duration", duration);
-  stage.style.setProperty("--kui-delay", delay);
-  stage.style.setProperty("--kui-ease", easing ?? params.text("ease", "ease-out"));
-  stage.style.setProperty("--kui-stagger", params.text("stagger", "60ms"));
-}
-function slatAssembleFinishMs(params, count) {
-  if (count === 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", 60);
-  return delayMs + (count - 1) * staggerMs + durationMs;
-}
-
-// 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_CSS_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"
-  }),
-  // `geometry.distance` only, not `...geometry`: `kui-blur-up` (media.css) reads `--kui-distance`
-  // and `--kui-blur` but never `--kui-to-scale` — this primitive doesn't even declare
-  // `CHANNEL.scale`. Spreading the whole shared object used to expose `scale:` as an
-  // apparently-valid, silently-inert parameter, the same shape `flip-3d`'s dead `perspective`
-  // parameter was (`entrance.css`'s comment on `kui-flip-in-x`).
-  cssPrimitive("media-blur-up", [CHANNEL.translate, CHANNEL.filter], {
-    parameters: {
-      distance: geometry.distance,
-      blur: { type: "length", default: "16px", cssProperty: "--kui-blur" }
-    },
-    perfClass: "paint"
-  }),
-  // No `defaultActivation` — same convention `core.ts`'s `parallax`/`parallax-scale`/
-  // `parallax-rotate`/`scroll-fade`/`desaturate`/`skew`/`progress`/`progress-stroke` already use
-  // for every other `timelines: ['view', 'scroll', ...]` primitive. `resolveActivation`
-  // (`animator.ts`) only consults `defaultActivation` when the author named no activation, and
-  // falls through to `element-config.ts`'s hardcoded `'enter'` when a primitive declares none.
-  // Setting it to `'manual'` here (matching `activations: ['manual']`) looked like the obviously
-  // correct pairing, but it is what actually broke the effect: `effectiveActivation`
-  // (`style-plan.ts`) only converts a stuck `'manual'` into `'enter'` when `config.timeline !==
-  // 'time'` — i.e. only once the author has actually written `timeline:view`/`timeline:scroll`.
-  // Authored bare (no `timeline:`, the sweep's own probe and the likely first thing anyone
-  // tries), `config.timeline` stays the default `'time'`, that conversion never fires, and the
-  // element sits at `data-kui-state="ready"` forever — which is also the state
-  // `entrance.css`'s `[data-kui-state='ready'] { --kui-distance: 0px !important; }` targets, so
-  // every sample read the same permanently-zeroed `--kui-distance`: not a paused animation, a
-  // zeroed one. `timeline:view`/`timeline:scroll` usage is unaffected either way, since a native
-  // timeline resolves to the `'native-timeline'` gate before activation is even consulted.
-  // `geometry.distance` only: `kui-image-parallax-frame` never reads `--kui-to-scale` and this
-  // primitive doesn't declare `CHANNEL.scale` — same dead-parameter shape as `media-blur-up` above.
-  cssPrimitive("media-parallax-frame", [CHANNEL.translate], {
-    parameters: { distance: geometry.distance },
-    timelines: ["view", "scroll"],
-    activations: ["manual"],
-    reducedMotion: "disable"
-  }),
-  // Its own `scale` parameter, not `geometry`: `kui-lightbox-open` opens from a fixed 0.92, never
-  // reading `--kui-to-scale` (or any `distance`, since this primitive doesn't animate position at
-  // all) — the whole shared object was dead weight here. Unlike `media-blur-up`/
-  // `media-parallax-frame`, this primitive *does* declare `CHANNEL.scale`, so the fix is to wire
-  // the keyframe up to a real parameter rather than remove the promise: `--kui-from-scale`, the
-  // same name and "starts at this scale, animates to 1" meaning `scale`/`scale-move`
-  // (`catalog/core.ts`) already use, so `lightbox-open scale:0.8` now does what it looks like it
-  // should. See `kui-lightbox-open` in `media.css`.
-  cssPrimitive("media-lightbox", [CHANNEL.opacity, CHANNEL.scale], {
-    parameters: { scale: { type: "number", default: "0.92", cssProperty: "--kui-from-scale" } }
-  })
-];
-var MEDIA_CSS_PRESETS = [
-  { name: "wipe-up", primitive: "media-wipe", keyframes: "kui-wipe-up", cloak: true },
-  { name: "wipe-down", primitive: "media-wipe", keyframes: "kui-wipe-down", cloak: true },
-  { name: "wipe-left", primitive: "media-wipe", keyframes: "kui-wipe-left", cloak: true },
-  { name: "wipe-right", primitive: "media-wipe", keyframes: "kui-wipe-right", cloak: true },
-  { name: "wipe-circle", primitive: "media-wipe", keyframes: "kui-wipe-circle", cloak: true },
-  { name: "wipe-diagonal", primitive: "media-wipe", keyframes: "kui-wipe-diagonal", cloak: true },
-  { name: "mask-reveal", primitive: "media-mask", keyframes: "kui-mask-reveal", cloak: true },
-  { name: "curtain-reveal", primitive: "media-wipe", keyframes: "kui-curtain-reveal", cloak: true },
-  { 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", cloak: true },
-  { 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" }
-];
-var slatParams = {
-  slats: {
-    type: "number",
-    default: "8",
-    cssProperty: "--kui-slats",
-    minimum: 2,
-    maximum: 24,
-    integer: true
-  },
-  axis: {
-    type: "keyword",
-    default: "vertical",
-    cssProperty: "--kui-axis",
-    values: ["vertical", "horizontal"]
-  },
-  /*
-   * The general form of `axis:`, in degrees: `0deg` is `axis:vertical`, `90deg` is
-   * `axis:horizontal`, and anything between cuts the picture into diagonal bands. An authored
-   * angle wins; leaving it off reads `axis:`, so every existing attribute keeps its meaning.
-   *
-   * `text`, not `angle`, for one reason: `readParams` pre-fills every declared parameter with its
-   * schema default, so a typed default is indistinguishable from an authored value and there would
-   * be no way to tell `angle:0deg` from "no angle, use the axis". An empty default is only possible
-   * on a type that is never written to a stylesheet, which is exactly what `text` is for — and this
-   * value never reaches CSS anyway. `slatAngleDegrees` does the parsing and the range clamp.
-   */
-  angle: { type: "text", default: "", cssProperty: "--kui-slat-angle" },
-  from: {
-    type: "keyword",
-    default: "alternate",
-    cssProperty: "--kui-from",
-    values: ["alternate", "start", "end", "edges", "random-ish"]
-  },
-  fold: { type: "keyword", default: "false", cssProperty: "--kui-fold", values: ["true", "false"] },
-  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: "60ms", cssProperty: "--kui-stagger" }
-};
-function prepareSlatAssemble(el, params, ctx) {
-  const doc = el.ownerDocument;
-  const count = Math.min(24, Math.max(2, Math.round(params.num("slats", 8))));
-  const axis = params.text("axis", "vertical");
-  const angleDegrees = slatAngleDegrees(params.text("angle", ""), axis);
-  const from = params.text("from", "alternate");
-  const fold = params.is("fold");
-  const node = el;
-  if (ctx.win.getComputedStyle(node).position === "static") ctx.style.set("position", "relative");
-  const built = installSlatStage(el, doc, ctx.win, { count, angleDegrees, from, fold });
-  if (!built) return () => {
-  };
-  const { stage } = built;
-  applySlatTimingVars(stage, params);
-  stage.classList.add("kui-slat-animating");
-  let settle2;
-  const finished = new Promise((resolve) => {
-    settle2 = resolve;
-  });
-  let landed = false;
-  const land = () => {
-    if (landed) return;
-    landed = true;
-    stage.classList.remove("kui-slat-animating");
-    built.restore();
-    settle2();
-  };
-  const timer = ctx.win.setTimeout(land, slatAssembleFinishMs(params, count));
-  return {
-    cleanup: () => {
-      ctx.win.clearTimeout(timer);
-      if (landed) return;
-      landed = true;
-      built.restore();
-    },
-    finished,
-    finish: () => {
-      ctx.win.clearTimeout(timer);
-      land();
-    }
-  };
-}
-var MEDIA_JS_PRIMITIVES = [
-  {
-    id: "slat-assemble",
-    renderer: "javascript",
-    channels: [CHANNEL.opacity, CHANNEL.translate, CHANNEL.rotate],
-    parameters: slatParams,
-    supportedTimelines: ["time"],
-    supportedActivations: ["load", "enter", "hover", "focus", "click", "manual"],
-    defaultActivation: "enter",
-    perfClass: "dom-transform",
-    // Same reasoning as every JS-rendered primitive in `text.ts`: nothing here declares a CSS
-    // `animation-duration` the reduced-motion policy layer could shorten, and `disable` is what
-    // stops `installSlatStage`'s DOM surgery from ever running at all under reduced motion — the
-    // animator never calls `activate()`, so the wrapped `<img>` is simply left exactly as authored.
-    reducedMotion: "disable",
-    // Land()ing hands the picture back to the real `<img>` and tears down every slat — see
-    // `prepareSlatAssemble`'s `land()`. Declared, not assumed: see `restoresOnFinish`'s own comment
-    // in `core/types.ts` for why the catalog's default is the opposite of this.
-    restoresOnFinish: true,
-    prepare: deferPrepare(prepareSlatAssemble)
-  }
-];
-var MEDIA_JS_PRESETS = [
-  { name: "slat-assemble", primitive: "slat-assemble", cloak: true }
-];
-var MEDIA_PRIMITIVES = [...MEDIA_CSS_PRIMITIVES, ...MEDIA_JS_PRIMITIVES];
-var MEDIA_PRESETS = [...MEDIA_CSS_PRESETS, ...MEDIA_JS_PRESETS];
-function registerMedia(registry) {
-  return registry.registerPrimitives(MEDIA_PRIMITIVES).registerPresets(MEDIA_PRESETS);
-}
-
-// src/effects/catalog/subtree-capture.ts
-function captureChildren(el) {
-  const authored = Array.from(el.childNodes);
-  return () => {
-    el.replaceChildren(...authored);
-  };
-}
-
-// src/effects/catalog/numbers-shared.ts
-var SR_ONLY_CLASS = "kui-sr-only";
-var DECORATIVE_CLASS = "kui-count-decorative";
-function installCountLayers(el, doc) {
-  const restoreChildren = captureChildren(el);
-  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: restoreChildren
-  };
-}
-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]),
-  // `from` gives `progress-bar` a real knob on its start scale — it had none before. `--kui-bar-from`
-  // is also what the `[data-kui-fx~='progress-bar'][data-kui-state='ready']` gate in numbers.css
-  // neutralizes; see that rule's comment for the on:enter fix this parameter doubles as.
-  cssPrimitive("meter-bar", [CHANNEL.scale], {
-    parameters: { from: { type: "number", default: "0", cssProperty: "--kui-bar-from" } }
-  }),
-  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" },
-  // `cloak: true`: `kui-progress-bar`'s `from { scale: 0 1 }` (numbers.css) is a zero-width box
-  // while paused, not just an invisible one — so while it waits it occupies no space in layout at
-  // all. Not, despite the tidier story, because an observer refuses to fire on it: Chromium was
-  // measured resolving a zero-area target's `intersectionRatio` to `1`. See numbers.css's
-  // `[data-kui-fx~='progress-bar'][data-kui-state='ready']` rule for the geometry half of the fix;
-  // `cloak` keeps the pre-JS and post-JS "waiting" look the same (invisible) either side of it.
-  { name: "progress-bar", primitive: "meter-bar", keyframes: "kui-progress-bar", cloak: true },
-  { 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 restoreChildren = captureChildren(el);
-  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: restoreChildren
-  };
-}
-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 textSweepParams = {
-  color: { type: "color", default: "currentColor", cssProperty: "--kui-sweep-color" }
-};
-var extrudeParams = {
-  angle: { type: "angle", default: "-20deg", cssProperty: "--kui-from-angle" },
-  distance: { type: "length", default: "32px", cssProperty: "--kui-distance" }
-};
-var TEXT_CSS_PRIMITIVES = [
-  // `color`, alongside `background`: both presets' unconditional rule sets `-webkit-text-fill-color:
-  // transparent` so the `background-image` gradient shows through the glyphs (the standard
-  // gradient-text technique). That is a real claim on the glyph fill, the same physical property
-  // `text-outline-fill` animates on its own `color` channel below — without this, the two looked
-  // disjoint to the compiler (`background` vs `stroke`+`color`) and composing them would let
-  // whichever applied last silently win the glyph fill instead of being flagged as a conflict.
-  cssPrimitive("text-shimmer", [CHANNEL.background, CHANNEL.color], { reducedMotion: "disable" }),
-  // `gradient-sweep` is the only one of the three `text-sweep`-family presets whose keyframe
-  // touches `-webkit-text-fill-color` (see text.css) — `highlight-sweep` and `underline-draw` only
-  // paint a `background-image`. Claiming `color` for all three made the compiler reject compositions
-  // like `underline-draw, text-outline-fill` as a glyph-fill conflict even though they touch disjoint
-  // properties. Split so only the preset that actually claims the fill declares the channel.
-  cssPrimitive("text-gradient-sweep", [CHANNEL.background, CHANNEL.color], { parameters: textSweepParams }),
-  cssPrimitive("text-sweep", [CHANNEL.background], { parameters: textSweepParams }),
-  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 }),
-  /*
-   * `defaultActivation: 'load'` for the same reason every ambient primitive declares it, and it
-   * was missing here: a marquee is continuous motion, so `reducedMotion: 'disable'` is only half
-   * the rule `ambient.ts` spells out — the other half is starting on `load` rather than waiting on
-   * a scroll-triggered `enter`.
-   *
-   * Without it, a bare `data-kui="marquee 42s"` resolved to `enter`, which `style-plan.ts`'s
-   * `resolveGate` sends down the `deferred` path and stamps `animation-play-state: paused`. It
-   * compiled correctly, reported `data-kui-state="ready"`, and never ran — measured on a marquee
-   * fully in view, so this was not an observer that had simply not fired yet. Every page carrying
-   * one had to know to write `on:load`, which is exactly the kind of thing an author cannot be
-   * expected to guess.
-   *
-   * `marquee-scroll-linked` is unaffected: its position comes from `animation-timeline: scroll()`,
-   * not from an activation.
-   */
-  cssPrimitive("text-marquee", [CHANNEL.translate], {
-    timelines: ["time", "scroll"],
-    defaultActivation: "load",
-    reducedMotion: "disable"
-  }),
-  cssPrimitive("redaction-reveal", [CHANNEL.clip]),
-  cssPrimitive("text-3d-extrude", [CHANNEL.rotate, CHANNEL.translate], { parameters: extrudeParams })
-];
-var TEXT_CSS_PRESETS = [
-  { name: "gradient-shimmer", primitive: "text-shimmer", keyframes: "kui-gradient-shimmer" },
-  { name: "gradient-sweep", primitive: "text-gradient-sweep", keyframes: "kui-gradient-sweep" },
-  {
-    name: "highlight-sweep",
-    primitive: "text-sweep",
-    keyframes: "kui-highlight-sweep",
-    params: { color: "gold" }
-  },
-  { 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 totalTicks = Math.max(1, graphemes.length * revealEvery);
-  const run = createStepRunner(ctx.win, {
-    delayMs: params.timing.delayMs ?? 0,
-    stepMs: stepMsFor(params, totalTicks, Math.max(1, 700 / totalTicks)),
-    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 restoreChildren = captureChildren(el);
-  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");
-      restoreChildren();
-    },
-    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" }, cloak: true },
-  { name: "text-reveal-down", primitive: "split-text", params: { unit: "words", direction: "down" }, cloak: true },
-  { name: "text-reveal-mask", primitive: "split-text", params: { unit: "lines", direction: "mask" }, cloak: true },
-  { 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 ENTRANCE_TIMELINES = ["time", "view", "scroll", "pin"];
-var PRIMITIVES = [
-  // --- entrance / exit -------------------------------------------------------------------
-  cssPrimitive("reveal", [CHANNEL.opacity, CHANNEL.translate], { timelines: ENTRANCE_TIMELINES, parameters: distance }),
-  cssPrimitive("scale", [CHANNEL.scale], {
-    timelines: ENTRANCE_TIMELINES,
-    parameters: { scale: { type: "number", default: "0.92", cssProperty: "--kui-from-scale" } }
-  }),
-  // Separate from `scale` because it claims translate as well and so composes differently.
-  // `distance.distance` only, not `...distance`: `kui-zoom-in-up`/`-down` (entrance.css) read
-  // `--kui-distance` and `--kui-from-scale` but never `--kui-from-opacity` — this primitive
-  // doesn't declare `CHANNEL.opacity`. Spreading the whole shared `distance` object used to expose
-  // `opacity:` as an apparently-valid, silently-inert parameter (same dead-parameter shape as
-  // `flip-3d`'s old `perspective`, fixed above).
-  cssPrimitive("scale-move", [CHANNEL.scale, CHANNEL.translate], {
-    timelines: ENTRANCE_TIMELINES,
-    parameters: {
-      distance: distance.distance,
-      scale: { type: "number", default: "0.92", cssProperty: "--kui-from-scale" }
-    }
-  }),
-  cssPrimitive("rotate", [CHANNEL.rotate], {
-    timelines: ENTRANCE_TIMELINES,
-    parameters: { angle: { type: "angle", default: "-8deg", cssProperty: "--kui-from-angle" } }
-  }),
-  // `distance.distance` only, not `...distance`: `kui-roll-in`/`-out` (entrance.css) write
-  // `rotate`/`translate`, never `opacity` — this primitive doesn't declare `CHANNEL.opacity`. Same
-  // dead-parameter shape as `scale-move` above.
-  cssPrimitive("roll", [CHANNEL.rotate, CHANNEL.translate], {
-    timelines: ENTRANCE_TIMELINES,
-    parameters: {
-      distance: distance.distance,
-      angle: { type: "angle", default: "-120deg", cssProperty: "--kui-from-angle" }
-    }
-  }),
-  // `skew`, not `rotate`: entrance.css's keyframes write `transform: perspective(...)
-  // rotateX/Y(...)`, not the individual `rotate:` property — the `perspective` parameter below
-  // used to compile cleanly and do nothing, because nothing read it. See entrance.css's own
-  // comment on `kui-flip-in-x` for the fix; `CHANNEL.skew` is this catalog's name for "claims the
-  // whole `transform` shorthand" (`core/types.ts`), shared with `scroll-skew` and `flip-face`.
-  cssPrimitive("flip-3d", [CHANNEL.skew], {
-    timelines: ENTRANCE_TIMELINES,
-    parameters: {
-      angle: { type: "angle", default: "90deg", cssProperty: "--kui-from-angle" },
-      perspective: { type: "length", default: "1200px", cssProperty: "--kui-perspective" }
-    }
-  }),
-  cssPrimitive("blur", [CHANNEL.filter], {
-    timelines: ENTRANCE_TIMELINES,
-    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], {
-    timelines: ENTRANCE_TIMELINES,
-    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:`.
-  // `distance.distance` only, not the whole `distance` object: `kui-parallax-y`/`-x` (scroll.css)
-  // write only `translate` — this primitive doesn't declare `CHANNEL.opacity`. Same dead-parameter
-  // shape as `scale-move`/`roll` above; `parallax-y`/`parallax-x`/`depth-layer` never read
-  // `--kui-from-opacity`.
-  cssPrimitive("parallax", [CHANNEL.translate], {
-    parameters: { distance: distance.distance },
-    timelines: ["view", "scroll", "pin"],
-    activations: ["manual"],
-    reducedMotion: "disable",
-    perfClass: "compositor"
-  }),
-  // `from` exists because the resting end was hardcoded (scale 1 / rotate 0deg), which fixed
-  // these to "grow slightly" and "tilt slightly" — a scroll-driven element that should sweep in
-  // from a quarter-size or from half a turn away had no way to say so. Same `--kui-from-*`
-  // properties the entrance primitives already use, so the two stay spellable the same way.
-  cssPrimitive("parallax-scale", [CHANNEL.scale], {
-    parameters: {
-      scale: { type: "number", default: "1.2", cssProperty: "--kui-to-scale" },
-      from: { type: "number", default: "1", cssProperty: "--kui-from-scale" }
-    },
-    timelines: ["view", "scroll", "pin"],
-    activations: ["manual"],
-    reducedMotion: "disable"
-  }),
-  cssPrimitive("parallax-rotate", [CHANNEL.rotate], {
-    parameters: {
-      angle: { type: "angle", default: "12deg", cssProperty: "--kui-to-angle" },
-      from: { type: "angle", default: "0deg", cssProperty: "--kui-from-angle" }
-    },
-    timelines: ["view", "scroll", "pin"],
-    activations: ["manual"],
-    reducedMotion: "disable"
-  }),
-  cssPrimitive("scroll-fade", [CHANNEL.opacity], {
-    parameters: { opacity: { type: "number", default: "0", cssProperty: "--kui-from-opacity" } },
-    timelines: ["view", "scroll", "pin"],
-    activations: ["manual"],
-    reducedMotion: "disable"
-  }),
-  // `filter`, not `opacity` — it collides with `blur`, and declaring the real channel is what
-  // makes `channels.ts` say so instead of letting the two silently overwrite each other's
-  // `filter` declaration.
-  cssPrimitive("desaturate", [CHANNEL.filter], {
-    parameters: {
-      from: { type: "percentage", default: "100%", cssProperty: "--kui-from-grayscale" },
-      to: { type: "percentage", default: "0%", cssProperty: "--kui-to-grayscale" }
-    },
-    timelines: ["view", "scroll", "pin"],
-    activations: ["manual"],
-    reducedMotion: "disable",
-    perfClass: "paint"
-  }),
-  /*
-   * `transform`, not one of the independent transform properties, because CSS never shipped a
-   * standalone `skew:`. That is also why `skew` is its own channel rather than folded in with
-   * `rotate`: writing `transform` replaces the entire shorthand, so a skew composed with anything
-   * else that wrote `transform` would silently win. Nothing else in the catalog does — every other
-   * transform in the library goes through `translate`/`rotate`/`scale` — so the shorthand is free.
-   */
-  cssPrimitive("skew", [CHANNEL.skew], {
-    parameters: {
-      from: { type: "angle", default: "8deg", cssProperty: "--kui-from-skew" },
-      to: { type: "angle", default: "0deg", cssProperty: "--kui-to-skew" }
-    },
-    timelines: ["view", "scroll", "pin"],
-    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 pIn = (name, primitive, keyframes, params) => ({ ...p(name, primitive, keyframes, params), cloak: true });
-var FADE = [
-  pIn("fade-in", "reveal", "kui-in"),
-  p("fade-out", "reveal", "kui-out"),
-  pIn("fade-up", "reveal", "kui-in-up"),
-  pIn("fade-down", "reveal", "kui-in-down"),
-  pIn("fade-left", "reveal", "kui-in-left"),
-  pIn("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 = [
-  pIn("slide-up", "reveal", "kui-in-up", SLIDE_PARAMS),
-  pIn("slide-down", "reveal", "kui-in-down", SLIDE_PARAMS),
-  pIn("slide-left", "reveal", "kui-in-left", SLIDE_PARAMS),
-  pIn("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 = [
-  pIn("slide-inline-start", "reveal", "kui-in-inline-start", SLIDE_PARAMS),
-  pIn("slide-inline-end", "reveal", "kui-in-inline-end", SLIDE_PARAMS),
-  pIn("slide-block-start", "reveal", "kui-in-up", SLIDE_PARAMS),
-  pIn("slide-block-end", "reveal", "kui-in-down", SLIDE_PARAMS)
-];
-var ZOOM = [
-  pIn("zoom-in", "scale", "kui-zoom-in"),
-  p("zoom-out", "scale", "kui-zoom-out"),
-  pIn("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" }),
-  pIn("zoom-in-up", "scale-move", "kui-zoom-in-up"),
-  pIn("zoom-in-down", "scale-move", "kui-zoom-in-down")
-];
-var FLIP = [
-  pIn("flip-in-x", "flip-3d", "kui-flip-in-x"),
-  pIn("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 = [
-  pIn("rotate-in", "rotate", "kui-rotate-in"),
-  p("rotate-out", "rotate", "kui-rotate-out"),
-  pIn("rotate-in-left", "rotate", "kui-rotate-in", { angle: "-45deg" }),
-  pIn("rotate-in-right", "rotate", "kui-rotate-in", { angle: "45deg" }),
-  pIn("roll-in", "roll", "kui-roll-in"),
-  p("roll-out", "roll", "kui-roll-out"),
-  pIn("swing-in", "rotate", "kui-swing-in", { angle: "-15deg", ease: "back-out" })
-];
-var BLUR = [
-  pIn("blur-in", "blur", "kui-blur-in"),
-  p("blur-out", "blur", "kui-blur-out"),
-  pIn("fade-blur-up", "reveal-blur", "kui-fade-blur-up"),
-  pIn("fade-blur-in", "reveal-blur", "kui-fade-blur-in")
-];
-var CHARACTER = [
-  pIn("bounce-in", "scale", "kui-zoom-in", { scale: "0.3", ease: "bounce" }),
-  pIn("bounce-in-up", "reveal", "kui-in-up", { distance: "60px", ease: "back-out" }),
-  pIn("bounce-in-down", "reveal", "kui-in-down", { distance: "60px", ease: "back-out" }),
-  pIn("back-in-up", "reveal", "kui-in-up", { distance: "120px", ease: "expo-out" }),
-  pIn("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-desaturate", "desaturate", "kui-desaturate"),
-  p("scroll-skew", "skew", "kui-scroll-skew"),
-  p("scroll-progress-bar", "progress", "kui-progress-x"),
-  p("scroll-progress-bar-y", "progress", "kui-progress-y"),
-  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.
-  pIn("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/step-marking.ts
-var STEP_STATE_ATTR = "data-kui-step-state";
-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 resolveTarget(selector, ctx, effect) {
-  if (!selector) return selector;
-  const breadth = selectorBreadth(selector, ctx.doc);
-  if (breadth === "invalid") {
-    ctx.warn(`${effect} target "${selector}" is not a valid selector and will be ignored`);
-    return "";
-  }
-  if (breadth === "document-wide") {
-    ctx.warn(`${effect} target "${selector}" matches the whole document and will be ignored`);
-    return "";
-  }
-  return selector;
-}
-function createStepMarker(resolve) {
-  const ledgers = /* @__PURE__ */ new Map();
-  return {
-    mark(index) {
-      const seen = /* @__PURE__ */ new Map();
-      for (const node of resolve()) {
-        const parent = node.parentElement;
-        const position = seen.get(parent) ?? 0;
-        seen.set(parent, position + 1);
-        let ledger = ledgers.get(node);
-        if (!ledger) {
-          ledger = createAttributeLedger(node);
-          ledgers.set(node, ledger);
-        }
-        ledger.set(STEP_STATE_ATTR, stepStateFor(position, index));
-      }
-    },
-    restore() {
-      for (const ledger of ledgers.values()) ledger.restore();
-      ledgers.clear();
-    }
-  };
-}
-function stepStateFor(position, index) {
-  if (position < index) return "before";
-  if (position === index) return "active";
-  return "after";
-}
-
-// 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()
-};
-function prepareSiblingScale(cssProperty) {
-  return (el, params) => {
-    const sibling = el.nextElementSibling;
-    sibling?.style.setProperty(cssProperty, String(params.num("scale", 1)));
-    return () => sibling?.style.removeProperty(cssProperty);
-  };
-}
-function siblingScalePrimitive(id, cssProperty) {
-  return {
-    id,
-    renderer: "javascript",
-    channels: [CHANNEL.translate, CHANNEL.scale, CHANNEL.opacity, CHANNEL.stroke, CHANNEL.color],
-    parameters: { scale: { type: "number", default: "1", cssProperty } },
-    supportedTimelines: ["time"],
-    supportedActivations: ["load"],
-    defaultActivation: "load",
-    perfClass: "compositor",
-    reducedMotion: "disable",
-    prepare: deferPrepare(prepareSiblingScale(cssProperty))
-  };
-}
-var TOGGLE_MORPH_PRIMITIVE = siblingScalePrimitive("toggle-morph", "--kui-toggle-scale");
-var RADIO_FILL_PRIMITIVE = siblingScalePrimitive("radio-fill", "--kui-radio-scale");
-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, ctx) {
-  const total = Math.max(1, Math.round(params.num("steps", 4)));
-  const selector = resolveTarget(params.text("target"), ctx, "step-progress");
-  const marker = createStepMarker(
-    () => selector ? ctx.doc.querySelectorAll(selector) : el.children
-  );
-  const self = createAttributeLedger(el);
-  let step = 0;
-  const render = () => {
-    self.set("data-kui-step", String(step));
-    marker.mark(step);
-  };
-  const advance = () => {
-    step = nextStep(step, total);
-    render();
-  };
-  el.addEventListener("click", advance);
-  render();
-  return () => {
-    el.removeEventListener("click", advance);
-    self.restore();
-    marker.restore();
-  };
-}
-var STEP_PROGRESS_PRIMITIVE = jsInputPrimitive(
-  "step-progress",
-  ["state"],
-  {
-    steps: { type: "number", default: "4", cssProperty: "--kui-steps", minimum: 1, maximum: 20, integer: true },
-    target: { type: "text", default: "", cssProperty: "--kui-target" }
-  },
-  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,
-  TOGGLE_MORPH_PRIMITIVE,
-  RADIO_FILL_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: "toggle-morph" },
-  { name: "checkbox-draw", primitive: "native-state" },
-  { name: "radio-fill", primitive: "radio-fill" },
-  { 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;
-  let longPressFired = false;
-  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;
-    longPressFired = false;
-    el.setPointerCapture?.(event.pointerId);
-    if (longPressMs > 0) {
-      longPressTimer = deps.setTimer(() => {
-        longPressFired = true;
-        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);
-    } else if (longPressFired) {
-      handlers.onEnd?.(vector, sample);
-    }
-    origin = null;
-    active = false;
-    longPressFired = 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
-  },
-  mass: {
-    type: "number",
-    default: "1",
-    cssProperty: "--kui-mass",
-    finite: true,
-    minimum: 0.1
-  }
-};
-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),
-    mass: params.num("mass", DEFAULT_SPRING.mass)
-  };
-}
-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 resistance = params.num("resistance", 0.55);
-  const momentum = params.num("momentum", 0.2);
-  const offset = { x: 0, y: 0 };
-  const pickup = { 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();
-        pickup.x = offset.x;
-        pickup.y = offset.y;
-        el.setAttribute("data-kui-dragging", "true");
-      },
-      onMove(vector) {
-        write({
-          x: resist(pickup.x + vector.dx, bounds, resistance),
-          y: resist(pickup.y + vector.dy, bounds, resistance)
-        });
-      },
-      onEnd(vector) {
-        el.setAttribute("data-kui-dragging", "false");
-        settle(runners, offset, vector, { returns, inertia, momentum });
-      }
-    },
-    { axis: params.text("axis", "both") }
-  );
-  ctx.invalidate();
-  return () => {
-    stopRecognising();
-    runners.x.stop();
-    runners.y.stop();
-    el.removeAttribute("data-kui-dragging");
-  };
-}
-function resist(delta, bounds, tension) {
-  return bounds > 0 ? rubberBand(delta, bounds, tension) : 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;
-  }
-  const carry = mode.inertia ? mode.momentum : 0;
-  runners.x.to(offset.x + vector.vx * carry);
-  runners.y.to(offset.y + vector.vy * carry);
-}
-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"]
-      },
-      resistance: {
-        type: "number",
-        default: "0.55",
-        cssProperty: "--kui-resistance",
-        finite: true,
-        minimum: 0,
-        maximum: 1
-      },
-      momentum: { type: "number", default: "0.2", cssProperty: "--kui-momentum", finite: true }
-    },
-    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;
-  let previous = node.getBoundingClientRect().height;
-  const observer = watchAttribute(node, params.text("attribute"), () => {
-    animation?.cancel();
-    const endpoints = heightEndpoints(node, previous);
-    previous = endpoints.to;
-    animation = animateHeight(node, endpoints, duration, params.text("ease"));
-  });
-  ctx.invalidate();
-  return () => {
-    observer();
-    animation?.cancel();
-  };
-}
-function heightEndpoints(node, previous) {
-  node.style.removeProperty("height");
-  const to = node.getBoundingClientRect().height;
-  return { from: previous, to };
-}
-function animateHeight(node, endpoints, duration, easing) {
-  const animate = node.animate;
-  if (typeof animate !== "function") return null;
-  return animate.call(
-    node,
-    [{ height: `${endpoints.from}px` }, { height: `${endpoints.to}px` }],
-    { 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);
-  const state = createAttributeLedger(el);
-  const unsubscribe = 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));
-    state.set("data-kui-shrunk", String(progress >= 1));
-  });
-  return () => {
-    unsubscribe();
-    state.restore();
-  };
-}
-function prepareHeaderHide(el, params, ctx) {
-  const minDelta = params.num("offset", 8);
-  let last = 0;
-  const state = createAttributeLedger(el);
-  const unsubscribe = subscribeScrollTop(el, ctx, (top) => {
-    const delta = top - last;
-    if (Math.abs(delta) < minDelta) return;
-    state.set("data-kui-hidden", String(delta > 0 && top > minDelta));
-    last = top;
-  });
-  return () => {
-    unsubscribe();
-    state.restore();
-  };
-}
-function prepareBackToTop(el, params, ctx) {
-  const offset = params.num("offset", 400);
-  const state = createAttributeLedger(el);
-  const unsubscribe = subscribeScrollTop(el, ctx, (top) => {
-    state.set("data-kui-visible", String(top > offset));
-  });
-  return () => {
-    unsubscribe();
-    state.restore();
-  };
-}
-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 };
-};
-var domPosition = (el) => {
-  const view = el.ownerDocument?.defaultView;
-  return view ? view.getComputedStyle(el).position : "static";
-};
-var domOffsetTop = (el) => {
-  const view = el.ownerDocument?.defaultView;
-  if (!view) return 0;
-  const parsed = Number.parseFloat(view.getComputedStyle(el).top);
-  return Number.isFinite(parsed) ? parsed : 0;
-};
-function geometrySource(el, positionOf) {
-  let outermostSticky = null;
-  for (let node = el; node; node = node.parentElement) {
-    if (positionOf(node) === "sticky") outermostSticky = node;
-  }
-  return outermostSticky?.parentElement ?? el;
-}
-function sourceTop(el, box, measure, positionOf) {
-  const source = geometrySource(el, positionOf);
-  return source === el ? box.top : measure(source).top;
-}
-function trackProgress(el, ctx, options, onProgress) {
-  const measure = options.measure ?? domGeometry;
-  const positionOf = options.positionOf ?? domPosition;
-  const offsetOf = options.offsetOf ?? domOffsetTop;
-  let scrollTop = 0;
-  let scrollportTop = 0;
-  const geometry2 = createMeasureCache(() => {
-    const box = measure(el);
-    const top = options.contentAnchor ? measure(options.contentAnchor).top - box.height : sourceTop(el, box, measure, positionOf);
-    const stickyOffset = options.stickyEl ? offsetOf(options.stickyEl) : 0;
-    return { contentTop: top - stickyOffset - 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/scroll-spy.ts
-function prepareScrollSpy(el, params, ctx) {
-  const sectionsAuthored = params.text("sections");
-  if (sectionsAuthored) {
-    const sectionsSelector = resolveTarget(sectionsAuthored, ctx, "scroll-spy sections");
-    return prepareScrollSpyContainer(el, params, ctx, sectionsSelector);
-  }
-  return prepareScrollSpySingle(el, params, ctx);
-}
-function prepareScrollSpySingle(el, params, ctx) {
-  if (params.text("offset-top", "0px") !== "0px") {
-    ctx.warn('scroll-spy "offset-top" has no effect without sections: and is ignored here');
-  }
-  const selector = resolveTarget(params.text("target"), ctx, "scroll-spy");
-  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 continuousSetup(() => {
-    untrack();
-    self.restore();
-    for (const ledger of links.values()) ledger.restore();
-  });
-}
-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 hrefHash(link) {
-  const href = link.getAttribute("href") ?? "";
-  const at = href.indexOf("#");
-  return at === -1 ? "" : href.slice(at);
-}
-function pairSectionsWithLinks(sections, links, ctx, sectionsSelector) {
-  const linksByHash = /* @__PURE__ */ new Map();
-  for (const link of links) {
-    const hash = hrefHash(link);
-    if (hash) linksByHash.set(hash, link);
-  }
-  const claimed = /* @__PURE__ */ new Set();
-  const pairs = sections.map((section) => {
-    if (!section.id) {
-      ctx.warn(
-        `scroll-spy: a section matched by sections:"${sectionsSelector}" has no id and cannot be paired with a link`
-      );
-      return { section, link: null };
-    }
-    const hash = `#${section.id}`;
-    const link = linksByHash.get(hash) ?? null;
-    if (link) claimed.add(hash);
-    return { section, link };
-  });
-  for (const [hash, link] of linksByHash) {
-    if (!claimed.has(hash)) {
-      ctx.warn(`scroll-spy: link "${link.getAttribute("href")}" matches no section id in sections:"${sectionsSelector}"`);
-    }
-  }
-  return pairs;
-}
-function offsetTopPixels(authored, frame) {
-  return toPixels(
-    authored,
-    {
-      viewportWidth: frame.metrics.viewportWidth,
-      viewportHeight: frame.metrics.viewportHeight,
-      percentBasis: 0,
-      fontSize: 16,
-      rootFontSize: 16
-    },
-    0
-  );
-}
-function highestReachedIndex(tops, scrollTop, line) {
-  let index = -1;
-  for (let i = 0; i < tops.length; i++) {
-    if (tops[i] - scrollTop - line <= 0) index = i;
-  }
-  return index;
-}
-function prepareScrollSpyContainer(el, params, ctx, sectionsSelector) {
-  if (params.text("distance", "100vh") !== "100vh") {
-    ctx.warn('scroll-spy "distance" has no effect with sections: \u2014 each section measures its own height');
-  }
-  const linksSelector = resolveTarget(params.text("target"), ctx, "scroll-spy target");
-  const sections = sectionsSelector ? [...el.querySelectorAll(sectionsSelector)] : [];
-  if (sectionsSelector && sections.length === 0) {
-    ctx.warn(`scroll-spy sections:"${sectionsSelector}" matched nothing inside this element`);
-  }
-  const links = linksSelector ? [...el.querySelectorAll(linksSelector)] : [];
-  const pairs = pairSectionsWithLinks(sections, links, ctx, sectionsSelector);
-  const sectionLedgers = pairs.map((pair) => createAttributeLedger(pair.section));
-  const linkLedgers = /* @__PURE__ */ new Map();
-  for (const { link } of pairs) {
-    if (link && !linkLedgers.has(link)) linkLedgers.set(link, createAttributeLedger(link));
-  }
-  const offsetAuthored = params.text("offset-top", "0px");
-  let scrollTop = 0;
-  let scrollportTop = 0;
-  const contentTops = createMeasureCache(
-    () => pairs.map(({ section }) => domGeometry(section).top - scrollportTop + scrollTop)
-  );
-  let active = -1;
-  function setActive(index, value) {
-    const pair = pairs[index];
-    sectionLedgers[index].set("data-kui-active", String(value));
-    if (pair.link) linkLedgers.get(pair.link).set("data-kui-active", String(value));
-  }
-  const untrack = ctx.scheduler.subscribe(ctx.rootFor(el), (frame) => {
-    scrollTop = frame.metrics.scrollTop;
-    scrollportTop = frame.metrics.viewportTop;
-    const tops = contentTops.read(frame.epoch);
-    const line = offsetTopPixels(offsetAuthored, frame);
-    const next = highestReachedIndex(tops, scrollTop, line);
-    if (next === active) return;
-    if (active !== -1) setActive(active, false);
-    if (next !== -1) setActive(next, true);
-    active = next;
-  });
-  return continuousSetup(() => {
-    untrack();
-    for (const ledger of sectionLedgers) ledger.restore();
-    for (const ledger of linkLedgers.values()) ledger.restore();
-  });
-}
-
-// src/effects/scroll-mechanics/primitives.ts
-var PROGRESS_VAR = "--kui-progress";
-var distanceParam = {
-  distance: { type: "length", default: "100vh", cssProperty: "--kui-distance" }
-};
-var stickyParams = {
-  "offset-top": {
-    type: "length",
-    default: "var(--kui-pin-offset, 0px)",
-    cssProperty: "--kui-offset-top"
-  },
-  spacer: {
-    type: "keyword",
-    default: "false",
-    cssProperty: "--kui-spacer",
-    values: ["true", "false"]
-  }
-};
-function installSticky(node, params, ctx) {
-  ctx.style.set("position", "sticky");
-  ctx.style.set("top", params.text("offset-top", "var(--kui-pin-offset, 0px)"));
-  const inserted = params.is("spacer") ? insertSpacer(node, params.text("distance"), ctx) : null;
-  return { spacer: inserted?.spacer ?? null, dispose: () => inserted?.remove() };
-}
-function scrollPrimitive(spec) {
-  const { id, channels, parameters, prepare, perfClass = "compositor" } = spec;
-  return {
-    id,
-    renderer: "javascript",
-    channels,
-    parameters,
-    // `'pin'` is accepted but ignored: these primitives read scroll position themselves and are
-    // never driven by an `animation-timeline`. It is listed so that composing the driver with the
-    // effects it drives — `data-kui="pin-section distance:200vh, parallax-rotate ... "` plus
-    // `timeline:pin` — survives `compile.ts`'s `intersect`. Without it the intersection empties,
-    // `style-plan.ts` refuses the timeline, and the scrub silently degrades to a one-shot.
-    supportedTimelines: ["time", "view", "scroll", "pin"],
-    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;
-  const { dispose: unstick } = installSticky(node, params, ctx);
-  const tracked = node.parentElement ?? el;
-  const untrack = trackProgress(tracked, ctx, { distance: params.text("distance"), stickyEl: node }, (progress) => {
-    writeProgress(ctx, progress);
-    el.setAttribute("data-kui-pinned", progress > 0 && progress < 1 ? "true" : "false");
-  });
-  return continuousSetup(() => {
-    untrack();
-    unstick();
-    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: () => {
-      spacer.remove();
-      ctx.invalidate();
-    }
-  };
-}
-function prepareProgress(el, params, ctx) {
-  const steps = Math.max(0, Math.round(params.num("steps", 0)));
-  const selector = resolveTarget(params.text("target"), ctx, "scrollytelling-step");
-  const marker = createStepMarker(() => ctx.doc.querySelectorAll(selector));
-  const self = createAttributeLedger(el);
-  let lastIndex;
-  const untrack = trackProgress(el, ctx, { distance: params.text("distance") }, (progress) => {
-    writeProgress(ctx, progress);
-    if (steps === 0) return;
-    const index = Math.min(steps - 1, Math.floor(progress * steps));
-    if (index === lastIndex) return;
-    lastIndex = index;
-    self.set("data-kui-step", String(index));
-    ctx.style.set("--kui-step", String(index));
-    if (selector) marker.mark(index);
-  });
-  return continuousSetup(() => {
-    untrack();
-    self.restore();
-    marker.restore();
-  });
-}
-function prepareHorizontal(el, params, ctx) {
-  const selector = resolveTarget(params.text("target"), ctx, "horizontal-scroll");
-  if (!selector) return prepareBareTrack(el, params, ctx);
-  const track = el.querySelector(selector);
-  if (!track) {
-    ctx.warn(`horizontal-scroll target "${selector}" matched nothing inside this element`);
-    return () => {
-    };
-  }
-  return prepareManagedTrack(el, track, params, ctx);
-}
-function prepareBareTrack(node, params, ctx) {
-  const authored = params.text("travel", "auto");
-  const travel = createMeasureCache(() => trackTravel(node, authored, node.ownerDocument));
-  return continuousSetup(
-    trackProgress(node, ctx, { distance: params.text("distance") }, (progress, frame) => {
-      ctx.style.set("translate", `${-progress * travel.read(frame.epoch)}px 0`);
-      writeProgress(ctx, progress);
-    })
-  );
-}
-function prepareManagedTrack(host, track, params, ctx) {
-  const offsetTop = params.text("offset-top", "var(--kui-pin-offset, 0px)");
-  ctx.style.set("position", "sticky");
-  ctx.style.set("top", offsetTop);
-  ctx.style.set("height", `calc(100vh - ${offsetTop})`);
-  ctx.style.set("overflow", "hidden");
-  ctx.style.set("display", "grid");
-  ctx.style.set("align-content", "center");
-  const { remove: removeSpacer } = insertSpacer(host, params.text("distance"), ctx);
-  const rail = createStyleLedger(track);
-  rail.set("display", "flex");
-  rail.set("width", "max-content");
-  const authored = params.text("travel", "auto");
-  const travel = createMeasureCache(() => trackTravel(track, authored, track.ownerDocument));
-  const tracked = host.parentElement ?? host;
-  const untrack = trackProgress(tracked, ctx, { distance: params.text("distance"), stickyEl: host }, (progress, frame) => {
-    rail.set("translate", `${-progress * travel.read(frame.epoch)}px 0`);
-    writeProgress(ctx, progress);
-  });
-  return continuousSetup(() => {
-    untrack();
-    rail.restore();
-    removeSpacer();
-  });
-}
-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 managed = params.is("spacer") ? installSticky(el, params, ctx) : null;
-  const contentAnchor = managed?.spacer ?? void 0;
-  const stickyEl = managed ? el : void 0;
-  const selector = resolveTarget(params.text("target"), ctx, "media-scrub");
-  const scrub = selector ? prepareTargetScrub(el, params, ctx, { selector, contentAnchor, stickyEl }) : prepareSrcScrub(el, params, ctx, { contentAnchor, stickyEl });
-  return continuousSetup(() => {
-    scrub();
-    managed?.dispose();
-  });
-}
-function prepareTargetScrub(el, params, ctx, authored) {
-  const { selector, contentAnchor, stickyEl } = authored;
-  const marker = createStepMarker(() => ctx.doc.querySelectorAll(selector));
-  const frames = Math.max(1, ctx.doc.querySelectorAll(selector).length);
-  let lastIndex;
-  const untrack = trackProgress(el, ctx, { distance: params.text("distance"), contentAnchor, stickyEl }, (progress) => {
-    writeProgress(ctx, progress);
-    const index = Math.min(frames - 1, Math.floor(progress * frames));
-    if (index === lastIndex) return;
-    lastIndex = index;
-    marker.mark(index);
-  });
-  marker.mark(0);
-  return () => {
-    untrack();
-    marker.restore();
-  };
-}
-function prepareSrcScrub(el, params, ctx, anchors) {
-  const { contentAnchor, stickyEl } = anchors;
-  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"), contentAnchor, stickyEl }, (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 prepareSmoothScroll(el, params, ctx) {
-  ctx.style.set("scroll-behavior", params.text("behavior", "smooth"));
-  return () => {
-  };
-}
-function prepareSnap(el, params, ctx) {
-  const axis = params.is("axis", "x") ? "x" : "y";
-  ctx.style.set("scroll-snap-type", `${axis} ${params.text("strictness", "mandatory")}`);
-  const selector = resolveTarget(params.text("target"), ctx, "scroll-snap");
-  const items = selector ? [...el.querySelectorAll(selector)] : [...el.children];
-  if (selector && items.length === 0) {
-    ctx.warn(`scroll-snap target "${selector}" matched nothing inside this element`);
-  }
-  if (selector) installSnapContainer(axis, ctx);
-  const childLedgers = items.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();
-  };
-}
-function installSnapContainer(axis, ctx) {
-  ctx.style.set(axis === "x" ? "overflow-x" : "overflow-y", "auto");
-  if (axis === "x") ctx.style.set("display", "flex");
-}
-var SCROLL_PRIMITIVES = [
-  scrollPrimitive({
-    id: "pin",
-    channels: ["layout", "progress"],
-    parameters: {
-      ...distanceParam,
-      ...stickyParams
-    },
-    prepare: deferPrepare(preparePin),
-    perfClass: "layout"
-  }),
-  scrollPrimitive({
-    id: "scroll-progress",
-    channels: ["progress"],
-    parameters: {
-      ...distanceParam,
-      steps: { type: "number", default: "0", cssProperty: "--kui-steps" },
-      // Same name, same shape and the same validation as scroll-spy's: one `target:` convention
-      // across the library rather than a second word for "the elements this effect marks".
-      target: { type: "text", default: "", cssProperty: "--kui-target" }
-    },
-    prepare: deferPrepare(prepareProgress)
-  }),
-  scrollPrimitive({
-    id: "horizontal-track",
-    channels: ["translate", "progress"],
-    parameters: {
-      ...distanceParam,
-      travel: { type: "text", default: "auto", cssProperty: "--kui-travel" },
-      // Same name, same shape and the same validation as scroll-spy's and media-scrub's: one
-      // `target:` convention across the library. Naming the row that moves is also what opts this
-      // primitive into owning the stage, the sticky window and the row's layout itself.
-      target: { type: "text", default: "", cssProperty: "--kui-target" },
-      "offset-top": {
-        type: "length",
-        default: "var(--kui-pin-offset, 0px)",
-        cssProperty: "--kui-offset-top"
-      }
-    },
-    prepare: deferPrepare(prepareHorizontal)
-  }),
-  scrollPrimitive({
-    id: "media-scrub",
-    channels: ["media", "progress"],
-    parameters: {
-      ...distanceParam,
-      // A scrub is a hold, so it needs the same two knobs a pin does. Declaring them here is what
-      // lets `sequence-scrub` become one attribute with no wrapper at all.
-      ...stickyParams,
-      frames: { type: "number", default: "1", cssProperty: "--kui-frames" },
-      src: { type: "text", default: "", cssProperty: "--kui-src" },
-      // The preferred form. `frames:`/`src:` remain for sequences too long to author as tags.
-      target: { type: "text", default: "", cssProperty: "--kui-target" }
-    },
-    prepare: deferPrepare(prepareMediaScrub),
-    perfClass: "paint"
-  }),
-  scrollPrimitive({
-    id: "scroll-spy",
-    channels: ["state"],
-    parameters: {
-      // `distance`: the per-section form only. `offset-top`: the container form only. Each is a
-      // no-op — warned, not silent — in the other; see `prepareScrollSpySingle` and
-      // `prepareScrollSpyContainer`.
-      ...distanceParam,
-      // Same name and meaning in both forms: the link(s) this instance marks. Per-section, the
-      // one link this section names; with `sections:`, every link `target:` matches, each paired
-      // to its own section by `href`. See `prepareScrollSpyContainer`.
-      target: { type: "text", default: "", cssProperty: "--kui-target" },
-      // Presence, not value, selects the container form: authoring this at all switches
-      // `prepareScrollSpy` from one-section-per-instance to one-instance-on-the-shared-ancestor.
-      sections: { type: "text", default: "", cssProperty: "--kui-sections" },
-      "offset-top": { type: "length", default: "0px", cssProperty: "--kui-offset-top" }
-    },
-    prepare: deferPrepare(prepareScrollSpy)
-  }),
-  scrollPrimitive({
-    id: "smooth-scroll",
-    channels: ["layout"],
-    parameters: {
-      behavior: { type: "keyword", default: "smooth", cssProperty: "--kui-scroll-behavior", values: ["smooth", "auto"] }
-    },
-    prepare: deferPrepare(prepareSmoothScroll),
-    perfClass: "layout"
-  }),
-  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"]
-      },
-      // Names the snap items. Also what opts this primitive into owning the scroll container
-      // itself — see `installSnapContainer`. Without it, the direct children are the items and
-      // the page keeps its own `overflow`, exactly as before.
-      target: { type: "text", default: "", cssProperty: "--kui-target" }
-    },
-    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 -------------------------------------------------------------------------------
-  /*
-   * `spacer:true` is what deletes the `.scrub-stage` wrapper a page used to hand-write.
-   *
-   * It could not be switched on until the tracker stopped measuring against the parent. A scrub
-   * makes itself sticky, and `geometrySource` escapes a sticky subtree by taking its parent — so
-   * with the wrapper gone the scrub was measured against whatever section contained it. Measured
-   * on `demo/scroll.html`: the parent started 926px above the scrub against a 1817px distance, so
-   * progress reached 51% before the element had even stuck and half the sequence played off
-   * screen. The wrapper was not ceremony; it was the tight box that made the parent honest.
-   *
-   * `trackProgress`'s `contentAnchor` is the fix. Progress is read from the spacer, which the
-   * library inserts, is exactly `distance` tall, is never sticky, and moves with the content — so
-   * there is no wrapper to write and nothing to disagree with.
-   *
-   * `video-scrub` stays off: a video positioned by the page is not asking the library for a box.
-   */
-  { name: "sequence-scrub", primitive: "media-scrub", params: { spacer: "true" } },
-  { name: "video-scrub", primitive: "media-scrub" },
-  // --- navigation --------------------------------------------------------------------------
-  { name: "scroll-spy", primitive: "scroll-spy" },
-  // --- native CSS passthroughs ---------------------------------------------------------------
-  { name: "smooth-scroll-to", primitive: "smooth-scroll" },
-  { 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: [],
-      subpaths: [],
-      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 = {
-    subpaths: [],
-    open: void 0,
-    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: [], subpaths: [], reason: "path must start with a command letter" };
-    }
-    index = consume(tokens, index, state);
-  }
-  if (state.subpaths.length === 0) {
-    return { segments: [], subpaths: [], reason: "no drawable segments" };
-  }
-  return { segments: state.subpaths.flatMap((sub) => sub.segments), subpaths: state.subpaths };
-}
-function pushSegment(state, segment) {
-  if (!state.open) {
-    state.open = { segments: [], closed: false };
-    state.subpaths.push(state.open);
-  }
-  state.open.segments.push(segment);
-}
-var ARITY = { m: 2, l: 2, h: 1, v: 1, c: 6, z: 0 };
-function closeSubpath(state) {
-  const { current, start, open } = state;
-  if (!open) return;
-  if (Math.abs(current.x - start.x) >= 1e-6 || Math.abs(current.y - start.y) >= 1e-6) {
-    open.segments.push(lineToCubic(current, start));
-  }
-  open.closed = true;
-  state.current = { ...start };
-  state.open = void 0;
-}
-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.open = void 0;
-    state.command = relative ? "l" : "L";
-    return index + arity;
-  }
-  pushSegment(state, 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 round(value) {
-  return Math.round(value * 100) / 100;
-}
-function subpathsToPathData(subpaths) {
-  const parts = [];
-  for (const sub of subpaths) {
-    const head = sub.segments[0];
-    parts.push(`M${round(head.from.x)},${round(head.from.y)}`);
-    for (const s of sub.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)}`
-      );
-    }
-    if (sub.closed) parts.push("Z");
-  }
-  return parts.join(" ");
-}
-function centroidOf(subpath) {
-  let x = 0;
-  let y = 0;
-  for (const s of subpath.segments) {
-    x += s.from.x;
-    y += s.from.y;
-  }
-  return { x: x / subpath.segments.length, y: y / subpath.segments.length };
-}
-function collapsedLike(partner) {
-  const at = centroidOf(partner);
-  return {
-    segments: partner.segments.map(() => ({
-      from: { ...at },
-      c1: { ...at },
-      c2: { ...at },
-      to: { ...at }
-    })),
-    closed: partner.closed
-  };
-}
-function normaliseSubpaths(a, b) {
-  const count = Math.max(a.length, b.length);
-  const from = [];
-  const to = [];
-  for (let i = 0; i < count; i++) {
-    const left = a[i] ?? collapsedLike(b[i]);
-    const right = b[i] ?? collapsedLike(a[i]);
-    const target = Math.max(left.segments.length, right.segments.length);
-    const closed = left.closed && right.closed;
-    from.push({ segments: normaliseCount(left.segments, target), closed });
-    to.push({ segments: normaliseCount(right.segments, target), closed });
-  }
-  return { from, to };
-}
-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 { from, to } = normaliseSubpaths(a.subpaths, b.subpaths);
-  const count = from.reduce((total, sub) => total + sub.segments.length, 0);
-  return {
-    morph: {
-      segmentCount: count,
-      at(t) {
-        const clamped = Math.min(1, Math.max(0, t));
-        return subpathsToPathData(
-          from.map((sub, i) => ({
-            segments: sub.segments.map(
-              (segment, j) => lerpCubic(segment, to[i].segments[j], clamped)
-            ),
-            closed: sub.closed
-          }))
-        );
-      }
-    }
-  };
-}
-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 PATH_DRAW_PRIMITIVE = cssPrimitive("path-draw", [CHANNEL.stroke], {
-  parameters: {
-    length: { type: "number", default: "100", cssProperty: "--kui-path-length", finite: true }
-  }
-});
-var SHAPE_FILL_PRIMITIVE = cssPrimitive("shape-fill", [CHANNEL.clip]);
-var BAR_GROW_PRIMITIVE = cssPrimitive("bar-grow", [CHANNEL.scale], {
-  parameters: { from: { type: "number", default: "0", cssProperty: "--kui-bar-from" } }
-});
-var LOGO_BUILD_PRIMITIVE = cssPrimitive("logo-assemble", [
-  CHANNEL.opacity,
-  CHANNEL.scale,
-  CHANNEL.rotate
-]);
-var ICON_TOGGLE_PRIMITIVE = {
-  id: "icon-toggle",
-  renderer: "javascript",
-  channels: [CHANNEL.translate, CHANNEL.rotate, CHANNEL.scale, CHANNEL.opacity, CHANNEL.clip],
-  parameters: {
-    duration: { type: "time", default: "260ms", cssProperty: "--kui-duration" },
-    ease: { type: "easing", default: "ease-out", cssProperty: "--kui-ease" }
-  },
-  supportedTimelines: ["time"],
-  supportedActivations: ["load"],
-  defaultActivation: "load",
-  perfClass: "compositor",
-  reducedMotion: "disable",
-  prepare: () => inertInstance()
-};
-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)
-  },
-  PATH_DRAW_PRIMITIVE,
-  SHAPE_FILL_PRIMITIVE,
-  BAR_GROW_PRIMITIVE,
-  LOGO_BUILD_PRIMITIVE,
-  ICON_TOGGLE_PRIMITIVE
-];
-var SVG_PRESETS = [
-  { name: "icon-morph", primitive: "path-morph" },
-  { name: "blob-morph", primitive: "path-morph", params: { duration: "800ms" } },
-  // Stroke draws. One keyframe block each rather than one shared block, matching the
-  // progress-ring/gauge-sweep/donut-sweep/sparkline-draw group in numbers.ts: identical bodies
-  // today, but each name is free to diverge and a consumer can restyle one without the others.
-  { name: "draw-stroke", primitive: "path-draw", keyframes: "kui-draw-stroke", params: { duration: "800ms", ease: "ease-in-out" } },
-  { name: "draw-signature", primitive: "path-draw", keyframes: "kui-draw-signature", params: { duration: "1600ms", ease: "ease-in-out" } },
-  { name: "draw-underline", primitive: "path-draw", keyframes: "kui-draw-underline", params: { duration: "420ms" } },
-  { name: "checkmark-draw", primitive: "path-draw", keyframes: "kui-checkmark-draw", params: { duration: "320ms" } },
-  { name: "cross-draw", primitive: "path-draw", keyframes: "kui-cross-draw", params: { duration: "260ms" } },
-  { name: "chart-line-draw", primitive: "path-draw", keyframes: "kui-chart-line-draw", params: { duration: "1200ms", ease: "ease-in-out" } },
-  { name: "gradient-stroke", primitive: "path-draw", keyframes: "kui-gradient-stroke", params: { duration: "2400ms", ease: "ease-in-out" } },
-  // Fills.
-  { name: "heart-fill", primitive: "shape-fill", keyframes: "kui-heart-fill", params: { duration: "420ms" } },
-  { name: "bookmark-fill", primitive: "shape-fill", keyframes: "kui-bookmark-fill", params: { duration: "360ms" } },
-  { name: "chart-area-fill", primitive: "shape-fill", keyframes: "kui-chart-area-fill", params: { duration: "900ms" } },
-  // `cloak: true`: `kui-chart-bar-grow`'s `from { scale: 1 0 }` (svg.css) is a zero-height box
-  // while paused, not just an invisible one — so it occupies no space in layout for the whole
-  // wait. Same defect `fold-panel` has, and the same fix shape: see svg.css's
-  // `[data-kui-fx~='chart-bar-grow'][data-kui-state='ready']` rule.
-  {
-    name: "chart-bar-grow",
-    primitive: "bar-grow",
-    keyframes: "kui-chart-bar-grow",
-    params: { duration: "700ms", ease: "back-out" },
-    cloak: true
-  },
-  { name: "logo-build", primitive: "logo-assemble", keyframes: "kui-logo-build", params: { duration: "520ms", ease: "back-out" } },
-  // Icon toggles — no `keyframes`, because their motion is a CSS transition in svg.css keyed off
-  // aria state, not a compiled animation. Same shape as forms.ts's native-state presets.
-  { name: "hamburger-to-x", primitive: "icon-toggle" },
-  { name: "play-to-pause", primitive: "icon-toggle" },
-  { name: "plus-to-minus", primitive: "icon-toggle" }
-];
-function registerSvg(registry) {
-  return registry.registerPrimitives(SVG_PRIMITIVES).registerPresets(SVG_PRESETS);
-}
-
-// src/effects/three-d/index.ts
-var CARD_TOGGLE_PRIMITIVE = {
-  id: "card-toggle",
-  renderer: "javascript",
-  channels: [CHANNEL.rotate],
-  parameters: {
-    duration: { type: "time", default: "700ms", cssProperty: "--kui-duration" },
-    ease: { type: "easing", default: "ease-in-out", cssProperty: "--kui-ease" },
-    perspective: { type: "length", default: "1600px", cssProperty: "--kui-perspective" }
-  },
-  supportedTimelines: ["time"],
-  supportedActivations: ["load"],
-  defaultActivation: "load",
-  perfClass: "compositor",
-  reducedMotion: "disable",
-  prepare: () => inertInstance()
-};
-var THREE_D_PRIMITIVES = [
-  // `skew`, not `rotate`: the keyframes in three-d.css write `transform: perspective(...)
-  // rotateX/Y(...)`, not the individual `rotate:` property — `perspective` only creates depth for
-  // an element's *children*, so giving one of these effects its own depth means reaching for the
-  // `perspective()` transform *function*, which only exists inside the `transform` shorthand.
-  // `CHANNEL.skew` is this catalog's name for "claims the whole `transform` shorthand"; see the
-  // comment on it in `core/types.ts`.
-  cssPrimitive("flip-face", [CHANNEL.skew], {
-    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]),
-  // `from` gives `loading-bar` a real knob on its start scale — it had none before, unlike
-  // `flip-face`'s `angle:` two rows up. `--kui-bar-from` is also what the fold-panel-style
-  // `[data-kui-fx~='loading-bar'][data-kui-state='ready']` gate neutralizes in three-d.css; see
-  // that rule's comment for the on:enter fix this parameter doubles as.
-  cssPrimitive("bar", [CHANNEL.scale], {
-    parameters: { from: { type: "number", default: "0", cssProperty: "--kui-bar-from" } }
-  }),
-  CARD_TOGGLE_PRIMITIVE
-];
-var THREE_D_PRESETS = [
-  // --- 3D & perspective ---
-  { name: "card-flip-y", primitive: "flip-face", keyframes: "kui-card-flip-y", cloak: true },
-  { name: "card-flip-x", primitive: "flip-face", keyframes: "kui-card-flip-x", cloak: true },
-  { 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" }
-  },
-  // `cloak: true`, unlike its `flip-face` siblings above: those are `to`-only keyframes, so their
-  // paused/waiting box is the ordinary, untransformed rest state. `fold-panel` is `from`-only —
-  // its `rotateX(-90deg)` (three-d.css) *is* the paused box, edge-on and zero-height, so it holds
-  // no space in layout for the whole wait; see the
-  // `[data-kui-fx~='fold-panel'][data-kui-state='ready']` rule in three-d.css for the other half
-  // of that fix. `cloak` only ever hid the pre-JS flash, not this, but adding it here keeps the
-  // pre-JS and post-JS "ready" appearances the same (invisible) instead of trading one flash for
-  // the other.
-  {
-    name: "fold-panel",
-    primitive: "flip-face",
-    keyframes: "kui-fold-panel",
-    params: { angle: "-90deg" },
-    cloak: true
-  },
-  // --- 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" } },
-  // `cloak: true` for the same reason as `fold-panel`: `kui-loading-bar`'s `from { scale: 0 1 }`
-  // (three-d.css) is a zero-width box, not just an invisible one — see that file's
-  // `[data-kui-fx~='loading-bar'][data-kui-state='ready']` rule.
-  { name: "loading-bar", primitive: "bar", keyframes: "kui-loading-bar", cloak: true },
-  // No `keyframes`: its motion is a CSS transition in three-d.css keyed off the control's
-  // aria-pressed, not a compiled animation. Same shape as the icon toggles in svg.ts.
-  { name: "flip-card", primitive: "card-toggle" }
-];
-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
-};