saccade 0.0.3 → 0.2.0

package/dist/core.cjs

@@ -26,21 +26,29 @@ __export(core_exports, {
   TimingController: () => TimingController,
   formatExportForLLM: () => formatExportForLLM,
   generateExport: () => generateExport,
-  getFrameAtTime: () => getFrameAtTime
+  getFrameAtTime: () => getFrameAtTime,
+  getSharedEngine: () => getSharedEngine,
+  resetSharedEngine: () => resetSharedEngine
 });
 module.exports = __toCommonJS(core_exports);
 
 // src/core/timing.ts
+var MEDIA_RATE_MIN = 0.0625;
+var MEDIA_RATE_MAX = 16;
+var ZERO_SPEED_DIVISOR = 1e-4;
 var TimingController = class {
   constructor() {
     this.speed = 1;
     this.virtualBaseline = 0;
     this.intervalMap = /* @__PURE__ */ new Map();
     this.nextIntervalId = 1e6;
-    this.mediaObserver = null;
-    this.animObserver = null;
     this._origAnimate = null;
     this.installed = false;
+    this.animPollId = 0;
+    this.gsapInstance = null;
+    // WeakMap tracking for animations and media
+    this.trackedAnims = /* @__PURE__ */ new WeakMap();
+    this.trackedMedia = /* @__PURE__ */ new WeakMap();
     this._raf = requestAnimationFrame.bind(window);
     this._caf = cancelAnimationFrame.bind(window);
     this._setTimeout = setTimeout.bind(window);
@@ -50,19 +58,34 @@ var TimingController = class {
     this._perfNow = performance.now.bind(performance);
     this._dateNow = Date.now;
     this.realBaseline = this._perfNow();
+    this.dateRealBaseline = this._dateNow();
+    this.dateVirtualBaseline = this.dateRealBaseline;
   }
   getVirtualTime() {
     const realElapsed = this._perfNow() - this.realBaseline;
     return this.virtualBaseline + realElapsed * this.speed;
   }
+  getVirtualDateNow() {
+    const realElapsed = this._dateNow() - this.dateRealBaseline;
+    return this.dateVirtualBaseline + realElapsed * this.speed;
+  }
   reanchor() {
     const virtualNow = this.getVirtualTime();
     this.realBaseline = this._perfNow();
     this.virtualBaseline = virtualNow;
+    const virtualDateNow = this.getVirtualDateNow();
+    this.dateRealBaseline = this._dateNow();
+    this.dateVirtualBaseline = virtualDateNow;
+  }
+  /** Effective speed divisor — avoids division by zero at speed=0. */
+  get speedDivisor() {
+    return this.speed || ZERO_SPEED_DIVISOR;
   }
   /** Install timing patches. Safe to call multiple times. */
   install() {
     if (this.installed) return;
+    if (window.__saccadeInstalled) return;
+    window.__saccadeInstalled = true;
     this.installed = true;
     const self = this;
     window.__LAPSE_ORIGINAL_RAF__ = this._raf;
@@ -71,21 +94,27 @@ var TimingController = class {
     Element.prototype.animate = function(...args) {
       const anim = origAnimate.apply(this, args);
       if (self.speed !== 1) {
-        anim.playbackRate = self.speed || 1e-3;
+        const originalRate = anim.playbackRate;
+        const applied = originalRate * (self.speed || 1e-3);
+        anim.playbackRate = applied;
+        self.trackedAnims.set(anim, { original: originalRate, applied });
       }
       return anim;
     };
     performance.now = () => self.getVirtualTime();
-    const dateBaseline = this._dateNow();
-    Date.now = () => dateBaseline + self.getVirtualTime();
+    Date.now = () => self.getVirtualDateNow();
     window.requestAnimationFrame = (callback) => {
       return self._raf(() => {
+        if (self.speed === 0) {
+          window.requestAnimationFrame(callback);
+          return;
+        }
         callback(self.getVirtualTime());
       });
     };
     window.cancelAnimationFrame = this._caf;
     window.setTimeout = ((handler, delay, ...args) => {
-      const scaledDelay = (delay ?? 0) / (self.speed || 1);
+      const scaledDelay = (delay ?? 0) / self.speedDivisor;
       return self._setTimeout(handler, scaledDelay, ...args);
     });
     window.clearTimeout = this._clearTimeout;
@@ -93,7 +122,7 @@ var TimingController = class {
       const id = self.nextIntervalId++;
       const baseDelay = delay ?? 0;
       function tick() {
-        const scaledDelay = baseDelay / (self.speed || 1);
+        const scaledDelay = baseDelay / self.speedDivisor;
         const realId = self._setTimeout(() => {
           if (typeof handler === "function") {
             ;
@@ -118,61 +147,99 @@ var TimingController = class {
         self._clearInterval(id);
       }
     });
-    this.mediaObserver = new MutationObserver((mutations) => {
-      for (const mutation of mutations) {
-        for (const node of mutation.addedNodes) {
-          if (node instanceof HTMLVideoElement || node instanceof HTMLAudioElement) {
-            node.playbackRate = self.speed;
-          }
-        }
-      }
-    });
-    if (document.body) {
-      this.mediaObserver.observe(document.body, { childList: true, subtree: true });
-    }
+    this.startAnimationPoll();
   }
   /** Set playback speed. Requires install() first. */
   setSpeed(newSpeed) {
     if (!this.installed) this.install();
     this.reanchor();
     this.speed = newSpeed;
-    document.querySelectorAll("video, audio").forEach((el) => {
-      ;
-      el.playbackRate = newSpeed;
-    });
     this.patchAnimations();
+    this.patchMedia();
+    this.patchGSAP();
+  }
+  getSpeed() {
+    return this.speed;
   }
-  /** Patch playbackRate on all active CSS transitions/animations via WAAPI. */
+  // ---------------------------------------------------------------------------
+  // Animation polling — per-frame via original rAF
+  // ---------------------------------------------------------------------------
+  startAnimationPoll() {
+    const poll = () => {
+      if (!this.installed) return;
+      this.patchAnimations();
+      this.patchMedia();
+      this.animPollId = this._raf(poll);
+    };
+    this.animPollId = this._raf(poll);
+  }
+  /** Patch playbackRate on all active animations via WAAPI. */
   patchAnimations() {
     try {
       const anims = document.getAnimations();
       for (const anim of anims) {
         const target = anim.effect?.target;
         if (target?.closest?.("[data-lapse-panel]")) continue;
-        anim.playbackRate = this.speed || 1e-3;
+        if (target?.closest?.("[data-saccade-exclude]")) continue;
+        const effectiveSpeed = this.speed || 1e-3;
+        let tracked = this.trackedAnims.get(anim);
+        if (!tracked) {
+          tracked = { original: anim.playbackRate, applied: anim.playbackRate };
+          this.trackedAnims.set(anim, tracked);
+        } else if (anim.playbackRate !== tracked.applied) {
+          tracked.original = anim.playbackRate;
+        }
+        const desired = tracked.original * effectiveSpeed;
+        if (anim.playbackRate !== desired) {
+          anim.playbackRate = desired;
+          tracked.applied = desired;
+        }
       }
     } catch {
     }
-    if (!this.animObserver) {
-      this.animObserver = this._setInterval(() => {
-        if (!this.installed) return;
-        try {
-          const anims = document.getAnimations();
-          for (const anim of anims) {
-            const target = anim.effect?.target;
-            if (target?.closest?.("[data-lapse-panel]")) continue;
-            if (anim.playbackRate !== this.speed) {
-              anim.playbackRate = this.speed || 1e-3;
-            }
-          }
-        } catch {
+  }
+  /** Patch playbackRate on all video/audio elements. */
+  patchMedia() {
+    try {
+      document.querySelectorAll("video, audio").forEach((node) => {
+        const el = node;
+        if (el.closest?.("[data-lapse-panel]")) return;
+        if (el.closest?.("[data-saccade-exclude]")) return;
+        let tracked = this.trackedMedia.get(el);
+        if (!tracked) {
+          tracked = { original: el.playbackRate, applied: el.playbackRate };
+          this.trackedMedia.set(el, tracked);
+        } else if (el.playbackRate !== tracked.applied) {
+          tracked.original = el.playbackRate;
         }
-      }, 100);
+        const desired = Math.min(MEDIA_RATE_MAX, Math.max(MEDIA_RATE_MIN, tracked.original * (this.speed || MEDIA_RATE_MIN)));
+        if (el.playbackRate !== desired) {
+          el.playbackRate = desired;
+          tracked.applied = desired;
+        }
+      });
+    } catch {
     }
   }
-  getSpeed() {
-    return this.speed;
+  /**
+   * Register a GSAP instance (for ES-module imports where window.gsap is
+   * undefined). Applies the current timeScale immediately if speed !== 1.
+   */
+  registerGSAP(gsap) {
+    this.gsapInstance = gsap;
+    if (this.speed !== 1) this.patchGSAP();
+  }
+  /** Sync GSAP's global timeline if present. */
+  patchGSAP() {
+    try {
+      const gsap = this.gsapInstance ?? window.gsap;
+      gsap?.globalTimeline?.timeScale(this.speed || 1e-3);
+    } catch {
+    }
   }
+  // ---------------------------------------------------------------------------
+  // Cleanup
+  // ---------------------------------------------------------------------------
   /** Restore all patched APIs to originals. */
   destroy() {
     if (!this.installed) return;
@@ -192,19 +259,33 @@ var TimingController = class {
       Element.prototype.animate = this._origAnimate;
       this._origAnimate = null;
     }
-    this.mediaObserver?.disconnect();
-    this.mediaObserver = null;
-    if (this.animObserver != null) {
-      this._clearInterval(this.animObserver);
-      this.animObserver = null;
+    if (this.animPollId) {
+      this._caf(this.animPollId);
+      this.animPollId = 0;
     }
     try {
       for (const anim of document.getAnimations()) {
-        anim.playbackRate = 1;
+        const tracked = this.trackedAnims.get(anim);
+        anim.playbackRate = tracked?.original ?? 1;
       }
     } catch {
     }
+    try {
+      document.querySelectorAll("video, audio").forEach((node) => {
+        const el = node;
+        const tracked = this.trackedMedia.get(el);
+        el.playbackRate = tracked?.original ?? 1;
+      });
+    } catch {
+    }
+    try {
+      const gsap = this.gsapInstance ?? window.gsap;
+      gsap?.globalTimeline?.timeScale(1);
+    } catch {
+    }
+    this.gsapInstance = null;
     delete window.__LAPSE_ORIGINAL_RAF__;
+    delete window.__saccadeInstalled;
     this.installed = false;
   }
 };
@@ -274,6 +355,10 @@ var SNAPSHOT_ATTRS = [
   "data-hover",
   "data-at-boundary",
   "data-scrubbing",
+  "data-starting-style",
+  "data-ending-style",
+  "data-panel-open",
+  "data-hidden",
   "aria-checked",
   "aria-selected",
   "aria-expanded",
@@ -287,6 +372,7 @@ var SNAPSHOT_ATTRS = [
   "checked",
   "disabled",
   "hidden",
+  "inert",
   "value",
   "class",
   "style"
@@ -418,6 +504,8 @@ var _TimelineRecorder = class _TimelineRecorder {
     // ---- WAAPI interception --------------------------------------------------
     /** Animations captured via Element.prototype.animate monkey-patch. */
     this.interceptedAnimations = [];
+    // ---- Seekable WAAPI clones (created in stopRecording for scrubbing) -----
+    this.seekableClones = /* @__PURE__ */ new Map();
     this.hiddenSince = null;
     this.onVisibilityChange = null;
     /** Set to true when the capture loop self-terminates due to limits. */
@@ -468,6 +556,7 @@ var _TimelineRecorder = class _TimelineRecorder {
     this.portalIdCounter = 0;
     this.currentPortalIds.clear();
     this.capturedPortals.clear();
+    this.seekableClones.clear();
     this.prevInlineStyles.clear();
     this.jsAnimStartTimes.clear();
     this.jsAnimLastSeen.clear();
@@ -821,6 +910,13 @@ var _TimelineRecorder = class _TimelineRecorder {
             } catch (_) {
             }
           }
+          const cleanedKeyframes = keyframes2.map((kf) => {
+            const clean = {};
+            for (const [k, v] of Object.entries(kf)) {
+              if (k !== "computedOffset" && k !== "composite") clean[k] = v;
+            }
+            return clean;
+          });
           this.animations.set(id, {
             id,
             name,
@@ -832,7 +928,9 @@ var _TimelineRecorder = class _TimelineRecorder {
             type,
             source,
             resolvedVars: Object.keys(resolvedVars).length > 0 ? resolvedVars : null,
-            conflicts
+            conflicts,
+            rawKeyframes: cleanedKeyframes,
+            rawTiming: { ...timing, fill: "both" }
           });
         }
         const keyframes = a.effect?.getKeyframes?.() || [];
@@ -1108,38 +1206,28 @@ var _TimelineRecorder = class _TimelineRecorder {
       } catch (_) {
       }
     }, 0);
-    if (this.frames.length > 0) {
-      const frame0 = this.frames[0];
-      if (frame0.elementSnapshots) {
-        for (const [sel, snap] of Object.entries(frame0.elementSnapshots)) {
-          const el = this.elements.get(sel);
-          if (!el || !el.isConnected) continue;
-          if (snap.__styles) {
-            for (const [prop, value] of Object.entries(snap.__styles)) {
-              if (SAFE_PROPS_SET.has(prop)) {
-                el.style.setProperty(prop, value, "important");
-              }
-            }
-          }
-          if (snap.__attrs) {
-            for (const [attr, value] of Object.entries(snap.__attrs)) {
-              if (attr === "checked") {
-                ;
-                el.checked = value === "true";
-              } else if (attr === "class" && value != null) {
-                el.className = value;
-              } else if (attr === "style") {
-              } else if (attr === "value" && value != null) {
-                ;
-                el.value = value;
-              } else if (value == null) {
-                el.removeAttribute(attr);
-              } else {
-                el.setAttribute(attr, value);
-              }
-            }
-          }
-        }
+    this.seekableClones.clear();
+    for (const [animId, animInfo] of this.animations) {
+      if (!animInfo.rawKeyframes?.length || !animInfo.rawTiming) continue;
+      if (animInfo.type === "JSAnimation") continue;
+      const firstColon = animId.indexOf(":");
+      const secondColon = animId.indexOf(":", firstColon + 1);
+      const elSelector = secondColon >= 0 ? animId.substring(secondColon + 1) : "";
+      const el = this.elements.get(elSelector);
+      if (!el?.isConnected) continue;
+      try {
+        const clone = el.animate(animInfo.rawKeyframes, {
+          ...animInfo.rawTiming,
+          fill: "both"
+        });
+        clone.pause();
+        clone.currentTime = 0;
+        this.seekableClones.set(animId, {
+          animation: clone,
+          element: el,
+          effect: clone.effect
+        });
+      } catch (_) {
       }
     }
     const duration = this.frames.length > 0 ? this.frames[this.frames.length - 1].time : 0;
@@ -1162,6 +1250,8 @@ var TimelineRecorder = _TimelineRecorder;
 // src/core/scrubber.ts
 var TimelineScrubber = class {
   constructor(state) {
+    /** Precomputed frame range per animation for O(1) before/after lookup. */
+    this.animFrameRanges = /* @__PURE__ */ new Map();
     /** Saved originals for restore on release */
     this._originalAnimate = null;
     this._originalRaf = null;
@@ -1171,36 +1261,24 @@ var TimelineScrubber = class {
     this.frames = state.frames;
     this.capturedPortals = state.capturedPortals;
     this.interceptedAnimations = state.interceptedAnimations;
-    this.SAFE_PROPS_SET = state.SAFE_PROPS_SET;
+    this.seekableClones = state.seekableClones;
     this._originalAnimate = window.__LAPSE_ORIGINAL_ANIMATE__ ?? null;
     this._originalRaf = window.__LAPSE_ORIGINAL_RAF__ ?? null;
     this._originalRemoveChild = window.__LAPSE_TIMELINE__?._removeChild ?? null;
     this._originalRemove = window.__LAPSE_TIMELINE__?._remove ?? null;
-  }
-  // ---------------------------------------------------------------------------
-  //  Selector helper — mirrors the recorder's getSelector so we can look up
-  //  elements by the same key the recorder used in frame.animations[].animationId
-  // ---------------------------------------------------------------------------
-  getSelector(el) {
-    if (!el || !el.tagName) return null;
-    const parts = [];
-    let current = el;
-    for (let i = 0; i < 5 && current && current.tagName && current.tagName !== "HTML"; i++) {
-      const tag = current.tagName.toLowerCase();
-      const parent = current.parentElement;
-      if (parent) {
-        const siblings = Array.from(parent.children);
-        const idx = siblings.indexOf(current) + 1;
-        parts.unshift(`${tag}:nth-child(${idx})`);
-      } else {
-        parts.unshift(tag);
+    for (let i = 0; i < this.frames.length; i++) {
+      for (const fa of this.frames[i].animations) {
+        const range = this.animFrameRanges.get(fa.animationId);
+        if (!range) {
+          this.animFrameRanges.set(fa.animationId, { first: i, last: i });
+        } else {
+          range.last = i;
+        }
       }
-      current = parent;
     }
-    return parts.join(" > ");
   }
   // ---------------------------------------------------------------------------
-  //  seekTo — scrub the DOM to match a specific timestamp
+  //  seekTo — scrub to a specific timestamp using WAAPI-native seeking
   // ---------------------------------------------------------------------------
   seekTo(timeMs) {
     if (!this.frames.length) return;
@@ -1248,6 +1326,34 @@ var TimelineScrubber = class {
         }
       }
     }
+    const activeAnimIds = /* @__PURE__ */ new Map();
+    for (const fa of frame.animations || []) {
+      activeAnimIds.set(fa.animationId, fa);
+    }
+    for (const [animId, clone] of this.seekableClones) {
+      const frameAnim = activeAnimIds.get(animId);
+      try {
+        if (frameAnim) {
+          if (!clone.animation.effect) {
+            clone.animation.effect = clone.effect;
+          }
+          clone.animation.currentTime = frameAnim.currentTime;
+        } else {
+          const range = this.animFrameRanges.get(animId);
+          if (!range || lo < range.first) {
+            clone.animation.effect = null;
+          } else {
+            if (!clone.animation.effect) {
+              clone.animation.effect = clone.effect;
+            }
+            const timing = clone.effect.getTiming();
+            const endTime = (typeof timing.duration === "number" ? timing.duration : 0) + (timing.delay || 0);
+            clone.animation.currentTime = endTime;
+          }
+        }
+      } catch {
+      }
+    }
     for (const entry of this.interceptedAnimations) {
       try {
         const anim = entry.animation;
@@ -1262,34 +1368,13 @@ var TimelineScrubber = class {
       const el = this.elements.get(sel);
       if (!el || !el.isConnected) continue;
       if (el.closest?.("[data-lapse-panel]")) continue;
-      const hasAnimation = (frame.animations || []).some(
-        (a) => a.animationId.endsWith(":" + sel) || a.animationId.includes(":" + sel.split(" > ").pop())
-      );
       const snapTyped = snap;
-      if (snapTyped.__styles) {
-        for (const [prop, value] of Object.entries(snapTyped.__styles)) {
-          if (this.SAFE_PROPS_SET.has(prop) || hasAnimation) {
-            el.style.setProperty(prop, value, "important");
-          }
-        }
-      }
       if (snapTyped.__attrs) {
         for (const [attr, value] of Object.entries(snapTyped.__attrs)) {
+          if (attr === "class" || attr === "style") continue;
           if (attr === "checked") {
             ;
             el.checked = value === "true";
-          } else if (attr === "class") {
-            if (value != null) el.className = value;
-          } else if (attr === "style") {
-            if (value) {
-              el.setAttribute("style", value);
-              el.style.transition = "none";
-              if (snapTyped.__styles) {
-                for (const [prop, val] of Object.entries(snapTyped.__styles)) {
-                  el.style.setProperty(prop, val, "important");
-                }
-              }
-            }
           } else if (attr === "value") {
             if (value != null) el.value = value;
           } else if (value == null) {
@@ -1300,39 +1385,31 @@ var TimelineScrubber = class {
         }
       }
     }
-    for (const anim of frame.animations || []) {
-      const firstColon = anim.animationId.indexOf(":");
-      const secondColon = anim.animationId.indexOf(":", firstColon + 1);
-      const animSel = secondColon >= 0 ? anim.animationId.substring(secondColon + 1) : "";
-      const animEl = this.elements.get(animSel);
-      if (!animEl || !animEl.isConnected) continue;
-      for (const prop of anim.properties || []) {
+    for (const fa of frame.animations || []) {
+      if (!fa.animationId.startsWith("JSAnimation:")) continue;
+      const firstColon = fa.animationId.indexOf(":");
+      const secondColon = fa.animationId.indexOf(":", firstColon + 1);
+      const elSel = secondColon >= 0 ? fa.animationId.substring(secondColon + 1) : "";
+      const el = this.elements.get(elSel);
+      if (!el || !el.isConnected) continue;
+      for (const prop of fa.properties) {
         if (prop.value) {
-          animEl.style.setProperty(prop.property, prop.value, "important");
+          el.style.setProperty(prop.property, prop.value, "important");
         }
       }
     }
-    const animatedSels = /* @__PURE__ */ new Set();
-    for (const anim of frame.animations || []) {
-      const fc = anim.animationId.indexOf(":");
-      const sc = anim.animationId.indexOf(":", fc + 1);
-      if (sc >= 0) animatedSels.add(anim.animationId.substring(sc + 1));
-    }
-    document.querySelectorAll(".checkbox-indicator, .radio-indicator").forEach((rawEl) => {
-      const el = rawEl;
-      const sel = this.getSelector(el);
-      if (sel && !animatedSels.has(sel)) {
-        el.style.removeProperty("opacity");
-        el.style.removeProperty("transform");
-        el.style.removeProperty("filter");
-        el.style.removeProperty("stroke-dashoffset");
-      }
-    });
   }
   // ---------------------------------------------------------------------------
   //  release — tear down all scrub state and restore the page to normal
   // ---------------------------------------------------------------------------
   release() {
+    for (const [, clone] of this.seekableClones) {
+      try {
+        clone.animation.cancel();
+      } catch {
+      }
+    }
+    this.seekableClones.clear();
     for (const entry of this.interceptedAnimations) {
       try {
         entry.animation.cancel();
@@ -1394,6 +1471,7 @@ var TimelineScrubber = class {
     this.elements.clear();
     this.frames.length = 0;
     this.capturedPortals.clear();
+    this.animFrameRanges.clear();
   }
 };
 
@@ -1480,7 +1558,7 @@ function generateExport(animations, frames, timeMs, filter = "active") {
     animations: animExports
   };
 }
-function formatExportForLLM(exp, detail = "standard") {
+function formatExportForLLM(exp, detail = "moderate") {
   const lines = [];
   const grouped = /* @__PURE__ */ new Map();
   for (const anim of exp.animations) {
@@ -1495,7 +1573,7 @@ function formatExportForLLM(exp, detail = "standard") {
     const [from, to] = prop.range.split(" \u2192 ");
     return !(from && to && from.trim() === to.trim());
   }
-  if (detail === "compact") {
+  if (detail === "brief") {
     lines.push(`# Animation State at ${exp.timestamp}`);
     lines.push("");
     for (const [, group] of grouped) {
@@ -1520,7 +1598,7 @@ function formatExportForLLM(exp, detail = "standard") {
   }
   lines.push(`# Animation State at ${exp.timestamp}`);
   lines.push("");
-  if (detail === "forensic") {
+  if (detail === "granular") {
     lines.push("**Environment:**");
     lines.push(`- Viewport: ${window.innerWidth}\xD7${window.innerHeight}`);
     lines.push(`- URL: ${window.location.href}`);
@@ -1587,7 +1665,7 @@ function formatExportForLLM(exp, detail = "standard") {
       lines.push(`Transitions: ${[...transitionSet].join(", ")}`);
       lines.push("");
       for (const line of cssPropLines) lines.push(line);
-      if (detail === "detailed" || detail === "forensic") {
+      if (detail === "detailed" || detail === "granular") {
         const allVars = {};
         for (const anim of cssAnims) {
           if (anim.resolvedVars) Object.assign(allVars, anim.resolvedVars);
@@ -1642,6 +1720,22 @@ var SaccadeEngine = class {
   getSpeed() {
     return this.timing.getSpeed();
   }
+  /**
+   * Install the timing patches immediately, without changing speed.
+   *
+   * Call this as early as possible (before app code, GSAP, or Framer Motion
+   * run) so they capture the patched time functions rather than the originals.
+   * Idempotent and harmless to call more than once. `setSpeed` and
+   * `startRecording` also install on demand, so this is only needed to win the
+   * early-load race against libraries that cache `Date.now`/`performance.now`.
+   */
+  install() {
+    this.timing.install();
+  }
+  /** Register a module-imported GSAP instance so saccade can slow it. */
+  registerGSAP(gsap) {
+    this.timing.registerGSAP(gsap);
+  }
   // -- Timeline recording ---------------------------------------------------
   startRecording(boundingBox) {
     if (this._state !== "idle") return;
@@ -1666,7 +1760,7 @@ var SaccadeEngine = class {
     try {
       capture = this.recorder.stopRecording();
     } catch (e) {
-      console.error("[Saccade] stopRecording failed:", e);
+      if (typeof console !== "undefined") console.error("[Saccade] stopRecording failed:", e);
       document.getElementById("__lapse-scrub-blocker")?.remove();
       document.getElementById("__lapse-no-transitions")?.remove();
       document.getElementById("__lapse-state-rules")?.remove();
@@ -1687,7 +1781,8 @@ var SaccadeEngine = class {
       frames: capture.frames,
       capturedPortals: this.recorder.capturedPortalIds,
       interceptedAnimations: this.recorder.interceptedAnimations,
-      SAFE_PROPS_SET: this.recorder.SAFE_PROPS_SET
+      SAFE_PROPS_SET: this.recorder.SAFE_PROPS_SET,
+      seekableClones: this.recorder.seekableClones
     };
     this.scrubber = new TimelineScrubber(scrubberState);
     this._state = "scrubbing";
@@ -1715,7 +1810,7 @@ var SaccadeEngine = class {
       filter
     );
   }
-  exportForLLM(timeMs, filter = "active", detail = "standard") {
+  exportForLLM(timeMs, filter = "active", detail = "moderate") {
     const exp = this.generateExport(timeMs, filter);
     if (!exp) return "";
     return formatExportForLLM(exp, detail);
@@ -1739,6 +1834,19 @@ var SaccadeEngine = class {
     this._state = "idle";
   }
 };
+
+// src/core/shared.ts
+var KEY = "__saccadeSharedEngine__";
+function getSharedEngine() {
+  const g = globalThis;
+  if (!g[KEY]) g[KEY] = new SaccadeEngine();
+  return g[KEY];
+}
+function resetSharedEngine() {
+  const g = globalThis;
+  g[KEY]?.destroy();
+  g[KEY] = null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SaccadeEngine,
@@ -1747,6 +1855,8 @@ var SaccadeEngine = class {
   TimingController,
   formatExportForLLM,
   generateExport,
-  getFrameAtTime
+  getFrameAtTime,
+  getSharedEngine,
+  resetSharedEngine
 });
 //# sourceMappingURL=core.cjs.map