@hyperframes/core 0.8.207 → 0.8.209

package/dist/removeScratch.d.ts

@@ -0,0 +1,5 @@
+/** Removes a scratch folder or file the mix is already done with. A refusal (Windows temp folders that deny
+ * delete) leaves it for the render's own cleanup and never fails the audio it served. */
+export declare function removeScratch(path: string): void;
+/** Runs `run`; whatever removeScratch left behind inside it (this run's only) goes to `report` once it ends. */
+export declare function collectScratchLeftovers<T>(run: () => Promise<T>, report: (left: string[]) => void): Promise<T>;

package/dist/removeScratch.js

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { rmSync } from "node:fs";
+const collecting = new AsyncLocalStorage();
+/** Removes a scratch folder or file the mix is already done with. A refusal (Windows temp folders that deny
+ * delete) leaves it for the render's own cleanup and never fails the audio it served. */
+export function removeScratch(path) {
+    try {
+        rmSync(path, { recursive: true, force: true });
+    }
+    catch {
+        collecting.getStore()?.push(path);
+    }
+}
+/** Runs `run`; whatever removeScratch left behind inside it (this run's only) goes to `report` once it ends. */
+export async function collectScratchLeftovers(run, report) {
+    const left = [];
+    try {
+        return await collecting.run(left, run);
+    }
+    finally {
+        report(left);
+    }
+}

package/dist/renameWithRetry.d.ts

@@ -0,0 +1,16 @@
+interface Options {
+    platform?: NodeJS.Platform;
+    /** Copy the bytes when Windows keeps refusing (a TEMP that denies delete). Not atomic: scratch files only. */
+    copyFallback?: boolean;
+}
+/** `renameSync` that rides out Windows' transient file locks; other platforms and errors throw at once. */
+export declare function renameWithRetry(from: string, to: string, options?: Options & {
+    rename?: (from: string, to: string) => void;
+    copy?: (from: string, to: string) => void;
+}): void;
+/** Async twin of {@link renameWithRetry}. */
+export declare function renameWithRetryAsync(from: string, to: string, options?: Options & {
+    rename?: (from: string, to: string) => Promise<void>;
+    copy?: (from: string, to: string) => Promise<void>;
+}): Promise<void>;
+export {};

package/dist/renameWithRetry.js

@@ -0,0 +1,81 @@
+import { copyFileSync, renameSync } from "node:fs";
+import { copyFile, rename } from "node:fs/promises";
+import { removeScratch } from "./removeScratch.js";
+// Windows reports EPERM/EACCES/EBUSY while antivirus or a just-exited process still holds the
+// file; the hold clears within milliseconds. Total wait before giving up: about 1.3 s.
+const RETRYABLE = new Set(["EPERM", "EACCES", "EBUSY"]);
+const BACKOFF_MS = [10, 20, 40, 80, 160, 320, 640];
+function isRetryable(error, platform) {
+    if (platform !== "win32")
+        return false;
+    return RETRYABLE.has(error?.code ?? "");
+}
+/** What a refused rename does next: wait and try again, fall back to a copy, or give up with the error. */
+function nextStep(error, attempt, options, platform) {
+    if (!isRetryable(error, platform))
+        return "throw";
+    if (attempt < BACKOFF_MS.length)
+        return "wait";
+    return options.copyFallback ? "copy" : "throw";
+}
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/** `renameSync` that rides out Windows' transient file locks; other platforms and errors throw at once. */
+export function renameWithRetry(from, to, options = {}) {
+    const doRename = options.rename ?? renameSync;
+    const doCopy = options.copy ?? copyFileSync;
+    const platform = options.platform ?? process.platform;
+    for (let attempt = 0;; attempt++) {
+        try {
+            doRename(from, to);
+            return;
+        }
+        catch (error) {
+            const step = nextStep(error, attempt, options, platform);
+            if (step === "throw")
+                throw error;
+            if (step === "wait") {
+                sleepSync(BACKOFF_MS[attempt]);
+                continue;
+            }
+            try {
+                doCopy(from, to);
+            }
+            catch {
+                throw error;
+            }
+            removeScratch(from);
+            return;
+        }
+    }
+}
+/** Async twin of {@link renameWithRetry}. */
+export async function renameWithRetryAsync(from, to, options = {}) {
+    const doRename = options.rename ?? rename;
+    const doCopy = options.copy ?? copyFile;
+    const platform = options.platform ?? process.platform;
+    for (let attempt = 0;; attempt++) {
+        try {
+            await doRename(from, to);
+            return;
+        }
+        catch (error) {
+            const step = nextStep(error, attempt, options, platform);
+            if (step === "throw")
+                throw error;
+            if (step === "wait") {
+                await new Promise((resolve) => setTimeout(resolve, BACKOFF_MS[attempt]));
+                continue;
+            }
+            try {
+                await doCopy(from, to);
+            }
+            catch {
+                throw error;
+            }
+            removeScratch(from);
+            return;
+        }
+    }
+}

package/dist/runtime/applyVariableBindings.d.ts

@@ -21,10 +21,10 @@
  * chain the color-grading runtime uses: `__hfVariablesByComp[compId]` for
  * inlined sub-compositions, then the top-level merged `getVariables()`.
  *
- * Applied at init AND re-applied after the composition loader inlines
- * external / template sub-compositions (their DOM and per-instance scoped
- * values don't exist at init). Idempotent: re-applying writes the same
- * values.
+ * Text is bound before composition scripts run; all of it at init and after
+ * the composition loader inlines external / template sub-compositions (their
+ * DOM and per-instance scoped values don't exist at init). Idempotent:
+ * re-applying writes the same values.
  */
 /**
  * Strip characters that could smuggle additional declarations or markup out of
@@ -45,3 +45,5 @@ export declare function sanitizeCssValue(value: string): string;
 export declare function unproxiedMediaSrc(el: Element): string | null;
 /** Applies the bindings in `doc`, or only those inside `within` and `within` itself. */
 export declare function applyVariableBindings(doc: Document, within?: Element): void;
+/** Binds only text, in `doc` or inside `within`: what composition scripts read before they run. */
+export declare function applyTextBindings(doc: Document, within?: Element): void;

package/dist/runtime/applyVariableBindings.js

@@ -21,10 +21,10 @@
  * chain the color-grading runtime uses: `__hfVariablesByComp[compId]` for
  * inlined sub-compositions, then the top-level merged `getVariables()`.
  *
- * Applied at init AND re-applied after the composition loader inlines
- * external / template sub-compositions (their DOM and per-instance scoped
- * values don't exist at init). Idempotent: re-applying writes the same
- * values.
+ * Text is bound before composition scripts run; all of it at init and after
+ * the composition loader inlines external / template sub-compositions (their
+ * DOM and per-instance scoped values don't exist at init). Idempotent:
+ * re-applying writes the same values.
  */
 import { readVariablesForElement } from "./variableScope.js";
 import { isScalarVariableValue as isScalar, isSafeMediaUrl, } from "@hyperframes/parsers/composition";
@@ -154,12 +154,13 @@ function variableSrcFor(el, cache, warn = true) {
 export function unproxiedMediaSrc(el) {
     return variableSrcFor(el, new Map(), false) ?? unproxiedSrc(el);
 }
+const matching = (doc, within, selector) => within
+    ? [...(within.matches(selector) ? [within] : []), ...within.querySelectorAll(selector)]
+    : Array.from(doc.querySelectorAll(selector));
 /** Applies the bindings in `doc`, or only those inside `within` and `within` itself. */
 export function applyVariableBindings(doc, within) {
     const cache = new Map();
-    const all = (selector) => within
-        ? [...(within.matches(selector) ? [within] : []), ...within.querySelectorAll(selector)]
-        : Array.from(doc.querySelectorAll(selector));
+    const all = (selector) => matching(doc, within, selector);
     const topRoot = within ? null : findTopRoot(doc);
     applyCssCustomProperties([...(topRoot ? [topRoot] : []), ...all("[data-composition-id]")], cache);
     for (const el of all("[data-var-src]")) {
@@ -167,12 +168,23 @@ export function applyVariableBindings(doc, within) {
         if (url !== null && unproxiedSrc(el) !== url)
             el.setAttribute("src", url);
     }
-    for (const el of all("[data-var-text]")) {
+    bindText(all("[data-var-text]"), cache);
+}
+/** Binds only text, in `doc` or inside `within`: what composition scripts read before they run. */
+export function applyTextBindings(doc, within) {
+    bindText(matching(doc, within, "[data-var-text]"), new Map());
+}
+const textWrittenOnce = new WeakSet();
+/** Writes each binding once: a script may then reshape the text, which a second write would duplicate. */
+function bindText(elements, cache) {
+    for (const el of elements) {
         const id = el.getAttribute("data-var-text")?.trim();
-        if (!id)
+        if (!id || textWrittenOnce.has(el))
             continue;
         const value = valuesForElement(el, cache)[id];
-        if (isScalar(value))
-            setOwnTextPreservingChildren(el, String(value));
+        if (!isScalar(value))
+            continue;
+        setOwnTextPreservingChildren(el, String(value));
+        textWrittenOnce.add(el);
     }
 }

package/dist/runtime/clock.js

@@ -1,5 +1,5 @@
 import { timeAtSourceTime } from "../speedRamp.js";
-import { MEDIA_HARD_SYNC_SECONDS } from "./media.js";
+import { MEDIA_HARD_SYNC_SECONDS } from "./mediaSteer.js";
 import { playRangeHoldTime } from "./protocol.js";
 /** GSAP's own `lagSmoothing` default — see the PR body for why this clock needs its own copy. */
 const STALL_THRESHOLD_MS = 500;

package/dist/runtime/getVariables.js

@@ -20,18 +20,19 @@
  *     const { title = "Untitled", theme = "light" } = getVariables<MyVars>();
  */
 import { cssVariableName, detectSlugCollisions } from "../tokenSlug.js";
+import { scopedVariablesFor } from "./variableScope.js";
 export function getVariables() {
     if (typeof document === "undefined")
         return {};
-    // Same collection the CSS-variable injection uses: <html> first, then any
-    // composition element carrying the attribute (later declarers win), then
-    // render-time overrides.
+    // <html> first, then any element carrying the attribute (later declarers win), then render-time
+    // overrides. A sub-composition's declaration is its own scope's, read from its scoped table.
     const declarers = new Set();
     if (document.documentElement?.hasAttribute("data-composition-variables")) {
         declarers.add(document.documentElement);
     }
     for (const el of Array.from(document.querySelectorAll("[data-composition-variables]"))) {
-        declarers.add(el);
+        if (!scopedVariablesFor(el))
+            declarers.add(el);
     }
     const declaredDefaults = {};
     for (const el of declarers) {

package/dist/runtime/mediaSteer.d.ts

@@ -1,5 +1,6 @@
 /** Drift a playing element may carry before sync pulls it back onto the playhead. */
 export declare const MEDIA_SYNC_TOLERANCE_SECONDS = 0.04;
+export declare const MEDIA_HARD_SYNC_SECONDS = 0.5;
 /** Rate or seek for media `offset` s behind (+) or ahead (-); a lag still growing (`settled` false) never seeks. */
 export declare function steerMedia(el: HTMLMediaElement, offset: number, baseRate: number, settled: boolean, audioOnly?: boolean): {
     rate: number;

package/dist/runtime/mediaSteer.js

@@ -1,5 +1,6 @@
 /** Drift a playing element may carry before sync pulls it back onto the playhead. */
 export const MEDIA_SYNC_TOLERANCE_SECONDS = 0.04;
+export const MEDIA_HARD_SYNC_SECONDS = 0.5;
 // Steered by rate, not seeked (a seek resets a video's decoder and clicks in audio); steps keep rate writes rare.
 const MEDIA_STEER = 0.03;
 const MEDIA_STEER_STEPS = [

package/dist/runtime/state.d.ts

@@ -1,5 +1,4 @@
-import type { RuntimeDeterministicAdapter, RuntimeTimelineLike } from "./types.js";
-import type { RuntimeMediaClip } from "./media.js";
+import type { RuntimeDeterministicAdapter, RuntimeMediaClip, RuntimeTimelineLike } from "./types.js";
 import type { TransportClock } from "./clock.js";
 export type RuntimeState = {
     capturedTimeline: RuntimeTimelineLike | null;

package/dist/runtime/timeline.js

@@ -3,7 +3,7 @@ import { findRootCompositionElement, parseCompositionDimension } from "./composi
 import { AUTHORED_DURATION_ATTR, AUTHORED_END_ATTR, resolveAuthoredTimingWindow, } from "./authoredTiming.js";
 import { swallow } from "./diagnostics.js";
 import { readTimelineDurationSeconds } from "./timelineDuration.js";
-import { readElementPlaybackRate, readElementPlaybackStart } from "./media.js";
+import { readElementPlaybackRate, readMediaStart } from "./playbackRate.js";
 import { parseStrictFiniteTimingNumber, resolveMediaElementDurationSeconds, resolveNaturalMediaTimelineDuration, resolveTimedImageDurationSeconds, } from "./playbackRate.js";
 import { resolveCssStackingContextId } from "./stackingContext.js";
 import { createRuntimeStartTimeResolver } from "./startResolver.js";
@@ -426,7 +426,7 @@ export function collectRuntimeTimelinePayload(params) {
             parentCompositionId: compositionContext.parentCompositionId,
             nodePath: null,
             compositionSrc: toAbsoluteAssetUrl(node.getAttribute("data-composition-src")),
-            playbackStart: readElementPlaybackStart(node),
+            playbackStart: readMediaStart(node),
             playbackRate: readElementPlaybackRate(node),
             assetUrl: resolveNodeAssetUrl(node),
             timelineRole: node.getAttribute("data-timeline-role"),
@@ -560,7 +560,7 @@ export function collectRuntimeTimelinePayload(params) {
                         parentCompositionId: rootCompositionIdForGsap,
                         nodePath: null,
                         compositionSrc: null,
-                        playbackStart: readElementPlaybackStart(el),
+                        playbackStart: readMediaStart(el),
                         playbackRate: readElementPlaybackRate(el),
                         assetUrl: null,
                         timelineRole: el.getAttribute("data-timeline-role"),
@@ -622,7 +622,7 @@ export function collectRuntimeTimelinePayload(params) {
                 parentCompositionId: rootCompositionIdForGsap,
                 nodePath: null,
                 compositionSrc: null,
-                playbackStart: readElementPlaybackStart(el),
+                playbackStart: readMediaStart(el),
                 playbackRate: readElementPlaybackRate(el),
                 assetUrl: null,
                 timelineRole,

package/dist/runtime/types.d.ts

@@ -1,5 +1,8 @@
 import type { HfColorGradingTarget } from "../colorGrading.js";
 import type { RuntimeAnalyticsEvent } from "./analytics.js";
+import type { AudioFades } from "../audioFade.js";
+import type { RateSpec } from "../speedRamp.js";
+import type { VolumeKeyframe } from "./mediaVolumeEnvelope.js";
 export type RuntimeJson = string | number | boolean | null | RuntimeJson[] | {
     [key: string]: RuntimeJson;
 };
@@ -378,4 +381,22 @@ type RuntimeDataControlFields = {
 };
 type RuntimeBridgeControlAction = RuntimeBridgeControlActionBase | "set-runtime-data" | "clear-runtime-data";
 export type RuntimeBridgeControlMessage = RuntimeBridgeControlMessageBase & RuntimeDataControlFields;
+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;
+    volume: number | null;
+    playbackRate: number;
+    /** The rate lane when the clip has one; otherwise `playbackRate`. */
+    rate?: RateSpec;
+    loop: boolean;
+    sourceDuration: number | null;
+    /** Probed from the GSAP timeline as the renderer does; when set they drive volume, not `data-volume`. */
+    volumeKeyframes?: VolumeKeyframe[];
+    fades?: AudioFades;
+};
 export {};

package/dist/runtime/variableScope.d.ts

@@ -5,4 +5,6 @@
  * runtime consumer of variables (color grading, declarative bindings) so the
  * scope chain can never diverge between channels.
  */
+/** The per-instance values of the inlined sub-composition an element belongs to, if any. */
+export declare function scopedVariablesFor(element: Element): Record<string, unknown> | undefined;
 export declare function readVariablesForElement(element: Element): Record<string, unknown>;

package/dist/runtime/variableScope.js

@@ -5,11 +5,17 @@
  * runtime consumer of variables (color grading, declarative bindings) so the
  * scope chain can never diverge between channels.
  */
-export function readVariablesForElement(element) {
-    const win = window;
+/** The per-instance values of the inlined sub-composition an element belongs to, if any. */
+export function scopedVariablesFor(element) {
     const scope = element.closest("[data-composition-id]");
     const compositionId = scope?.getAttribute("data-composition-id")?.trim() ?? "";
-    const scoped = compositionId ? win.__hfVariablesByComp?.[compositionId] : undefined;
+    return compositionId
+        ? window.__hfVariablesByComp?.[compositionId]
+        : undefined;
+}
+export function readVariablesForElement(element) {
+    const win = window;
+    const scoped = scopedVariablesFor(element);
     if (scoped)
         return scoped;
     const fromHelper = win.__hyperframes?.getVariables?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/core",
-  "version": "0.8.207",
+  "version": "0.8.209",
   "description": "",
   "repository": {
     "type": "git",
@@ -64,6 +64,14 @@
       "import": "./dist/removeTree.js",
       "types": "./dist/removeTree.d.ts"
     },
+    "./rename-retry": {
+      "import": "./dist/renameWithRetry.js",
+      "types": "./dist/renameWithRetry.d.ts"
+    },
+    "./remove-scratch": {
+      "import": "./dist/removeScratch.js",
+      "types": "./dist/removeScratch.d.ts"
+    },
     "./project-folders": {
       "import": "./dist/projectFolders.js",
       "types": "./dist/projectFolders.d.ts"
@@ -417,9 +425,9 @@
     "linkedom": "^0.18.12",
     "postcss": "^8.5.8",
     "wawoff2": "^2.0.1",
-    "@hyperframes/lint": "0.8.207",
-    "@hyperframes/studio-server": "0.8.207",
-    "@hyperframes/parsers": "0.8.207"
+    "@hyperframes/lint": "0.8.209",
+    "@hyperframes/parsers": "0.8.209",
+    "@hyperframes/studio-server": "0.8.209"
   },
   "devDependencies": {
     "@fontsource/archivo-black": "^5.2.8",

package/dist/runtime/adapters/seek-dispatch.d.ts

@@ -1,37 +0,0 @@
-export interface HfSeekEventDetail {
-    time: number;
-    waitUntil: (promise: PromiseLike<unknown>) => void;
-}
-/**
- * Join `promise` to the seek-completion barrier: `waitForSeekCompletion` will
- * not resolve until it settles, and its rejection (the first one) becomes the
- * barrier's.
- *
- * Exported because the `"hf-seek"` event's synchronous `waitUntil()` is not
- * the only asynchronous seek work a frame can owe. `runtime/vfx.ts` registers
- * its preview-side capture here, so the CLI seek paths that already await this
- * barrier wait for a `self` chain's paint instead of racing it.
- */
-export declare function registerSeekCompletion(promise: Promise<unknown>, kind?: "video-frame"): void;
-export declare function dispatchSeekEvent(time: number): void;
-/**
- * Force-dispatch a `"hf-seek"` event even if `time` equals the last dispatched
- * time, bypassing the dedup guard.
- *
- * Needed for the post-video-injection GPU re-render: the engine seeks to time
- * T (GPU adapters render once, before video frames are injected), then injects
- * the decoded `__render_frame__` images, then must re-render GPU compositions
- * at the *same* T so they re-upload textures from the now-present frames. The
- * normal dedup would swallow that second dispatch.
- */
-export declare function forceDispatchSeekEvent(time: number): void;
-export declare function isSeekCompletionBarrierActive(): boolean;
-/** Settles with every pending completion, without consuming a failure the barrier reports. */
-export declare function seekCompletionsSettled(): Promise<void>;
-export declare function hasPendingSeekCompletion(): boolean;
-/** `videoFrames: false` skips only the video-frame holds: a geometry read needs every other completion. */
-export declare function waitForSeekCompletion(options?: {
-    videoFrames?: boolean;
-}): Promise<void>;
-/** Reset internal state — used in tests to prevent cross-test contamination. */
-export declare function resetSeekDispatchState(): void;

package/dist/runtime/adapters/seek-dispatch.js

@@ -1,143 +0,0 @@
-import { swallow } from "../diagnostics.js";
-/**
- * Shared, deduplicated `"hf-seek"` CustomEvent dispatcher for GPU adapters.
- *
- * Both the Three.js and TypeGPU adapters dispatch the same `"hf-seek"` event
- * so that compositions need not know which GPU library they're paired with.
- * Without deduplication, a seek to time T would fire two events (one from each
- * adapter), doubling per-scrub work in any composition that has both present.
- *
- * This module deduplicates by tracking the last dispatched time. If the same
- * time value is dispatched twice in the same synchronous call stack (e.g. two
- * adapters both calling `dispatchSeekEvent(5.0)` without yielding), only the
- * first call fires the event.
- *
- * The deduplication is intentionally coarse (exact float equality). Adapter
- * seek paths clamp and normalise time before calling this function, so the
- * values that arrive here are already stable.
- */
-let _lastDispatchedTime = -1;
-let _pendingCompletions = new Set();
-let _videoFrameCompletions = new WeakSet();
-let _pendingFailure;
-let _activeCompletionBarriers = 0;
-function dispatch(time) {
-    const pending = [];
-    let accepting = true;
-    const detail = {
-        time,
-        waitUntil: (promise) => {
-            if (!accepting) {
-                throw new Error("hf-seek waitUntil() must be called synchronously from the event listener");
-            }
-            pending.push(promise);
-        },
-    };
-    try {
-        window.dispatchEvent(new CustomEvent("hf-seek", { detail }));
-    }
-    catch (err) {
-        swallow("runtime.adapters.seek-dispatch.site1", err);
-    }
-    finally {
-        accepting = false;
-    }
-    if (pending.length === 0)
-        return;
-    registerSeekCompletion(Promise.all(pending));
-}
-/**
- * Join `promise` to the seek-completion barrier: `waitForSeekCompletion` will
- * not resolve until it settles, and its rejection (the first one) becomes the
- * barrier's.
- *
- * Exported because the `"hf-seek"` event's synchronous `waitUntil()` is not
- * the only asynchronous seek work a frame can owe. `runtime/vfx.ts` registers
- * its preview-side capture here, so the CLI seek paths that already await this
- * barrier wait for a `self` chain's paint instead of racing it.
- */
-export function registerSeekCompletion(promise, kind) {
-    const completion = promise
-        .then(() => ({ status: "fulfilled" }))
-        .catch((reason) => ({ status: "rejected", reason }));
-    _pendingCompletions.add(completion);
-    if (kind === "video-frame")
-        _videoFrameCompletions.add(completion);
-    void completion.then((result) => {
-        if (!_pendingCompletions.delete(completion))
-            return;
-        if (result.status === "rejected" && _pendingFailure === undefined) {
-            _pendingFailure = { reason: result.reason };
-        }
-    });
-}
-export function dispatchSeekEvent(time) {
-    if (time === _lastDispatchedTime)
-        return;
-    _lastDispatchedTime = time;
-    dispatch(time);
-}
-/**
- * Force-dispatch a `"hf-seek"` event even if `time` equals the last dispatched
- * time, bypassing the dedup guard.
- *
- * Needed for the post-video-injection GPU re-render: the engine seeks to time
- * T (GPU adapters render once, before video frames are injected), then injects
- * the decoded `__render_frame__` images, then must re-render GPU compositions
- * at the *same* T so they re-upload textures from the now-present frames. The
- * normal dedup would swallow that second dispatch.
- */
-export function forceDispatchSeekEvent(time) {
-    _lastDispatchedTime = time;
-    dispatch(time);
-}
-export function isSeekCompletionBarrierActive() {
-    return _activeCompletionBarriers > 0;
-}
-/** Settles with every pending completion, without consuming a failure the barrier reports. */
-export async function seekCompletionsSettled() {
-    for (let pending = [..._pendingCompletions]; pending.length > 0; pending = [..._pendingCompletions]) {
-        await Promise.all(pending);
-    }
-}
-export function hasPendingSeekCompletion() {
-    return _pendingCompletions.size > 0;
-}
-/** `videoFrames: false` skips only the video-frame holds: a geometry read needs every other completion. */
-export async function waitForSeekCompletion(options) {
-    const awaited = () => [..._pendingCompletions].filter((completion) => options?.videoFrames !== false || !_videoFrameCompletions.has(completion));
-    _activeCompletionBarriers += 1;
-    let failed = _pendingFailure;
-    try {
-        // Let concurrently started barriers snapshot the same retained failure
-        // before either one consumes it.
-        await Promise.resolve();
-        for (let pending = awaited(); pending.length > 0; pending = awaited()) {
-            const results = await Promise.all(pending);
-            const rejected = results.find((result) => result.status === "rejected");
-            if (failed === undefined && rejected?.status === "rejected") {
-                failed = { reason: rejected.reason };
-            }
-        }
-        const retainedFailure = _pendingFailure;
-        if (failed === undefined) {
-            failed = retainedFailure;
-        }
-        if (_pendingFailure === retainedFailure) {
-            _pendingFailure = undefined;
-        }
-        if (failed)
-            throw failed.reason;
-    }
-    finally {
-        _activeCompletionBarriers -= 1;
-    }
-}
-/** Reset internal state — used in tests to prevent cross-test contamination. */
-export function resetSeekDispatchState() {
-    _lastDispatchedTime = -1;
-    _pendingCompletions = new Set();
-    _videoFrameCompletions = new WeakSet();
-    _pendingFailure = undefined;
-    _activeCompletionBarriers = 0;
-}