@onmark/cli 0.1.3

package/packages/launcher/dist/src/release.js

@@ -0,0 +1,49 @@
+// Desktop release metadata is the single source for supported platform artifacts.
+import { Browser, BrowserPlatform } from "@puppeteer/browsers";
+import manifest from "../desktop-release.json" with { type: "json" };
+export const BROWSER_BUILD = manifest.browserBuild;
+export class UnsupportedReleaseTargetError extends Error {
+    constructor(host) {
+        super(`Onmark has no release artifact for ${host.platform}-${host.arch}`);
+        this.name = "UnsupportedReleaseTargetError";
+    }
+}
+export function desktopTarget(host) {
+    const name = releaseTarget(host);
+    const value = manifest.targets[name];
+    return Object.freeze({
+        browser: browser(value.browser),
+        browserPlatform: browserPlatform(value.browserPlatform),
+        packageName: `@onmark/cli-${name}`,
+        sha256: value.sha256,
+    });
+}
+function releaseTarget(host) {
+    const target = `${host.platform}-${host.arch}`;
+    if (target in manifest.targets) {
+        return target;
+    }
+    throw new UnsupportedReleaseTargetError(host);
+}
+function browser(value) {
+    switch (value) {
+        case Browser.CHROME:
+            return Browser.CHROME;
+        case Browser.CHROMEHEADLESSSHELL:
+            return Browser.CHROMEHEADLESSSHELL;
+        default:
+            throw new Error(`desktop release declares unsupported browser ${value}`);
+    }
+}
+function browserPlatform(value) {
+    switch (value) {
+        case BrowserPlatform.LINUX:
+            return BrowserPlatform.LINUX;
+        case BrowserPlatform.MAC_ARM:
+            return BrowserPlatform.MAC_ARM;
+        case BrowserPlatform.WIN64:
+            return BrowserPlatform.WIN64;
+        default:
+            throw new Error(`desktop release declares unsupported browser platform ${value}`);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { gsap } from "gsap";
+import type { PresentationExtension, PresentationTargetKind } from "../../../authoring/dist/src/index.js";
+/** Local GSAP authoring facts for one semantic screenplay element. */
+export interface GsapMotionContext {
+    readonly durationSeconds: number;
+    readonly element: HTMLElement;
+    readonly timeline: ReturnType<typeof gsap.timeline>;
+}
+/** Adds local animation to one Onmark-owned paused timeline. */
+export type GsapMotionHandler = (context: GsapMotionContext) => void;
+/** Semantic handlers and optional selector handlers for local motion. */
+export type GsapMotionDefinition = Readonly<Partial<Record<PresentationTargetKind, GsapMotionHandler>> & {
+    readonly selectors?: Readonly<Record<string, GsapMotionHandler>>;
+}>;
+/** 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

@@ -0,0 +1,139 @@
+// Exact-frame GSAP integration over Onmark's vendor-neutral extension contract.
+// Authors describe local motion; this adapter owns paused playheads and cleanup.
+import { gsap } from "gsap";
+/** Creates exact-frame GSAP effects without exposing runtime lifecycle code. */
+export function gsapMotion(definition) {
+    const rules = ownRules(definition);
+    return Object.freeze({
+        bind(context) {
+            return {
+                effects: bindGsapEffects(rules, context),
+                resources: [],
+            };
+        },
+    });
+}
+// ── Element motion ──
+function bindGsapEffects(rules, context) {
+    const effects = [];
+    try {
+        for (const target of context.targets) {
+            const handlers = matchingHandlers(rules, target);
+            if (handlers.length === 0) {
+                continue;
+            }
+            effects.push(bindGsapEffect(handlers, target, context));
+        }
+    }
+    catch (error) {
+        const cleanupFailure = releaseGsapEffects(effects);
+        if (cleanupFailure !== undefined) {
+            throw new AggregateError([error, cleanupFailure], "GSAP motion binding failed and cleanup was incomplete");
+        }
+        throw error;
+    }
+    return Object.freeze(effects);
+}
+function bindGsapEffect(handlers, target, context) {
+    const durationSeconds = intervalSeconds(target, context);
+    const timeline = gsap.timeline({ paused: true });
+    try {
+        const motion = Object.freeze({
+            durationSeconds,
+            element: target.element,
+            timeline,
+        });
+        for (const handler of handlers) {
+            handler(motion);
+        }
+        requireLocalTimeline(timeline, durationSeconds, target.kind);
+        // Add the full compiler-owned domain only after author construction. A
+        // leading sentinel would move GSAP's default append position to the end.
+        const sentinel = { value: 0 };
+        timeline.to(sentinel, { duration: durationSeconds, ease: "none", value: 0 }, 0);
+    }
+    catch (error) {
+        try {
+            timeline.kill();
+        }
+        catch (cleanupFailure) {
+            throw new AggregateError([error, cleanupFailure], "GSAP motion binding failed and cleanup was incomplete");
+        }
+        throw error;
+    }
+    return {
+        apply(frame) {
+            if (frame.index < target.interval.start ||
+                frame.index >= target.interval.end) {
+                return;
+            }
+            // A fresh GSAP timeline already reports time zero, and `time(0)` is a
+            // no-op. Force rendering so a first-frame `.set()` and a repeated exact
+            // frame both restore the authored state.
+            timeline.render(localSeconds(frame, target, context), true, true);
+        },
+        dispose() {
+            timeline.kill();
+        },
+    };
+}
+function ownRules(definition) {
+    const kinds = Object.freeze({
+        film: definition.film,
+        scene: definition.scene,
+        shot: definition.shot,
+        video: definition.video,
+        title: definition.title,
+        callToAction: definition.callToAction,
+        caption: definition.caption,
+    });
+    const selectors = Object.freeze(Object.entries(definition.selectors ?? {}).map(ownSelector));
+    return Object.freeze({ kinds, selectors });
+}
+function ownSelector([selector, animate]) {
+    if (selector.trim().length === 0) {
+        throw new RangeError("GSAP motion selector cannot be blank");
+    }
+    return Object.freeze({ animate, selector });
+}
+function matchingHandlers(rules, target) {
+    const handlers = [];
+    const kind = rules.kinds[target.kind];
+    if (kind !== undefined) {
+        handlers.push(kind);
+    }
+    for (const rule of rules.selectors) {
+        if (target.element.matches(rule.selector)) {
+            handlers.push(rule.animate);
+        }
+    }
+    return handlers;
+}
+// ── Exact-frame playheads ──
+function intervalSeconds(target, context) {
+    const frames = target.interval.end - target.interval.start;
+    return (frames / context.frameRate.numerator) * context.frameRate.denominator;
+}
+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));
+    return ((localFrame / context.frameRate.numerator) * context.frameRate.denominator);
+}
+function requireLocalTimeline(timeline, durationSeconds, label) {
+    if (timeline.duration() <= durationSeconds) {
+        return;
+    }
+    throw new RangeError(`${label} motion exceeds its compiler-owned interval of ${durationSeconds} seconds`);
+}
+function releaseGsapEffects(effects) {
+    let failure;
+    for (const effect of effects.toReversed()) {
+        try {
+            effect.dispose();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+    }
+    return failure;
+}

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

@@ -0,0 +1,10 @@
+import type { WireFrameRate } from "./generated/browser-request.js";
+/** One exact frame together with its browser-facing time projection. */
+export interface RuntimeFrame {
+    /** Absolute frame identity selected by the native executor. */
+    readonly index: number;
+    /** Seconds derived from the exact rational rate for browser APIs. */
+    readonly timeSeconds: number;
+}
+/** Projects one exact frame through the Rust-owned rational frame rate. */
+export declare function runtimeFrameAt(index: number, frameRate: WireFrameRate): RuntimeFrame;

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

@@ -0,0 +1,19 @@
+// Deterministic projection from exact protocol frames to browser API time.
+// Integral frame identity remains authoritative; floating seconds are an edge value only.
+/** Projects one exact frame through the Rust-owned rational frame rate. */
+export function runtimeFrameAt(index, frameRate) {
+    safeInteger(index, "frame index", { allowZero: true });
+    safeInteger(frameRate.numerator, "frame-rate numerator");
+    safeInteger(frameRate.denominator, "frame-rate denominator");
+    // Divide before multiplying so exact wire integers are not first combined
+    // into an integer beyond JavaScript's safe range. The resulting Number is
+    // used only at browser APIs; scheduling and identity continue to use index.
+    const timeSeconds = (index / frameRate.numerator) * frameRate.denominator;
+    return Object.freeze({ index, timeSeconds });
+}
+function safeInteger(value, role, options = {}) {
+    const minimum = options.allowZero === true ? 0 : 1;
+    if (!Number.isSafeInteger(value) || value < minimum) {
+        throw new TypeError(`${role} must be a safe integer at least ${minimum}`);
+    }
+}

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

@@ -0,0 +1,143 @@
+/**
+ * Closed commands understood by the browser runtime.
+ */
+export type BrowserCommand = {
+    plan: BrowserPlan;
+    type: "load";
+} | {
+    /**
+     * Exact frame integer accepted by JavaScript without rounding.
+     */
+    evaluationStart: number;
+    type: "prepare";
+} | {
+    /**
+     * Exact frame integer accepted by JavaScript without rounding.
+     */
+    frame: number;
+    type: "seek";
+} | {
+    /**
+     * Exact frame integer accepted by JavaScript without rounding.
+     */
+    frame: number;
+    type: "confirm";
+} | {
+    type: "dispose";
+};
+/**
+ * Exact frame integer accepted by JavaScript without rounding.
+ */
+export type WireFrame = number;
+/**
+ * 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 overlay roles understood by the browser presentation.
+ */
+export type BrowserOverlayKind = "title" | "callToAction" | "caption";
+/**
+ * Correlation identity shared by one request and its response events.
+ */
+export type RequestId = number;
+/**
+ * Version of the native-to-browser message contract.
+ */
+export type ProtocolVersion = 1;
+/**
+ * One versioned command sent from the native executor to the browser.
+ */
+export interface BrowserRequest {
+    command: BrowserCommand;
+    requestId: RequestId;
+    version: ProtocolVersion;
+}
+/**
+ * Solved frame facts consumed by the runtime clock.
+ */
+export interface BrowserPlan {
+    evaluation: WireInterval;
+    film: BrowserNode;
+    frameRate: WireFrameRate;
+    output: WireInterval;
+    /**
+     * @maxItems 10000
+     */
+    overlays: BrowserOverlay[];
+    /**
+     * @maxItems 10000
+     */
+    scenes: BrowserScene[];
+    /**
+     * @maxItems 10000
+     */
+    shots: BrowserShot[];
+    timeline: WireInterval;
+    timelineVersion: 1;
+    /**
+     * @maxItems 10000
+     */
+    videos: BrowserVideo[];
+}
+/**
+ * One half-open browser frame interval.
+ */
+export interface WireInterval {
+    end: WireFrame;
+    start: WireFrame;
+}
+/**
+ * Browser-facing identity retained from one Timeline element.
+ */
+export interface BrowserNode {
+    authoredId?: string | null;
+    nodeId: BrowserNodeId;
+}
+/**
+ * Exact rational frame rate represented with browser-safe integers.
+ */
+export interface WireFrameRate {
+    denominator: number;
+    numerator: number;
+}
+/**
+ * One solved overlay placement consumed by the browser presentation.
+ */
+export interface BrowserOverlay {
+    interval: WireInterval;
+    kind: BrowserOverlayKind;
+    node: BrowserNode;
+    shotId?: BrowserNodeId | null;
+    text: string;
+}
+/**
+ * One scene container intersecting this unit, with its complete Timeline interval.
+ */
+export interface BrowserScene {
+    interval: WireInterval;
+    node: BrowserNode;
+}
+/**
+ * One shot container intersecting this unit, with its complete Timeline interval.
+ */
+export interface BrowserShot {
+    interval: WireInterval;
+    node: BrowserNode;
+    sceneId: BrowserNodeId;
+}
+/**
+ * One primary video placement consumed by the browser presentation adapter.
+ */
+export interface BrowserVideo {
+    assetId: string;
+    interval: WireInterval;
+    node: BrowserNode;
+    shotId: BrowserNodeId;
+    sourceFrameRate: WireFrameRate;
+}

package/packages/runtime/dist/src/generated/browser-request.js

@@ -0,0 +1,2 @@
+// Generated by `cargo xtask schema`; edit Rust protocol types instead.
+export {};

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

@@ -0,0 +1,58 @@
+/**
+ * Closed events emitted by the browser runtime.
+ */
+export type BrowserEvent = {
+    type: "loaded";
+} | {
+    /**
+     * Frame at which preparation completed.
+     */
+    evaluationStart: number;
+    type: "prepared";
+} | {
+    /**
+     * Exact frame represented by staged browser state.
+     */
+    frame: number;
+    type: "frameStaged";
+} | {
+    /**
+     * Exact frame confirmed by browser media state.
+     */
+    frame: number;
+    type: "frameReady";
+} | {
+    /**
+     * Stable machine-readable failure category.
+     */
+    code: "protocolMismatch" | "invalidRequest" | "loadFailed" | "prepareFailed" | "seekFailed" | "confirmFailed" | "readinessTimeout" | "internal";
+    /**
+     * Direct explanation in browser/runtime terms.
+     */
+    message: string;
+    /**
+     * Resources that prevented readiness, in caller-owned deterministic order.
+     *
+     * @maxItems 256
+     */
+    pendingResources: string[];
+    type: "failed";
+} | {
+    type: "disposed";
+};
+/**
+ * Correlation identity shared by one request and its response events.
+ */
+export type RequestId = number;
+/**
+ * Version of the native-to-browser message contract.
+ */
+export type ProtocolVersion = 1;
+/**
+ * One versioned event returned by the browser runtime.
+ */
+export interface BrowserResponse {
+    event: BrowserEvent;
+    requestId: RequestId;
+    version: ProtocolVersion;
+}

package/packages/runtime/dist/src/generated/browser-response.js

@@ -0,0 +1,2 @@
+// Generated by `cargo xtask schema`; edit Rust protocol types instead.
+export {};

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

@@ -0,0 +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 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

@@ -0,0 +1,14 @@
+// Generated by `cargo xtask schema`; edit Rust protocol types instead.
+export const BUNDLE_ASSET_DIRECTORY = "assets/sha256";
+export const PRESENTATION_TEMPORAL_CAPABILITIES = Object.freeze([
+    "sequential",
+    "randomAccess",
+]);
+export const PRESENTATION_VISUAL_CAPABILITIES = Object.freeze([
+    "browserComposite",
+    "separableOverlay",
+]);
+export const PRESENTATION_FRAME_BEHAVIORS = Object.freeze([
+    "perFrame",
+    "placementBounded",
+]);

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

@@ -0,0 +1,8 @@
+import type { BrowserRequest } from "./browser-request.js";
+import type { BrowserResponse } from "./browser-response.js";
+export declare class ProtocolDecodeError extends Error {
+    readonly issues: readonly string[];
+    constructor(message: string, issues: readonly string[]);
+}
+export declare function decodeBrowserRequest(value: unknown): BrowserRequest;
+export declare function decodeBrowserResponse(value: unknown): BrowserResponse;

package/packages/runtime/dist/src/generated/codec.js

@@ -0,0 +1,22 @@
+import { validateBrowserRequest, validateBrowserResponse, } from "./validators.js";
+export class ProtocolDecodeError extends Error {
+    issues;
+    constructor(message, issues) {
+        super(message);
+        this.name = "ProtocolDecodeError";
+        this.issues = issues;
+    }
+}
+export function decodeBrowserRequest(value) {
+    return decode(value, validateBrowserRequest, "browser request");
+}
+export function decodeBrowserResponse(value) {
+    return decode(value, validateBrowserResponse, "browser response");
+}
+function decode(value, validator, role) {
+    if (validator(value)) {
+        return value;
+    }
+    const issues = (validator.errors ?? []).map((error) => `${error.instancePath || "/"}: ${error.message ?? error.keyword}`);
+    throw new ProtocolDecodeError(`invalid ${role}`, issues);
+}

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

@@ -0,0 +1,7 @@
+export declare const RUNTIME_HOST_NAME: "__ONMARK_RUNTIME__";
+export declare const MAX_BROWSER_VIDEOS: 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;
+export declare const MAX_PENDING_RESOURCES: 256;
+export declare const MAX_PENDING_RESOURCE_CHARACTERS: 1024;

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

@@ -0,0 +1,8 @@
+// Generated by `cargo xtask schema`; edit Rust protocol types instead.
+export const RUNTIME_HOST_NAME = "__ONMARK_RUNTIME__";
+export const MAX_BROWSER_VIDEOS = 10000;
+export const MAX_BROWSER_OVERLAYS = 10000;
+export const MAX_BROWSER_OVERLAY_TEXT_CHARACTERS = 65536;
+export const MAX_FAILURE_MESSAGE_CHARACTERS = 4096;
+export const MAX_PENDING_RESOURCES = 256;
+export const MAX_PENDING_RESOURCE_CHARACTERS = 1024;

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

@@ -0,0 +1,13 @@
+export declare const validateBrowserRequest: typeof validate20;
+declare function validate20(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
+    dynamicAnchors?: {} | undefined;
+    instancePath?: string | undefined;
+    rootData?: any;
+}): boolean;
+export declare const validateBrowserResponse: typeof validate47;
+declare function validate47(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
+    dynamicAnchors?: {} | undefined;
+    instancePath?: string | undefined;
+    rootData?: any;
+}): boolean;
+export {};