@onmark/cli 0.2.3 → 0.3.0

package/packages/runtime/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 export { ProtocolDecodeError, decodeBrowserRequest, decodeBrowserResponse, } from "./generated/codec.js";
 export type { BrowserRequest } from "./generated/browser-request.js";
 export type { BrowserResponse } from "./generated/browser-response.js";
-export type { BrowserPlan } from "./generated/browser-request.js";
+export type { BrowserPlan, BrowserVideo } from "./generated/browser-request.js";
 export { runtimeFrameAt, type RuntimeFrame } from "./clock.js";
 export { videoFrameSelection, type RuntimeVideo, type VideoFrameSelection, } from "./media.js";
 export { DecodedVideo, materializedVideoSource, type BrowserVideoElement, type DecodedVideoOptions, } from "./video.js";

package/packages/runtime/dist/src/media.d.ts

@@ -7,6 +7,8 @@ type FrameRate = RuntimePlan["frameRate"];
 export interface VideoFrameSelection {
     readonly mediaTimeSeconds: number;
     readonly seekTimeSeconds: number;
+    /** Largest callback error that cannot identify an adjacent source frame. */
+    readonly readinessToleranceSeconds: number;
 }
 /** Selects the source frame visible at one output-frame midpoint. */
 export declare function videoFrameSelection(frame: RuntimeFrame, video: RuntimeVideo, outputFrameRate: FrameRate): VideoFrameSelection | undefined;

package/packages/runtime/dist/src/media.js

@@ -8,12 +8,8 @@ export function videoFrameSelection(frame, video, outputFrameRate) {
         return undefined;
     }
     const localFrame = frame.index - video.interval.start;
-    const sourceFrame = sourceFrameAtMidpoint(localFrame, outputFrameRate, video.sourceFrameRate, video.source);
-    const sourceFrameDuration = video.sourceFrameRate.denominator / video.sourceFrameRate.numerator;
-    return Object.freeze({
-        mediaTimeSeconds: sourceFrame * sourceFrameDuration,
-        seekTimeSeconds: (sourceFrame + 0.5) * sourceFrameDuration,
-    });
+    const sourceTime = sourceTimeAtMidpoint(localFrame, outputFrameRate, video.source);
+    return selectSourceFrame(sourceTime, video.sourceTiming, video.source);
 }
 /** Checks protocol source facts without deriving any authored timeline. */
 export function videoSourceMappingIsValid(video, outputFrameRate) {
@@ -26,14 +22,23 @@ export function videoSourceMappingIsValid(video, outputFrameRate) {
         naturalEnd > MAX_DURATION_NANOSECONDS) {
         return false;
     }
-    if (!exactRatioIsCanonical(video.sourceFrameRate) ||
-        !exactRatioIsCanonical(source.playbackRate)) {
+    if (!exactRatioIsCanonical(source.playbackRate) ||
+        !Number.isInteger(source.plays) ||
+        source.plays <= 0 ||
+        source.plays > 4_294_967_295 ||
+        !canonicalUnsignedInteger(source.holdLastNanoseconds) ||
+        !sourceTimingIsValid(video.sourceTiming, naturalEnd)) {
         return false;
     }
     const sourceDuration = end - start;
-    const numerator = sourceDuration *
+    const playbackNumerator = sourceDuration *
+        BigInt(outputFrameRate.numerator) *
+        BigInt(source.playbackRate.denominator) *
+        BigInt(source.plays);
+    const holdNumerator = BigInt(source.holdLastNanoseconds) *
         BigInt(outputFrameRate.numerator) *
-        BigInt(source.playbackRate.denominator);
+        BigInt(source.playbackRate.numerator);
+    const numerator = playbackNumerator + holdNumerator;
     const denominator = 1000000000n *
         BigInt(outputFrameRate.denominator) *
         BigInt(source.playbackRate.numerator);
@@ -41,35 +46,142 @@ export function videoSourceMappingIsValid(video, outputFrameRate) {
     const actualFrames = BigInt(video.interval.end - video.interval.start);
     return actualFrames === expectedFrames;
 }
-function sourceFrameAtMidpoint(localFrame, outputFrameRate, sourceFrameRate, source) {
+function sourceTimeAtMidpoint(localFrame, outputFrameRate, source) {
     const midpoint = 2n * BigInt(localFrame) + 1n;
     const outputNumerator = BigInt(outputFrameRate.numerator);
     const outputDenominator = BigInt(outputFrameRate.denominator);
-    const sourceNumerator = BigInt(sourceFrameRate.numerator);
-    const sourceDenominator = BigInt(sourceFrameRate.denominator);
     const speedNumerator = BigInt(source.playbackRate.numerator);
     const speedDenominator = BigInt(source.playbackRate.denominator);
     const startNanoseconds = BigInt(source.startNanoseconds);
     const endNanoseconds = BigInt(source.endNanoseconds);
+    const plays = BigInt(source.plays);
     const nanosecondsPerSecond = 1000000000n;
-    // Rust owns the affine source-time mapping. This integer projection samples
-    // the output-frame midpoint without reconstructing a browser timeline.
+    // Rust owns the source treatment. This integer projection samples one exact
+    // pass without reconstructing a browser timeline.
     const timeDenominator = 2n * outputNumerator * speedDenominator;
-    const sourceTimeNumerator = startNanoseconds * timeDenominator +
-        midpoint * outputDenominator * speedNumerator * nanosecondsPerSecond;
-    const frameNumerator = sourceTimeNumerator * sourceNumerator;
-    const denominator = timeDenominator * nanosecondsPerSecond * sourceDenominator;
-    const selectedFrame = frameNumerator / denominator;
-    const sourceEndNumerator = endNanoseconds * sourceNumerator;
-    const sourceFrameDenominator = nanosecondsPerSecond * sourceDenominator;
-    const exclusiveEndFrame = (sourceEndNumerator + sourceFrameDenominator - 1n) / sourceFrameDenominator;
-    // Ceil-rounded output may expose one midpoint beyond the trim edge. Keep
-    // that final sample inside the last source frame intersecting the interval.
-    const sourceFrame = Number(selectedFrame < exclusiveEndFrame ? selectedFrame : exclusiveEndFrame - 1n);
-    if (!Number.isSafeInteger(sourceFrame)) {
-        throw new RangeError("selected source frame exceeds JavaScript's exact integer range");
+    const elapsedNumerator = midpoint * outputDenominator * speedNumerator * nanosecondsPerSecond;
+    const passNumerator = (endNanoseconds - startNanoseconds) * timeDenominator;
+    const playbackNumerator = passNumerator * plays;
+    const sourceTimeNumerator = elapsedNumerator < playbackNumerator
+        ? startNanoseconds * timeDenominator + (elapsedNumerator % passNumerator)
+        : endNanoseconds * timeDenominator - 1n;
+    return {
+        numerator: sourceTimeNumerator,
+        denominator: timeDenominator,
+    };
+}
+// ── CFR and VFR projection ──
+function selectSourceFrame(time, timing, source) {
+    switch (timing.kind) {
+        case "constant":
+            return selectConstantFrame(time, timing.frameRate, source);
+        case "variable":
+            return selectVariableFrame(time, timing);
+    }
+}
+function selectConstantFrame(time, rate, source) {
+    const rateNumerator = BigInt(rate.numerator);
+    const frameDenominator = time.denominator * 1000000000n * BigInt(rate.denominator);
+    const selected = (time.numerator * rateNumerator) / frameDenominator;
+    const sourceEnd = BigInt(source.endNanoseconds) * rateNumerator;
+    const exclusiveEnd = divideCeil(sourceEnd, 1000000000n * BigInt(rate.denominator));
+    const frame = selected < exclusiveEnd ? selected : exclusiveEnd - 1n;
+    const rateDenominator = BigInt(rate.denominator);
+    return projectFrameInterval(frame * rateDenominator, (frame + 1n) * rateDenominator, rateNumerator, rateDenominator);
+}
+function selectVariableFrame(time, timing) {
+    const selected = sourceFrameIndex(time, timing.timebase, timing.boundaries);
+    const start = timing.boundaries[selected];
+    const end = timing.boundaries[selected + 1];
+    if (start === undefined || end === undefined) {
+        throw new RangeError("selected source frame lies outside its timestamp map");
+    }
+    const startTick = BigInt(start);
+    const endTick = BigInt(end);
+    const timebaseNumerator = BigInt(timing.timebase.numerator);
+    const previous = timing.boundaries[selected - 1];
+    const previousDistance = previous === undefined ? endTick - startTick : startTick - BigInt(previous);
+    const nearestDistance = previousDistance < endTick - startTick
+        ? previousDistance
+        : endTick - startTick;
+    return projectFrameInterval(startTick * timebaseNumerator, endTick * timebaseNumerator, BigInt(timing.timebase.denominator), nearestDistance * timebaseNumerator);
+}
+function projectFrameInterval(startNumerator, endNumerator, denominator, neighborDistanceNumerator) {
+    // Frame identity remains exact until this single projection into the
+    // browser's floating-point media API. Reject intervals for which no
+    // representable interior second can prove the selected frame.
+    const mediaTimeSeconds = rationalSeconds(startNumerator, denominator);
+    const seekTimeSeconds = rationalSeconds(startNumerator + endNumerator, 2n * denominator);
+    const endTimeSeconds = rationalSeconds(endNumerator, denominator);
+    const readinessToleranceSeconds = Math.min(0.000_001, rationalSeconds(neighborDistanceNumerator, denominator) / 4);
+    if (!Number.isFinite(mediaTimeSeconds) ||
+        !(mediaTimeSeconds < seekTimeSeconds) ||
+        !(seekTimeSeconds < endTimeSeconds) ||
+        !(readinessToleranceSeconds > 0)) {
+        throw new RangeError("selected source frame has no representable interior seek time");
+    }
+    return Object.freeze({
+        mediaTimeSeconds,
+        seekTimeSeconds,
+        readinessToleranceSeconds,
+    });
+}
+function rationalSeconds(numerator, denominator) {
+    const whole = numerator / denominator;
+    const remainder = numerator % denominator;
+    return Number(whole) + Number(remainder) / Number(denominator);
+}
+function sourceFrameIndex(time, timebase, boundaries) {
+    const targetNumerator = time.numerator * BigInt(timebase.denominator);
+    const targetDenominator = time.denominator * BigInt(timebase.numerator) * 1000000000n;
+    let low = 0;
+    let high = boundaries.length;
+    while (low < high) {
+        const middle = low + Math.floor((high - low) / 2);
+        const boundary = boundaries[middle];
+        if (boundary !== undefined &&
+            BigInt(boundary) * targetDenominator <= targetNumerator) {
+            low = middle + 1;
+        }
+        else {
+            high = middle;
+        }
+    }
+    return Math.min(low - 1, boundaries.length - 2);
+}
+// ── Wire-fact validation ──
+function sourceTimingIsValid(timing, naturalEndNanoseconds) {
+    if (timing.kind === "constant") {
+        return exactRatioIsCanonical(timing.frameRate);
+    }
+    if (!exactRatioIsCanonical(timing.timebase) ||
+        timing.boundaries.length < 3 ||
+        timing.boundaries.length > 100_000) {
+        return false;
+    }
+    let previous = -1n;
+    for (const spelling of timing.boundaries) {
+        if (!canonicalUnsignedInteger(spelling)) {
+            return false;
+        }
+        const boundary = BigInt(spelling);
+        if (boundary <= previous) {
+            return false;
+        }
+        previous = boundary;
+    }
+    if (timing.boundaries[0] !== "0") {
+        return false;
     }
-    return sourceFrame;
+    const duration = divideCeil(previous * BigInt(timing.timebase.numerator) * 1000000000n, BigInt(timing.timebase.denominator));
+    return duration === naturalEndNanoseconds;
+}
+function canonicalUnsignedInteger(value) {
+    return (/^(0|[1-9][0-9]*)$/u.test(value) &&
+        BigInt(value) <= MAX_DURATION_NANOSECONDS);
+}
+function divideCeil(numerator, denominator) {
+    return (numerator + denominator - 1n) / denominator;
 }
 /** Checks the canonical positive-rational spelling used by Rust wire values. */
 export function exactRatioIsCanonical(rate) {

package/packages/runtime/dist/src/session.js

@@ -157,7 +157,7 @@ export class RuntimeSession {
     }
 }
 function response(requestId, event) {
-    return decodeBrowserResponse({ version: 2, requestId, event });
+    return decodeBrowserResponse({ version: 3, requestId, event });
 }
 function invalidRequest(requestId, message) {
     return response(requestId, {
@@ -406,13 +406,31 @@ function snapshotVideo(video) {
         shotId: video.shotId,
         assetId: video.assetId,
         interval: Object.freeze({ ...video.interval }),
-        sourceFrameRate: Object.freeze({ ...video.sourceFrameRate }),
+        sourceTiming: snapshotSourceTiming(video.sourceTiming),
         source: Object.freeze({
             ...video.source,
             playbackRate: Object.freeze({ ...video.source.playbackRate }),
         }),
     });
 }
+function snapshotSourceTiming(timing) {
+    switch (timing.kind) {
+        case "constant":
+            return Object.freeze({
+                kind: timing.kind,
+                frameRate: Object.freeze({ ...timing.frameRate }),
+            });
+        case "variable":
+            return Object.freeze({
+                kind: timing.kind,
+                timebase: Object.freeze({ ...timing.timebase }),
+                boundaries: snapshotFrameBoundaries(timing.boundaries),
+            });
+    }
+}
+function snapshotFrameBoundaries([first, second, third, ...rest]) {
+    return Object.freeze([first, second, third, ...rest]);
+}
 function snapshotOverlay(overlay) {
     return Object.freeze({
         node: snapshotNode(overlay.node),

package/packages/runtime/dist/src/video.js

@@ -3,7 +3,6 @@
 import { BUNDLE_ASSET_DIRECTORY } from "./generated/bundle-layout.js";
 import { requireReadinessTimeout } from "./resource.js";
 import { RuntimeAdapterError } from "./session.js";
-const FRAME_TOLERANCE_SECONDS = 0.000_001;
 const LOAD_READINESS = {
     event: "loadeddata",
     failureMessage: "video data failed to load",
@@ -247,7 +246,9 @@ class StagedFrame {
     }
     matches(selection) {
         return (selection.mediaTimeSeconds === this.#selection.mediaTimeSeconds &&
-            selection.seekTimeSeconds === this.#selection.seekTimeSeconds);
+            selection.seekTimeSeconds === this.#selection.seekTimeSeconds &&
+            selection.readinessToleranceSeconds ===
+                this.#selection.readinessToleranceSeconds);
     }
     async confirm(timeoutMilliseconds) {
         const observation = await observedBeforeDeadline(this.#observation, timeoutMilliseconds, this.#pendingResource);
@@ -267,7 +268,7 @@ class StagedFrame {
     #inspectFrame = (_now, metadata) => {
         this.#frameCallback = undefined;
         const exactFrame = Math.abs(metadata.mediaTime - this.#selection.mediaTimeSeconds) <=
-            FRAME_TOLERANCE_SECONDS;
+            this.#selection.readinessToleranceSeconds;
         if (exactFrame) {
             this.#finish({ kind: "presented" });
             return;
@@ -337,7 +338,11 @@ function requireSelection(selection) {
     if (!Number.isFinite(selection.mediaTimeSeconds) ||
         selection.mediaTimeSeconds < 0 ||
         !Number.isFinite(selection.seekTimeSeconds) ||
-        selection.seekTimeSeconds < selection.mediaTimeSeconds) {
+        selection.seekTimeSeconds <= selection.mediaTimeSeconds ||
+        !Number.isFinite(selection.readinessToleranceSeconds) ||
+        selection.readinessToleranceSeconds <= 0 ||
+        selection.readinessToleranceSeconds >=
+            selection.seekTimeSeconds - selection.mediaTimeSeconds) {
         throw new RuntimeAdapterError("operation", "video frame selection is invalid");
     }
 }