@cueframe/kernel 0.0.1

package/dist/chunk-DLF4WVSE.js

@@ -0,0 +1,9 @@
+// ../execution/primitives/src/lib/text/recolor.ts
+import { interpolateColors } from "remotion";
+function recolor(progress, from, to) {
+  return interpolateColors(progress, [0, 1], [from, to]);
+}
+
+export {
+  recolor
+};

package/dist/chunk-DSNG6WLU.js

@@ -0,0 +1,82 @@
+import {
+  fitTextOnNLines
+} from "./chunk-YA3OR2KK.js";
+
+// ../execution/primitives/src/lib/text/fitText.tsx
+import React from "react";
+function resolveFitFontSize({
+  singleLineFitFontSize,
+  minFontSize,
+  maxFontSize
+}) {
+  const capped = Math.min(maxFontSize, singleLineFitFontSize);
+  if (capped >= minFontSize) return { fontSize: capped, overflow: false };
+  return { fontSize: minFontSize, overflow: true };
+}
+var FitText = ({
+  children,
+  maxWidth,
+  maxFontSize,
+  maxLines = 1,
+  minFontSize,
+  fontFamily,
+  fontWeight = 400,
+  letterSpacing,
+  textTransform,
+  style
+}) => {
+  const text = (children ?? "").toString();
+  const floor = minFontSize ?? Math.round(maxFontSize * 0.55);
+  const fitted = React.useMemo(() => {
+    if (text.trim().length === 0) return maxFontSize;
+    try {
+      const { fontSize: fontSize2 } = fitTextOnNLines({
+        text,
+        maxLines,
+        maxBoxWidth: maxWidth,
+        fontFamily,
+        fontWeight,
+        letterSpacing,
+        textTransform,
+        maxFontSize,
+        validateFontIsLoaded: false
+      });
+      return fontSize2;
+    } catch {
+      return maxFontSize;
+    }
+  }, [text, maxLines, maxWidth, fontFamily, fontWeight, letterSpacing, textTransform, maxFontSize]);
+  const { fontSize } = resolveFitFontSize({
+    singleLineFitFontSize: fitted,
+    minFontSize: floor,
+    maxFontSize
+  });
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        fontSize,
+        fontFamily,
+        fontWeight,
+        letterSpacing,
+        textTransform,
+        maxWidth,
+        // Clamp to maxLines with an ellipsis for the extreme case (text still too long
+        // at the floor). For maxLines===1 this also keeps it single-line.
+        display: "-webkit-box",
+        WebkitBoxOrient: "vertical",
+        WebkitLineClamp: maxLines,
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        wordBreak: "break-word",
+        ...style
+      }
+    },
+    text
+  );
+};
+
+export {
+  resolveFitFontSize,
+  FitText
+};

package/dist/chunk-EA6MYCYW.js

@@ -0,0 +1,135 @@
+// ../composition/src/reframe/aspectLoss.ts
+function coverVisibleFraction(source, target) {
+  const s = source.width / source.height;
+  const t = target.width / target.height;
+  if (!Number.isFinite(s) || !Number.isFinite(t) || s <= 0 || t <= 0) return 1;
+  return Math.min(s, t) / Math.max(s, t);
+}
+var VISIBLE_FRACTION_FLOOR = 0.75;
+var MAX_NAMED = 6;
+function collectMediaClips(value, nearestId, out) {
+  if (Array.isArray(value)) {
+    for (const v of value) collectMediaClips(v, nearestId, out);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  const obj = value;
+  const id = typeof obj.id === "string" ? obj.id : nearestId;
+  if (obj.kind === "media" && typeof obj.mediaId === "string") {
+    const reframe = obj.reframe;
+    const hasReframe = Array.isArray(reframe?.segments) && reframe.segments.length > 0;
+    out.push({
+      mediaId: obj.mediaId,
+      hasCamera: hasReframe || obj.kenBurns != null,
+      ...id !== void 0 ? { clipId: id } : {}
+    });
+    return;
+  }
+  for (const v of Object.values(obj)) collectMediaClips(v, id, out);
+}
+function detectAspectCropLoss(composition, dimensionsByMediaId, target) {
+  const placed = [];
+  collectMediaClips(composition, void 0, placed);
+  if (placed.length === 0) return [];
+  const offenders = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const clip of placed) {
+    if (clip.hasCamera) continue;
+    const dim = dimensionsByMediaId[clip.mediaId];
+    if (!dim?.width || !dim?.height) continue;
+    const visible = coverVisibleFraction({ width: dim.width, height: dim.height }, target);
+    if (visible >= VISIBLE_FRACTION_FLOOR) continue;
+    const label = clip.clipId ?? clip.mediaId;
+    if (seen.has(label)) continue;
+    seen.add(label);
+    offenders.push({ label, lostPct: Math.round((1 - visible) * 100) });
+  }
+  if (offenders.length === 0) return [];
+  const worst = offenders.reduce((a, b) => b.lostPct > a.lostPct ? b : a);
+  const shown = offenders.slice(0, MAX_NAMED).map((o) => `${o.label} (\u2212${o.lostPct}%)`).join(", ");
+  const elided = offenders.length > MAX_NAMED ? ` (+${offenders.length - MAX_NAMED} more)` : "";
+  return [
+    `aspect_crop_loss \u2014 ${offenders.length} clip${offenders.length === 1 ? "" : "s"} ${offenders.length === 1 ? "is" : "are"} shaped very differently from the ${target.width}\xD7${target.height} output and author no camera, so each is centre-cropped to fill \u2014 discarding up to ${worst.lostPct}% of the picture with faces and subjects as likely to fall outside the crop as inside it: ${shown}${elided}. Author a \`reframe\` (focus a face, a point, or all-faces) or a \`kenBurns\` move on these clips, or render a format closer to their shape. Note \`fit:"contain"\` does NOT avoid this for stills \u2014 images are cropped by the still trajectory, which centres when it has no focus.`
+  ];
+}
+
+// ../composition/src/reframe/index.ts
+import { z } from "zod";
+var Focus = z.discriminatedUnion("mode", [
+  z.object({ mode: z.literal("frame-center") }),
+  z.object({ mode: z.literal("point"), x: z.number().min(0).max(1), y: z.number().min(0).max(1) }),
+  z.object({
+    mode: z.literal("face"),
+    faceId: z.string().min(1),
+    shotScale: z.enum(["close", "standard", "wide"]).optional()
+  }),
+  z.object({ mode: z.literal("all-faces") }),
+  z.object({ mode: z.literal("active-speaker") })
+]);
+var ReframeSegmentFields = z.object({
+  startSec: z.number().nonnegative().describe(
+    "Segment START in seconds, clip-relative. Segments tile the clip's duration in order."
+  ),
+  endSec: z.number().positive().describe(
+    "Segment END in seconds, clip-relative. The span (endSec \u2212 startSec) is this segment's duration \u2014 the window `ease` ramps over."
+  ),
+  /** WHO/WHAT the camera tracks — see the `.describe()` for per-mode guidance. */
+  focus: Focus.describe(
+    "WHO/WHAT the camera tracks this segment (the reframe center), selected by `mode`: `frame-center` = no tracking, hold the geometric center (static/graphic footage, or a pure zoom); `point` = lock to a fixed source-normalized {x,y} (a non-moving on-screen element); `face` = track a detected face by `faceId` (from get_media_context), with optional `shotScale` close|standard|wide for tightness; `all-faces` = frame the bounding box of every detected face (group/ensemble shots); `active-speaker` = follow whoever is speaking (diarized talking-head / podcast). Pick by what the beat is about; pair with `zoom` for how tight."
+  ),
+  /** Editorial language for diff/log readability ("speaker-tight",
+   *  "wide-context", "interviewer-reaction"). Not honored by the derive math
+   *  — a relabel must not bust the variant cache, so it is EXCLUDED from
+   *  `hashReframe`. */
+  intent: z.string().optional().describe(
+    "Optional editorial LABEL for diff/log readability (e.g. 'speaker-tight', 'wide-context'). Cosmetic \u2014 NOT honored by the derive math and excluded from the variant cache key."
+  ),
+  /** <1 punches in; 1 = full frame. Omitted when `focus.shotScale` governs — the
+   *  two are MUTUALLY EXCLUSIVE (see the refine below). Absent = 1 (full frame),
+   *  which is how `hashReframe` has always canonicalized it. */
+  zoom: z.number().min(0.1).max(1).optional().describe(
+    "How TIGHT the framing is \u2014 the fraction of the source the output viewport shows. <1 punches IN (a smaller source fraction, magnified to fill the frame); 1 = the full frame (no crop). ~0.6\u20130.8 is a moderate push-in, ~0.5 a tight close-up, 0.1 the maximum zoom. There is NO zoom-OUT past the full frame (max 1). Omit for the full frame. MUTUALLY EXCLUSIVE with `focus.shotScale`: a face-tracked shot is sized EITHER by the editorial scale (shotScale, calibrated to the detected face) OR by an explicit zoom \u2014 never both."
+  ),
+  /** Ease-in / ease-out durations (seconds) for the zoom ramp at this segment's
+   *  edges. Honored at derive time (baked into the per-frame channel). */
+  ease: z.object({
+    in: z.number().nonnegative().describe("Ease-IN ramp DURATION in seconds at the segment START."),
+    out: z.number().nonnegative().describe("Ease-OUT ramp DURATION in seconds at the segment END.")
+  }).optional().describe(
+    "Zoom/center ramp DURATIONS in SECONDS at this segment's edges \u2014 NOT a unitless 0\u20131 curve. ~0.3\u20130.6s reads as a snappy push; >1s reads sluggish. Keep `in` + `out` \u2264 the segment's duration (endSec \u2212 startSec): the two edges share the span, so to ramp across the WHOLE segment set one edge to the full duration and the other to 0. Omit for an instant cut to this framing."
+  ),
+  /** Optional fine framing nudge, source-normalized [-0.3,0.3]. */
+  bias: z.object({
+    x: z.number().min(-0.3).max(0.3).describe("Horizontal nudge, source-normalized (+ = right)."),
+    y: z.number().min(-0.3).max(0.3).describe("Vertical nudge, source-normalized (+ = down).")
+  }).optional().describe(
+    "Optional FINE framing nudge off the focus center, source-normalized in [\u22120.3, 0.3]. A small correction (headroom, rule-of-thirds), NOT a reframe \u2014 use `focus`/`zoom` for the actual shot. Omit (treated as 0) to sit dead-center on the focus."
+  )
+});
+var ReframeSegment = ReframeSegmentFields.refine(
+  // ONE knob sizes the crop. `shotScale` and `zoom` both do, and the bake gives
+  // shotScale precedence (calibrateShotScale takes zoom only as a FALLBACK) — so a
+  // segment carrying both SILENTLY discards the zoom. That is how a stored
+  // composition came to claim `zoom: 1` (full frame) on a segment the renderer
+  // punched in to 0.55: reading the artifact said "no zoom" while the render
+  // plainly zoomed (2026-07-13). The state is incoherent, so make it
+  // unrepresentable — here, at the wire shape, not just at the authoring tools.
+  //
+  // Rows written before compile stopped stamping `zoom: 1` are MIGRATED (convex
+  // migrations: dropZoomUnderShotScale), not tolerated.
+  (s) => !(s.focus.mode === "face" && s.focus.shotScale !== void 0 && s.zoom !== void 0),
+  {
+    message: "a face segment takes EITHER focus.shotScale (editorial scale, calibrated to the detected face) OR an explicit zoom \u2014 never both; shotScale wins at bake time and the zoom would be silently discarded",
+    path: ["zoom"]
+  }
+);
+var Reframe = z.object({ segments: z.array(ReframeSegment).min(1) });
+
+export {
+  coverVisibleFraction,
+  detectAspectCropLoss,
+  Focus,
+  ReframeSegmentFields,
+  ReframeSegment,
+  Reframe
+};

package/dist/chunk-EAUSEGB7.js

@@ -0,0 +1,420 @@
+// ../../node_modules/.pnpm/@remotion+transitions@4.0.429_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@remotion/transitions/dist/esm/index.mjs
+import { useMemo } from "react";
+import { AbsoluteFill } from "remotion";
+import { jsx } from "react/jsx-runtime";
+import { interpolate } from "remotion";
+import { measureSpring, spring } from "remotion";
+import { Children, useMemo as useMemo3 } from "react";
+import { Internals, Sequence, useCurrentFrame, useVideoConfig } from "remotion";
+import { NoReactInternals as NoReactInternals2 } from "remotion/no-react";
+import React2, { useMemo as useMemo2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+import React3 from "react";
+import { NoReactInternals } from "remotion/no-react";
+import { jsx as jsx3, Fragment } from "react/jsx-runtime";
+import React4 from "react";
+var epsilon = 0.01;
+var SlidePresentation = ({
+  children,
+  presentationProgress,
+  presentationDirection,
+  passedProps: { direction = "from-left", enterStyle, exitStyle }
+}) => {
+  const directionStyle = useMemo(() => {
+    const presentationProgressWithEpsilonCorrection = presentationProgress === 1 ? presentationProgress * 100 : presentationProgress * 100 - epsilon;
+    if (presentationDirection === "exiting") {
+      switch (direction) {
+        case "from-left":
+          return {
+            transform: `translateX(${presentationProgressWithEpsilonCorrection}%)`
+          };
+        case "from-right":
+          return {
+            transform: `translateX(${-presentationProgress * 100}%)`
+          };
+        case "from-top":
+          return {
+            transform: `translateY(${presentationProgressWithEpsilonCorrection}%)`
+          };
+        case "from-bottom":
+          return {
+            transform: `translateY(${-presentationProgress * 100}%)`
+          };
+        default:
+          throw new Error(`Invalid direction: ${direction}`);
+      }
+    }
+    switch (direction) {
+      case "from-left":
+        return {
+          transform: `translateX(${-100 + presentationProgress * 100}%)`
+        };
+      case "from-right":
+        return {
+          transform: `translateX(${100 - presentationProgressWithEpsilonCorrection}%)`
+        };
+      case "from-top":
+        return {
+          transform: `translateY(${-100 + presentationProgress * 100}%)`
+        };
+      case "from-bottom":
+        return {
+          transform: `translateY(${100 - presentationProgressWithEpsilonCorrection}%)`
+        };
+      default:
+        throw new Error(`Invalid direction: ${direction}`);
+    }
+  }, [presentationDirection, presentationProgress, direction]);
+  const style = useMemo(() => {
+    return {
+      width: "100%",
+      height: "100%",
+      justifyContent: "center",
+      alignItems: "center",
+      ...directionStyle,
+      ...presentationDirection === "entering" ? enterStyle : exitStyle
+    };
+  }, [directionStyle, enterStyle, exitStyle, presentationDirection]);
+  return /* @__PURE__ */ jsx(AbsoluteFill, {
+    style,
+    children
+  });
+};
+var slide = (props) => {
+  return {
+    component: SlidePresentation,
+    props: props ?? {}
+  };
+};
+var linearTiming = (options) => {
+  return {
+    getDurationInFrames: () => {
+      return options.durationInFrames;
+    },
+    getProgress: ({ frame }) => {
+      return interpolate(frame, [0, options.durationInFrames], [0, 1], {
+        easing: options.easing,
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+    }
+  };
+};
+var EnteringContext = React2.createContext(null);
+var ExitingContext = React2.createContext(null);
+var WrapInEnteringProgressContext = ({ presentationProgress, children }) => {
+  const value = useMemo2(() => {
+    return {
+      enteringProgress: presentationProgress
+    };
+  }, [presentationProgress]);
+  return /* @__PURE__ */ jsx2(EnteringContext.Provider, {
+    value,
+    children
+  });
+};
+var WrapInExitingProgressContext = ({ presentationProgress, children }) => {
+  const value = useMemo2(() => {
+    return {
+      exitingProgress: presentationProgress
+    };
+  }, [presentationProgress]);
+  return /* @__PURE__ */ jsx2(ExitingContext.Provider, {
+    value,
+    children
+  });
+};
+var flattenChildren = (children) => {
+  const childrenArray = React3.Children.toArray(children);
+  return childrenArray.reduce((flatChildren, child) => {
+    if (child.type === React3.Fragment) {
+      return flatChildren.concat(flattenChildren(child.props.children));
+    }
+    flatChildren.push(child);
+    return flatChildren;
+  }, []);
+};
+var validateDurationInFrames = NoReactInternals.validateDurationInFrames;
+var TransitionSeriesTransition = function(_props) {
+  return null;
+};
+var SeriesOverlay = () => {
+  return null;
+};
+var SeriesSequence = ({ children }) => {
+  return /* @__PURE__ */ jsx3(Fragment, {
+    children
+  });
+};
+var TransitionSeriesChildren = ({
+  children
+}) => {
+  const { fps } = useVideoConfig();
+  const frame = useCurrentFrame();
+  const childrenValue = useMemo3(() => {
+    let transitionOffsets = 0;
+    let startFrame = 0;
+    const flattedChildren = flattenChildren(children);
+    const overlayRenders = [];
+    const sequenceDurations = [];
+    let pendingOverlayValidation = false;
+    const mainChildren = Children.map(flattedChildren, (child, i) => {
+      const current = child;
+      if (typeof current === "string") {
+        if (current.trim() === "") {
+          return null;
+        }
+        throw new TypeError(`The <TransitionSeries /> component only accepts a list of <TransitionSeries.Sequence /> components as its children, but you passed a string "${current}"`);
+      }
+      const hasPrev = flattedChildren[i - 1];
+      const nextPrev = flattedChildren[i + 1];
+      const prevIsTransition = typeof hasPrev === "string" || typeof hasPrev === "undefined" ? false : hasPrev.type === TransitionSeriesTransition;
+      const prevIsOverlay = typeof hasPrev === "string" || typeof hasPrev === "undefined" ? false : hasPrev.type === SeriesOverlay;
+      if (current.type === SeriesOverlay) {
+        if (prevIsOverlay) {
+          throw new TypeError(`A <TransitionSeries.Overlay /> component must not be followed by another <TransitionSeries.Overlay /> component (nth children = ${i - 1} and ${i})`);
+        }
+        if (prevIsTransition) {
+          throw new TypeError(`A <TransitionSeries.Transition /> component must not be followed by a <TransitionSeries.Overlay /> component (nth children = ${i - 1} and ${i})`);
+        }
+        const nextIsTransition = typeof nextPrev === "string" || typeof nextPrev === "undefined" ? false : nextPrev.type === TransitionSeriesTransition;
+        if (nextIsTransition) {
+          throw new TypeError(`A <TransitionSeries.Overlay /> component must not be followed by a <TransitionSeries.Transition /> component (nth children = ${i} and ${i + 1})`);
+        }
+        const overlayProps = current.props;
+        validateDurationInFrames(overlayProps.durationInFrames, {
+          component: `of a <TransitionSeries.Overlay /> component`,
+          allowFloats: false
+        });
+        const overlayOffset = overlayProps.offset ?? 0;
+        if (Number.isNaN(overlayOffset)) {
+          throw new TypeError(`The "offset" property of a <TransitionSeries.Overlay /> must not be NaN, but got NaN.`);
+        }
+        if (!Number.isFinite(overlayOffset)) {
+          throw new TypeError(`The "offset" property of a <TransitionSeries.Overlay /> must be finite, but got ${overlayOffset}.`);
+        }
+        if (overlayOffset % 1 !== 0) {
+          throw new TypeError(`The "offset" property of a <TransitionSeries.Overlay /> must be an integer, but got ${overlayOffset}.`);
+        }
+        const cutPoint = startFrame + transitionOffsets;
+        const halfDuration = overlayProps.durationInFrames / 2;
+        const overlayFrom = cutPoint - halfDuration + overlayOffset;
+        if (overlayFrom < 0) {
+          throw new TypeError(`A <TransitionSeries.Overlay /> extends before frame 0. The overlay starts at frame ${overlayFrom}. Reduce the duration or adjust the offset.`);
+        }
+        const prevSeqIdx = sequenceDurations.length - 1;
+        if (prevSeqIdx >= 0) {
+          const overlayStartInPrev = halfDuration - overlayOffset;
+          if (overlayStartInPrev > sequenceDurations[prevSeqIdx]) {
+            throw new TypeError(`A <TransitionSeries.Overlay /> extends beyond the previous sequence. The overlay needs ${overlayStartInPrev} frames before the cut, but the previous sequence is only ${sequenceDurations[prevSeqIdx]} frames long.`);
+          }
+        }
+        pendingOverlayValidation = true;
+        overlayRenders.push({
+          cutPoint,
+          overlayFrom,
+          durationInFrames: overlayProps.durationInFrames,
+          overlayOffset,
+          halfDuration,
+          children: overlayProps.children,
+          index: i
+        });
+        return null;
+      }
+      if (current.type === TransitionSeriesTransition) {
+        if (prevIsTransition) {
+          throw new TypeError(`A <TransitionSeries.Transition /> component must not be followed by another <TransitionSeries.Transition /> component (nth children = ${i - 1} and ${i})`);
+        }
+        if (prevIsOverlay) {
+          throw new TypeError(`A <TransitionSeries.Overlay /> component must not be followed by a <TransitionSeries.Transition /> component (nth children = ${i - 1} and ${i})`);
+        }
+        return null;
+      }
+      if (current.type !== SeriesSequence) {
+        throw new TypeError(`The <TransitionSeries /> component only accepts a list of <TransitionSeries.Sequence />, <TransitionSeries.Transition />, and <TransitionSeries.Overlay /> components as its children, but got ${current} instead`);
+      }
+      const prev = typeof hasPrev === "string" || typeof hasPrev === "undefined" ? null : hasPrev.type === TransitionSeriesTransition ? hasPrev : null;
+      const next = typeof nextPrev === "string" || typeof nextPrev === "undefined" ? null : nextPrev.type === TransitionSeriesTransition ? nextPrev : null;
+      const castedChildAgain = current;
+      const debugInfo = `index = ${i}, duration = ${castedChildAgain.props.durationInFrames}`;
+      if (!castedChildAgain?.props.children) {
+        throw new TypeError(`A <TransitionSeries.Sequence /> component (${debugInfo}) was detected to not have any children. Delete it to fix this error.`);
+      }
+      const durationInFramesProp = castedChildAgain.props.durationInFrames;
+      const {
+        durationInFrames,
+        children: _children,
+        ...passedProps
+      } = castedChildAgain.props;
+      validateDurationInFrames(durationInFramesProp, {
+        component: `of a <TransitionSeries.Sequence /> component`,
+        allowFloats: true
+      });
+      const offset = castedChildAgain.props.offset ?? 0;
+      if (Number.isNaN(offset)) {
+        throw new TypeError(`The "offset" property of a <TransitionSeries.Sequence /> must not be NaN, but got NaN (${debugInfo}).`);
+      }
+      if (!Number.isFinite(offset)) {
+        throw new TypeError(`The "offset" property of a <TransitionSeries.Sequence /> must be finite, but got ${offset} (${debugInfo}).`);
+      }
+      if (offset % 1 !== 0) {
+        throw new TypeError(`The "offset" property of a <TransitionSeries.Sequence /> must be finite, but got ${offset} (${debugInfo}).`);
+      }
+      const currentStartFrame = startFrame + offset;
+      let duration = 0;
+      if (prev) {
+        duration = prev.props.timing.getDurationInFrames({
+          fps
+        });
+        transitionOffsets -= duration;
+      }
+      let actualStartFrame = currentStartFrame + transitionOffsets;
+      startFrame += durationInFramesProp + offset;
+      if (actualStartFrame < 0) {
+        startFrame -= actualStartFrame;
+        actualStartFrame = 0;
+      }
+      sequenceDurations.push(durationInFramesProp);
+      if (pendingOverlayValidation) {
+        pendingOverlayValidation = false;
+        const lastOverlay = overlayRenders[overlayRenders.length - 1];
+        const framesAfterCut = lastOverlay.halfDuration + lastOverlay.overlayOffset;
+        if (framesAfterCut > durationInFramesProp) {
+          throw new TypeError(`A <TransitionSeries.Overlay /> extends beyond the next sequence. The overlay needs ${framesAfterCut} frames after the cut, but the next sequence is only ${durationInFramesProp} frames long.`);
+        }
+      }
+      const nextProgress = next ? next.props.timing.getProgress({
+        frame: frame - actualStartFrame - durationInFrames + next.props.timing.getDurationInFrames({ fps }),
+        fps
+      }) : null;
+      const prevProgress = prev ? prev.props.timing.getProgress({
+        frame: frame - actualStartFrame,
+        fps
+      }) : null;
+      if (next && durationInFramesProp < next.props.timing.getDurationInFrames({ fps })) {
+        throw new Error(`The duration of a <TransitionSeries.Sequence /> must not be shorter than the duration of the next <TransitionSeries.Transition />. The transition is ${next.props.timing.getDurationInFrames({ fps })} frames long, but the sequence is only ${durationInFramesProp} frames long (${debugInfo})`);
+      }
+      if (prev && durationInFramesProp < prev.props.timing.getDurationInFrames({ fps })) {
+        throw new Error(`The duration of a <TransitionSeries.Sequence /> must not be shorter than the duration of the previous <TransitionSeries.Transition />. The transition is ${prev.props.timing.getDurationInFrames({ fps })} frames long, but the sequence is only ${durationInFramesProp} frames long (${debugInfo})`);
+      }
+      if (next && prev && nextProgress !== null && prevProgress !== null) {
+        const nextPresentation = next.props.presentation ?? slide();
+        const prevPresentation = prev.props.presentation ?? slide();
+        const UppercaseNextPresentation = nextPresentation.component;
+        const UppercasePrevPresentation = prevPresentation.component;
+        return /* @__PURE__ */ jsx3(Sequence, {
+          from: actualStartFrame,
+          durationInFrames: durationInFramesProp,
+          ...passedProps,
+          name: passedProps.name || "<TS.Sequence>",
+          children: /* @__PURE__ */ jsx3(UppercaseNextPresentation, {
+            passedProps: nextPresentation.props ?? {},
+            presentationDirection: "exiting",
+            presentationProgress: nextProgress,
+            presentationDurationInFrames: next.props.timing.getDurationInFrames({ fps }),
+            children: /* @__PURE__ */ jsx3(WrapInExitingProgressContext, {
+              presentationProgress: nextProgress,
+              children: /* @__PURE__ */ jsx3(UppercasePrevPresentation, {
+                passedProps: prevPresentation.props ?? {},
+                presentationDirection: "entering",
+                presentationProgress: prevProgress,
+                presentationDurationInFrames: prev.props.timing.getDurationInFrames({ fps }),
+                children: /* @__PURE__ */ jsx3(WrapInEnteringProgressContext, {
+                  presentationProgress: prevProgress,
+                  children: child
+                })
+              })
+            })
+          })
+        }, i);
+      }
+      if (prevProgress !== null && prev) {
+        const prevPresentation = prev.props.presentation ?? slide();
+        const UppercasePrevPresentation = prevPresentation.component;
+        return /* @__PURE__ */ jsx3(Sequence, {
+          from: actualStartFrame,
+          durationInFrames: durationInFramesProp,
+          ...passedProps,
+          name: passedProps.name || "<TS.Sequence>",
+          children: /* @__PURE__ */ jsx3(UppercasePrevPresentation, {
+            passedProps: prevPresentation.props ?? {},
+            presentationDirection: "entering",
+            presentationProgress: prevProgress,
+            presentationDurationInFrames: prev.props.timing.getDurationInFrames({ fps }),
+            children: /* @__PURE__ */ jsx3(WrapInEnteringProgressContext, {
+              presentationProgress: prevProgress,
+              children: child
+            })
+          })
+        }, i);
+      }
+      if (nextProgress !== null && next) {
+        const nextPresentation = next.props.presentation ?? slide();
+        const UppercaseNextPresentation = nextPresentation.component;
+        return /* @__PURE__ */ jsx3(Sequence, {
+          from: actualStartFrame,
+          durationInFrames: durationInFramesProp,
+          ...passedProps,
+          name: passedProps.name || "<TS.Sequence>",
+          children: /* @__PURE__ */ jsx3(UppercaseNextPresentation, {
+            passedProps: nextPresentation.props ?? {},
+            presentationDirection: "exiting",
+            presentationProgress: nextProgress,
+            presentationDurationInFrames: next.props.timing.getDurationInFrames({ fps }),
+            children: /* @__PURE__ */ jsx3(WrapInExitingProgressContext, {
+              presentationProgress: nextProgress,
+              children: child
+            })
+          })
+        }, i);
+      }
+      return /* @__PURE__ */ jsx3(Sequence, {
+        from: actualStartFrame,
+        durationInFrames: durationInFramesProp,
+        ...passedProps,
+        name: passedProps.name || "<TS.Sequence>",
+        children: child
+      }, i);
+    });
+    const overlayElements = overlayRenders.map((overlayInfo) => {
+      const info = overlayInfo;
+      return /* @__PURE__ */ jsx3(Sequence, {
+        from: Math.round(info.overlayFrom),
+        durationInFrames: info.durationInFrames,
+        name: "<TS.Overlay>",
+        layout: "absolute-fill",
+        children: info.children
+      }, `overlay-${info.index}`);
+    });
+    return [...mainChildren || [], ...overlayElements];
+  }, [children, fps, frame]);
+  return /* @__PURE__ */ jsx3(Fragment, {
+    children: childrenValue
+  });
+};
+var TransitionSeries = ({ children, name, layout: passedLayout, ...otherProps }) => {
+  const displayName = name ?? "<TransitionSeries>";
+  const layout = passedLayout ?? "absolute-fill";
+  if (NoReactInternals2.ENABLE_V5_BREAKING_CHANGES && layout !== "absolute-fill") {
+    throw new TypeError(`The "layout" prop of <TransitionSeries /> is not supported anymore in v5. TransitionSeries' must be absolutely positioned.`);
+  }
+  return /* @__PURE__ */ jsx3(Sequence, {
+    name: displayName,
+    layout,
+    ...otherProps,
+    children: /* @__PURE__ */ jsx3(TransitionSeriesChildren, {
+      children
+    })
+  });
+};
+TransitionSeries.Sequence = SeriesSequence;
+TransitionSeries.Transition = TransitionSeriesTransition;
+TransitionSeries.Overlay = SeriesOverlay;
+Internals.addSequenceStackTraces(TransitionSeries);
+Internals.addSequenceStackTraces(SeriesSequence);
+Internals.addSequenceStackTraces(SeriesOverlay);
+
+export {
+  linearTiming,
+  TransitionSeries
+};