@onmark/cli 0.3.0 → 0.5.0

package/packages/bundler/dist/src/presentation.js

@@ -6,7 +6,8 @@ import { createRequire } from "node:module";
 import { dirname, extname, isAbsolute, join, relative, resolve, sep, } from "node:path";
 import { build, } from "esbuild";
 import { BUNDLE_ENTRY_POINT, BUNDLE_FRAME_BEHAVIORS, BUNDLE_MANIFEST_FILE, BUNDLE_REGION_DIRECTORY, BUNDLE_TEMPORAL_CAPABILITIES, BUNDLE_VISUAL_CAPABILITIES, BUNDLE_VERSION, } from "./generated/bundle-manifest.js";
-import { AuthoredHtmlError, projectShotDocument, readAuthoredHtml, } from "./authored_html.js";
+import { AuthoredHtmlError, projectRegionDocument, readAuthoredHtml, } from "./authored_html.js";
+import { BundleProjectionError, decodeBundleProjection, } from "./bundle_projection.js";
 import { HtmlImageError, HtmlImageLimitError, projectedImageResources, } from "./html_image.js";
 import { hasAmbientImageAnimation } from "./image_admission.js";
 // Authored files live outside the package tree, so public facades resolve from
@@ -46,10 +47,10 @@ export class BundleError extends Error {
 // ── Build pipeline
 /** Builds one HTML-authored presentation without a parallel entry file. */
 export async function bundlePresentation(options) {
-    const maxOutputBytes = validateOutputByteLimit(options.maxOutputBytes);
+    const controls = snapshotControls(options);
     let html;
     try {
-        html = await readAuthoredHtml(options.document, maxOutputBytes, options.resolveDirectory);
+        html = await readAuthoredHtml(options.document, controls.maxOutputBytes, options.resolveDirectory);
     }
     catch (error) {
         if (error instanceof HtmlImageLimitError) {
@@ -60,17 +61,13 @@ export async function bundlePresentation(options) {
         }
         throw error;
     }
-    return bundle({
-        html,
-        maxOutputBytes,
-        outputDirectory: options.outputDirectory,
-        temporalCapability: options.temporalCapability,
-        visualCapability: options.visualCapability,
-        frameBehavior: options.frameBehavior,
-    });
+    return bundle(Object.freeze({
+        ...controls,
+        html: Object.freeze({ ...html }),
+        visualCapability: resolveVisualCapability(controls.visualCapability, html.visualCapability),
+    }));
 }
-async function bundle(options) {
-    const input = validateInput(options);
+async function bundle(input) {
     await requireAbsent(input.outputDirectory);
     await mkdir(dirname(input.outputDirectory), { recursive: true });
     const staging = await mkdtemp(join(dirname(input.outputDirectory), ".onmark-bundle-"));
@@ -105,7 +102,7 @@ async function buildArtifact(input, staging) {
         }))),
     });
 }
-function validateInput(options) {
+function snapshotControls(options) {
     if (options.outputDirectory.length === 0) {
         throw new BundleError("configuration", "output directory cannot be empty");
     }
@@ -114,26 +111,62 @@ function validateInput(options) {
         throw new BundleError("configuration", "maximum output bytes must be a positive safe integer");
     }
     const temporalCapability = validateTemporalCapability(options.temporalCapability);
-    const visualCapability = validateVisualCapability(options.visualCapability);
+    const visualCapability = options.visualCapability === undefined
+        ? undefined
+        : validateVisualCapability(options.visualCapability);
     const frameBehavior = validateFrameBehavior(options.frameBehavior);
     if (frameBehavior === "placementBounded" &&
         temporalCapability !== "randomAccess") {
         throw new BundleError("configuration", "placement-bounded frames require random-access presentation timing");
     }
-    return Object.freeze({
+    const input = {
         outputDirectory: resolve(options.outputDirectory),
         maxOutputBytes: options.maxOutputBytes,
-        html: Object.freeze({ ...options.html }),
-        temporalCapability,
         visualCapability,
         frameBehavior,
-    });
+    };
+    return temporalCapability === "randomAccess"
+        ? Object.freeze({
+            ...input,
+            projection: snapshotProjection(requireProjection(options.projection)),
+            temporalCapability,
+        })
+        : Object.freeze({ ...input, temporalCapability });
 }
-function validateOutputByteLimit(value) {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-        throw new BundleError("configuration", "maximum output bytes must be a positive safe integer");
+function requireProjection(projection) {
+    if (projection === undefined) {
+        throw new BundleError("configuration", "random-access presentation requires a bundle projection");
     }
-    return value;
+    return projection;
+}
+function snapshotProjection(projection) {
+    try {
+        projection = decodeBundleProjection(projection);
+    }
+    catch (error) {
+        if (error instanceof BundleProjectionError) {
+            throw new BundleError("configuration", error.message, error);
+        }
+        throw error;
+    }
+    const [first, ...rest] = projection.regions;
+    const regions = [
+        snapshotProjectionRegion(first),
+        ...rest.map(snapshotProjectionRegion),
+    ];
+    return Object.freeze({
+        version: projection.version,
+        regions: Object.freeze(regions),
+    });
+}
+function snapshotProjectionRegion(region) {
+    return Object.freeze({
+        shotIndices: snapshotShotIndices(region.shotIndices),
+    });
+}
+function snapshotShotIndices(indices) {
+    const [first, ...rest] = indices;
+    return Object.freeze([first, ...rest]);
 }
 function validateTemporalCapability(capability) {
     const admitted = BUNDLE_TEMPORAL_CAPABILITIES.find((candidate) => candidate === capability);
@@ -147,7 +180,15 @@ function validateVisualCapability(capability) {
     if (admitted !== undefined) {
         return admitted;
     }
-    throw new BundleError("configuration", "visual capability must be browserComposite or separableOverlay");
+    throw new BundleError("configuration", "visual capability must be browserComposite, separableBackdrop, or separableOverlay");
+}
+function resolveVisualCapability(configured, authored) {
+    if (configured !== undefined &&
+        authored !== undefined &&
+        configured !== authored) {
+        throw new BundleError("configuration", "configured and authored visual capabilities disagree");
+    }
+    return configured ?? authored ?? "browserComposite";
 }
 function validateFrameBehavior(behavior) {
     const admitted = BUNDLE_FRAME_BEHAVIORS.find((candidate) => candidate === behavior);
@@ -373,11 +414,11 @@ async function writeRegionArtifacts(staging, input, generated, resources, initia
     if (input.temporalCapability !== "randomAccess") {
         return [];
     }
-    validateRegionCount(input.html.regions.length, generated.length + resources.length);
+    validateRegionCount(input.projection.regions.length, generated.length + resources.length);
     let remaining = initialBudget;
     const regions = [];
-    for (const [index, region] of input.html.regions.entries()) {
-        const document = projectShotDocument(input.html, region);
+    for (const [index, region] of input.projection.regions.entries()) {
+        const document = projectRegionDocument(input.html, region.shotIndices);
         const files = presentationFiles([
             ...generated,
             ...authoredResourceFiles(projectedImageResources(document.document, resources)),
@@ -386,7 +427,7 @@ async function writeRegionArtifacts(staging, input, generated, resources, initia
         const manifestBytes = encodeManifest(manifest);
         const entry = files.find((file) => file.path === BUNDLE_ENTRY_POINT);
         if (entry === undefined) {
-            throw new BundleError("build", "shot-scoped bundle has no entry point");
+            throw new BundleError("build", "render-region bundle has no entry point");
         }
         remaining = consumeOutputBudget(remaining, entry.contents.byteLength);
         remaining = consumeOutputBudget(remaining, manifestBytes.byteLength);
@@ -411,11 +452,11 @@ async function writeRegionFiles(staging, directory, files) {
 }
 function validateRegionCount(regions, generated) {
     if (regions > MAX_REGION_ARTIFACTS) {
-        throw new BundleError("outputLimit", "presentation exceeds the shot-scoped bundle limit");
+        throw new BundleError("outputLimit", "presentation exceeds the render-region bundle limit");
     }
     const links = regions * generated;
     if (!Number.isSafeInteger(links) || links > MAX_REGION_LINKS) {
-        throw new BundleError("outputLimit", "presentation exceeds the shot-scoped bundle file limit");
+        throw new BundleError("outputLimit", "presentation exceeds the render-region bundle file limit");
     }
 }
 async function requireAbsent(outputDirectory) {

package/packages/motion-gsap/dist/src/index.d.ts

@@ -1,5 +1,5 @@
 import { gsap } from "gsap";
-import type { PresentationExtension, PresentationTargetKind } from "../../../authoring/dist/src/index.js";
+import type { PresentationExtension, PresentationElementTargetKind } from "../../../authoring/dist/src/index.js";
 /** Local GSAP authoring facts for one semantic screenplay element. */
 export interface GsapMotionContext {
     readonly durationSeconds: number;
@@ -8,9 +8,17 @@ export interface GsapMotionContext {
 }
 /** Adds local animation to one Onmark-owned paused timeline. */
 export type GsapMotionHandler = (context: GsapMotionContext) => void;
+/** Local GSAP transition facts with both adjacent shot elements. */
+export interface GsapTransitionContext extends GsapMotionContext {
+    readonly incomingElement: HTMLElement;
+    readonly outgoingElement: HTMLElement;
+}
+/** Adds local animation across one compiler-owned shot overlap. */
+export type GsapTransitionHandler = (context: GsapTransitionContext) => void;
 /** Semantic handlers and optional selector handlers for local motion. */
-export type GsapMotionDefinition = Readonly<Partial<Record<PresentationTargetKind, GsapMotionHandler>> & {
+export type GsapMotionDefinition = Readonly<Partial<Record<PresentationElementTargetKind, GsapMotionHandler>> & {
     readonly selectors?: Readonly<Record<string, GsapMotionHandler>>;
+    readonly transition?: GsapTransitionHandler;
 }>;
 /** Creates exact-frame GSAP effects without exposing runtime lifecycle code. */
 export declare function gsapMotion(definition: GsapMotionDefinition): PresentationExtension;

package/packages/motion-gsap/dist/src/index.js

@@ -19,7 +19,7 @@ function bindGsapEffects(rules, context) {
     try {
         for (const target of context.targets) {
             const handlers = matchingHandlers(rules, target);
-            if (handlers.length === 0) {
+            if (handlers.elements.length === 0 && handlers.transition === undefined) {
                 continue;
             }
             effects.push(bindGsapEffect(handlers, target, context));
@@ -43,7 +43,10 @@ function bindGsapEffect(handlers, target, context) {
             element: target.element,
             timeline,
         });
-        for (const handler of handlers) {
+        if (target.kind === "transition" && handlers.transition !== undefined) {
+            handlers.transition(transitionContext(motion, target));
+        }
+        for (const handler of handlers.elements) {
             handler(motion);
         }
         requireLocalTimeline(timeline, durationSeconds, target.kind);
@@ -88,7 +91,11 @@ function ownRules(definition) {
         caption: definition.caption,
     });
     const selectors = Object.freeze(Object.entries(definition.selectors ?? {}).map(ownSelector));
-    return Object.freeze({ kinds, selectors });
+    return Object.freeze({
+        kinds,
+        selectors,
+        transition: definition.transition,
+    });
 }
 function ownSelector([selector, animate]) {
     if (selector.trim().length === 0) {
@@ -98,7 +105,7 @@ function ownSelector([selector, animate]) {
 }
 function matchingHandlers(rules, target) {
     const handlers = [];
-    const kind = rules.kinds[target.kind];
+    const kind = target.kind === "transition" ? undefined : rules.kinds[target.kind];
     if (kind !== undefined) {
         handlers.push(kind);
     }
@@ -107,7 +114,10 @@ function matchingHandlers(rules, target) {
             handlers.push(rule.animate);
         }
     }
-    return handlers;
+    return Object.freeze({
+        elements: Object.freeze(handlers),
+        transition: target.kind === "transition" ? rules.transition : undefined,
+    });
 }
 // ── Exact-frame playheads ──
 function intervalSeconds(target, context) {
@@ -117,8 +127,20 @@ function intervalSeconds(target, context) {
 function localSeconds(frame, target, context) {
     const durationFrames = target.interval.end - target.interval.start;
     const localFrame = Math.max(0, Math.min(frame.index - target.interval.start, durationFrames));
+    if (target.kind === "transition") {
+        const finalFrame = durationFrames - 1;
+        const progress = finalFrame === 0 ? 1 : localFrame / finalFrame;
+        return intervalSeconds(target, context) * progress;
+    }
     return ((localFrame / context.frameRate.numerator) * context.frameRate.denominator);
 }
+function transitionContext(context, target) {
+    return Object.freeze({
+        ...context,
+        incomingElement: target.incomingElement,
+        outgoingElement: target.outgoingElement,
+    });
+}
 function requireLocalTimeline(timeline, durationSeconds, label) {
     if (timeline.duration() <= durationSeconds) {
         return;

package/packages/runtime/dist/src/generated/browser-request.d.ts

@@ -2,6 +2,10 @@
  * Closed commands understood by the browser runtime.
  */
 export type BrowserCommand = {
+    /**
+     * Browser responsibility for primary-media elements.
+     */
+    mediaMode: "decoded" | "omitted" | "layoutOnly";
     plan: BrowserPlan;
     type: "load";
 } | {
@@ -66,7 +70,7 @@ export type RequestId = number;
 /**
  * Version of the native-to-browser message contract.
  */
-export type ProtocolVersion = 3;
+export type ProtocolVersion = 5;
 /**
  * One versioned command sent from the native executor to the browser.
  */
@@ -96,7 +100,11 @@ export interface BrowserPlan {
      */
     shots: BrowserShot[];
     timeline: WireInterval;
-    timelineVersion: 2;
+    timelineVersion: 3;
+    /**
+     * @maxItems 10000
+     */
+    transitions: BrowserTransition[];
     /**
      * @maxItems 10000
      */
@@ -148,6 +156,15 @@ export interface BrowserShot {
     node: BrowserNode;
     sceneId: BrowserNodeId;
 }
+/**
+ * One solved transition between two adjacent browser shots.
+ */
+export interface BrowserTransition {
+    incomingShotId: BrowserNodeId;
+    interval: WireInterval;
+    node: BrowserNode;
+    outgoingShotId: BrowserNodeId;
+}
 /**
  * One primary video placement consumed by the browser presentation adapter.
  */

package/packages/runtime/dist/src/generated/browser-response.d.ts

@@ -8,6 +8,7 @@ export type BrowserEvent = {
      * Frame at which preparation completed.
      */
     evaluationStart: number;
+    mediaLayout: BrowserMediaLayout;
     type: "prepared";
 } | {
     /**
@@ -40,6 +41,25 @@ export type BrowserEvent = {
 } | {
     type: "disposed";
 };
+/**
+ * Browser identity for one Timeline element or imported caption.
+ *
+ * IDs form dense renderable-semantic preorder within one Browser Plan.
+ *
+ * Authored IDs, rather than this unit-local key, retain cross-projection
+ * semantic identity.
+ */
+export type BrowserNodeId = number;
+/**
+ * Closed CSS object-fit subset admitted by native media.
+ */
+export type BrowserObjectFit = "fill" | "contain" | "cover";
+/**
+ * Exact static media layout observed by the browser.
+ *
+ * @maxItems 16
+ */
+export type BrowserMediaLayout = BrowserMediaPlacement[];
 /**
  * Correlation identity shared by one request and its response events.
  */
@@ -47,7 +67,7 @@ export type RequestId = number;
 /**
  * Version of the native-to-browser message contract.
  */
-export type ProtocolVersion = 3;
+export type ProtocolVersion = 5;
 /**
  * One versioned event returned by the browser runtime.
  */
@@ -56,3 +76,28 @@ export interface BrowserResponse {
     requestId: RequestId;
     version: ProtocolVersion;
 }
+/**
+ * One video element's static, axis-aligned browser layout.
+ */
+export interface BrowserMediaPlacement {
+    nodeId: BrowserNodeId;
+    objectFit: BrowserObjectFit;
+    objectPosition: BrowserObjectPosition;
+    rectangle: BrowserPixelRectangle;
+}
+/**
+ * Fixed-point CSS object-position, where one million represents 100%.
+ */
+export interface BrowserObjectPosition {
+    x: number;
+    y: number;
+}
+/**
+ * Positive pixel rectangle relative to the output viewport.
+ */
+export interface BrowserPixelRectangle {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+}

package/packages/runtime/dist/src/generated/bundle-layout.d.ts

@@ -1,7 +1,7 @@
 export declare const BUNDLE_ASSET_DIRECTORY: "assets/sha256";
 export declare const PRESENTATION_TEMPORAL_CAPABILITIES: readonly ["sequential", "randomAccess"];
 export type PresentationTemporalCapability = (typeof PRESENTATION_TEMPORAL_CAPABILITIES)[number];
-export declare const PRESENTATION_VISUAL_CAPABILITIES: readonly ["browserComposite", "separableOverlay"];
+export declare const PRESENTATION_VISUAL_CAPABILITIES: readonly ["browserComposite", "separableBackdrop", "separableOverlay"];
 export type PresentationVisualCapability = (typeof PRESENTATION_VISUAL_CAPABILITIES)[number];
 export declare const PRESENTATION_FRAME_BEHAVIORS: readonly ["perFrame", "placementBounded"];
 export type PresentationFrameBehavior = (typeof PRESENTATION_FRAME_BEHAVIORS)[number];

package/packages/runtime/dist/src/generated/bundle-layout.js

@@ -6,6 +6,7 @@ export const PRESENTATION_TEMPORAL_CAPABILITIES = Object.freeze([
 ]);
 export const PRESENTATION_VISUAL_CAPABILITIES = Object.freeze([
     "browserComposite",
+    "separableBackdrop",
     "separableOverlay",
 ]);
 export const PRESENTATION_FRAME_BEHAVIORS = Object.freeze([

package/packages/runtime/dist/src/generated/runtime-contract.d.ts

@@ -1,5 +1,9 @@
 export declare const RUNTIME_HOST_NAME: "__ONMARK_RUNTIME__";
+export declare const BROWSER_PROTOCOL_VERSION: 5;
 export declare const MAX_BROWSER_VIDEOS: 10000;
+export declare const MAX_BROWSER_MEDIA_LAYOUTS: 16;
+export declare const BROWSER_OBJECT_POSITION_SCALE: 1000000;
+export declare const MAX_BROWSER_TRANSITIONS: 10000;
 export declare const MAX_BROWSER_OVERLAYS: 10000;
 export declare const MAX_BROWSER_OVERLAY_TEXT_CHARACTERS: 65536;
 export declare const MAX_FAILURE_MESSAGE_CHARACTERS: 4096;

package/packages/runtime/dist/src/generated/runtime-contract.js

@@ -1,6 +1,10 @@
 // Generated by `cargo xtask schema`; edit Rust protocol types instead.
 export const RUNTIME_HOST_NAME = "__ONMARK_RUNTIME__";
+export const BROWSER_PROTOCOL_VERSION = 5;
 export const MAX_BROWSER_VIDEOS = 10000;
+export const MAX_BROWSER_MEDIA_LAYOUTS = 16;
+export const BROWSER_OBJECT_POSITION_SCALE = 1000000;
+export const MAX_BROWSER_TRANSITIONS = 10000;
 export const MAX_BROWSER_OVERLAYS = 10000;
 export const MAX_BROWSER_OVERLAY_TEXT_CHARACTERS = 65536;
 export const MAX_FAILURE_MESSAGE_CHARACTERS = 4096;

package/packages/runtime/dist/src/generated/validators.d.ts

@@ -4,8 +4,8 @@ declare function validate20(data: any, { instancePath, parentData, parentDataPro
     instancePath?: string | undefined;
     rootData?: any;
 }): boolean;
-export declare const validateBrowserResponse: typeof validate51;
-declare function validate51(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
+export declare const validateBrowserResponse: typeof validate55;
+declare function validate55(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
     dynamicAnchors?: {} | undefined;
     instancePath?: string | undefined;
     rootData?: any;