videobook 0.0.0-stage → 0.2.0

package/dist/remotion/keyword-placement.js

@@ -0,0 +1,182 @@
+import { LANDSCAPE_HEIGHT, LANDSCAPE_WIDTH, PORTRAIT_HEIGHT, PORTRAIT_WIDTH, SQUARE_HEIGHT, SQUARE_WIDTH, getHighlightFontSize, getImpactFontSize, getYPosition, } from "./constants.js";
+export const KEYWORD_PLACEMENT_VERSION = 1;
+export const KEYWORD_FRAME_CACHE_FILENAME = ".keyword-frames.jpg";
+export const KEYWORD_PLACEMENT_METADATA_KEY = "keyword-graphics.placement";
+const PLACEMENT_SCALES = [1, 0.85, 0.7];
+const ANCHORS = [
+    "upper-left",
+    "upper-right",
+    "middle-left",
+    "middle-right",
+];
+const OCCUPIED_MARGIN = 0.04;
+export function keywordCueId(graphic) {
+    const frameTime = graphic.frameTime ?? graphic.start;
+    return `${graphic.text.toLocaleLowerCase()}@${frameTime.toFixed(3)}`;
+}
+export function orientationDimensions(orientation) {
+    if (orientation === "portrait")
+        return { width: PORTRAIT_WIDTH, height: PORTRAIT_HEIGHT };
+    if (orientation === "square")
+        return { width: SQUARE_WIDTH, height: SQUARE_HEIGHT };
+    return { width: LANDSCAPE_WIDTH, height: LANDSCAPE_HEIGHT };
+}
+export function keywordFontSize(text, width, height, scale = 1) {
+    const portrait = height > width;
+    const square = height === width;
+    const base = width * (portrait ? 0.095 : square ? 0.078 : 0.055);
+    const length = Array.from(text).length;
+    const lengthScale = length > 16 ? 0.64 : length > 11 ? 0.78 : 1;
+    return Math.round(base * lengthScale * scale);
+}
+function keywordAnchorSide(anchor) {
+    return anchor.endsWith("right") ? "right" : "left";
+}
+export function keywordLayout(text, anchor, width, height, scale = 1) {
+    const portrait = height > width;
+    const top = height * (anchor.startsWith("upper") ? 0.18 : 0.38);
+    const sideInset = width * (portrait ? 0.065 : 0.07);
+    const containerWidth = width * (portrait ? 0.72 : 0.43);
+    const fontSize = keywordFontSize(text, width, height, scale);
+    const textWidth = Math.min(containerWidth, Array.from(text).length * fontSize * 0.68);
+    const underlineWidth = Math.min(width * 0.14, fontSize * 2.25);
+    const rectWidth = Math.max(textWidth, underlineWidth);
+    const rectHeight = fontSize * 1.22 + Math.max(2, width * 0.002);
+    const side = keywordAnchorSide(anchor);
+    const x = side === "left" ? sideInset : width - sideInset - rectWidth;
+    return {
+        top,
+        sideInset,
+        containerWidth,
+        fontSize,
+        side,
+        rect: {
+            x: x / width,
+            y: top / height,
+            width: rectWidth / width,
+            height: rectHeight / height,
+        },
+    };
+}
+function clampRect(rect) {
+    const x = Math.max(0, Math.min(1, rect.x));
+    const y = Math.max(0, Math.min(1, rect.y));
+    return {
+        x,
+        y,
+        width: Math.max(0, Math.min(1 - x, rect.width)),
+        height: Math.max(0, Math.min(1 - y, rect.height)),
+    };
+}
+export function expandRect(rect, margin) {
+    return clampRect({
+        x: rect.x - margin,
+        y: rect.y - margin,
+        width: rect.width + margin * 2,
+        height: rect.height + margin * 2,
+    });
+}
+function intersects(a, b) {
+    return a.x < b.x + b.width
+        && a.x + a.width > b.x
+        && a.y < b.y + b.height
+        && a.y + a.height > b.y;
+}
+function rectGap(a, b) {
+    const dx = Math.max(a.x - (b.x + b.width), b.x - (a.x + a.width), 0);
+    const dy = Math.max(a.y - (b.y + b.height), b.y - (a.y + a.height), 0);
+    return Math.hypot(dx, dy);
+}
+export function intersectionArea(a, b) {
+    const width = Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x);
+    const height = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
+    return width > 0 && height > 0 ? width * height : 0;
+}
+export function mapSourceRectToTarget(rect, sourceWidth, sourceHeight, targetWidth, targetHeight) {
+    const sourceAspect = sourceWidth / sourceHeight;
+    const targetAspect = targetWidth / targetHeight;
+    let foregroundWidth;
+    let foregroundHeight;
+    if (sourceAspect > targetAspect) {
+        foregroundWidth = targetWidth;
+        foregroundHeight = targetWidth / sourceAspect;
+    }
+    else {
+        foregroundHeight = targetHeight;
+        foregroundWidth = targetHeight * sourceAspect;
+    }
+    const offsetX = (targetWidth - foregroundWidth) / 2;
+    const offsetY = (targetHeight - foregroundHeight) / 2;
+    return clampRect({
+        x: (offsetX + rect.x * foregroundWidth) / targetWidth,
+        y: (offsetY + rect.y * foregroundHeight) / targetHeight,
+        width: rect.width * foregroundWidth / targetWidth,
+        height: rect.height * foregroundHeight / targetHeight,
+    });
+}
+export function subtitleBand(orientation, targetHeight, position, style, fontSize) {
+    const y = getYPosition(position, orientation);
+    const fontPx = style !== "highlight"
+        ? getImpactFontSize(fontSize, orientation)
+        : getHighlightFontSize(fontSize, orientation);
+    const height = Math.max(targetHeight * 0.1, fontPx * 1.9) / targetHeight;
+    const top = position === "top"
+        ? y - 0.025
+        : position === "bottom"
+            ? y - height + 0.025
+            : y - height / 2;
+    return clampRect({ x: 0.02, y: top, width: 0.96, height });
+}
+function preferredAnchorOrder(index) {
+    const preferRight = index % 2 === 0;
+    return preferRight
+        ? ["upper-right", "middle-right", "upper-left", "middle-left"]
+        : ["upper-left", "middle-left", "upper-right", "middle-right"];
+}
+function choosePlacement(graphic, index, targetWidth, targetHeight, occupied) {
+    const order = preferredAnchorOrder(index);
+    for (const scale of PLACEMENT_SCALES) {
+        const safe = ANCHORS.flatMap((anchor) => {
+            const rect = keywordLayout(graphic.text, anchor, targetWidth, targetHeight, scale).rect;
+            if (occupied.some((region) => intersects(rect, region)))
+                return [];
+            const distance = occupied.length === 0
+                ? 1
+                : Math.min(...occupied.map((region) => rectGap(rect, region)));
+            const preference = (order.length - order.indexOf(anchor)) * 0.0001;
+            return [{ anchor, scale, score: distance + preference }];
+        });
+        safe.sort((a, b) => b.score - a.score);
+        if (safe[0])
+            return { anchor: safe[0].anchor, scale: safe[0].scale };
+    }
+    return null;
+}
+export function resolveKeywordPlacements(graphics, analysis, orientation, settings) {
+    const { width, height } = orientationDimensions(orientation);
+    const cues = new Map(analysis.cues.map((cue) => [cue.cueId, cue]));
+    const placed = [];
+    const skipped = [];
+    for (let index = 0; index < graphics.length; index++) {
+        const graphic = graphics[index];
+        const cue = cues.get(keywordCueId(graphic));
+        if (!cue)
+            throw new Error(`Missing placement analysis for keyword ${graphic.text}`);
+        const occupied = cue.regions.map((region) => expandRect(mapSourceRectToTarget(region, analysis.sourceWidth, analysis.sourceHeight, width, height), OCCUPIED_MARGIN));
+        if (settings.subtitlesEnabled) {
+            occupied.push(expandRect(subtitleBand(orientation, height, settings.subtitlePosition, settings.subtitleStyle, settings.subtitleFontSize), OCCUPIED_MARGIN));
+        }
+        const decision = choosePlacement(graphic, index, width, height, occupied);
+        if (!decision) {
+            skipped.push(graphic.text);
+            continue;
+        }
+        placed.push({
+            ...graphic,
+            anchor: decision.anchor,
+            scale: decision.scale,
+            side: keywordAnchorSide(decision.anchor),
+        });
+    }
+    return { graphics: placed, skipped };
+}

package/dist/remotion/osg-spec.js

@@ -0,0 +1,198 @@
+import { expandRect, intersectionArea, orientationDimensions, } from "./keyword-placement.js";
+// Max edge of the graphic as a fraction of the video width. Sized for a
+// visible on-screen graphic (TV-style logo bug): `medium` ≈ 14% of width,
+// `small` half that, `large` 1.5×. The previous 5%/2.5%/7.5% presets rendered
+// a near-invisible corner thumbnail that users read as "OSG didn't apply".
+const SIZE_FACTOR = {
+    small: 0.07,
+    medium: 0.14,
+    large: 0.21,
+};
+// The OSG always eases in/out over this window so it never pops abruptly.
+export const FADE_SECONDS = 0.4;
+/**
+ * Resolve the visibility window [startFrame, endFrame). Precedence: an explicit
+ * absolute window (startSeconds/endSeconds) wins; else a duration-relative tail;
+ * else the full clip.
+ */
+export function resolveOsgWindow(opts) {
+    const { startSeconds, endSeconds, tailSeconds, durationInFrames, fps } = opts;
+    const hasAbsoluteWindow = startSeconds != null || endSeconds != null;
+    let startFrame;
+    let endFrame;
+    if (hasAbsoluteWindow) {
+        startFrame = startSeconds != null ? Math.round(startSeconds * fps) : 0;
+        endFrame = endSeconds != null ? Math.round(endSeconds * fps) : durationInFrames;
+    }
+    else if (tailSeconds != null) {
+        startFrame = Math.max(0, durationInFrames - Math.round(tailSeconds * fps));
+        endFrame = durationInFrames;
+    }
+    else {
+        startFrame = 0;
+        endFrame = durationInFrames;
+    }
+    startFrame = Math.min(Math.max(0, startFrame), durationInFrames);
+    endFrame = Math.min(Math.max(startFrame, endFrame), durationInFrames);
+    return { startFrame, endFrame, hasExplicitEnd: endFrame < durationInFrames };
+}
+function ramp(frame, x0, x1, y0, y1) {
+    if (frame <= x0)
+        return y0;
+    if (frame >= x1)
+        return y1;
+    return y0 + ((frame - x0) / (x1 - x0)) * (y1 - y0);
+}
+/**
+ * Opacity envelope for a frame within a window: eases in over FADE_SECONDS and
+ * symmetrically eases out toward the window end — including the implicit
+ * end-of-clip, so a whole-video watermark fades at both edges. Frames outside
+ * [startFrame, endFrame) are hard-gated to 0 so a collapsed fade on a
+ * sub-second span can't leave the graphic showing past its window.
+ */
+export function osgFadeEnvelope(frame, window, fps) {
+    const { startFrame, endFrame } = window;
+    if (frame < startFrame || frame >= endFrame)
+        return 0;
+    const span = Math.max(1, endFrame - startFrame);
+    const maxFade = Math.max(1, Math.round(FADE_SECONDS * fps));
+    const fade = Math.max(1, Math.min(maxFade, Math.floor(span / 2)));
+    const inEnd = startFrame + fade;
+    const outStart = endFrame - fade;
+    if (outStart > inEnd) {
+        if (frame >= outStart)
+            return ramp(frame, outStart, endFrame, 1, 0);
+        return ramp(frame, startFrame, inEnd, 0, 1);
+    }
+    return ramp(frame, startFrame, inEnd, 0, 1);
+}
+export function osgMaxSize(width, size, scale) {
+    return Math.round(width * SIZE_FACTOR[size] * scale);
+}
+export function osgPadding(width) {
+    return Math.round(width * 0.02);
+}
+export function osgAnchorPlacement(position, padding) {
+    const [vertical, horizontal] = position.split("-");
+    const placement = { transforms: [] };
+    if (vertical === "top")
+        placement.top = padding;
+    else if (vertical === "bottom")
+        placement.bottom = padding;
+    else {
+        placement.top = "50%";
+        placement.transforms.push("translateY(-50%)");
+    }
+    if (horizontal === "left")
+        placement.left = padding;
+    else if (horizontal === "right")
+        placement.right = padding;
+    else {
+        placement.left = "50%";
+        placement.transforms.push("translateX(-50%)");
+    }
+    return placement;
+}
+// ---------------------------------------------------------------------------
+// Floating watermark: a faint QR + @handle badge shown for the whole clip.
+// Sized off the canvas's min dimension (via a per-orientation osgScale) so the
+// badge is the same physical size on landscape, portrait, and square renders.
+// ---------------------------------------------------------------------------
+// Badge height as a fraction of min(width, height) — ≈173px on a 1080 min dim,
+// keeping the QR (~2/3 of badge height) scannable while staying unobtrusive.
+export const WATERMARK_MIN_DIM_FRACTION = 0.16;
+export const WATERMARK_OSG_SIZE = "medium";
+export const WATERMARK_OPACITY = 0.5;
+// Candidate anchors in tie-break preference order.
+export const WATERMARK_CORNERS = [
+    "bottom-right",
+    "bottom-left",
+    "top-right",
+    "top-left",
+];
+const WATERMARK_OCCUPIED_MARGIN = 0.04;
+const REGION_KIND_WEIGHT = {
+    face: 3,
+    text: 2,
+    graphic: 1,
+};
+/**
+ * OsgOverlay sizes off canvas width; translate the min-dim target into the
+ * equivalent per-orientation osgScale for the `medium` preset, clamped to the
+ * set_video_overlay schema range.
+ */
+export function watermarkOsgScale(orientation, userScale = 1) {
+    const { width, height } = orientationDimensions(orientation);
+    const minDim = Math.min(width, height);
+    const raw = (WATERMARK_MIN_DIM_FRACTION / SIZE_FACTOR[WATERMARK_OSG_SIZE]) * (minDim / width) * userScale;
+    return Math.min(2, Math.max(0.1, Number(raw.toFixed(4))));
+}
+/**
+ * On-canvas rect of the contain-fitted badge at a given anchor, normalized to
+ * an arbitrary canvas (a render orientation or the source frame itself, for
+ * burned-in watermarks). `aspect` is the badge's width/height (< 1: the badge
+ * is taller than wide, so height binds at maxSize).
+ */
+function watermarkRectForCanvas(width, height, corner, aspect, userScale = 1) {
+    const maxSize = Math.round(Math.min(width, height) * WATERMARK_MIN_DIM_FRACTION * userScale);
+    const badgeHeight = aspect < 1 ? maxSize : maxSize / aspect;
+    const badgeWidth = badgeHeight * aspect;
+    const padding = osgPadding(width);
+    const [vertical, horizontal] = corner.split("-");
+    const x = horizontal === "left"
+        ? padding
+        : horizontal === "right"
+            ? width - padding - badgeWidth
+            : (width - badgeWidth) / 2;
+    const y = vertical === "top"
+        ? padding
+        : vertical === "bottom"
+            ? height - padding - badgeHeight
+            : (height - badgeHeight) / 2;
+    return {
+        x: x / width,
+        y: y / height,
+        width: badgeWidth / width,
+        height: badgeHeight / height,
+    };
+}
+export function watermarkRectForCorner(orientation, corner, aspect, userScale = 1) {
+    const { width, height } = orientationDimensions(orientation);
+    return watermarkRectForCanvas(width, height, corner, aspect, userScale);
+}
+/**
+ * Pick the least-occupied corner for the watermark. Score per corner is the
+ * summed overlap area with each occupied region (expanded by a margin),
+ * weighted by region kind and confidence; the subtitle band counts as a
+ * full-confidence text region. Ties resolve by WATERMARK_CORNERS order.
+ */
+export function scoreWatermarkCornersForCanvas(width, height, occupied, opts) {
+    const { aspect, userScale = 1, subtitleBand = null } = opts;
+    const scores = {};
+    let best = WATERMARK_CORNERS[0];
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const corner of WATERMARK_CORNERS) {
+        const rect = watermarkRectForCanvas(width, height, corner, aspect, userScale);
+        let score = 0;
+        for (const region of occupied) {
+            const expanded = expandRect(region, WATERMARK_OCCUPIED_MARGIN);
+            score += intersectionArea(rect, expanded) * REGION_KIND_WEIGHT[region.kind] * region.confidence;
+        }
+        if (subtitleBand) {
+            const expanded = expandRect(subtitleBand, WATERMARK_OCCUPIED_MARGIN);
+            score += intersectionArea(rect, expanded) * REGION_KIND_WEIGHT.text;
+        }
+        scores[corner] = score;
+        // Epsilon so float noise between mathematically-equal corner areas can't
+        // steal a tie from the preference order.
+        if (score < bestScore - 1e-9) {
+            bestScore = score;
+            best = corner;
+        }
+    }
+    return { position: best, scores };
+}
+export function scoreWatermarkCorners(orientation, occupied, opts) {
+    const { width, height } = orientationDimensions(orientation);
+    return scoreWatermarkCornersForCanvas(width, height, occupied, opts);
+}

package/dist/remotion/qr-outro-audio.js

@@ -0,0 +1 @@
+export const DEFAULT_QR_OUTRO_SOUND_FILENAME = "qr-outro-impact.wav";

package/dist/remotion/qr-outro-spec.js

@@ -0,0 +1,211 @@
+const FPS = 30;
+const IMPACT_INTERVAL_S = 0.4;
+const IMPACT_INTERVAL_FRAMES = Math.round(IMPACT_INTERVAL_S * FPS);
+const FIRST_IMPACT_S = 0.4;
+const FIRST_IMPACT_FRAME = Math.round(FIRST_IMPACT_S * FPS);
+const MIN_DURATION_S = 3.0;
+const TAIL_AFTER_LAST_IMPACT_S = 1.6;
+const ENTRY_FRAMES = IMPACT_INTERVAL_FRAMES;
+const ENTRY_OVERSCAN_FRACTION = 0.25;
+const MAX_FINAL_CUE_S = 0.6;
+const BACKGROUND_COLOR = "#0A0A0A";
+const LAYOUT_PAD = 24;
+const CARD_GAP = 16;
+export { FPS, IMPACT_INTERVAL_FRAMES, FIRST_IMPACT_FRAME, ENTRY_FRAMES, MAX_FINAL_CUE_S, BACKGROUND_COLOR, LAYOUT_PAD, };
+export function qrLayout(ratio) {
+    switch (ratio) {
+        case "16:9": {
+            const w = 1920;
+            const h = 1080;
+            return {
+                width: w,
+                height: h,
+                contentRect: { x: 0, y: 0, w, h },
+                entryEdge: "right",
+            };
+        }
+        case "9:16": {
+            const w = 1080;
+            const h = 1920;
+            return {
+                width: w,
+                height: h,
+                contentRect: { x: 0, y: 0, w, h },
+                entryEdge: "bottom",
+            };
+        }
+        case "1:1": {
+            const w = 1080;
+            const h = 1080;
+            return {
+                width: w,
+                height: h,
+                contentRect: { x: 0, y: 0, w, h },
+                entryEdge: "right",
+            };
+        }
+    }
+}
+export function orientationForAspectRatio(ratio) {
+    if (ratio === "9:16")
+        return "portrait";
+    if (ratio === "1:1")
+        return "square";
+    return "landscape";
+}
+export function cardPlacements(qrCount, contentRect) {
+    if (qrCount < 1 || qrCount > 4) {
+        throw new Error(`qrCount must be 1-4, got ${qrCount}`);
+    }
+    const insetX = contentRect.x + LAYOUT_PAD;
+    const insetY = contentRect.y + LAYOUT_PAD;
+    const availW = contentRect.w - LAYOUT_PAD * 2;
+    const availH = contentRect.h - LAYOUT_PAD * 2;
+    if (qrCount === 1) {
+        const side = Math.min(availW, availH);
+        return [{
+                x: insetX + Math.floor((availW - side) / 2),
+                y: insetY + Math.floor((availH - side) / 2),
+                w: side,
+                h: side,
+                index: 0,
+            }];
+    }
+    if (qrCount === 2) {
+        if (availW >= availH) {
+            const cardW = Math.floor((availW - CARD_GAP) / 2);
+            const side = Math.min(cardW, availH);
+            const cy = insetY + Math.floor((availH - side) / 2);
+            return [
+                { x: insetX + Math.floor((cardW - side) / 2), y: cy, w: side, h: side, index: 0 },
+                { x: insetX + cardW + CARD_GAP + Math.floor((cardW - side) / 2), y: cy, w: side, h: side, index: 1 },
+            ];
+        }
+        const cardH = Math.floor((availH - CARD_GAP) / 2);
+        const side = Math.min(availW, cardH);
+        const cx = insetX + Math.floor((availW - side) / 2);
+        return [
+            { x: cx, y: insetY + Math.floor((cardH - side) / 2), w: side, h: side, index: 0 },
+            { x: cx, y: insetY + cardH + CARD_GAP + Math.floor((cardH - side) / 2), w: side, h: side, index: 1 },
+        ];
+    }
+    const cols = 2;
+    const rows = 2;
+    const cellW = Math.floor((availW - CARD_GAP * (cols - 1)) / cols);
+    const cellH = Math.floor((availH - CARD_GAP * (rows - 1)) / rows);
+    const side = Math.min(cellW, cellH);
+    const placements = [];
+    for (let i = 0; i < qrCount; i++) {
+        const col = i % cols;
+        const row = Math.floor(i / cols);
+        const cellX = insetX + col * (cellW + CARD_GAP);
+        const cellY = insetY + row * (cellH + CARD_GAP);
+        placements.push({
+            x: cellX + Math.floor((cellW - side) / 2),
+            y: cellY + Math.floor((cellH - side) / 2),
+            w: side,
+            h: side,
+            index: i,
+        });
+    }
+    return placements;
+}
+export function cardEntryOffset(placement, layout) {
+    const driftDirection = placement.index % 2 === 0 ? -1 : 1;
+    const overscan = Math.ceil(Math.max(placement.w, placement.h) * ENTRY_OVERSCAN_FRACTION);
+    if (layout.entryEdge === "right") {
+        return {
+            x: layout.width - placement.x + overscan,
+            y: driftDirection * placement.h * 0.12,
+        };
+    }
+    return {
+        x: driftDirection * placement.w * 0.12,
+        y: layout.height - placement.y + overscan,
+    };
+}
+export function impactFrames(qrCount) {
+    const impacts = [];
+    for (let i = 0; i < qrCount; i++) {
+        impacts.push({
+            frame: FIRST_IMPACT_FRAME + i * IMPACT_INTERVAL_FRAMES,
+            cardIndex: i,
+        });
+    }
+    return impacts;
+}
+export function totalDuration(qrCount, requestedSeconds) {
+    const lastImpactS = FIRST_IMPACT_S + (qrCount - 1) * IMPACT_INTERVAL_S;
+    const minimumDurationS = Math.max(MIN_DURATION_S, lastImpactS + TAIL_AFTER_LAST_IMPACT_S);
+    const durationS = Math.max(minimumDurationS, requestedSeconds ?? 0);
+    const frames = Math.round(durationS * FPS);
+    return { frames, seconds: frames / FPS };
+}
+export function buildOutroSpec(ratio, qrCount, requestedSeconds) {
+    const layout = qrLayout(ratio);
+    const cards = cardPlacements(qrCount, layout.contentRect);
+    const impacts = impactFrames(qrCount);
+    const dur = totalDuration(qrCount, requestedSeconds);
+    return {
+        layout,
+        cards,
+        impacts,
+        totalDurationFrames: dur.frames,
+        totalDurationSeconds: dur.seconds,
+        fps: FPS,
+    };
+}
+export function cardAnimationProgress(currentFrame, impactFrame) {
+    const entryStart = impactFrame - ENTRY_FRAMES;
+    if (currentFrame < entryStart) {
+        return {
+            visible: false,
+            opacity: 0,
+            translateFraction: 1,
+            rotation: 8,
+            scale: 1.2,
+        };
+    }
+    if (currentFrame < impactFrame) {
+        const elapsed = currentFrame - entryStart;
+        const t = elapsed / ENTRY_FRAMES;
+        const eased = 1 - Math.pow(1 - t, 2);
+        return {
+            visible: true,
+            opacity: eased,
+            translateFraction: 1 - eased,
+            rotation: (1 - eased) * 8,
+            scale: 1.2 - eased * 0.26,
+        };
+    }
+    const settleElapsed = currentFrame - impactFrame;
+    const settleDuration = 6;
+    if (settleElapsed < settleDuration) {
+        const t = settleElapsed / settleDuration;
+        const spring = 0.94 + 0.06 * t + 0.045 * Math.sin(t * Math.PI * 2) * (1 - t);
+        return {
+            visible: true,
+            opacity: 1,
+            translateFraction: 0,
+            rotation: 0,
+            scale: spring,
+        };
+    }
+    return { visible: true, opacity: 1, translateFraction: 0, rotation: 0, scale: 1 };
+}
+export function cueWindows(qrCount, totalFrames) {
+    const impacts = impactFrames(qrCount);
+    const windows = [];
+    for (let i = 0; i < impacts.length; i++) {
+        const start = impacts[i].frame;
+        let end;
+        if (i < impacts.length - 1) {
+            end = impacts[i + 1].frame;
+        }
+        else {
+            end = Math.min(start + Math.round(MAX_FINAL_CUE_S * FPS), totalFrames);
+        }
+        windows.push({ startFrame: start, endFrame: end, impactIndex: i });
+    }
+    return windows;
+}

package/dist/remotion/shared-bundle.js

@@ -0,0 +1,37 @@
+import { bundle } from "@remotion/bundler";
+import { fileURLToPath } from "node:url";
+import { dirname, extname, join } from "node:path";
+const MODULE_PATH = fileURLToPath(import.meta.url);
+const REMOTION_DIR = dirname(MODULE_PATH);
+const REMOTION_ENTRY = join(REMOTION_DIR, extname(MODULE_PATH) === ".js" ? "index.js" : "index.tsx");
+const REMOTION_PUBLIC_DIR = join(REMOTION_DIR, "public");
+let bundleLocation = null;
+let bundlePromise = null;
+export async function getSharedBundleLocation() {
+    if (bundleLocation)
+        return bundleLocation;
+    if (bundlePromise)
+        return bundlePromise;
+    bundlePromise = bundle({
+        entryPoint: REMOTION_ENTRY,
+        publicDir: REMOTION_PUBLIC_DIR,
+        webpackOverride: (config) => ({
+            ...config,
+            resolve: {
+                ...config.resolve,
+                extensions: [".tsx", ".ts", ".js", ".jsx", ".mjs", ".cjs", ".json"],
+                extensionAlias: {
+                    ".js": [".tsx", ".ts", ".js"],
+                },
+            },
+        }),
+    }).then((location) => {
+        bundleLocation = location;
+        bundlePromise = null;
+        return location;
+    }).catch((err) => {
+        bundlePromise = null;
+        throw err;
+    });
+    return bundlePromise;
+}