cineview 0.0.1-beta

package/dist/media/VideoFrameRenderer.d.ts

@@ -0,0 +1,48 @@
+import { CSSProperties, FormEventHandler, MutableRefObject, ReactEventHandler } from 'react';
+import { MotionValue } from 'framer-motion';
+import { AnimateTimelineFrame } from '../types';
+type VideoEventHandler = ReactEventHandler<HTMLVideoElement>;
+type VideoErrorHandler = FormEventHandler<HTMLVideoElement>;
+/**
+ * Imperative media-residency control for scroll-driven scrub videos
+ * (AnimateVideo `releaseOnLeave`, task-flow 2026-08-14 Plan A).
+ *
+ * Decoded video frames and GPU textures stay resident after a `<video>` has
+ * been scrubbed through, and the compositor pressure they create measurably
+ * drops frames in *other* scenes once the viewer scrolls past (probe evidence:
+ * `site/scripts/_rv-video-residency.mjs`). This handle lets the owner drop
+ * that residency once the zone is far away and restore it before return:
+ *
+ * - `release()`: pause + drop `src` + `load()` — the browser discards decoded
+ *   frames/buffer. The blob URL lease is *kept* so warm-up costs no network.
+ * - `warmUp()`: re-attach `src` (blob already in memory) and bump the media
+ *   epoch — pending scrub seeks re-arm on the next `loadedmetadata` and catch
+ *   up to the current timeline position.
+ */
+export interface VideoFrameRendererControl {
+    release(): void;
+    warmUp(): void;
+}
+export interface VideoFrameRendererProps {
+    src: string;
+    /** Legacy progress-only input. Atomic timelineFrame takes ownership when supplied. */
+    progress: number | MotionValue<number>;
+    timelineFrame?: MotionValue<AnimateTimelineFrame>;
+    scrubRange?: readonly [fromSeconds: number, toSeconds: number];
+    width?: number | string;
+    height?: number | string;
+    style?: CSSProperties;
+    'aria-label'?: string;
+    preload?: boolean;
+    poster?: string;
+    playbackRate?: number;
+    onEnded?: VideoEventHandler;
+    onPlay?: VideoEventHandler;
+    onPause?: VideoEventHandler;
+    onTimeUpdate?: VideoEventHandler;
+    onError?: VideoErrorHandler;
+    /** Optional imperative release/warm-up handle (see VideoFrameRendererControl). */
+    controlRef?: MutableRefObject<VideoFrameRendererControl | null>;
+}
+export declare const VideoFrameRenderer: import('react').ForwardRefExoticComponent<VideoFrameRendererProps & import('react').RefAttributes<HTMLVideoElement>>;
+export {};

package/dist/media/videoPlaybackOwnership.d.ts

@@ -0,0 +1,63 @@
+import { AnimateTimelineFrame } from '../types';
+export type VideoPlaybackOwnershipStatus = 'framework-scrub' | 'play-pending' | 'native-playback' | 'native-paused' | 'play-rejected' | 'ended';
+export interface VideoPlaybackOwnershipState {
+    readonly activationId: number;
+    readonly status: VideoPlaybackOwnershipStatus;
+    readonly activePlayRequestId: number | null;
+    /** Most recent framework play request whose promise/event may still arrive. */
+    readonly settledPlayRequestId: number | null;
+    readonly nextPlayRequestId: number;
+    readonly lastSeekTime: number | null;
+    readonly endpointLatched: boolean;
+    readonly outgoingLatched: boolean;
+    /** Blocks untagged late play events after framework has reclaimed scrub ownership. */
+    readonly frameworkPlayBlocked: boolean;
+    /** The next native pause event acknowledges a framework-issued pause command. */
+    readonly frameworkPausePending: boolean;
+}
+export type VideoPlaybackOwnershipCommand = {
+    readonly type: 'pause';
+} | {
+    readonly type: 'seek';
+    readonly time: number;
+} | {
+    readonly type: 'play';
+    readonly requestId: number;
+};
+interface TimelineFrameEvent {
+    readonly type: 'timeline-frame';
+    readonly frame: AnimateTimelineFrame;
+    readonly duration: number;
+    readonly scrubRange?: readonly [fromSeconds: number, toSeconds: number];
+}
+export type VideoPlaybackOwnershipEvent = TimelineFrameEvent | {
+    readonly type: 'media-play';
+    readonly requestId?: number;
+    readonly activationId: number;
+} | {
+    readonly type: 'media-pause';
+    readonly activationId: number;
+} | {
+    readonly type: 'media-ended';
+    readonly activationId: number;
+} | {
+    readonly type: 'play-resolved';
+    readonly requestId: number;
+} | {
+    readonly type: 'play-rejected';
+    readonly requestId: number;
+} | {
+    readonly type: 'activate';
+    readonly activationId: number;
+} | {
+    readonly type: 'reset';
+    readonly activationId: number;
+};
+export interface VideoPlaybackOwnershipResult {
+    readonly state: VideoPlaybackOwnershipState;
+    readonly commands: readonly VideoPlaybackOwnershipCommand[];
+}
+export declare function mapVideoScrubProgress(progress: number, duration: number, scrubRange?: readonly [fromSeconds: number, toSeconds: number]): number | null;
+export declare function createVideoPlaybackOwnershipState(activationId: number): VideoPlaybackOwnershipState;
+export declare function reduceVideoPlaybackOwnership(state: VideoPlaybackOwnershipState, event: VideoPlaybackOwnershipEvent): VideoPlaybackOwnershipResult;
+export {};

package/dist/performance-monitor-AlOOwzY_.mjs

@@ -0,0 +1,73 @@
+var l = class {
+  constructor() {
+    this.frameCount = 0, this.lastTime = performance.now(), this.frameTimes = [], this.memorySamples = [], this.lastMemorySampleTime = 0, this.cachedMemoryUsage = void 0, this.cachedBundleSizeKb = 0, this.rafId = null, this.isMonitoring = !1, this.measure = () => {
+      if (!this.isMonitoring) return;
+      const e = performance.now(), s = e - this.lastTime;
+      this.frameCount++, this.frameTimes.push(s), this.frameTimes.length > 60 && this.frameTimes.shift(), this.sampleMemory(e), this.lastTime = e, this.rafId = requestAnimationFrame(this.measure);
+    };
+  }
+  start() {
+    this.isMonitoring || (this.isMonitoring = !0, this.frameCount = 0, this.lastTime = performance.now(), this.frameTimes = [], this.memorySamples = [], this.lastMemorySampleTime = 0, this.cachedMemoryUsage = void 0, this.cachedBundleSizeKb = this.estimateBundleSizeKb(), this.measure());
+  }
+  stop() {
+    this.isMonitoring = !1, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
+  }
+  getMetrics() {
+    const e = this.calculateAvgFrameTime();
+    if (this.frameTimes.length === 0) return {
+      fps: 0,
+      avgFrameTime: 0,
+      memoryUsage: this.getMemoryUsage(),
+      bundleSize: this.getBundleSizeKb()
+    };
+    const s = 1e3 / Math.max(e, 1);
+    return {
+      fps: Math.round(Math.min(Math.max(s, 0), 60) * 10) / 10,
+      avgFrameTime: Math.round(e * 100) / 100,
+      memoryUsage: this.getMemoryUsage(),
+      bundleSize: this.getBundleSizeKb()
+    };
+  }
+  calculateAvgFrameTime() {
+    return this.frameTimes.length === 0 ? 0 : this.frameTimes.reduce((e, s) => e + s, 0) / this.frameTimes.length;
+  }
+  getMemoryUsage() {
+    return this.sampleMemory(performance.now(), this.cachedMemoryUsage === void 0), this.cachedMemoryUsage;
+  }
+  sampleMemory(e, s = !1) {
+    if (!performance.memory) {
+      this.cachedMemoryUsage = void 0, this.memorySamples = [];
+      return;
+    }
+    if (!s && e - this.lastMemorySampleTime < 1e3) return;
+    const a = performance.memory.usedJSHeapSize / 1048576;
+    this.memorySamples.push(a), this.memorySamples.length > 8 && this.memorySamples.shift();
+    const i = [...this.memorySamples].sort((o, h) => o - h), t = Math.floor(i.length / 2), n = i.length % 2 === 0 ? (i[t - 1] + i[t]) / 2 : i[t];
+    this.cachedMemoryUsage = Math.round(n * 10) / 10, this.lastMemorySampleTime = e;
+  }
+  getBundleSizeKb() {
+    return this.cachedBundleSizeKb > 0 ? this.cachedBundleSizeKb : (this.cachedBundleSizeKb = this.estimateBundleSizeKb(), this.cachedBundleSizeKb);
+  }
+  estimateBundleSizeKb() {
+    if (typeof performance > "u" || typeof performance.getEntriesByType != "function") return 0;
+    const e = performance.getEntriesByType("resource");
+    if (e.length === 0) return 0;
+    const s = e.reduce((a, i) => {
+      const t = i.name.toLowerCase();
+      return t.endsWith(".js") || t.endsWith(".mjs") || t.endsWith(".css") || t.includes(".js?") || t.includes(".mjs?") || t.includes(".css?") ? a + Math.max(i.decodedBodySize || 0, i.transferSize || 0) : a;
+    }, 0);
+    return Math.round(s / 1024 * 10) / 10;
+  }
+}, m = new l(), r = 0, c = m, u = () => {
+  r += 1, r === 1 && m.start();
+  let e = !1;
+  return () => {
+    e || (e = !0, r = Math.max(r - 1, 0), r === 0 && m.stop());
+  };
+};
+export {
+  c as n,
+  u as t
+};
+
+//# sourceMappingURL=performance-monitor-AlOOwzY_.mjs.map

package/dist/public-api.d.ts

@@ -0,0 +1,12 @@
+import { ForwardRefExoticComponent, ReactNode, RefAttributes } from 'react';
+import { AnimateProps, PositionProps, SceneProps } from './types';
+export { useAnimateTimeline } from './components/Animate';
+export { Container } from './components/Container';
+export { Image } from './components/Image';
+export type { ImageProps } from './components/Image';
+export { AnimateVideo } from './components/Animate/AnimateVideo';
+export type { AnimateVideoProps } from './components/Animate/AnimateVideo';
+export declare const Animate: (props: AnimateProps) => ReactNode;
+export declare const Position: ForwardRefExoticComponent<PositionProps & RefAttributes<HTMLDivElement>>;
+export declare const Scene: ForwardRefExoticComponent<SceneProps & RefAttributes<HTMLDivElement>>;
+export type { SlideDirection, ScrollMode, SceneAnchor, SceneStackMode, DragThresholdConfig, DragTimelineUnit, SceneDragConfig, DragModeConfig, ScrollModeConfig, ScrollbarConfig, A11yConfig, SceneChangeDetail, CineviewErrorCode, CineviewErrorDetail, DragDetail, DragStartDetail, DragBlockedDetail, DragEndDetail, ZoneDetail, ZoneProgressDetail, SceneVisibilityDetail, CineviewCommonCallbacks, CineviewDragCallbacks, CineviewScrollCallbacks, DragModeCallbacks, ScrollModeCallbacks, CineviewCallbacks, PresetAnimation, CustomAnimation, ComposedAnimation, AnimationType, CineviewBaseProps, CineviewDragModeProps, CineviewScrollModeProps, CineviewProps, PerformanceMetrics, CineviewRef, CineviewScrollRef, CineviewPreloadTarget, AnimateProps, AnimateStaggerConfig, AnimateRenderState, AnimatePhase, AnimateTimelineLane, AnimateTimelineSource, AnimateTimelineFrame, AnimateTimeline, PositionProps, ContainerProps, SceneProps, } from './types';

package/dist/rotate-BMEBKDk5.mjs

@@ -0,0 +1,69 @@
+var t = {
+  rotate: {
+    initial: {
+      rotate: -180,
+      opacity: 0
+    },
+    animate: {
+      rotate: 0,
+      opacity: 1
+    },
+    exit: {
+      rotate: 180,
+      opacity: 0
+    }
+  },
+  "rotate-in": {
+    initial: {
+      rotate: -180,
+      scale: 0,
+      opacity: 0
+    },
+    animate: {
+      rotate: 0,
+      scale: 1,
+      opacity: 1
+    },
+    exit: {
+      rotate: 0,
+      scale: 1,
+      opacity: 1
+    }
+  },
+  "rotate-out": {
+    initial: {
+      rotate: 0,
+      scale: 1,
+      opacity: 1
+    },
+    animate: {
+      rotate: 0,
+      scale: 1,
+      opacity: 1
+    },
+    exit: {
+      rotate: 180,
+      scale: 0,
+      opacity: 0
+    }
+  },
+  spin: {
+    initial: {
+      rotate: 0,
+      opacity: 0
+    },
+    animate: {
+      rotate: 360,
+      opacity: 1
+    },
+    exit: {
+      rotate: 720,
+      opacity: 0
+    }
+  }
+};
+export {
+  t as rotateAnimations
+};
+
+//# sourceMappingURL=rotate-BMEBKDk5.mjs.map

package/dist/scene-animation-registry-8b0m_IaZ.mjs

@@ -0,0 +1,422 @@
+import { useCallback as p, useEffect as Q, useRef as y, useState as X } from "react";
+function de(...e) {
+}
+function $e(...e) {
+}
+function we(e, ...a) {
+}
+function B(e, a) {
+  return e === a || e === "visibility" && a === "scroll";
+}
+var fe = class {
+  constructor(e) {
+    this.source = new Map(e), Object.freeze(this);
+  }
+  get size() {
+    return this.source.size;
+  }
+  get(e) {
+    return this.source.get(e);
+  }
+  has(e) {
+    return this.source.has(e);
+  }
+  forEach(e, a) {
+    this.source.forEach((i, s) => e.call(a, i, s, this));
+  }
+  entries() {
+    return this.source.entries();
+  }
+  keys() {
+    return this.source.keys();
+  }
+  values() {
+    return this.source.values();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get [Symbol.toStringTag]() {
+    return "ImmutableMapView";
+  }
+};
+function Z(e) {
+  return new fe(e);
+}
+function pe(e) {
+  const a = [];
+  return e.registrations.forEach((i, s) => {
+    a.push([s, Object.freeze({ ...i })]);
+  }), Object.freeze({
+    registrations: Z(a),
+    calculatedDelays: Z(e.calculatedDelays),
+    issues: Object.freeze([...e.issues]),
+    timelineDuration: e.timelineDuration
+  });
+}
+function ee(e) {
+  switch (e.type) {
+    case "missing-dependency":
+      return `${e.type}:${e.animateId}:${e.after}`;
+    case "circular-dependency":
+      return `${e.type}:${e.animateId}:${e.cycle.join(">")}`;
+    case "duplicate-id":
+      return `${e.type}:${e.animateId}`;
+    case "incompatible-lane":
+      return `${e.type}:${e.animateId}:${e.after}:${e.followerLane}:${e.leaderLane}`;
+  }
+}
+function b(e, a) {
+  const i = ee(a);
+  e.some((s) => ee(s) === i) || e.push(a);
+}
+function ye(e) {
+  const a = e.slice(0, -1);
+  let i = 0;
+  for (let l = 1; l < a.length; l += 1) a[l] < a[i] && (i = l);
+  const s = a.slice(i).concat(a.slice(0, i));
+  return s.concat(s[0]);
+}
+function te({ baseDuration: e, registrations: a, declaredLanes: i = /* @__PURE__ */ new Map(), duplicateIds: s = [] }) {
+  const l = /* @__PURE__ */ new Map(), m = [], w = /* @__PURE__ */ new Set(), D = /* @__PURE__ */ new Set();
+  Array.from(s).forEach((o) => {
+    b(m, {
+      type: "duplicate-id",
+      animateId: o
+    });
+  });
+  const I = (o, d) => {
+    const $ = l.get(o);
+    if ($ !== void 0) return $;
+    const f = a.get(o);
+    if (w.has(o)) {
+      const k = d.indexOf(o), R = ye(d.slice(k).concat(o));
+      return R.slice(0, -1).forEach((A) => D.add(A)), b(m, {
+        type: "circular-dependency",
+        animateId: R[0],
+        cycle: R
+      }), l.set(o, f.delay), f.delay;
+    }
+    w.add(o);
+    let v = f.delay;
+    if (f.after) {
+      const k = a.get(f.after), R = i.get(f.after);
+      if (!k)
+        f.lane !== void 0 && R !== void 0 && !B(f.lane, R) ? b(m, {
+          type: "incompatible-lane",
+          animateId: o,
+          after: f.after,
+          followerLane: f.lane,
+          leaderLane: R
+        }) : b(m, {
+          type: "missing-dependency",
+          animateId: o,
+          after: f.after
+        });
+      else if (f.lane !== void 0 && k.lane !== void 0 && !B(f.lane, k.lane)) b(m, {
+        type: "incompatible-lane",
+        animateId: o,
+        after: f.after,
+        followerLane: f.lane,
+        leaderLane: k.lane
+      });
+      else {
+        const A = I(f.after, d.concat(o));
+        !(f.lane === "visibility" && k.lane === "scroll") && !D.has(o) && (v += A + k.duration);
+      }
+    }
+    return w.delete(o), l.set(o, v), v;
+  };
+  a.forEach((o, d) => {
+    I(d, []);
+  });
+  let L = Math.max(e, 0);
+  return a.forEach((o, d) => {
+    const $ = l.get(d);
+    L = Math.max(L, $ + o.duration);
+  }), {
+    registrations: new Map(a),
+    calculatedDelays: l,
+    issues: m,
+    timelineDuration: L
+  };
+}
+function _(e) {
+  switch (e.type) {
+    case "missing-dependency":
+      return `${e.type}:${e.animateId}:${e.after}`;
+    case "circular-dependency":
+      return `${e.type}:${e.animateId}:${e.cycle.join(">")}`;
+    case "duplicate-id":
+      return `${e.type}:${e.animateId}`;
+    case "incompatible-lane":
+      return `${e.type}:${e.animateId}:${e.after}:${e.followerLane}:${e.leaderLane}`;
+  }
+}
+function me(e) {
+  return e.kind === "invalid" ? `${e.kind}:${e.leaderId}:${e.reason}` : `${e.kind}:${e.leaderId ?? ""}:${e.generation ?? ""}:${e.kind === "satisfied" ? e.source : ""}`;
+}
+function j(e) {
+  let a;
+  return e.forEach((i) => {
+    a = i;
+  }), a;
+}
+function F(e, a, i = Object.is) {
+  if (e.size !== a.size) return !1;
+  for (const [s, l] of e) {
+    const m = a.get(s);
+    if (m === void 0 || !i(l, m)) return !1;
+  }
+  return !0;
+}
+function ge(e, a) {
+  return e.timelineDuration === a.timelineDuration && F(e.registrations, a.registrations, (i, s) => i.delay === s.delay && i.duration === s.duration && i.after === s.after && i.lane === s.lane) && F(e.calculatedDelays, a.calculatedDelays) && e.issues.length === a.issues.length && e.issues.every((i, s) => _(i) === _(a.issues[s]));
+}
+function ve({ sceneIndex: e, baseDuration: a, reportError: i, onStableSnapshot: s }) {
+  const l = y(/* @__PURE__ */ new Map()), m = y(/* @__PURE__ */ new Map()), w = y(/* @__PURE__ */ new Map()), D = y(/* @__PURE__ */ new Map()), I = y(/* @__PURE__ */ new Set()), L = y(te({
+    baseDuration: a,
+    registrations: w.current
+  })), o = y(/* @__PURE__ */ new Set()), d = y(null), $ = y(/* @__PURE__ */ new Map()), f = y(0), v = y(0), k = y(0), R = y(null), A = y(null), M = y(!0), P = y(i);
+  P.current = i;
+  const x = y(s);
+  x.current = s;
+  const K = y(a), [ne, re] = X(a), [ae, q] = X(!1), z = p(() => {
+    M.current && q(!1);
+  }, []), H = p((t) => {
+    t.forEach((n) => {
+      const r = _(n);
+      if (o.current.has(r)) return;
+      o.current.add(r);
+      let c, u;
+      n.type === "missing-dependency" ? (c = "INVALID_ANIMATION", u = `Animate "${n.animateId}" references non-existent component "${n.after}" via after in Scene ${e}.`) : n.type === "circular-dependency" ? (c = "CIRCULAR_DEPENDENCY", u = `Animate after chain contains a cycle in Scene ${e}: ${n.cycle.join(" -> ")}.`) : n.type === "duplicate-id" ? (c = "INVALID_COMPONENT_HIERARCHY", u = `More than one Animate component registered animateId "${n.animateId}" in Scene ${e}.`) : (c = "INVALID_ANIMATION", u = `Animate "${n.animateId}" uses ${n.followerLane} after "${n.after}" driven by ${n.leaderLane} in Scene ${e}; this dependency direction is incompatible.`), P.current?.({
+        code: c,
+        message: u,
+        context: { sceneIndex: e }
+      });
+    });
+  }, [e]), U = p(() => {
+    w.current.clear(), D.current.clear(), I.current.clear(), l.current.forEach((t, n) => {
+      const r = j(t);
+      r && w.current.set(n, r.info), t.size > 1 && I.current.add(n);
+    }), m.current.forEach((t, n) => {
+      let r;
+      t.forEach((c) => {
+        c.disposed || (r = c);
+      }), r && D.current.set(n, r.lane);
+    });
+  }, []), E = p(() => {
+    U();
+    const t = te({
+      baseDuration: a,
+      registrations: w.current,
+      declaredLanes: D.current,
+      duplicateIds: I.current
+    });
+    return L.current = t, K.current = t.timelineDuration, M.current && re((n) => n === t.timelineDuration ? n : t.timelineDuration), t;
+  }, [a, U]), Y = p((t) => L.current.issues.some((n) => n.type === "circular-dependency" && n.cycle.includes(t)), []), C = p((t, n) => {
+    const { follower: r, leaderId: c } = t, u = l.current.get(c), h = D.current.get(c);
+    if (!u || u.size === 0)
+      return n && h !== void 0 && r.info.lane !== void 0 && !B(r.info.lane, h) ? (t.sawLeader = !0, {
+        kind: "invalid",
+        leaderId: c,
+        reason: "incompatible-lane"
+      }) : n ? {
+        kind: "invalid",
+        leaderId: c,
+        reason: t.sawLeader ? "leader-unregistered" : "missing"
+      } : {
+        kind: "pending",
+        leaderId: c
+      };
+    t.sawLeader = !0;
+    const g = j(u);
+    return n && Y(r.id) ? {
+      kind: "invalid",
+      leaderId: c,
+      reason: "cycle"
+    } : n && u.size > 1 ? {
+      kind: "invalid",
+      leaderId: c,
+      reason: "duplicate"
+    } : n && r.info.lane !== void 0 && g.info.lane !== void 0 && !B(r.info.lane, g.info.lane) ? {
+      kind: "invalid",
+      leaderId: c,
+      reason: "incompatible-lane"
+    } : g.enterCompleted ? {
+      kind: "satisfied",
+      source: "completed",
+      leaderId: c,
+      generation: g.generation
+    } : {
+      kind: "pending",
+      leaderId: c,
+      generation: g.generation
+    };
+  }, [Y]), V = p((t, n) => {
+    if (t.terminal) return;
+    const r = me(n);
+    t.lastSignature !== r && (t.lastSignature = r, t.listener(n), n.kind !== "pending" && (t.terminal = !0));
+  }, []), O = p((t) => {
+    $.current.forEach((n) => {
+      [...n].forEach((r) => {
+        if (r.follower.disposed || r.terminal) {
+          n.delete(r);
+          return;
+        }
+        V(r, C(r, t)), r.terminal && n.delete(r);
+      });
+    }), $.current.forEach((n, r) => {
+      n.size === 0 && $.current.delete(r);
+    });
+  }, [V, C]), W = p((t) => {
+    if (v.current !== 0 || !M.current) return;
+    const n = /* @__PURE__ */ new Map();
+    l.current.forEach((h, g) => {
+      const J = j(h);
+      J?.enterVariant && n.set(g, J.enterVariant);
+    });
+    const r = R.current, c = A.current, u = r !== null && c !== null && ge(r, t) && F(c, n);
+    q(!0), !u && (k.current += 1, R.current = t, A.current = new Map(n), x.current?.(pe(t), k.current, n));
+  }, []), N = p(() => {
+    if (v.current !== 0 || !M.current) return;
+    d.current !== null && (clearTimeout(d.current), d.current = null);
+    const t = E();
+    H(t.issues), O(!0), W(t);
+  }, [
+    W,
+    E,
+    O,
+    H
+  ]), S = p(() => {
+    z(), d.current !== null && clearTimeout(d.current), d.current = setTimeout(() => {
+      d.current = null, N();
+    }, 0);
+  }, [N, z]), ce = p(() => {
+    v.current += 1, z();
+    let t = !1;
+    const n = () => t ? !1 : (t = !0, v.current = Math.max(0, v.current - 1), v.current === 0);
+    return {
+      complete: () => {
+        n() && N();
+      },
+      cancel: () => {
+        n() && S();
+      }
+    };
+  }, [
+    N,
+    z,
+    S
+  ]), G = p((t) => {
+    $.current.forEach((n, r) => {
+      n.forEach((c) => {
+        c.follower.token === t.token && n.delete(c);
+      }), n.size === 0 && $.current.delete(r);
+    });
+  }, []), T = p((t) => {
+    if (t.disposed) return;
+    t.disposed = !0, G(t);
+    const n = l.current.get(t.id);
+    n?.delete(t.token), n?.size === 0 && l.current.delete(t.id), E(), S();
+  }, [
+    E,
+    G,
+    S
+  ]), ie = p((t, n) => {
+    const r = {
+      token: Symbol(t),
+      id: t,
+      generation: ++f.current,
+      info: n,
+      enterVariant: null,
+      enterCompleted: !1,
+      disposed: !1
+    };
+    let c = l.current.get(t);
+    return c || (c = /* @__PURE__ */ new Map(), l.current.set(t, c)), c.set(r.token, r), E(), S(), w.current.size > 100 && `${e}${w.current.size}`, {
+      animateId: t,
+      generation: r.generation,
+      getCalculatedDelay: () => L.current.calculatedDelays.get(t) ?? r.info.delay,
+      setEnterVariant: (u) => {
+        r.disposed || l.current.get(t)?.has(r.token) && (r.enterVariant = u, S());
+      },
+      observeAfter: (u) => {
+        if (!r.info.after)
+          return u({
+            kind: "satisfied",
+            source: "none"
+          }), () => {
+          };
+        const h = {
+          follower: r,
+          listener: u,
+          leaderId: r.info.after,
+          sawLeader: !1,
+          lastSignature: null,
+          terminal: !1
+        };
+        let g = $.current.get(h.leaderId);
+        return g || (g = /* @__PURE__ */ new Set(), $.current.set(h.leaderId, g)), g.add(h), V(h, C(h, v.current === 0 && d.current === null)), () => {
+          h.terminal = !0, g?.delete(h), g?.size === 0 && $.current.delete(h.leaderId);
+        };
+      },
+      publishEnterCompleted: () => {
+        r.disposed || r.enterCompleted || l.current.get(t)?.has(r.token) && (r.enterCompleted = !0, O(!1));
+      },
+      dispose: () => T(r)
+    };
+  }, [
+    T,
+    V,
+    C,
+    E,
+    O,
+    e,
+    S
+  ]), le = p((t, n) => {
+    const r = {
+      token: Symbol(t),
+      id: t,
+      lane: n,
+      disposed: !1
+    };
+    let c = m.current.get(t);
+    return c || (c = /* @__PURE__ */ new Map(), m.current.set(t, c)), c.set(r.token, r), E(), S(), { dispose: () => {
+      if (r.disposed) return;
+      r.disposed = !0;
+      const u = m.current.get(t);
+      u?.delete(r.token), u?.size === 0 && m.current.delete(t), E(), S();
+    } };
+  }, [E, S]), oe = p((t) => {
+    const n = l.current.get(t), r = n ? j(n) : void 0;
+    r && T(r);
+  }, [T]), se = p((t) => L.current.calculatedDelays.get(t) ?? w.current.get(t)?.delay ?? 0, []), ue = p(() => K.current, []);
+  return Q(() => {
+    S();
+  }, [a, S]), Q(() => {
+    M.current = !0;
+    const t = l.current, n = m.current, r = w.current, c = D.current, u = I.current, h = o.current, g = $.current;
+    return () => {
+      M.current = !1, d.current !== null && (clearTimeout(d.current), d.current = null), v.current = 0, t.clear(), n.clear(), r.clear(), c.clear(), u.clear(), h.clear(), g.clear();
+    };
+  }, []), {
+    timelineDuration: ne,
+    isStable: ae,
+    beginPreparation: ce,
+    registerAnimate: ie,
+    declareAnimateLane: le,
+    unregisterAnimate: oe,
+    getCalculatedDelay: se,
+    getTimelineDuration: ue
+  };
+}
+export {
+  de as a,
+  we as i,
+  Z as n,
+  $e as r,
+  ve as t
+};
+
+//# sourceMappingURL=scene-animation-registry-8b0m_IaZ.mjs.map