@onmark/cli 0.1.4 → 0.2.3

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

@@ -10,4 +10,11 @@ export interface VideoFrameSelection {
 }
 /** 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,90 @@
 // 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 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,
     });
 }
-function sourceFrameAtMidpoint(localFrame, outputFrameRate, sourceFrameRate) {
-    const numerator = (2n * BigInt(localFrame) + 1n) *
-        BigInt(outputFrameRate.denominator) *
-        BigInt(sourceFrameRate.numerator);
-    const denominator = 2n *
+/** 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(video.sourceFrameRate) ||
+        !exactRatioIsCanonical(source.playbackRate)) {
+        return false;
+    }
+    const sourceDuration = end - start;
+    const numerator = sourceDuration *
         BigInt(outputFrameRate.numerator) *
-        BigInt(sourceFrameRate.denominator);
-    const sourceFrame = Number(numerator / denominator);
+        BigInt(source.playbackRate.denominator);
+    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 sourceFrameAtMidpoint(localFrame, outputFrameRate, sourceFrameRate, 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 nanosecondsPerSecond = 1000000000n;
+    // Rust owns the affine source-time mapping. This integer projection samples
+    // the output-frame midpoint 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");
     }
     return sourceFrame;
 }
+/** 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 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: 2, 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);
@@ -400,6 +407,10 @@ function snapshotVideo(video) {
         assetId: video.assetId,
         interval: Object.freeze({ ...video.interval }),
         sourceFrameRate: Object.freeze({ ...video.sourceFrameRate }),
+        source: Object.freeze({
+            ...video.source,
+            playbackRate: Object.freeze({ ...video.source.playbackRate }),
+        }),
     });
 }
 function snapshotOverlay(overlay) {