@unseenco/theatre-gsap 0.4.3 → 0.5.0

package/dist/index.js

@@ -20,19 +20,30 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  attachGsapSequenceBridge: () => import_theatre_core.attachGsapSequenceBridge,
+  attachGsapSequenceBridge: () => import_theatre_core2.attachGsapSequenceBridge,
+  attachTheatrePageScroll: () => attachTheatrePageScroll,
+  bindGsapScrollTriggerPlugin: () => bindGsapScrollTriggerPlugin,
+  bindGsapTickerToRafDriver: () => bindGsapTickerToRafDriver,
   configureTheatreGsap: () => configureTheatreGsap,
+  createDefaultPageScrollDriver: () => createDefaultPageScrollDriver,
   getAnimationEntry: () => getAnimationEntry2,
   getAnimationEntryById: () => getAnimationEntryById,
   getAnimationEntryForSheetObject: () => getAnimationEntryForSheetObject2,
   getTheatreGsapConfig: () => getTheatreGsapConfig,
+  getTheatrePageScrollContext: () => getTheatrePageScrollContext,
+  isRafDriverDrivenByGsapTicker: () => isRafDriverDrivenByGsapTicker,
   listAnimationEntries: () => listAnimationEntries2,
-  registerGsapAnimation: () => registerGsapAnimation
+  refreshRegisteredGsapScrollTriggerLayouts: () => refreshRegisteredGsapScrollTriggerLayouts,
+  registerAllGsapScrollTriggers: () => registerAllGsapScrollTriggers,
+  registerGsapAnimation: () => registerGsapAnimation,
+  registerGsapScrollTrigger: () => registerGsapScrollTrigger,
+  scheduleGsapTickerRafWarningCheck: () => scheduleGsapTickerRafWarningCheck,
+  warnIfGsapTickerNotDrivingTheatreRaf: () => warnIfGsapTickerNotDrivingTheatreRaf
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/registerGsapAnimation.ts
-var import_privateAPIs = require("@unseenco/theatre-core/privateAPIs");
+var import_privateAPIs2 = require("@unseenco/theatre-core/privateAPIs");
 
 // ../../theatre/shared/src/utils/errors.ts
 var TheatreError = class extends Error {
@@ -555,11 +566,11 @@ function validateAndSanitiseSlashedPathOrThrow(unsanitisedPath, fnName) {
 Please replace the path with the sanitized one, otherwise it will likely break in the future.`,
       [
         {
-          url: "https://www.theatrejs.com/docs/latest/manual/objects#creating-sheet-objects",
+          url: "https://unseen-theatre.netlify.app/docs/guide/manual/objects#creating-objects",
           title: "Sheet Objects"
         },
         {
-          url: "https://www.theatrejs.com/docs/latest/api/core#sheet.object",
+          url: "https://unseen-theatre.netlify.app/docs/api/theatre-core#sheet.object",
           title: "API"
         }
       ]
@@ -628,6 +639,21 @@ function linkGsapTimelineChildAnimations(animation) {
   return map;
 }
 
+// ../../theatre/shared/src/gsap/gsapAnimationLabel.ts
+function readGsapAnimationVarsId(animation) {
+  const id = animation.vars?.id;
+  if (typeof id === "string" && id.trim().length > 0) {
+    return id.trim();
+  }
+  return void 0;
+}
+function resolveGsapAnimationRegistrationLabel(animation, optionsLabel, fallback = "GSAP animation") {
+  if (typeof optionsLabel === "string" && optionsLabel.length > 0) {
+    return optionsLabel;
+  }
+  return readGsapAnimationVarsId(animation) ?? fallback;
+}
+
 // ../../theatre/shared/src/gsap/gsapSheetObjectKey.ts
 var GSAP_NAMESPACE_STORE_KEY = "__unseenco_theatre_gsap_configuredNamespace__";
 function setConfiguredGsapSheetObjectNamespace(namespace) {
@@ -2226,22 +2252,136 @@ function listAnimationEntries() {
   return entries;
 }
 
+// ../../theatre/shared/src/sheets/pageScrollContext.ts
+var defaultPageScrollContext = {
+  scroller: null,
+  axis: "vertical"
+};
+var activePageScrollContext = defaultPageScrollContext;
+function setActivePageScrollContext(context) {
+  activePageScrollContext = {
+    scroller: context.scroller,
+    axis: context.axis ?? "vertical"
+  };
+}
+function resolvePageScrollAxis(context = defaultPageScrollContext) {
+  return context.axis ?? "vertical";
+}
+function resolvePageScrollScroller(st, defaultsScroller) {
+  const surface = st;
+  const fromSt = surface.scroller ?? surface.vars?.scroller;
+  if (fromSt != null) {
+    return fromSt;
+  }
+  if (defaultsScroller !== void 0) {
+    return defaultsScroller;
+  }
+  return null;
+}
+function isWindowLike(value) {
+  return typeof Window !== "undefined" && (value === window || value instanceof Window);
+}
+function isNativeDocumentScroller(scroller) {
+  if (scroller == null)
+    return true;
+  if (isWindowLike(scroller))
+    return true;
+  if (typeof document === "undefined")
+    return false;
+  return scroller === document.documentElement || scroller === document.body;
+}
+function pageScrollScrollersMatch(a, b) {
+  if (a === b)
+    return true;
+  if (isNativeDocumentScroller(a) && isNativeDocumentScroller(b))
+    return true;
+  return false;
+}
+function isScrollTriggerHorizontal(st) {
+  const surface = st;
+  return surface.horizontal === true || surface.vars?.horizontal === true;
+}
+function isPageScrollTrigger(st, context = defaultPageScrollContext) {
+  const axis = resolvePageScrollAxis(context);
+  const stHorizontal = isScrollTriggerHorizontal(st);
+  if (stHorizontal !== (axis === "horizontal")) {
+    return false;
+  }
+  const stScroller = resolvePageScrollScroller(st, context.scroller);
+  return pageScrollScrollersMatch(stScroller, context.scroller);
+}
+
+// src/gsapScrollTriggerPlugin.ts
+var import_ScrollTrigger = require("gsap/ScrollTrigger");
+var boundScrollTrigger;
+function bindGsapScrollTriggerPlugin(scrollTrigger) {
+  boundScrollTrigger = scrollTrigger;
+}
+function getGsapScrollTriggerPlugin() {
+  if (boundScrollTrigger) {
+    return boundScrollTrigger;
+  }
+  const g = globalThis;
+  return g.ScrollTrigger ?? import_ScrollTrigger.ScrollTrigger;
+}
+function requireGsapScrollTriggerPlugin() {
+  const plugin = getGsapScrollTriggerPlugin();
+  if (!plugin) {
+    throw new Error(
+      'ScrollTrigger is not available. Import ScrollTrigger from "gsap/ScrollTrigger", call gsap.registerPlugin(ScrollTrigger), and optionally bindGsapScrollTriggerPlugin(ScrollTrigger) before registering scroll triggers with Theatre.'
+    );
+  }
+  return plugin;
+}
+function refreshGsapScrollTriggers() {
+  getGsapScrollTriggerPlugin()?.refresh();
+}
+
 // src/config.ts
 var activeConfig = {
   namespace: "GSAP",
   outlineNamespace: { defaultCollapsed: false }
 };
 setConfiguredGsapSheetObjectNamespace(activeConfig.namespace);
+function pageScrollContextFromConfig(pageScroll) {
+  return {
+    scroller: pageScroll.scroller ?? defaultPageScrollContext.scroller,
+    axis: pageScroll.axis ?? defaultPageScrollContext.axis ?? "vertical"
+  };
+}
+function applyScrollTriggerDefaultsForPageScroll(pageScroll) {
+  const ScrollTrigger = getGsapScrollTriggerPlugin();
+  const { scroller, axis } = pageScrollContextFromConfig(pageScroll);
+  ScrollTrigger?.defaults?.({
+    scroller: scroller ?? void 0,
+    ...axis === "horizontal" ? { horizontal: true } : {}
+  });
+}
 function configureTheatreGsap(config) {
   const prev = activeConfig;
   activeConfig = {
     namespace: config.namespace ?? prev.namespace ?? "GSAP",
-    outlineNamespace: config.outlineNamespace ?? prev.outlineNamespace
+    outlineNamespace: config.outlineNamespace ?? prev.outlineNamespace,
+    suppressGsapTickerRafWarning: config.suppressGsapTickerRafWarning ?? prev.suppressGsapTickerRafWarning,
+    pageScroll: config.pageScroll ?? prev.pageScroll
   };
   setConfiguredGsapSheetObjectNamespace(activeConfig.namespace ?? "GSAP");
+  if (config.pageScroll !== void 0) {
+    const ctx = pageScrollContextFromConfig(config.pageScroll);
+    setActivePageScrollContext(ctx);
+    applyScrollTriggerDefaultsForPageScroll(config.pageScroll);
+  }
   return {
     reset() {
       activeConfig = prev;
+      setConfiguredGsapSheetObjectNamespace(prev.namespace ?? "GSAP");
+      if (prev.pageScroll !== void 0) {
+        const ctx = pageScrollContextFromConfig(prev.pageScroll);
+        setActivePageScrollContext(ctx);
+        applyScrollTriggerDefaultsForPageScroll(prev.pageScroll);
+      } else {
+        setActivePageScrollContext(defaultPageScrollContext);
+      }
     }
   };
 }
@@ -2298,33 +2438,479 @@ function formatOutlineNamespacePathKey(pathSegments) {
   return pathSegments.join(" / ");
 }
 
+// src/gsapTickerRafBridge.ts
+var import_privateAPIs = require("@unseenco/theatre-core/privateAPIs");
+var gsapTickerDrivenDriverIds = /* @__PURE__ */ new Set();
+function bindGsapTickerToRafDriver(rafDriver, gsap) {
+  const onTick = (time) => {
+    rafDriver.tick(time * 1e3);
+  };
+  gsapTickerDrivenDriverIds.add(rafDriver.id);
+  gsap.ticker.add(onTick);
+  return () => {
+    gsap.ticker.remove(onTick);
+    gsapTickerDrivenDriverIds.delete(rafDriver.id);
+  };
+}
+function isRafDriverDrivenByGsapTicker(rafDriver) {
+  return gsapTickerDrivenDriverIds.has(rafDriver.id);
+}
+var hasWarnedGsapTickerRaf = false;
+var gsapTickerRafWarningMicrotaskQueued = false;
+function scheduleGsapTickerRafWarningCheck() {
+  if (gsapTickerRafWarningMicrotaskQueued)
+    return;
+  gsapTickerRafWarningMicrotaskQueued = true;
+  queueMicrotask(() => {
+    gsapTickerRafWarningMicrotaskQueued = false;
+    warnIfGsapTickerNotDrivingTheatreRaf();
+  });
+}
+function warnIfGsapTickerNotDrivingTheatreRaf() {
+  if (typeof window === "undefined")
+    return;
+  if (getTheatreGsapConfig().suppressGsapTickerRafWarning)
+    return;
+  if (hasWarnedGsapTickerRaf)
+    return;
+  const coreDriver = (0, import_privateAPIs.getTheatreCoreRafDriver)();
+  if (!isRafDriverDrivenByGsapTicker(coreDriver)) {
+    hasWarnedGsapTickerRaf = true;
+    console.warn(
+      "[theatre-gsap] Theatre is not driven by gsap.ticker. After setCoreRafDriver(), call bindGsapTickerToRafDriver(rafDriver, gsap) so GSAP and Theatre share one clock. See the GSAP extension guide."
+    );
+  }
+}
+
 // src/registerGsapAnimation.ts
 function registerGsapAnimation(animation, sheet, options) {
   const config = getTheatreGsapConfig();
   const namespace = options.namespace ?? config.namespace ?? "GSAP";
-  const objectKey = buildGsapSheetObjectKey(namespace, options.label);
+  const label = resolveGsapAnimationRegistrationLabel(animation, options.label);
+  const objectKey = buildGsapSheetObjectKey(namespace, label);
   const id = options.id ?? objectKey;
   animation.pause();
   const sheetObjectPublic = sheet.object(objectKey, {}, { reconfigure: false });
-  const sheetObjectInternal = (0, import_privateAPIs.privateAPI)(sheetObjectPublic);
+  const sheetObjectInternal = (0, import_privateAPIs2.privateAPI)(sheetObjectPublic);
   const existing = getAnimationEntry(sheetObjectInternal, id);
   if (config.outlineNamespace && !existing) {
-    (0, import_privateAPIs.privateAPI)(sheet).template.setOutlineNamespaceConfig(
+    (0, import_privateAPIs2.privateAPI)(sheet).template.setOutlineNamespaceConfig(
       formatOutlineNamespacePathKey([namespace]),
       config.outlineNamespace
     );
   }
   registerAnimationInRegistry2({
     id,
-    label: options.label,
+    label,
     animation,
     sheetObject: sheetObjectInternal,
-    defaultDuration: options.defaultDuration,
+    defaultDuration: options.defaultDuration ?? (sheet.getSequenceMode() === "page" ? 10 : void 0),
     onRebuildTimeline: options.onRebuildTimeline
   });
+  scheduleGsapTickerRafWarningCheck();
   return { id, sheetObject: sheetObjectPublic };
 }
 
-// src/attachGsapSequenceBridge.ts
+// src/registerGsapScrollTrigger.ts
+var import_privateAPIs3 = require("@unseenco/theatre-core/privateAPIs");
+
+// ../../theatre/shared/src/gsap/scrollTriggerGuards.ts
+function resolveScrollTriggerAnimation(st) {
+  const surface = st;
+  if (surface.animation != null)
+    return surface.animation;
+  if (surface.vars?.animation != null)
+    return surface.vars.animation;
+  return void 0;
+}
+function defaultScrollTriggerLabel(st, fallbackIndex) {
+  const surface = st;
+  const id = surface.vars?.id;
+  if (typeof id === "string" && id.length > 0)
+    return id;
+  const trigger = surface.trigger;
+  if (trigger && typeof trigger === "object" && "id" in trigger) {
+    const elementId = trigger.id;
+    if (typeof elementId === "string" && elementId.length > 0) {
+      return elementId;
+    }
+  }
+  return `ScrollTrigger ${fallbackIndex + 1}`;
+}
+function readAnimationSpanSeconds(animation) {
+  return Math.max(readGsapTweenTimelineDuration(animation), MIN_ANIMATION_SPAN);
+}
+var MIN_ANIMATION_SPAN = 0.01;
+
+// ../../theatre/shared/src/gsap/scrollTriggerLayout.ts
+var MIN_SEQUENCE_DURATION = 0.01;
+function scrollPixelsToPageUnits(startPx, endPx, maxScrollPx, sequenceLength) {
+  const length = Math.max(sequenceLength, MIN_SEQUENCE_DURATION);
+  if (maxScrollPx <= 0) {
+    return { start: 0, duration: length };
+  }
+  const startProgress = Math.max(0, Math.min(1, startPx / maxScrollPx));
+  const endProgress = Math.max(0, Math.min(1, endPx / maxScrollPx));
+  const lo = Math.min(startProgress, endProgress);
+  const hi = Math.max(startProgress, endProgress);
+  let start = lo * length;
+  let duration = Math.max((hi - lo) * length, MIN_SEQUENCE_DURATION);
+  if (start + duration > length) {
+    start = Math.max(0, length - duration);
+  }
+  if (start < 0)
+    start = 0;
+  return { start, duration };
+}
+function getNativeDocumentMaxScroll(axis = "vertical") {
+  if (typeof document === "undefined" || typeof window === "undefined") {
+    return 0;
+  }
+  const el = document.documentElement;
+  if (axis === "horizontal") {
+    const scrolling = document.scrollingElement ?? el;
+    return Math.max(0, scrolling.scrollWidth - scrolling.clientWidth);
+  }
+  return Math.max(0, el.scrollHeight - window.innerHeight);
+}
+function getMaxScrollForScroller(scroller, axis = "vertical") {
+  if (typeof document === "undefined" || typeof window === "undefined") {
+    return 0;
+  }
+  if (isNativeDocumentScroller(scroller)) {
+    return getNativeDocumentMaxScroll(axis);
+  }
+  const el = scroller;
+  if (axis === "horizontal") {
+    return Math.max(0, el.scrollWidth - el.clientWidth);
+  }
+  return Math.max(0, el.scrollHeight - el.clientHeight);
+}
+function getMaxScrollForPageScrollContext(scroller, axis = "vertical") {
+  return getMaxScrollForScroller(scroller, axis);
+}
+
+// ../../theatre/shared/src/sheets/remotePageScrollMetrics.ts
+var remoteMetrics;
+function resolveMaxScrollPxForPageLayout(localMaxScrollPx, axis) {
+  if (localMaxScrollPx > 0) {
+    return localMaxScrollPx;
+  }
+  const remote = remoteMetrics;
+  if (remote && remote.axis === axis && remote.maxScroll > 0) {
+    return remote.maxScroll;
+  }
+  return localMaxScrollPx;
+}
+
+// ../../theatre/shared/src/gsap/extractScrollTriggerLayout.ts
+function extractScrollTriggerLayout(st, options) {
+  const pageScrollContext = options.pageScrollContext ?? defaultPageScrollContext;
+  if (!isPageScrollTrigger(st, pageScrollContext)) {
+    return { ok: false, reason: "unsupported_scroller" };
+  }
+  const surface = st;
+  const animation = resolveScrollTriggerAnimation(st);
+  if (!animation) {
+    return { ok: false, reason: "missing_animation" };
+  }
+  const axis = resolvePageScrollAxis(pageScrollContext);
+  const localMaxScroll = getMaxScrollForPageScrollContext(
+    pageScrollContext.scroller,
+    axis
+  );
+  const maxScroll = resolveMaxScrollPxForPageLayout(localMaxScroll, axis);
+  const layout = scrollPixelsToPageUnits(
+    surface.start,
+    surface.end,
+    maxScroll,
+    options.sequenceLength
+  );
+  const fallbackIndex = options.fallbackIndex ?? 0;
+  const label = options.label ?? defaultScrollTriggerLabel(st, fallbackIndex);
+  const id = options.id ?? (typeof surface.vars?.id === "string" && surface.vars.id.length > 0 ? surface.vars.id : `st_${label.replace(/\s+/g, "_")}_${fallbackIndex}`);
+  const kind = isGsapTimeline(animation) ? "timeline" : "tween";
+  const animationSpanSeconds = readAnimationSpanSeconds(animation);
+  const timelineChildren = kind === "timeline" ? introspectGsapTimelineChildren(animation) : [];
+  return {
+    ok: true,
+    value: {
+      id,
+      label,
+      layout,
+      kind,
+      animationSpanSeconds,
+      timelineChildren
+    }
+  };
+}
+
+// ../../theatre/shared/src/gsap/scrollTriggerRegistry.ts
+var DEFAULT_SHEET_INSTANCE_ID2 = "default";
+var REGISTRY_KEY2 = "__unseenco_theatre_gsap_scrollTriggerRegistry__";
+function sheetAddressKey(address) {
+  const sheetInstanceId = address.sheetInstanceId ?? DEFAULT_SHEET_INSTANCE_ID2;
+  return `${address.projectId}|${address.sheetId}|${sheetInstanceId}`;
+}
+function getStore3() {
+  const g = globalThis;
+  if (!g[REGISTRY_KEY2]) {
+    g[REGISTRY_KEY2] = { bySheetAddress: /* @__PURE__ */ new Map() };
+  }
+  return g[REGISTRY_KEY2];
+}
+function getSheetMap(key) {
+  const store = getStore3();
+  let map = store.bySheetAddress.get(key);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    store.bySheetAddress.set(key, map);
+  }
+  return map;
+}
+function registerScrollTriggerInRegistry(sheetKey, entry) {
+  const map = getSheetMap(sheetKey);
+  for (const existing of map.values()) {
+    if (existing.scrollTrigger === entry.scrollTrigger) {
+      return "duplicate";
+    }
+    if (existing.id === entry.id) {
+      return "duplicate";
+    }
+  }
+  map.set(entry.id, entry);
+  bumpGsapStudioRegistryRevision();
+  return "registered";
+}
+function findScrollTriggerEntryByInstance(sheetKey, scrollTrigger) {
+  const map = getStore3().bySheetAddress.get(sheetKey);
+  if (!map)
+    return void 0;
+  for (const entry of map.values()) {
+    if (entry.scrollTrigger === scrollTrigger) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+function updateScrollTriggerLayoutInRegistry(sheetKey, id, patch) {
+  const existing = getSheetMap(sheetKey).get(id);
+  if (!existing)
+    return;
+  getSheetMap(sheetKey).set(id, { ...existing, ...patch });
+  bumpGsapStudioRegistryRevision();
+}
+function listScrollTriggerEntriesForSheet(sheetKey) {
+  const map = getStore3().bySheetAddress.get(sheetKey);
+  if (!map)
+    return [];
+  return [...map.values()].sort((a, b) => a.layout.start - b.layout.start);
+}
+
+// src/attachTheatrePageScroll.ts
 var import_theatre_core = require("@unseenco/theatre-core");
+function applyScrollTriggerDefaultsFromGsapConfig() {
+  const { pageScroll } = getTheatreGsapConfig();
+  if (!pageScroll)
+    return;
+  const ScrollTrigger = getGsapScrollTriggerPlugin();
+  if (!ScrollTrigger?.defaults)
+    return;
+  const axis = pageScroll.axis ?? defaultPageScrollContext.axis ?? "vertical";
+  ScrollTrigger.defaults({
+    scroller: pageScroll.scroller ?? void 0,
+    ...axis === "horizontal" ? { horizontal: true } : {}
+  });
+}
+function getTheatrePageScrollContext() {
+  applyScrollTriggerDefaultsFromGsapConfig();
+  const pageScroll = getTheatreGsapConfig().pageScroll;
+  if (pageScroll) {
+    const ctx = {
+      scroller: pageScroll.scroller ?? defaultPageScrollContext.scroller,
+      axis: pageScroll.axis ?? defaultPageScrollContext.axis
+    };
+    setActivePageScrollContext(ctx);
+    return ctx;
+  }
+  return (0, import_theatre_core.getTheatrePageScrollContext)();
+}
+function createDefaultPageScrollDriver(scroller = getTheatrePageScrollContext().scroller) {
+  const ctx = getTheatrePageScrollContext();
+  return (0, import_theatre_core.createDefaultPageScrollDriver)(scroller, resolvePageScrollAxis(ctx));
+}
+function attachTheatrePageScroll(sheet, options = {}) {
+  applyScrollTriggerDefaultsFromGsapConfig();
+  return (0, import_theatre_core.attachTheatrePageScroll)(sheet, options);
+}
+
+// ../../theatre/shared/src/gsap/scrollTriggerGlobal.ts
+function refreshGsapScrollTriggersFromGlobal() {
+  const ScrollTrigger = globalThis.ScrollTrigger;
+  ScrollTrigger?.refresh?.();
+}
+
+// ../../theatre/shared/src/gsap/refreshScrollTriggerLayoutsForSheet.ts
+function refreshScrollTriggerLayoutsForSheet(sheetKey, sequenceLength, pageScrollContext = defaultPageScrollContext) {
+  refreshGsapScrollTriggersFromGlobal();
+  for (const entry of listScrollTriggerEntriesForSheet(sheetKey)) {
+    const extracted = extractScrollTriggerLayout(entry.scrollTrigger, {
+      sequenceLength,
+      id: entry.id,
+      label: entry.label,
+      pageScrollContext
+    });
+    if (!extracted.ok)
+      continue;
+    updateScrollTriggerLayoutInRegistry(sheetKey, entry.id, {
+      layout: extracted.value.layout,
+      kind: extracted.value.kind,
+      animationSpanSeconds: extracted.value.animationSpanSeconds,
+      timelineChildren: extracted.value.timelineChildren
+    });
+  }
+}
+
+// src/registerGsapScrollTrigger.ts
+function assertPageMode(sheet) {
+  if (sheet.getSequenceMode() !== "page") {
+    throw new Error(
+      'registerGsapScrollTrigger() requires the sheet to use sequenceMode "page".'
+    );
+  }
+}
+function sequenceLengthForSheet(sheet) {
+  return (0, import_privateAPIs3.privateAPI)(sheet).getSequence().length;
+}
+function scrollTriggerObjectKey(namespace, label) {
+  return buildGsapSheetObjectKey(namespace, `ScrollTriggers / ${label}`);
+}
+function registerOneGsapScrollTriggerOnSheet(sheet, st, options, fallbackIndex) {
+  const config = getTheatreGsapConfig();
+  const namespace = options.namespace ?? config.namespace ?? "GSAP";
+  const sheetInternal = (0, import_privateAPIs3.privateAPI)(sheet);
+  const sheetKey = sheetAddressKey(sheetInternal.address);
+  const sequenceLength = sequenceLengthForSheet(sheet);
+  const existingByInstance = findScrollTriggerEntryByInstance(sheetKey, st);
+  if (existingByInstance?.sheetObject) {
+    console.warn(
+      `[theatre-gsap] ScrollTrigger "${options.label}" is already registered for this sheet (id "${existingByInstance.id}"). Skipping duplicate registration.`
+    );
+    return {
+      id: existingByInstance.id,
+      sheetObject: existingByInstance.sheetObject.publicApi
+    };
+  }
+  refreshGsapScrollTriggers();
+  const pageScrollContext = getTheatrePageScrollContext();
+  const extracted = extractScrollTriggerLayout(st, {
+    sequenceLength,
+    id: options.id,
+    label: options.label,
+    fallbackIndex,
+    pageScrollContext
+  });
+  if (!extracted.ok) {
+    if (extracted.reason === "unsupported_scroller") {
+      console.warn(
+        `[theatre-gsap] Skipped ScrollTrigger "${options.label}": scroller or scroll axis does not match configured page scroll (see configureTheatreGsap pageScroll scroller and axis).`
+      );
+    } else {
+      console.warn(
+        `[theatre-gsap] Skipped ScrollTrigger "${options.label}": no linked tween or timeline found.`
+      );
+    }
+    return null;
+  }
+  const { value } = extracted;
+  const objectKey = scrollTriggerObjectKey(namespace, value.label);
+  const id = options.id ?? value.id;
+  const sheetObjectPublic = sheet.object(objectKey, {}, { reconfigure: false });
+  const sheetObjectInternal = (0, import_privateAPIs3.privateAPI)(sheetObjectPublic);
+  if (config.outlineNamespace) {
+    (0, import_privateAPIs3.privateAPI)(sheet).template.setOutlineNamespaceConfig(
+      formatOutlineNamespacePathKey([namespace]),
+      config.outlineNamespace
+    );
+  }
+  const entry = {
+    id,
+    label: value.label,
+    scrollTrigger: st,
+    sheetObject: sheetObjectInternal,
+    layout: value.layout,
+    kind: value.kind,
+    animationSpanSeconds: value.animationSpanSeconds,
+    timelineChildren: value.timelineChildren
+  };
+  registerScrollTriggerInRegistry(sheetKey, entry);
+  return { id, sheetObject: sheetObjectPublic };
+}
+function registerGsapScrollTrigger(scrollTrigger, sheet, options) {
+  assertPageMode(sheet);
+  requireGsapScrollTriggerPlugin();
+  const result = registerOneGsapScrollTriggerOnSheet(
+    sheet,
+    scrollTrigger,
+    options,
+    0
+  );
+  if (!result) {
+    throw new Error(
+      `Could not register ScrollTrigger "${options.label}". See console warnings for details.`
+    );
+  }
+  scheduleGsapTickerRafWarningCheck();
+  return result;
+}
+function refreshRegisteredGsapScrollTriggerLayouts(sheet) {
+  if (sheet.getSequenceMode() !== "page")
+    return;
+  const sheetInternal = (0, import_privateAPIs3.privateAPI)(sheet);
+  const sheetKey = sheetAddressKey(sheetInternal.address);
+  refreshScrollTriggerLayoutsForSheet(
+    sheetKey,
+    sequenceLengthForSheet(sheet),
+    getTheatrePageScrollContext()
+  );
+}
+
+// src/registerAllGsapScrollTriggers.ts
+var import_privateAPIs4 = require("@unseenco/theatre-core/privateAPIs");
+function registerAllGsapScrollTriggers(sheet) {
+  if (sheet.getSequenceMode() !== "page") {
+    throw new Error(
+      'registerAllGsapScrollTriggers() requires the sheet to use sequenceMode "page".'
+    );
+  }
+  const ScrollTrigger = requireGsapScrollTriggerPlugin();
+  refreshGsapScrollTriggers();
+  const all = ScrollTrigger.getAll();
+  const sheetKey = sheetAddressKey((0, import_privateAPIs4.privateAPI)(sheet).address);
+  const registered = [];
+  let skipped = 0;
+  all.forEach((st, index) => {
+    const already = findScrollTriggerEntryByInstance(sheetKey, st);
+    const label = defaultScrollTriggerLabel(st, index);
+    const id = typeof st.vars?.id === "string" && st.vars.id.length > 0 ? st.vars.id : void 0;
+    const result = registerOneGsapScrollTriggerOnSheet(
+      sheet,
+      st,
+      { label, id },
+      index
+    );
+    if (!result) {
+      skipped += 1;
+    } else if (already) {
+      skipped += 1;
+    } else {
+      registered.push(result);
+    }
+  });
+  scheduleGsapTickerRafWarningCheck();
+  return { registered, skipped };
+}
+
+// src/attachGsapSequenceBridge.ts
+var import_theatre_core2 = require("@unseenco/theatre-core");
 //# sourceMappingURL=index.js.map