@onmark/cli 0.3.0 → 0.4.0

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

@@ -119,39 +119,81 @@ function projectShotStructure(source) {
     const film = findElement(document, "om-film");
     if (film === undefined) {
         return {
-            regions: Object.freeze([]),
+            shots: Object.freeze([]),
             regionStructure: Object.freeze({ scenes: Object.freeze([]) }),
         };
     }
-    const scenes = childElements(film, "om-scene").map((scene) => {
-        const shots = childElements(scene, "om-shot").map((shot) => removableElementRange(source, shot));
-        return Object.freeze({
-            range: removableElementRange(source, scene),
-            shots: Object.freeze(shots),
-        });
-    });
-    const regions = scenes.flatMap((scene, sceneIndex) => scene.shots.map((_, shotIndex) => Object.freeze({ scene: sceneIndex, shot: shotIndex })));
+    const shots = [];
+    const scenes = childElements(film, "om-scene").map((scene, sceneIndex) => projectSceneStructure(source, scene, sceneIndex, shots));
     return {
-        regions: Object.freeze(regions),
+        shots: Object.freeze(shots),
         regionStructure: Object.freeze({ scenes: Object.freeze(scenes) }),
     };
 }
-/** Materializes one shot projection without retaining every projected document. */
-export function projectShotDocument(html, region) {
-    const selectedScene = html.regionStructure.scenes[region.scene];
-    const selectedShot = selectedScene?.shots[region.shot];
-    if (selectedScene === undefined || selectedShot === undefined) {
-        throw new AuthoredHtmlError("browser projection selects an unknown shot");
+function projectSceneStructure(source, scene, sceneIndex, documentShots) {
+    const shots = [];
+    const transitions = [];
+    let outgoingShot;
+    let pendingTransition;
+    for (const element of directElements(scene)) {
+        if (element.tagName === "om-transition") {
+            if (outgoingShot === undefined || pendingTransition !== undefined) {
+                throw transitionProjectionError();
+            }
+            pendingTransition = removableElementRange(source, element);
+            continue;
+        }
+        if (element.tagName !== "om-shot") {
+            continue;
+        }
+        const index = documentShots.length;
+        const shot = Object.freeze({ scene: sceneIndex, shot: shots.length });
+        documentShots.push(shot);
+        shots.push(Object.freeze({
+            index,
+            range: removableElementRange(source, element),
+        }));
+        if (pendingTransition !== undefined && outgoingShot !== undefined) {
+            transitions.push(Object.freeze({
+                incomingShot: index,
+                outgoingShot,
+                range: pendingTransition,
+            }));
+            pendingTransition = undefined;
+        }
+        outgoingShot = index;
     }
+    if (pendingTransition !== undefined) {
+        throw transitionProjectionError();
+    }
+    return Object.freeze({
+        range: removableElementRange(source, scene),
+        shots: Object.freeze(shots),
+        transitions: Object.freeze(transitions),
+    });
+}
+function transitionProjectionError() {
+    return new AuthoredHtmlError("compiled transition boundaries cannot be projected into browser regions");
+}
+/** Materializes one Rust-planned region without retaining every projection. */
+export function projectRegionDocument(html, shotIndices) {
+    const selectedShots = selectedShotSet(html, shotIndices);
     const ranges = [];
-    for (const [sceneIndex, scene] of html.regionStructure.scenes.entries()) {
-        if (sceneIndex !== region.scene) {
+    for (const scene of html.regionStructure.scenes) {
+        if (!scene.shots.some((shot) => selectedShots.has(shot.index))) {
             ranges.push(scene.range);
             continue;
         }
-        for (const [shotIndex, shot] of scene.shots.entries()) {
-            if (shotIndex !== region.shot) {
-                ranges.push(shot);
+        for (const shot of scene.shots) {
+            if (!selectedShots.has(shot.index)) {
+                ranges.push(shot.range);
+            }
+        }
+        for (const transition of scene.transitions) {
+            const retained = selectedShots.has(transition.outgoingShot) &&
+                selectedShots.has(transition.incomingShot);
+            if (!retained) {
+                ranges.push(transition.range);
             }
         }
     }
@@ -160,6 +202,16 @@ export function projectShotDocument(html, region) {
         runtimeOffset: projectOffset(html.runtimeOffset, ranges),
     });
 }
+function selectedShotSet(html, shotIndices) {
+    const selected = new Set();
+    for (const index of shotIndices) {
+        if (html.shots[index] === undefined) {
+            throw new AuthoredHtmlError(`browser projection selects unknown shot ${index}`);
+        }
+        selected.add(index);
+    }
+    return selected;
+}
 function parseDocument(source) {
     const errors = [];
     const document = parse(source, {
@@ -234,6 +286,9 @@ function findElement(node, name) {
 function childElements(parent, name) {
     return parent.childNodes.filter((child) => "tagName" in child && child.tagName === name);
 }
+function directElements(parent) {
+    return parent.childNodes.filter((child) => "tagName" in child);
+}
 function visit(node, visitor) {
     const pending = [node];
     while (pending.length > 0) {
@@ -328,9 +383,12 @@ function isCompilerOnlyAttribute(tagName, attributeName) {
         case "om-title":
             return attributeName === "cue" || attributeName === "delay";
         case "om-shot":
+        case "om-transition":
             return attributeName === "duration";
         case "video":
             return (attributeName === "delay" ||
+                attributeName === "hold-last" ||
+                attributeName === "plays" ||
                 attributeName === "speed" ||
                 attributeName === "src" ||
                 attributeName === "trim");

package/packages/bundler/dist/src/bundle_projection.d.ts

@@ -0,0 +1,9 @@
+import type { BundleProjection } from "./generated/bundle-projection.js";
+/** Invalid or unreadable projection data at the bundler process boundary. */
+export declare class BundleProjectionError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/** Reads and validates one bounded Rust-owned projection snapshot. */
+export declare function readBundleProjection(path: string): Promise<BundleProjection>;
+/** Decodes one checked projection at an in-process or file boundary. */
+export declare function decodeBundleProjection(value: unknown): BundleProjection;

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

@@ -0,0 +1,66 @@
+// Bounded reader for the Rust-owned render-region projection contract.
+// It validates process input before authored HTML is projected or published.
+import { open } from "node:fs/promises";
+import { resolve } from "node:path";
+import { validateBundleProjection } from "./generated/bundle-projection-validator.js";
+const MAX_PROJECTION_BYTES = 1024 * 1024;
+/** Invalid or unreadable projection data at the bundler process boundary. */
+export class BundleProjectionError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "BundleProjectionError";
+    }
+}
+/** Reads and validates one bounded Rust-owned projection snapshot. */
+export async function readBundleProjection(path) {
+    const absolute = resolve(path);
+    let file;
+    try {
+        file = await open(absolute, "r");
+    }
+    catch (error) {
+        throw new BundleProjectionError(`cannot open bundle projection ${absolute}`, { cause: error });
+    }
+    try {
+        const bytes = await readBoundedProjection(file);
+        const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        return decodeBundleProjection(value);
+    }
+    catch (error) {
+        if (error instanceof BundleProjectionError) {
+            throw error;
+        }
+        throw new BundleProjectionError(`cannot read bundle projection ${absolute}`, { cause: error });
+    }
+    finally {
+        await file.close();
+    }
+}
+/** Decodes one checked projection at an in-process or file boundary. */
+export function decodeBundleProjection(value) {
+    if (!validateBundleProjection(value)) {
+        throw invalidProjection();
+    }
+    return value;
+}
+async function readBoundedProjection(file) {
+    const bytes = Buffer.allocUnsafe(MAX_PROJECTION_BYTES + 1);
+    let length = 0;
+    while (length < bytes.length) {
+        const { bytesRead } = await file.read(bytes, length, bytes.length - length, length);
+        if (bytesRead === 0) {
+            break;
+        }
+        length += bytesRead;
+    }
+    if (length > MAX_PROJECTION_BYTES) {
+        throw new BundleProjectionError(`bundle projection exceeds the ${MAX_PROJECTION_BYTES}-byte limit`);
+    }
+    return bytes.subarray(0, length);
+}
+function invalidProjection() {
+    const error = validateBundleProjection.errors?.[0];
+    const path = error?.instancePath ?? "";
+    const detail = error?.message ?? "does not match its schema";
+    return new BundleProjectionError(`bundle projection${path} ${detail}`.trim());
+}

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

@@ -3,11 +3,13 @@
 import process from "node:process";
 import { parseArgs } from "node:util";
 import { BundleError, bundlePresentation, } from "./presentation.js";
+import { BundleProjectionError, readBundleProjection, } from "./bundle_projection.js";
 import { BUNDLE_FRAME_BEHAVIORS, BUNDLE_TEMPORAL_CAPABILITIES, BUNDLE_VISUAL_CAPABILITIES, } from "./generated/bundle-manifest.js";
 const USAGE = [
     "Usage: onmark-bundle",
     "  --html <path>",
     "  [--resolve-directory <directory>]",
+    "  [--projection <path>  # required for randomAccess]",
     "  --output <directory>",
     "  --max-output-bytes <bytes>",
     "  --frame-behavior <perFrame|placementBounded>",
@@ -17,7 +19,7 @@ const USAGE = [
 ].join("\n");
 // ── Execution ──
 try {
-    const command = parseArguments(process.argv.slice(2));
+    const command = await parseArguments(process.argv.slice(2));
     if (command.kind === "help") {
         process.stdout.write(USAGE);
     }
@@ -31,7 +33,7 @@ catch (error) {
     process.exitCode = failure.kind === "configuration" ? 2 : 1;
 }
 // ── Arguments ──
-function parseArguments(arguments_) {
+async function parseArguments(arguments_) {
     const values = commandValues(arguments_);
     if (values.help !== undefined) {
         if (arguments_.length !== 1) {
@@ -48,16 +50,25 @@ function parseArguments(arguments_) {
         frameBehavior,
         maxOutputBytes,
         outputDirectory,
-        temporalCapability,
         visualCapability,
     };
+    const common = {
+        ...controls,
+        document: oneValue(values.html, "--html"),
+        ...optionalResolveDirectory(values["resolve-directory"]),
+    };
+    if (temporalCapability === "sequential") {
+        rejectValue(values.projection, "--projection requires randomAccess");
+        return {
+            kind: "bundle",
+            options: { ...common, temporalCapability },
+        };
+    }
+    const projectionPath = oneValue(values.projection, "--projection");
+    const projection = await readBundleProjection(projectionPath);
     return {
         kind: "bundle",
-        options: {
-            ...controls,
-            document: oneValue(values.html, "--html"),
-            ...optionalResolveDirectory(values["resolve-directory"]),
-        },
+        options: { ...common, projection, temporalCapability },
     };
 }
 function commandValues(arguments_) {
@@ -71,6 +82,7 @@ function commandValues(arguments_) {
                 html: { type: "string", multiple: true },
                 "max-output-bytes": { type: "string", multiple: true },
                 output: { type: "string", multiple: true },
+                projection: { type: "string", multiple: true },
                 "resolve-directory": { type: "string", multiple: true },
                 "temporal-capability": { type: "string", multiple: true },
                 "visual-capability": { type: "string", multiple: true },
@@ -119,6 +131,11 @@ function oneValue(values, name) {
     }
     return value;
 }
+function rejectValue(values, message) {
+    if (values !== undefined) {
+        throw configuration(message);
+    }
+}
 function parseByteLimit(value) {
     const bytes = Number(value);
     if (!Number.isSafeInteger(bytes) || bytes <= 0) {
@@ -134,5 +151,8 @@ function commandFailure(error) {
     if (error instanceof BundleError) {
         return error;
     }
+    if (error instanceof BundleProjectionError) {
+        return configuration(error.message, error);
+    }
     return new BundleError("output", "unexpected bundler failure", error);
 }

package/packages/bundler/dist/src/generated/bundle-projection-validator.d.ts

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