@onmark/cli 0.2.1 → 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,7 +7,16 @@ 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;
+/** Checks protocol source facts without deriving any authored timeline. */
+export declare function videoSourceMappingIsValid(video: RuntimeVideo, outputFrameRate: FrameRate): boolean;
+/** Checks the canonical positive-rational spelling used by Rust wire values. */
+export declare function exactRatioIsCanonical(rate: {
+    readonly numerator: number;
+    readonly denominator: number;
+}): boolean;
 export {};

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

@@ -1,28 +1,202 @@
 // Browser-media projection from exact Rust-owned frame facts.
 // It selects source frames without becoming a second timeline solver.
+const MAX_DURATION_NANOSECONDS = 18446744073709551615n;
+const MAX_RATIO_PART = 4_294_967_295;
 /** Selects the source frame visible at one output-frame midpoint. */
 export function videoFrameSelection(frame, video, outputFrameRate) {
     if (frame.index < video.interval.start || frame.index >= video.interval.end) {
         return undefined;
     }
     const localFrame = frame.index - video.interval.start;
-    const sourceFrame = sourceFrameAtMidpoint(localFrame, outputFrameRate, video.sourceFrameRate);
-    const sourceFrameDuration = video.sourceFrameRate.denominator / video.sourceFrameRate.numerator;
+    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) {
+    const source = video.source;
+    const start = BigInt(source.startNanoseconds);
+    const end = BigInt(source.endNanoseconds);
+    const naturalEnd = BigInt(source.naturalEndNanoseconds);
+    if (start >= end ||
+        end > naturalEnd ||
+        naturalEnd > MAX_DURATION_NANOSECONDS) {
+        return false;
+    }
+    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 playbackNumerator = sourceDuration *
+        BigInt(outputFrameRate.numerator) *
+        BigInt(source.playbackRate.denominator) *
+        BigInt(source.plays);
+    const holdNumerator = BigInt(source.holdLastNanoseconds) *
+        BigInt(outputFrameRate.numerator) *
+        BigInt(source.playbackRate.numerator);
+    const numerator = playbackNumerator + holdNumerator;
+    const denominator = 1000000000n *
+        BigInt(outputFrameRate.denominator) *
+        BigInt(source.playbackRate.numerator);
+    const expectedFrames = (numerator + denominator - 1n) / denominator;
+    const actualFrames = BigInt(video.interval.end - video.interval.start);
+    return actualFrames === expectedFrames;
+}
+function sourceTimeAtMidpoint(localFrame, outputFrameRate, source) {
+    const midpoint = 2n * BigInt(localFrame) + 1n;
+    const outputNumerator = BigInt(outputFrameRate.numerator);
+    const outputDenominator = BigInt(outputFrameRate.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 source treatment. This integer projection samples one exact
+    // pass without reconstructing a browser timeline.
+    const timeDenominator = 2n * outputNumerator * speedDenominator;
+    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: sourceFrame * sourceFrameDuration,
-        seekTimeSeconds: (sourceFrame + 0.5) * sourceFrameDuration,
+        mediaTimeSeconds,
+        seekTimeSeconds,
+        readinessToleranceSeconds,
     });
 }
-function sourceFrameAtMidpoint(localFrame, outputFrameRate, sourceFrameRate) {
-    const numerator = (2n * BigInt(localFrame) + 1n) *
-        BigInt(outputFrameRate.denominator) *
-        BigInt(sourceFrameRate.numerator);
-    const denominator = 2n *
-        BigInt(outputFrameRate.numerator) *
-        BigInt(sourceFrameRate.denominator);
-    const sourceFrame = Number(numerator / denominator);
-    if (!Number.isSafeInteger(sourceFrame)) {
-        throw new RangeError("selected source frame exceeds JavaScript's exact integer range");
+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;
+    }
+    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) {
+    if (!Number.isInteger(rate.numerator) ||
+        !Number.isInteger(rate.denominator) ||
+        rate.numerator < 1 ||
+        rate.denominator < 1 ||
+        rate.numerator > MAX_RATIO_PART ||
+        rate.denominator > MAX_RATIO_PART) {
+        return false;
+    }
+    let left = BigInt(rate.numerator);
+    let right = BigInt(rate.denominator);
+    while (right !== 0n) {
+        [left, right] = [right, left % right];
     }
-    return sourceFrame;
+    return left === 1n;
 }

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

@@ -4,6 +4,7 @@
 import { decodeBrowserResponse } from "./generated/codec.js";
 import { MAX_FAILURE_MESSAGE_CHARACTERS, MAX_PENDING_RESOURCE_CHARACTERS, MAX_PENDING_RESOURCES, } from "./generated/runtime-contract.js";
 import { runtimeFrameAt } from "./clock.js";
+import { exactRatioIsCanonical, videoSourceMappingIsValid } from "./media.js";
 /** Expected failure reported by a browser adapter. */
 export class RuntimeAdapterError extends Error {
     kind;
@@ -156,7 +157,7 @@ export class RuntimeSession {
     }
 }
 function response(requestId, event) {
-    return decodeBrowserResponse({ version: 1, requestId, event });
+    return decodeBrowserResponse({ version: 3, requestId, event });
 }
 function invalidRequest(requestId, message) {
     return response(requestId, {
@@ -195,6 +196,9 @@ function readinessFailure(requestId, operationCode, error) {
     return operationFailure(requestId, operationCode, error);
 }
 function planViolation(plan) {
+    if (!exactRatioIsCanonical(plan.frameRate)) {
+        return "plan frame rate is not canonical";
+    }
     if (plan.timeline.start >= plan.timeline.end) {
         return "plan timeline interval is empty or reversed";
     }
@@ -267,6 +271,9 @@ function planViolation(plan) {
         if (!insideInterval(video.interval, shotInterval)) {
             return "plan video interval falls outside its shot";
         }
+        if (!videoSourceMappingIsValid(video, plan.frameRate)) {
+            return "plan video source mapping disagrees with its interval";
+        }
     }
     for (const overlay of plan.overlays) {
         const nodeViolation = claimNode(overlay.node, nodeIds, authoredIds);
@@ -399,9 +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");
     }
 }