@hyperframes/core 0.8.145 → 0.8.146

package/dist/runtime/globals.d.ts

@@ -9,4 +9,3 @@ export interface HFDebugSurface {
     };
 }
 export declare function getDebugSurface(): HFDebugSurface;
-//# sourceMappingURL=globals.d.ts.map

package/dist/runtime/globals.js

@@ -1,4 +1,3 @@
 export function getDebugSurface() {
     return globalThis;
 }
-//# sourceMappingURL=globals.js.map

package/dist/runtime/levelTap.d.ts

@@ -9,4 +9,3 @@ export interface LevelTap {
 }
 /** A side branch off `source`; the explicit-stereo gain up-mixes mono to both channels. */
 export declare function createLevelTap(ctx: BaseAudioContext, source: AudioNode): LevelTap;
-//# sourceMappingURL=levelTap.d.ts.map

package/dist/runtime/levelTap.js

@@ -35,4 +35,3 @@ export function createLevelTap(ctx, source) {
         },
     };
 }
-//# sourceMappingURL=levelTap.js.map

package/dist/runtime/media.d.ts

@@ -1,6 +1,7 @@
 import { type VolumeKeyframe } from "./mediaVolumeEnvelope.js";
 import { type AudioFades } from "../audioFade.js";
 import { type RateSpec } from "../speedRamp.js";
+import { type HostSlot } from "../mediaTiming.js";
 export { readElementPlaybackRate, readElementRateSpec, resolveNaturalMediaTimelineDuration, } from "./playbackRate.js";
 export declare function readElementPlaybackStart(el: Element): number;
 export declare const HOLD_CAP_MS = 5000;
@@ -20,6 +21,8 @@ export declare function resolveRuntimeMediaClipDuration(params: {
 export type RuntimeMediaClip = {
     el: HTMLVideoElement | HTMLAudioElement;
     start: number;
+    /** The clip's own t=0 when a host's in-point cut its head; source time, lanes and fades run from it. */
+    origin?: number;
     mediaStart: number;
     duration: number;
     end: number;
@@ -43,6 +46,7 @@ export type RuntimeMediaClip = {
 export declare function refreshRuntimeMediaCache(params?: {
     resolveStartSeconds?: (element: Element) => number;
     resolveDurationSeconds?: (element: HTMLVideoElement | HTMLAudioElement) => number | null;
+    resolveHostSlots?: (element: HTMLVideoElement | HTMLAudioElement) => HostSlot[];
     shouldIncludeElement?: (element: HTMLVideoElement | HTMLAudioElement) => boolean;
     /**
      * Build clips for exactly these elements instead of scanning the document for
@@ -119,4 +123,3 @@ export declare function syncRuntimeMedia(params: {
      *  A thunk, because deriving the duration is only worth it for a clip past its own end. */
     getCompositionDuration: () => number;
 }): void;
-//# sourceMappingURL=media.d.ts.map

package/dist/runtime/media.js

@@ -10,6 +10,7 @@ import { clampAudioGain } from "../audioGain.js";
 import { isMemberGroupHidden } from "../audioGroups.js";
 import { findInjectedRenderFrame } from "./renderFrameSibling.js";
 import { registerSeekCompletion } from "./adapters/seek-dispatch.js";
+import { cutToHostSlots } from "../mediaTiming.js";
 export { readElementPlaybackRate, readElementRateSpec, resolveNaturalMediaTimelineDuration, } from "./playbackRate.js";
 export function readElementPlaybackStart(el) {
     return readMediaStart(el);
@@ -70,7 +71,7 @@ export function refreshRuntimeMediaCache(params) {
     const videoClips = [];
     let maxMediaEnd = 0;
     for (const el of timedMediaEls) {
-        const start = params?.resolveStartSeconds
+        let start = params?.resolveStartSeconds
             ? params.resolveStartSeconds(el)
             : Number.parseFloat(el.dataset.start ?? "0");
         if (!Number.isFinite(start))
@@ -87,13 +88,20 @@ export function refreshRuntimeMediaCache(params) {
             duration = Math.max(0, timeAtSourceTime(rate, sourceDuration - mediaStart));
         }
         const hasKnownDuration = Number.isFinite(duration) && duration >= 0;
-        const end = hasKnownDuration ? start + duration : Number.POSITIVE_INFINITY;
+        let end = hasKnownDuration ? start + duration : Number.POSITIVE_INFINITY;
+        const origin = start;
+        const kept = cutToHostSlots({ start, end }, params?.resolveHostSlots?.(el) ?? []);
+        if (kept.start !== start || kept.end !== end) {
+            ({ start, end } = kept);
+            duration = end - start;
+        }
         const volumeRaw = Number.parseFloat(el.dataset.volume ?? "");
         const clip = {
             el,
             start,
+            origin,
             mediaStart,
-            duration: hasKnownDuration ? duration : Number.POSITIVE_INFINITY,
+            duration: Number.isFinite(end) ? duration : Number.POSITIVE_INFINITY,
             end,
             volume: Number.isFinite(volumeRaw) ? volumeRaw : null,
             playbackRate,
@@ -185,6 +193,8 @@ export function hasMediaSyncStateForTest(el) {
 export const MEDIA_HARD_SYNC_SECONDS = 0.5;
 /** Drift a playing audio element may carry before sync pulls it back onto the playhead. */
 export const MEDIA_SYNC_TOLERANCE_SECONDS = 0.04;
+// Chromium refuses a slower playbackRate (NotSupportedError).
+const MIN_NATIVE_PLAYBACK_RATE = 1 / 16;
 // A playing video is steered back by rate, not seeked (a seek resets its decoder).
 // Its rate is written only when steering starts or stops: every write costs a frame.
 const VIDEO_STEER = 0.03;
@@ -211,13 +221,14 @@ export function syncRuntimeMedia(params) {
         if (!el.isConnected)
             continue;
         const clipRate = clip.rate ?? clip.playbackRate;
+        const origin = clip.origin ?? clip.start;
         const isNonLoopVideo = el.tagName === "VIDEO" && !clip.loop;
         const inWindow = isInClipWindow(params.timeSeconds, clip.start, clip.end);
         const dueIn = clip.start - params.timeSeconds;
         const startsEarly = el.tagName === "AUDIO" &&
             !inWindow &&
             dueIn > 0 &&
-            dueIn * Math.max(1, rateAt(clipRate, 0)) <=
+            dueIn * Math.max(1, rateAt(clipRate, clip.start - origin)) <=
                 Math.max(params.cueAheadSeconds ?? 0, startedEarly.has(el) ? MEDIA_SYNC_TOLERANCE_SECONDS : 0);
         if (startsEarly)
             startedEarly.add(el);
@@ -229,7 +240,7 @@ export function syncRuntimeMedia(params) {
             !inWindow &&
             (params.timeSeconds >= clip.end || sameInstant(params.timeSeconds, clip.end)) &&
             isClipVisibleAt(params.timeSeconds, clip.start, clip.end, params.getCompositionDuration());
-        let relTime = sourceTimeAt(clipRate, Math.max(0, Math.min(params.timeSeconds, clip.end) - clip.start)) +
+        let relTime = sourceTimeAt(clipRate, Math.max(0, Math.min(params.timeSeconds, clip.end) - origin)) +
             clip.mediaStart;
         const isHeldVideoTail = isTerminalVideo ||
             (isNonLoopVideo && clip.sourceDuration != null && relTime >= clip.sourceDuration && inWindow);
@@ -278,7 +289,7 @@ export function syncRuntimeMedia(params) {
             // different position than it renders, or ran it off the end entirely on a
             // trimmed clip. The FX lanes on this same feature use clip-local elapsed;
             // there is one time base, and this is it.
-            const laneGain = elementVolumeLaneGain(el, params.timeSeconds - clip.start);
+            const laneGain = elementVolumeLaneGain(el, params.timeSeconds - origin);
             if (laneGain !== null) {
                 authorVolume = clampAudioGain(laneGain);
             }
@@ -290,7 +301,7 @@ export function syncRuntimeMedia(params) {
                 // `relTime` is a position inside the media SOURCE — it carries `mediaStart`
                 // and the playback rate — so it only coincides with the envelope's time base
                 // for an untrimmed clip playing at 1x from t=0.
-                const elapsedInClip = params.timeSeconds - clip.start;
+                const elapsedInClip = params.timeSeconds - origin;
                 authorVolume = clampAudioGain(interpolateVolumeGain(clip.volumeKeyframes, elapsedInClip));
             }
             else if (params.isWebAudioRouted?.(el)) {
@@ -327,7 +338,7 @@ export function syncRuntimeMedia(params) {
             // Clip-local fade on top of the resolved level, matching render's afade-after-volume.
             const fades = clip.fades ?? NO_FADES;
             if (fades.fadeIn > 0 || fades.fadeOut > 0) {
-                authorVolume *= fadeGain(params.timeSeconds - clip.start, clip.duration, fades);
+                authorVolume *= fadeGain(params.timeSeconds - origin, clip.duration + clip.start - origin, fades);
             }
             // A data-hidden ancestor is silent in the export (audioMixer.ts drops
             // it), so preview matches. Folded into the per-tick volume, not
@@ -355,7 +366,9 @@ export function syncRuntimeMedia(params) {
             if (el.preload !== "auto")
                 el.preload = "auto";
             // Per-element rate × global transport rate
-            const baseRate = rateAt(clipRate, params.timeSeconds - clip.start) * params.playbackRate;
+            const baseRate = rateAt(clipRate, params.timeSeconds - origin) * params.playbackRate;
+            // Too slow for the browser to play: kept paused and stepped onto the playhead by seeks.
+            const playing = params.playing && baseRate >= MIN_NATIVE_PLAYBACK_RATE;
             // Drift correction — three tiers:
             //
             // 1. Hard sync (0.5s): first tick, timeline jumps (scrub), catastrophic
@@ -398,12 +411,13 @@ export function syncRuntimeMedia(params) {
             // seek→freeze→drift→seek stutter. So a playing video skips strict and force sync; only hard
             // sync (>0.5s) warrants the decoder-reset cost. A paused transport pauses this video below,
             // so a seek that pauses mid-playback still lands it.
-            const isPlayingVideo = el.tagName === "VIDEO" && !el.paused && params.playing;
+            const isPlayingVideo = el.tagName === "VIDEO" && !el.paused && playing;
             // Only apply strict sync when offset has stabilized (not growing).
             // During initial buffering, offset grows ~16ms/tick as the timeline
             // advances while media stays at 0. Accumulated drift from pause/play
             // toggling shows up as a stable, non-zero offset (delta near 0).
-            const offsetStabilized = prevOffset !== undefined && Math.abs(offset - prevOffset) < 0.004;
+            const heldBelowFloor = params.playing && !playing;
+            const offsetStabilized = heldBelowFloor || (prevOffset !== undefined && Math.abs(offset - prevOffset) < 0.004);
             let strictSync = false;
             if (!isPlayingVideo &&
                 !hardSync &&
@@ -425,7 +439,7 @@ export function syncRuntimeMedia(params) {
                 // A hard sync lands the video on the playhead, so its pre-seek offset says nothing.
                 if (!isPlayingVideo || hardSync)
                     videoSteering.delete(el);
-                const rate = isPlayingVideo && !hardSync ? steeredVideoRate(el, offset, baseRate) : baseRate;
+                const rate = Math.max(MIN_NATIVE_PLAYBACK_RATE, isPlayingVideo && !hardSync ? steeredVideoRate(el, offset, baseRate) : baseRate);
                 // Some engines read a rate back at lower precision; an equal-enough rate is not rewritten.
                 if (Math.abs(el.playbackRate - rate) > 1e-6)
                     el.playbackRate = rate;
@@ -468,14 +482,14 @@ export function syncRuntimeMedia(params) {
                 }
                 playRequested.delete(el);
             }
-            else if (!params.playing) {
+            else if (!playing) {
                 holdSeekBarrierUntilVideoLands(el);
             }
             if (isHeldVideoTail) {
                 if (!el.paused)
                     el.pause();
             }
-            else if (params.playing && el.paused && !playRequested.has(el) && !isUnplayable(el)) {
+            else if (playing && el.paused && !playRequested.has(el) && !isUnplayable(el)) {
                 // `HTMLMediaElement.play()` is spec'd to queue playback and resolve
                 // once enough data is buffered, so we can unconditionally call it —
                 // no need to gate on `readyState` or defer to a `canplay` listener.
@@ -504,7 +518,7 @@ export function syncRuntimeMedia(params) {
                         params.onAutoplayBlocked?.();
                 });
             }
-            else if (!params.playing && !el.paused) {
+            else if (!playing && !el.paused) {
                 el.pause();
             }
             continue;
@@ -523,4 +537,3 @@ export function syncRuntimeMedia(params) {
             el.pause();
     }
 }
-//# sourceMappingURL=media.js.map

package/dist/runtime/mediaVolumeEnvelope.d.ts

@@ -61,4 +61,3 @@ export interface VolumeProbeOptions {
  * each read.
  */
 export declare function probeAndCacheElementVolume(mediaEl: HTMLMediaElement, timeline: RuntimeTimelineRef | null | undefined, compositionDuration: number, cache: WeakMap<HTMLMediaElement, VolumeKeyframe[]>, options?: VolumeProbeOptions): void;
-//# sourceMappingURL=mediaVolumeEnvelope.d.ts.map

package/dist/runtime/mediaVolumeEnvelope.js

@@ -234,4 +234,3 @@ export function probeAndCacheElementVolume(mediaEl, timeline, compositionDuratio
             cache.set(mediaEl, envelope);
     }
 }
-//# sourceMappingURL=mediaVolumeEnvelope.js.map

package/dist/runtime/playbackRate.d.ts

@@ -24,4 +24,3 @@ export declare function resolveMediaElementDurationSeconds(el: Pick<Element, "ge
 export declare function resolveTimedImageDurationSeconds(el: Element, startSeconds?: number): number | null;
 /** A constant rate goes through the shared arithmetic; a `rate` lane integrates over its points. */
 export declare function resolveNaturalMediaTimelineDurationFromValues(sourceDuration: number, mediaStart: number, playbackRate: RateSpec): number | null;
-//# sourceMappingURL=playbackRate.d.ts.map

package/dist/runtime/playbackRate.js

@@ -66,4 +66,3 @@ export function resolveNaturalMediaTimelineDurationFromValues(sourceDuration, me
         return null;
     return timeAtSourceTime(playbackRate, Math.max(0, sourceDuration - mediaStart));
 }
-//# sourceMappingURL=playbackRate.js.map

package/dist/runtime/positionEdits.d.ts

@@ -71,4 +71,3 @@ export declare function applyPositionEdits(doc: Document, opts?: {
 /** Reapply SDK position edits after every render seek, including late-bound seeks. */
 export declare function installPositionEditsSeekReapply(win: Window & typeof globalThis): void;
 export {};
-//# sourceMappingURL=positionEdits.d.ts.map

package/dist/runtime/positionEdits.js

@@ -314,4 +314,3 @@ export function installPositionEditsSeekReapply(win) {
             target.clearInterval(interval);
     }, 50);
 }
-//# sourceMappingURL=positionEdits.js.map

package/dist/runtime/protocol.d.ts

@@ -28,4 +28,3 @@ export declare function runtimeProtocolFpsToNumber(value: unknown): number | nul
 export declare function runtimeProtocolMetadata(fps: number): RuntimeProtocolV1;
 export declare function frameDisplayScale(frame: HTMLElement): number | null;
 export declare function inspectRuntimeProtocol(value: unknown, legacyFps?: number): RuntimeProtocolInspection;
-//# sourceMappingURL=protocol.d.ts.map

package/dist/runtime/protocol.js

@@ -80,4 +80,3 @@ export function inspectRuntimeProtocol(value, legacyFps = 30) {
         metadata: message,
     };
 }
-//# sourceMappingURL=protocol.js.map

package/dist/runtime/proxySrc.d.ts

@@ -1,4 +1,3 @@
 /** Media elements swapped to their proxy, each with the src attribute it had before the swap. */
 export declare const swappedElements: WeakMap<Element, string | null>;
 export declare function unproxiedSrc(el: Element): string | null;
-//# sourceMappingURL=proxySrc.d.ts.map

package/dist/runtime/proxySrc.js

@@ -3,4 +3,3 @@ export const swappedElements = new WeakMap();
 export function unproxiedSrc(el) {
     return swappedElements.has(el) ? (swappedElements.get(el) ?? null) : el.getAttribute("src");
 }
-//# sourceMappingURL=proxySrc.js.map

package/dist/runtime/renderFrameSibling.d.ts

@@ -38,4 +38,3 @@ export declare function renderFrameElementId(media: Element): string | null;
  * (where the producer never creates one). Siblings first: a staged scene copy repeats the id.
  */
 export declare function findInjectedRenderFrame(media: Element): HTMLImageElement | null;
-//# sourceMappingURL=renderFrameSibling.d.ts.map

package/dist/runtime/renderFrameSibling.js

@@ -57,4 +57,3 @@ export function findInjectedRenderFrame(media) {
     frame ??= byId;
     return isImageElement(frame) ? frame : null;
 }
-//# sourceMappingURL=renderFrameSibling.js.map

package/dist/runtime/stackingContext.d.ts

@@ -5,4 +5,3 @@ export declare const ROOT_CSS_STACKING_CONTEXT_ID = "css:root";
  * z-index with siblings in its parent's context.
  */
 export declare function resolveCssStackingContextId(node: Element): string;
-//# sourceMappingURL=stackingContext.d.ts.map

package/dist/runtime/stackingContext.js

@@ -112,4 +112,3 @@ export function resolveCssStackingContextId(node) {
     }
     return ROOT_CSS_STACKING_CONTEXT_ID;
 }
-//# sourceMappingURL=stackingContext.js.map

package/dist/runtime/startExpression.d.ts

@@ -12,4 +12,3 @@
  *   - `"intro - 0.5"`     -> 0.5s before `intro` ends (overlap)
  */
 export { parseNumeric, parseStartExpression, type ReferenceExpression, } from "@hyperframes/parsers/composition-contract";
-//# sourceMappingURL=startExpression.d.ts.map

package/dist/runtime/startExpression.js

@@ -12,4 +12,3 @@
  *   - `"intro - 0.5"`     -> 0.5s before `intro` ends (overlap)
  */
 export { parseNumeric, parseStartExpression, } from "@hyperframes/parsers/composition-contract";
-//# sourceMappingURL=startExpression.js.map

package/dist/runtime/startResolver.d.ts

@@ -1,4 +1,5 @@
 import type { RuntimeTimelineLike } from "./types";
+import { type HostSlot } from "../mediaTiming";
 export declare function createRuntimeStartTimeResolver(params: {
     timelineRegistry?: Record<string, Pick<RuntimeTimelineLike, "duration"> | undefined>;
     includeAuthoredTimingAttrs?: boolean;
@@ -14,7 +15,7 @@ export declare function createRuntimeStartTimeResolver(params: {
     resolveDurationForElement: (element: Element) => number | null;
     resolveMediaStartForElement: (element: Element) => number;
     resolveHostStartForElement: (element: Element) => number;
+    resolveHostSlotsForElement: (element: Element) => HostSlot[];
     isRootGlobalMediaStartForElement: (element: Element) => boolean;
 };
 export type { RuntimeTimelineLike } from "./types";
-//# sourceMappingURL=startResolver.d.ts.map

package/dist/runtime/startResolver.js

@@ -1,4 +1,4 @@
-import { swallow } from "./diagnostics.js";
+import { readTimelineDurationSeconds } from "./timelineDuration.js";
 import { resolveAuthoredTimingWindow } from "./authoredTiming.js";
 // Straight from playbackRate, not through media.ts's re-export: media.ts
 // imports mediaVolumeEnvelope, which needs this resolver, and the round trip
@@ -6,7 +6,7 @@ import { resolveAuthoredTimingWindow } from "./authoredTiming.js";
 import { parseStrictFiniteTimingNumber, resolveNaturalMediaTimelineDuration, resolveTimedImageDurationSeconds, } from "./playbackRate.js";
 import { isMediaElement } from "./domRealm.js";
 import { parseStartExpression } from "./startExpression.js";
-import { isRootGlobalMediaStart, MEDIA_START_BASIS_ATTR, resolveMediaStartSeconds, } from "../mediaTiming.js";
+import { compositionOriginSeconds, hostInPointSeconds, isRootGlobalMediaStart, MEDIA_START_BASIS_ATTR, resolveMediaStartSeconds, } from "../mediaTiming.js";
 export function createRuntimeStartTimeResolver(params) {
     const timelineRegistry = params.timelineRegistry ?? {};
     const includeAuthoredTimingAttrs = params.includeAuthoredTimingAttrs ?? false;
@@ -20,75 +20,76 @@ export function createRuntimeStartTimeResolver(params) {
             return byId;
         return (doc.querySelector(`[data-composition-id="${CSS.escape(refId)}"]`) ?? null);
     };
+    const authoredAttr = (element, name) => includeAuthoredTimingAttrs ? element.getAttribute(name) : null;
+    const resolveAuthoredDuration = (element) => resolveAuthoredTimingWindow({
+        start: 0,
+        duration: element.getAttribute("data-duration"),
+        authoredDuration: authoredAttr(element, "data-hf-authored-duration"),
+    })?.duration ??
+        resolveAuthoredTimingWindow({
+            start: resolveStartForElementInternal(element, 0),
+            end: element.getAttribute("data-end"),
+            authoredEnd: authoredAttr(element, "data-hf-authored-end"),
+        })?.duration ??
+        null;
+    const positive = (value) => value != null && Number.isFinite(value) && value > 0 ? value : null;
+    const resolveRegisteredTimelineDuration = (element) => {
+        const compositionId = element.getAttribute("data-composition-id");
+        return compositionId
+            ? positive(readTimelineDurationSeconds(timelineRegistry[compositionId]))
+            : null;
+    };
     const resolveDurationForElement = (element) => {
         const cached = durationCache.get(element);
         if (cached !== undefined)
             return cached;
-        let resolved = null;
-        const durationTiming = resolveAuthoredTimingWindow({
-            start: 0,
-            duration: element.getAttribute("data-duration"),
-            authoredDuration: includeAuthoredTimingAttrs
-                ? element.getAttribute("data-hf-authored-duration")
-                : null,
-        });
-        if (durationTiming?.duration != null && durationTiming.duration > 0) {
-            resolved = durationTiming.duration;
-        }
-        if (resolved == null || resolved <= 0) {
-            const start = resolveStartForElementInternal(element, 0);
-            const endTiming = resolveAuthoredTimingWindow({
-                start,
-                end: element.getAttribute("data-end"),
-                authoredEnd: includeAuthoredTimingAttrs
-                    ? element.getAttribute("data-hf-authored-end")
-                    : null,
-            });
-            if (endTiming?.duration != null && endTiming.duration > 0) {
-                resolved = endTiming.duration;
-            }
-        }
-        if ((resolved == null || resolved <= 0) && isMediaElement(element)) {
-            resolved = resolveNaturalMediaTimelineDuration(element, element.duration);
-        }
-        if (resolved == null || resolved <= 0)
-            resolved = resolveTimedImageDurationSeconds(element);
-        if (resolved == null || resolved <= 0) {
-            const compositionId = element.getAttribute("data-composition-id");
-            if (compositionId) {
-                const timeline = timelineRegistry[compositionId] ?? null;
-                if (timeline && typeof timeline.duration === "function") {
-                    try {
-                        const timelineDuration = Number(timeline.duration());
-                        if (Number.isFinite(timelineDuration) && timelineDuration > 0) {
-                            resolved = timelineDuration;
-                        }
-                    }
-                    catch (err) {
-                        // ignore broken timeline impls
-                        swallow("runtime.startResolver.site1", err);
-                    }
-                }
-            }
-        }
-        if (resolved != null && Number.isFinite(resolved) && resolved > 0) {
-            durationCache.set(element, resolved);
-            return resolved;
-        }
-        durationCache.set(element, null);
-        return null;
+        const resolved = resolveAuthoredDuration(element) ??
+            positive(isMediaElement(element)
+                ? resolveNaturalMediaTimelineDuration(element, element.duration)
+                : null) ??
+            positive(resolveTimedImageDurationSeconds(element)) ??
+            resolveRegisteredTimelineDuration(element);
+        durationCache.set(element, resolved);
+        return resolved;
     };
+    const isCompositionHost = (element) => element.hasAttribute("data-composition-src") ||
+        element.hasAttribute("data-composition-id") ||
+        element.hasAttribute("data-composition-file");
+    // A mounted composition root without its own `data-start` takes its timing from the host it was
+    // loaded into: the host may use a different id than the file, or none (an anonymous host).
+    const inheritedTimingHost = (element) => {
+        const parent = element.parentElement;
+        if (!parent || !element.hasAttribute("data-composition-id"))
+            return null;
+        if (parseStartExpression(element.getAttribute("data-start")))
+            return null;
+        return isCompositionHost(parent) ? parent : null;
+    };
+    const resolveCompositionOrigin = (compositionRoot, fallback) => compositionOriginSeconds(resolveStartForElementInternal(compositionRoot, fallback), inheritedTimingHost(compositionRoot) ?? compositionRoot);
     const resolveHostOffsetForElement = (element, fallback) => {
-        if (element.hasAttribute("data-composition-id")) {
-            const parentComposition = element.parentElement?.closest("[data-composition-id]");
-            if (!parentComposition)
-                return 0;
-            return resolveStartForElementInternal(parentComposition, fallback);
+        const compositionRoot = element.hasAttribute("data-composition-id")
+            ? element.parentElement?.closest("[data-composition-id]")
+            : element.closest("[data-composition-id]");
+        return compositionRoot ? resolveCompositionOrigin(compositionRoot, fallback) : 0;
+    };
+    const computeStart = (element, fallback) => {
+        const expression = parseStartExpression(element.getAttribute("data-start"));
+        if (!expression) {
+            const host = inheritedTimingHost(element);
+            return host ? resolveStartForElementInternal(host, fallback) : fallback;
         }
-        const compositionRoot = element.closest("[data-composition-id]");
-        if (!compositionRoot)
-            return 0;
-        return resolveStartForElementInternal(compositionRoot, fallback);
+        if (expression.kind === "absolute") {
+            // Negative when a host's in-point is past its start; the host's slot cuts that part.
+            return resolveHostOffsetForElement(element, fallback) + Math.max(0, expression.value);
+        }
+        const target = findReferenceTarget(expression.refId);
+        if (!target)
+            return fallback;
+        const targetStart = resolveStartForElementInternal(target, 0);
+        const targetDuration = resolveDurationForElement(target) ?? 0;
+        // Clamped at local 0, as a numeric start is, once an in-point puts local 0 before 0.
+        const floor = Math.min(0, resolveHostOffsetForElement(element, 0));
+        return Math.max(floor, targetStart + targetDuration + expression.offset);
     };
     const resolveStartForElementInternal = (element, fallback) => {
         const cached = startCache.get(element);
@@ -100,51 +101,7 @@ export function createRuntimeStartTimeResolver(params) {
         }
         visiting.add(element);
         try {
-            const expression = parseStartExpression(element.getAttribute("data-start"));
-            if (!expression) {
-                // If this element is a loaded composition inner root (has data-composition-id
-                // but no data-start), walk up to the host parent which carries the actual
-                // timing. This happens when the host uses a different data-composition-id
-                // than the loaded file — e.g. host="montage" but file has "scene-10", or
-                // when the host itself has no data-composition-id at all (an "anonymous"
-                // host) and the composition's own id was restored onto the inlined wrapper.
-                // Check data-composition-src (runtime, not yet inlined), data-composition-id
-                // (bundled/compiled host with its own id), and data-composition-file (the
-                // marker every inlined host gets, compiled or bundled, once
-                // data-composition-src is stripped — covers the anonymous-host case).
-                if (element.hasAttribute("data-composition-id")) {
-                    const parent = element.parentElement;
-                    if (parent &&
-                        (parent.hasAttribute("data-composition-src") ||
-                            parent.hasAttribute("data-composition-id") ||
-                            parent.hasAttribute("data-composition-file"))) {
-                        const parentStart = resolveStartForElementInternal(parent, fallback);
-                        startCache.set(element, parentStart);
-                        return parentStart;
-                    }
-                }
-                startCache.set(element, fallback);
-                return fallback;
-            }
-            if (expression.kind === "absolute") {
-                const absolute = Math.max(0, expression.value);
-                const resolved = Math.max(0, resolveHostOffsetForElement(element, fallback) + absolute);
-                startCache.set(element, resolved);
-                return resolved;
-            }
-            const target = findReferenceTarget(expression.refId);
-            if (!target) {
-                startCache.set(element, fallback);
-                return fallback;
-            }
-            const targetStart = resolveStartForElementInternal(target, 0);
-            const targetDuration = resolveDurationForElement(target);
-            if (targetDuration == null || targetDuration <= 0) {
-                const unresolved = Math.max(0, targetStart + expression.offset);
-                startCache.set(element, unresolved);
-                return unresolved;
-            }
-            const resolved = Math.max(0, targetStart + targetDuration + expression.offset);
+            const resolved = computeStart(element, fallback);
             startCache.set(element, resolved);
             return resolved;
         }
@@ -167,7 +124,7 @@ export function createRuntimeStartTimeResolver(params) {
         const compositionRoot = element.closest("[data-composition-id]");
         return {
             authoredStart: parseStrictFiniteTimingNumber(element.getAttribute("data-start")),
-            hostStart: compositionRoot ? resolveStartForElementInternal(compositionRoot, 0) : 0,
+            hostStart: compositionRoot ? resolveCompositionOrigin(compositionRoot, 0) : 0,
             hasAutoStart: element.hasAttribute("data-hf-auto-start"),
             basis: element.getAttribute(MEDIA_START_BASIS_ATTR),
         };
@@ -179,13 +136,27 @@ export function createRuntimeStartTimeResolver(params) {
             ordinaryStart: () => resolveStartForElementInternal(element, input.hostStart),
         });
     };
+    // Hosts with an in-point, found by their composition attributes so an anonymous one counts too.
+    const resolveHostSlotsForElement = (element) => {
+        const slots = [];
+        for (let node = element.parentElement; node; node = node.parentElement) {
+            if (!isCompositionHost(node) || inheritedTimingHost(node))
+                continue;
+            if (hostInPointSeconds(node) <= 0)
+                continue;
+            const start = resolveStartForElementInternal(node, 0);
+            const duration = resolveAuthoredDuration(node);
+            slots.push({ start, end: duration ? start + duration : Infinity });
+        }
+        return slots;
+    };
     const isRootGlobalMediaStartForElement = (element) => isMediaElement(element) && isRootGlobalMediaStart(mediaStartInput(element));
     return {
         resolveStartForElement: (element, fallback = 0) => resolveStartForElementInternal(element, Math.max(0, fallback)),
         resolveDurationForElement: (element) => resolveDurationForElement(element),
         resolveMediaStartForElement,
         resolveHostStartForElement: (element) => resolveHostOffsetForElement(element, 0),
+        resolveHostSlotsForElement,
         isRootGlobalMediaStartForElement,
     };
 }
-//# sourceMappingURL=startResolver.js.map

package/dist/runtime/state.d.ts

@@ -92,4 +92,3 @@ export type RuntimeState = {
     transportRafId: number | null;
 };
 export declare function createRuntimeState(): RuntimeState;
-//# sourceMappingURL=state.d.ts.map

package/dist/runtime/state.js

@@ -32,4 +32,3 @@ export function createRuntimeState() {
         transportRafId: null,
     };
 }
-//# sourceMappingURL=state.js.map

package/dist/runtime/timeline.d.ts

@@ -17,4 +17,3 @@ export declare function parseAuthoredTrack(el: Element, fallback: number): numbe
 export declare function collectRuntimeTimelinePayload(params: {
     canonicalFps: number;
 }): RuntimeTimelineMessage;
-//# sourceMappingURL=timeline.d.ts.map