cineview 0.0.1-beta

package/dist/element-track-Du10P12_.mjs

@@ -0,0 +1,316 @@
+import { useCallback as ht, useEffect as y, useRef as c } from "react";
+import { animate as F } from "framer-motion";
+var g = "time", J = {
+  time: 10,
+  percent: 1
+}, Et = {
+  unit: g,
+  scale: J[g]
+};
+function Ft(l) {
+  return l === "time" || l === "percent";
+}
+function vt(l) {
+  return l?.unit !== void 0 || l?.scale !== void 0;
+}
+function _t(l, v, p) {
+  const M = vt(v) ? v : l, C = M?.unit;
+  if (C !== void 0 && !Ft(C))
+    return p?.({
+      field: "unit",
+      value: C
+    }), {
+      unit: g,
+      scale: J.time
+    };
+  const k = C ?? "time", R = M?.scale;
+  return R !== void 0 && (typeof R != "number" || !Number.isFinite(R) || R < 0) ? (p?.({
+    field: "scale",
+    value: R
+  }), {
+    unit: k,
+    scale: J[k]
+  }) : {
+    unit: k,
+    scale: R ?? J[k]
+  };
+}
+function N(l, v, p) {
+  const M = Math.max(0, Number.isFinite(v) ? v : 0), C = Number.isFinite(p) ? p : 0, k = l.unit === "time" ? l.scale : M * l.scale / 100;
+  return Math.min(M, Math.max(0, C * k));
+}
+function Nt({ slideMode: l, isActive: v, sceneIndex: p, sceneOffset: M, globalDirection: C, globalIsDragging: k, candidateSuspended: R = !1, globalRenderProgress: tt, globalDragTimelineProgress: G, renderProgressMotion: rt, dragTimelineProgressMotion: A, dragRelease: z, firstSceneEnterReady: et, elementElapsedMotion: nt, getTimelineDuration: ut, timelineDurationState: bt, dragTransaction: O, preparedSnapshot: Q, requirePreparedSnapshot: ct = !1, dragMappingConfig: st, takeoverSnapshot: T, onElementContinuationChange: lt, onSettleComplete: ot, onColdStartComplete: at }) {
+  const r = c(null), a = c(null), o = c(0), V = c(null), S = c(null), W = c(!1), d = c(0), X = c(!1), B = c(ut);
+  B.current = ut;
+  const it = c(O);
+  it.current = O;
+  const Y = c(Q);
+  Y.current = Q;
+  const _ = c(ct);
+  _.current = ct;
+  const ft = c(null), Z = () => {
+    const t = it.current;
+    return t || (_.current ? null : Y.current ?? null);
+  }, D = (t) => t?.registrySnapshot.timelineDuration ?? B.current(), mt = (t) => t?.mapping ?? kt.current, x = c(ot);
+  x.current = ot;
+  const L = c(at);
+  L.current = at;
+  const pt = c(lt);
+  pt.current = lt;
+  const $ = c(!1), f = (t) => {
+    $.current !== t && ($.current = t, pt.current?.(t));
+  }, b = c(nt);
+  b.current = nt;
+  const I = c(null), w = c(null), H = c(null), K = c(null), kt = c(st ?? Et);
+  kt.current = st ?? Et;
+  const P = c(A?.get() ?? G);
+  return P.current = A?.get() ?? G, y(() => {
+    if (!(l !== "drag" || !R) && r.current) {
+      if ($.current) {
+        I.current = Math.max(0, b.current.get());
+        const t = T?.current, u = t?.sceneIndices.includes(p) ?? !1;
+        H.current = u ? t.token : null, w.current = u ? t.baseRatio : null, K.current = null;
+      }
+      o.current += 1, r.current.stop(), r.current = null, a.current = null;
+    }
+  }, [
+    R,
+    p,
+    l,
+    T
+  ]), y(() => {
+    if (R || k) return;
+    const t = H.current, u = T?.current;
+    t !== null && u?.token === t && u.baseRatio !== null || (I.current = null, w.current = null, H.current = null, K.current = null);
+  }, [
+    R,
+    k,
+    T
+  ]), y(() => {
+    if (l !== "drag" || !k) return;
+    r.current && (r.current.stop(), r.current = null, a.current = null), f(!1), W.current = !0, X.current = !1;
+    const t = (u) => {
+      P.current = u;
+      const s = rt?.get() ?? tt, e = s > 1e-4 ? "forward" : s < -1e-4 ? "backward" : C;
+      if (!(e === "forward" && M === 1 || e === "backward" && M === -1)) return;
+      const n = Z();
+      if (_.current && !n) return;
+      const m = D(n), h = Math.max(0, Math.min(u, 1)), i = mt(n), E = I.current;
+      if (E !== null) {
+        const U = T?.current, j = H.current;
+        if (j !== null && U?.token === j && U.sceneIndices.includes(p) && U.baseRatio !== null) {
+          const q = U.baseRatio;
+          if (w.current = q, K.current !== j && Math.abs(Math.abs(s) - q) <= 1e-6 && Math.abs(h - U.staleRatio) <= 1e-6 && Math.abs(h - q) > 1e-6) {
+            K.current = j;
+            return;
+          }
+          const Ut = N(i, m, q * 100), yt = N(i, m, h * 100);
+          b.current.set(Math.max(0, Math.min(m, E + yt - Ut)));
+          return;
+        }
+        const Rt = w.current;
+        if (Rt === null) {
+          w.current = h;
+          return;
+        }
+        const Mt = N(i, m, Rt * 100), Ct = N(i, m, h * 100);
+        b.current.set(Math.max(0, Math.min(m, E + Ct - Mt)));
+        return;
+      }
+      b.current.set(N(i, m, h * 100));
+    };
+    if (t(A?.get() ?? G), A) return A.on("change", t);
+  }, [
+    l,
+    k,
+    G,
+    tt,
+    A,
+    rt,
+    C,
+    M,
+    p,
+    T,
+    O?.transactionId
+  ]), y(() => {
+    if (l !== "drag" || R) return;
+    const t = z;
+    if (!t || t.targetSceneIndex !== p) return;
+    const u = Z();
+    if (_.current && !u || V.current === t.token) return;
+    V.current = t.token;
+    const s = ++o.current;
+    r.current?.stop(), r.current = null, f(!1);
+    const e = b.current, n = D(u), m = typeof t.progressRatio == "number" ? t.progressRatio : P.current, h = u && "releaseSeed" in u ? u.releaseSeed.elapsedMs : N(mt(u), n, Math.max(0, Math.min(m, 1)) * 100), i = Math.max(0, e.get(), h);
+    if (i > e.get() && e.set(i), t.mode === "enter") {
+      if (e.set(0), n <= 1e-3) {
+        e.set(n);
+        return;
+      }
+      a.current = "cold-start", r.current = F(e, n, {
+        duration: n / 1e3,
+        ease: "linear",
+        onUpdate: (E) => {
+          o.current === s && e.set(E);
+        },
+        onComplete: () => {
+          o.current === s && (r.current = null, a.current = null, e.set(n));
+        }
+      });
+    } else if (t.mode === "settle") {
+      const E = n - i;
+      if (E <= 1e-3) {
+        f(!1), e.set(n), S.current = t.token, x.current?.();
+        return;
+      }
+      a.current = "settle", f(!0), r.current = F(e, n, {
+        duration: E / 1e3,
+        ease: "linear",
+        onUpdate: (U) => {
+          o.current === s && e.set(U);
+        },
+        onComplete: () => {
+          o.current === s && (r.current = null, a.current = null, f(!1), e.set(n), S.current = t.token, x.current?.());
+        }
+      });
+    } else {
+      if (i <= 1e-3) {
+        f(!1), e.set(0);
+        return;
+      }
+      const E = Math.min(Math.max(i, 0) * 0.5, 300);
+      a.current = "bounce", f(!0), r.current = F(e, 0, {
+        duration: E / 1e3,
+        ease: "easeOut",
+        onUpdate: (U) => {
+          o.current === s && e.set(U);
+        },
+        onComplete: () => {
+          o.current === s && (r.current = null, a.current = null, f(!1), e.set(0));
+        }
+      });
+    }
+  }, [
+    l,
+    z?.token,
+    p,
+    O?.transactionId
+  ]), y(() => {
+    if (l !== "drag" || R || k) return;
+    const t = z;
+    if (!t || t.mode === "enter" || t.targetSceneIndex !== p || V.current !== t.token || t.mode === "settle" && S.current === t.token || r.current) return;
+    const u = Z();
+    if (_.current && !u) return;
+    const s = b.current, e = Math.max(0, s.get());
+    if (t.mode === "bounce") {
+      if (e <= 1e-3) {
+        f(!1), s.set(0);
+        return;
+      }
+      const i = ++o.current;
+      a.current = "bounce", f(!0), r.current = F(s, 0, {
+        duration: Math.min(e * 0.5, 300) / 1e3,
+        ease: "easeOut",
+        onUpdate: (E) => {
+          o.current === i && s.set(E);
+        },
+        onComplete: () => {
+          o.current === i && (r.current = null, a.current = null, f(!1), s.set(0));
+        }
+      });
+      return;
+    }
+    const n = D(u), m = n - e;
+    if (m <= 1e-3) {
+      f(!1), s.set(n), S.current = t.token, x.current?.();
+      return;
+    }
+    const h = ++o.current;
+    a.current = "settle", f(!0), r.current = F(s, n, {
+      duration: m / 1e3,
+      ease: "linear",
+      onUpdate: (i) => {
+        o.current === h && s.set(i);
+      },
+      onComplete: () => {
+        o.current === h && (r.current = null, a.current = null, f(!1), s.set(n), S.current = t.token, x.current?.());
+      }
+    });
+  }, [
+    l,
+    R,
+    k,
+    z?.token,
+    p
+  ]), y(() => {
+    if (l !== "drag" || p !== 0 || !et || k) return;
+    const t = b.current;
+    if (!W.current) {
+      const n = Y.current ?? null;
+      if (_.current && !n) return;
+      ft.current = n;
+      const m = D(n);
+      W.current = !0, X.current = n === null, d.current = m;
+      const h = m - Math.max(0, t.get());
+      if (h <= 1e-3) {
+        t.set(m), L.current?.();
+        return;
+      }
+      const i = ++o.current;
+      a.current = "cold-start", r.current = F(t, m, {
+        duration: h / 1e3,
+        ease: "linear",
+        onUpdate: (E) => {
+          o.current === i && t.set(E);
+        },
+        onComplete: () => {
+          o.current === i && (r.current = null, a.current = null, t.set(d.current), L.current?.());
+        }
+      });
+      return;
+    }
+    if (!X.current || ft.current) return;
+    const u = B.current();
+    if (u <= d.current + 1e-3) return;
+    r.current?.stop(), d.current = u;
+    const s = u - Math.max(0, t.get());
+    if (s <= 1e-3) {
+      t.set(u), r.current = null, a.current = null, L.current?.();
+      return;
+    }
+    const e = ++o.current;
+    a.current = "cold-start", r.current = F(t, u, {
+      duration: s / 1e3,
+      ease: "linear",
+      onUpdate: (n) => {
+        o.current === e && t.set(n);
+      },
+      onComplete: () => {
+        o.current === e && (r.current = null, a.current = null, t.set(d.current), L.current?.());
+      }
+    });
+  }, [
+    l,
+    p,
+    et,
+    k,
+    bt,
+    Q?.revision
+  ]), y(() => () => {
+    r.current?.stop(), r.current = null, f(!1);
+  }, []), {
+    completeImmediately: ht(() => {
+      o.current += 1, r.current?.stop(), r.current = null, a.current = null, f(!1), b.current.set(B.current());
+    }, []),
+    resetImmediately: ht(() => {
+      o.current += 1, r.current?.stop(), r.current = null, a.current = null, f(!1), b.current.set(0);
+    }, [])
+  };
+}
+export {
+  N as n,
+  _t as r,
+  Nt as t
+};
+
+//# sourceMappingURL=element-track-Du10P12_.mjs.map

package/dist/entry-drag.d.ts

@@ -0,0 +1,14 @@
+// 由 scripts/build-all.mjs 生成，请勿手改。
+// 拖拽专用入口的类型面：与全量入口的唯一差异是 `Cineview` 不接受 `mode`
+// （本产物只含拖拽引擎；需要另一种模式请用 "cineview/scroll"，
+// 需要运行时按 mode 切换请用 "cineview"）。
+import type { ForwardRefExoticComponent, RefAttributes } from 'react';
+import type { CineviewProps, CineviewRef } from './index';
+
+export * from './index';
+
+export declare type CineviewDragProps = Omit<Extract<CineviewProps, { mode?: 'drag' }>, 'mode'>;
+
+export declare const Cineview: ForwardRefExoticComponent<
+    CineviewDragProps & RefAttributes<CineviewRef>
+>;

package/dist/entry-scroll.d.ts

@@ -0,0 +1,14 @@
+// 由 scripts/build-all.mjs 生成，请勿手改。
+// 滚动专用入口的类型面：与全量入口的唯一差异是 `Cineview` 不接受 `mode`
+// （本产物只含滚动引擎；需要另一种模式请用 "cineview/drag"，
+// 需要运行时按 mode 切换请用 "cineview"）。
+import type { ForwardRefExoticComponent, RefAttributes } from 'react';
+import type { CineviewProps, CineviewRef } from './index';
+
+export * from './index';
+
+export declare type CineviewScrollProps = Omit<Extract<CineviewProps, { mode: 'scroll' }>, 'mode'>;
+
+export declare const Cineview: ForwardRefExoticComponent<
+    CineviewScrollProps & RefAttributes<CineviewRef>
+>;

package/dist/fade-DXxFsgxR.mjs

@@ -0,0 +1,22 @@
+var i = {
+  fade: {
+    initial: { opacity: 0 },
+    animate: { opacity: 1 },
+    exit: { opacity: 0 }
+  },
+  "fade-in": {
+    initial: { opacity: 0 },
+    animate: { opacity: 1 },
+    exit: { opacity: 1 }
+  },
+  "fade-out": {
+    initial: { opacity: 1 },
+    animate: { opacity: 1 },
+    exit: { opacity: 0 }
+  }
+};
+export {
+  i as fadeAnimations
+};
+
+//# sourceMappingURL=fade-DXxFsgxR.mjs.map

package/dist/flip-CrCoNIws.mjs

@@ -0,0 +1,49 @@
+var t = {
+  flip: {
+    initial: {
+      rotateY: -180,
+      opacity: 0
+    },
+    animate: {
+      rotateY: 0,
+      opacity: 1
+    },
+    exit: {
+      rotateY: 180,
+      opacity: 0
+    }
+  },
+  "flip-x": {
+    initial: {
+      rotateX: -180,
+      opacity: 0
+    },
+    animate: {
+      rotateX: 0,
+      opacity: 1
+    },
+    exit: {
+      rotateX: 180,
+      opacity: 0
+    }
+  },
+  "flip-y": {
+    initial: {
+      rotateY: -180,
+      opacity: 0
+    },
+    animate: {
+      rotateY: 0,
+      opacity: 1
+    },
+    exit: {
+      rotateY: 180,
+      opacity: 0
+    }
+  }
+};
+export {
+  t as flipAnimations
+};
+
+//# sourceMappingURL=flip-CrCoNIws.mjs.map

package/dist/hooks/imagePreloadCache.d.ts

@@ -0,0 +1,4 @@
+export declare function markImageAsPreloaded(url: string): void;
+export declare function isImagePreloaded(url: string): boolean;
+export declare function subscribeToPreloadedImages(listener: (url: string) => void): () => void;
+export declare function resetPreloadedImageCache(): void;

package/dist/hooks/mediaPreloadCache.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Media preload cache (video blobs), parallel to imagePreloadCache.
+ *
+ * Unlike images where `onload` means ready, video scrub requires the entire
+ * buffer to be seekable. This cache defines "ready" as "video blob fetched
+ * and seekable", and waits for it as part of priorityComplete in the first-screen
+ * cold-start gate. Eviction revokes objectURLs. Disabled in SSR/no-window environments.
+ */
+export type MediaKind = 'video';
+/** Infers media type from URL extension; returns null for non-video (caller can pass explicit kind). */
+export declare function inferMediaKind(src: string): MediaKind | null;
+export declare function isMediaPreloaded(src: string): boolean;
+export declare function getVideoObjectUrl(src: string): string | undefined;
+export declare function subscribeToPreloadedMedia(listener: (url: string) => void): () => void;
+/**
+ * Acquires and leases an objectURL for a mounted video consumer. LRU must not revoke
+ * URLs while leases exist. Each successful acquire must be paired with one release.
+ */
+export declare function acquireVideoObjectUrl(src: string): string | undefined;
+/** Releases the mounted consumer's lease; retries budget eviction immediately after the last lease is released. */
+export declare function releaseVideoObjectUrl(src: string): void;
+/**
+ * Preloads a media resource. Already ready → resolves immediately; in-flight → reuses
+ * same Promise (deduplication). When kind is missing, infers from extension; inference
+ * failure rejects. Failure clears in-flight record, allowing retries.
+ */
+export declare function preloadMedia(src: string, kind?: MediaKind): Promise<void>;
+/** Sets LRU byte budget (default 128MB). Immediately evicts to new budget after setting. */
+export declare function setMediaByteBudget(bytes: number): void;
+/** Test/hot-reload reset: clears cache and revokes all objectURLs. */
+export declare function resetMediaPreloadCache(): void;

package/dist/hooks/useFirstSceneEnter.d.ts

@@ -0,0 +1,65 @@
+import { CineviewErrorCode } from '../types';
+/**
+ * Global first-screen cold-start gate. Mode-agnostic: owns the two decoupled
+ * booleans that govern when the first mounted scene is allowed to play its
+ * one-shot enter pass, plus the priority-asset / timeout / preventDefault /
+ * static-reveal coordination that used to live inline in Cineview.
+ *
+ * Two-boolean model (intentionally NOT a 3-state enum — see project memory):
+ * - `firstSceneEnterActive` — the WINDOW flag. While true, the first scene is
+ *   held at / playing its enter pass instead of snapping to rest. In drag mode
+ *   `useAnimateDrag` reads it; in scroll mode it is inert (the scroll visibility
+ *   path gates on `firstSceneEnterReady` only), but kept so the lifecycle is
+ *   identical across modes.
+ * - `firstSceneEnterReady` — the START trigger. Turns true once first-screen
+ *   priority assets settle (or are forced ready). `(active=true, ready=false)`
+ *   means "held at initial, not yet entering" (pre-load and the preventDefault
+ *   path); `(active=false, ready=true)` is the completed-extendable state.
+ *
+ * This hook owns the GATING SIGNAL only — it never runs the enter tween itself.
+ * Each mode's element track / visibility state machine consumes `ready` and
+ * plays its own animation; drag clears the window via `handleComplete` when its
+ * element track reaches T. Scroll leaves the (inert) window as-is.
+ */
+export interface UseFirstSceneEnterParams {
+    /** Whether the cold-start mechanism is engaged at all (false → reveal statically). */
+    enabled: boolean;
+    /** Whether a first scene exists to drive. */
+    hasFirstScene: boolean;
+    /** First-screen priority assets are ready (preloadState.priorityComplete). */
+    priorityComplete: boolean;
+    /** Fallback timeout before emitting FIRST_SCENE_TIMEOUT and revealing statically. */
+    timeoutMs: number;
+    /**
+     * When true, an external owner has preempted the cold start (e.g. the user
+     * grabbed the first scene mid-enter in drag mode). Clears both flags so the
+     * gesture fully owns the track. Scroll passes false.
+     */
+    preemptSignal?: boolean;
+    /**
+     * Routes a recoverable FIRST_SCENE_TIMEOUT to the consumer. Returns true if
+     * the consumer handled it (preventDefault) — in which case the scene is left
+     * at its initial visual for consumer-driven recovery instead of static reveal.
+     */
+    emitRecoverableError: (code: CineviewErrorCode, message: string, context?: Record<string, unknown>) => boolean;
+    /** Lazily read preload counts for the timeout error context. */
+    getPreloadCounts: () => {
+        loadedCount: number;
+        totalCount: number;
+    };
+}
+export type FirstSceneActivationKind = 'ready' | 'static';
+export interface UseFirstSceneEnterResult {
+    firstSceneEnterActive: boolean;
+    firstSceneEnterReady: boolean;
+    /**
+     * Monotonic one-shot signal for the first Scene's formal activation. Asset
+     * readiness and the default timeout fallback activate; a handled timeout or
+     * pointer preemption does not.
+     */
+    firstSceneActivationToken: number;
+    firstSceneActivationKind: FirstSceneActivationKind | null;
+    /** Clears the window once the first scene's enter pass reaches its terminal. */
+    handleComplete: () => void;
+}
+export declare function useFirstSceneEnter({ enabled, hasFirstScene, priorityComplete, timeoutMs, preemptSignal, emitRecoverableError, getPreloadCounts, }: UseFirstSceneEnterParams): UseFirstSceneEnterResult;

package/dist/hooks/useImagePreloader.d.ts

@@ -0,0 +1,31 @@
+/**
+ * useImagePreloader Hook
+ * Manages image preload queue and progress tracking
+ */
+export interface ImageLoadResult {
+    url: string;
+    success: boolean;
+    error?: Error;
+}
+export interface UseImagePreloaderOptions {
+    priorityUrls?: string[];
+    backgroundUrls?: string[];
+    onProgress?: (progress: number) => void;
+    onComplete?: (results: ImageLoadResult[]) => void;
+    onError?: (url: string, error: Error) => void;
+}
+export interface UseImagePreloaderState {
+    isLoading: boolean;
+    progress: number;
+    loadedCount: number;
+    totalCount: number;
+    results: ImageLoadResult[];
+    errors: Map<string, Error>;
+    priorityComplete: boolean;
+}
+export interface UseImagePreloaderActions {
+    startPreload: () => Promise<void>;
+    reset: () => void;
+    addUrls: (urls: string[], priority?: boolean) => void;
+}
+export declare const useImagePreloader: (options?: UseImagePreloaderOptions) => [UseImagePreloaderState, UseImagePreloaderActions];

package/dist/hooks/usePrefersReducedMotion.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The OS "reduce motion" preference.
+ *
+ * It is an external input that can flip while a scene stays mounted, so it is read
+ * through `useSyncExternalStore` rather than sampled once. The server snapshot is
+ * `false`: SSR has no media query, and rendering the reduced variant into HTML that
+ * a full-motion client then hydrates would be the wrong default.
+ *
+ * Read this once at the Cineview root and pass it down the runtime context — one
+ * matchMedia subscription per root, not one per Animate.
+ */
+export declare function usePrefersReducedMotion(): boolean;

package/dist/hooks/useSceneManager.d.ts

@@ -0,0 +1,79 @@
+import { ScrollMode } from '../types';
+export interface DragRelease {
+    token: number;
+    mode: 'settle' | 'bounce' | 'enter';
+    direction: 'forward' | 'backward';
+    targetSceneIndex: number;
+    progressRatio?: number;
+}
+export type DragReleaseInput = Omit<DragRelease, 'token'>;
+export interface ScrollTransitionSnapshot {
+    fromScene: number;
+    toScene: number;
+    direction: 'forward' | 'backward';
+    progressRatio: number;
+    startedAt: number;
+    lastInputAt: number;
+    isSettling: boolean;
+    settleDirection: 'forward' | 'backward' | null;
+}
+export interface UseSceneManagerOptions {
+    totalScenes: number;
+    initialScene?: number;
+    mode?: ScrollMode;
+    onBeforeChange?: (from: number, to: number) => void;
+    /**
+     * Fires at the authoritative index commit. Unlike onAfterChange, this is not a
+     * lifecycle notification and is used internally to mint Scene activation tokens.
+     */
+    onCommit?: (sceneIndex: number, previousIndex: number, kind: 'drag' | 'programmatic') => void;
+    onAfterChange?: (sceneIndex: number, previousIndex?: number) => void;
+}
+export interface SceneManagerState {
+    currentScene: number;
+    isAnimating: boolean;
+    direction: 'forward' | 'backward' | null;
+    dragProgress: number;
+    dragTimelineProgress: number;
+    scrollProgress: number;
+    scrollDirection: 'forward' | 'backward' | null;
+    renderProgress: number;
+    isDragging: boolean;
+    isScrolling: boolean;
+    sharedTimelineDurationMs: number;
+    dragRelease: DragRelease | null;
+    scrollTransitionSnapshot: ScrollTransitionSnapshot | null;
+}
+export interface SceneManagerActions {
+    reconcileSceneList: (index: number) => void;
+    goToScene: (index: number, animated?: boolean) => void;
+    nextScene: () => void;
+    prevScene: () => void;
+    setAnimating: (animating: boolean) => void;
+    canGoNext: () => boolean;
+    canGoPrev: () => boolean;
+    setDragProgress: (progress: number) => void;
+    setDragTimelineProgress: (progress: number) => void;
+    setScrollProgress: (progress: number) => void;
+    setScrollDirection: (direction: 'forward' | 'backward' | null) => void;
+    setScrollTransitionSnapshot: (snapshot: ScrollTransitionSnapshot | null) => void;
+    setRenderProgress: (progress: number) => void;
+    setIsDragging: (dragging: boolean) => void;
+    setIsScrolling: (scrolling: boolean) => void;
+    setSharedTimelineDurationMs: (duration: number) => void;
+    setDragRelease: (release: DragReleaseInput | null) => void;
+    resetDragInteraction: () => void;
+    /** Ends a superseded settle/bounce join without changing the current render position. */
+    abortDragContinuation: () => void;
+    resetScrollInteraction: () => void;
+    /**
+     * Applies a drag commit. Returns `true` when the scene index actually moved.
+     * An out-of-bounds target returns `false` WITHOUT touching `currentScene`, so
+     * callers that arm work on the scene-change render must disarm it on `false`.
+     */
+    commitDragSceneChange: (direction: 'forward' | 'backward', progressRatio: number, elapsedMs?: number, timelineDuration?: number) => boolean;
+    completeDragTransition: () => void;
+    commitScrollSceneChange: (direction: 'forward' | 'backward', progressRatio: number) => void;
+    clearScrollTransitionSnapshot: () => void;
+}
+export declare const useSceneManager: (options: UseSceneManagerOptions) => [SceneManagerState, SceneManagerActions];

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CineView React UI Framework
+ * A React UI framework for creating cinematic full-screen sliding page introductions
+ *
+ * This entry point is **full-featured**: `CineView` is a runtime-dispatched component
+ * based on `mode`, and both engines are included in the bundle.
+ * Maintains existing behavior and export surface (default `mode='drag'`).
+ *
+ * For single-mode usage with smaller bundle size, use mode-specific entry points
+ * (especially relevant for UMD consumers, as single-file UMD cannot code-split
+ * and the full entry point will always include both engines):
+ *   - `cineview/drag`   → drag engine only
+ *   - `cineview/scroll` → scroll engine only
+ * See `src/entry-drag.ts` / `src/entry-scroll.ts`.
+ */
+export * from './public-api';
+export { Cineview } from './components/Cineview';