@onmark/cli 0.3.0 → 0.4.0

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

@@ -0,0 +1,432 @@
+// Generated by `cargo xtask schema`; do not edit.
+"use strict";
+export const validateBundleProjection = validate20;
+const schema31 = {
+    $defs: {
+        BundleProjectionRegion: {
+            additionalProperties: false,
+            description: "Dense screenplay-order shots retained by one render region.",
+            properties: {
+                shotIndices: {
+                    items: { format: "uint32", minimum: 0, type: "integer" },
+                    maxItems: 10000,
+                    minItems: 1,
+                    type: "array",
+                },
+            },
+            required: ["shotIndices"],
+            type: "object",
+        },
+        BundleProjectionVersion: {
+            const: 1,
+            description: "Current immutable projection-plan version.",
+            format: "uint16",
+            maximum: 65535,
+            minimum: 0,
+            type: "integer",
+        },
+    },
+    $id: "https://onmark.dev/schemas/bundle-projection-v1.schema.json",
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    additionalProperties: false,
+    description: "Exact shot dependencies for every render region in output order.",
+    properties: {
+        regions: {
+            items: { $ref: "#/$defs/BundleProjectionRegion" },
+            maxItems: 10000,
+            minItems: 1,
+            type: "array",
+        },
+        version: { $ref: "#/$defs/BundleProjectionVersion" },
+    },
+    required: ["version", "regions"],
+    title: "BundleProjection",
+    type: "object",
+};
+const schema32 = {
+    additionalProperties: false,
+    description: "Dense screenplay-order shots retained by one render region.",
+    properties: {
+        shotIndices: {
+            items: { format: "uint32", minimum: 0, type: "integer" },
+            maxItems: 10000,
+            minItems: 1,
+            type: "array",
+        },
+    },
+    required: ["shotIndices"],
+    type: "object",
+};
+const schema33 = {
+    const: 1,
+    description: "Current immutable projection-plan version.",
+    format: "uint16",
+    maximum: 65535,
+    minimum: 0,
+    type: "integer",
+};
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {}, } = {}) {
+    /*# sourceURL="https://onmark.dev/schemas/bundle-projection-v1.schema.json" */ let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate20.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.version === undefined) {
+            const err0 = {
+                instancePath,
+                schemaPath: "#/required",
+                keyword: "required",
+                params: { missingProperty: "version" },
+                message: "must have required property '" + "version" + "'",
+            };
+            if (vErrors === null) {
+                vErrors = [err0];
+            }
+            else {
+                vErrors.push(err0);
+            }
+            errors++;
+        }
+        if (data.regions === undefined) {
+            const err1 = {
+                instancePath,
+                schemaPath: "#/required",
+                keyword: "required",
+                params: { missingProperty: "regions" },
+                message: "must have required property '" + "regions" + "'",
+            };
+            if (vErrors === null) {
+                vErrors = [err1];
+            }
+            else {
+                vErrors.push(err1);
+            }
+            errors++;
+        }
+        for (const key0 in data) {
+            if (!(key0 === "regions" || key0 === "version")) {
+                const err2 = {
+                    instancePath,
+                    schemaPath: "#/additionalProperties",
+                    keyword: "additionalProperties",
+                    params: { additionalProperty: key0 },
+                    message: "must NOT have additional properties",
+                };
+                if (vErrors === null) {
+                    vErrors = [err2];
+                }
+                else {
+                    vErrors.push(err2);
+                }
+                errors++;
+            }
+        }
+        if (data.regions !== undefined) {
+            let data0 = data.regions;
+            if (Array.isArray(data0)) {
+                if (data0.length > 10000) {
+                    const err3 = {
+                        instancePath: instancePath + "/regions",
+                        schemaPath: "#/properties/regions/maxItems",
+                        keyword: "maxItems",
+                        params: { limit: 10000 },
+                        message: "must NOT have more than 10000 items",
+                    };
+                    if (vErrors === null) {
+                        vErrors = [err3];
+                    }
+                    else {
+                        vErrors.push(err3);
+                    }
+                    errors++;
+                }
+                if (data0.length < 1) {
+                    const err4 = {
+                        instancePath: instancePath + "/regions",
+                        schemaPath: "#/properties/regions/minItems",
+                        keyword: "minItems",
+                        params: { limit: 1 },
+                        message: "must NOT have fewer than 1 items",
+                    };
+                    if (vErrors === null) {
+                        vErrors = [err4];
+                    }
+                    else {
+                        vErrors.push(err4);
+                    }
+                    errors++;
+                }
+                const len0 = data0.length;
+                for (let i0 = 0; i0 < len0; i0++) {
+                    let data1 = data0[i0];
+                    if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                        if (data1.shotIndices === undefined) {
+                            const err5 = {
+                                instancePath: instancePath + "/regions/" + i0,
+                                schemaPath: "#/$defs/BundleProjectionRegion/required",
+                                keyword: "required",
+                                params: { missingProperty: "shotIndices" },
+                                message: "must have required property '" + "shotIndices" + "'",
+                            };
+                            if (vErrors === null) {
+                                vErrors = [err5];
+                            }
+                            else {
+                                vErrors.push(err5);
+                            }
+                            errors++;
+                        }
+                        for (const key1 in data1) {
+                            if (!(key1 === "shotIndices")) {
+                                const err6 = {
+                                    instancePath: instancePath + "/regions/" + i0,
+                                    schemaPath: "#/$defs/BundleProjectionRegion/additionalProperties",
+                                    keyword: "additionalProperties",
+                                    params: { additionalProperty: key1 },
+                                    message: "must NOT have additional properties",
+                                };
+                                if (vErrors === null) {
+                                    vErrors = [err6];
+                                }
+                                else {
+                                    vErrors.push(err6);
+                                }
+                                errors++;
+                            }
+                        }
+                        if (data1.shotIndices !== undefined) {
+                            let data2 = data1.shotIndices;
+                            if (Array.isArray(data2)) {
+                                if (data2.length > 10000) {
+                                    const err7 = {
+                                        instancePath: instancePath + "/regions/" + i0 + "/shotIndices",
+                                        schemaPath: "#/$defs/BundleProjectionRegion/properties/shotIndices/maxItems",
+                                        keyword: "maxItems",
+                                        params: { limit: 10000 },
+                                        message: "must NOT have more than 10000 items",
+                                    };
+                                    if (vErrors === null) {
+                                        vErrors = [err7];
+                                    }
+                                    else {
+                                        vErrors.push(err7);
+                                    }
+                                    errors++;
+                                }
+                                if (data2.length < 1) {
+                                    const err8 = {
+                                        instancePath: instancePath + "/regions/" + i0 + "/shotIndices",
+                                        schemaPath: "#/$defs/BundleProjectionRegion/properties/shotIndices/minItems",
+                                        keyword: "minItems",
+                                        params: { limit: 1 },
+                                        message: "must NOT have fewer than 1 items",
+                                    };
+                                    if (vErrors === null) {
+                                        vErrors = [err8];
+                                    }
+                                    else {
+                                        vErrors.push(err8);
+                                    }
+                                    errors++;
+                                }
+                                const len1 = data2.length;
+                                for (let i1 = 0; i1 < len1; i1++) {
+                                    let data3 = data2[i1];
+                                    if (!(typeof data3 == "number" &&
+                                        !(data3 % 1) &&
+                                        !isNaN(data3) &&
+                                        isFinite(data3))) {
+                                        const err9 = {
+                                            instancePath: instancePath + "/regions/" + i0 + "/shotIndices/" + i1,
+                                            schemaPath: "#/$defs/BundleProjectionRegion/properties/shotIndices/items/type",
+                                            keyword: "type",
+                                            params: { type: "integer" },
+                                            message: "must be integer",
+                                        };
+                                        if (vErrors === null) {
+                                            vErrors = [err9];
+                                        }
+                                        else {
+                                            vErrors.push(err9);
+                                        }
+                                        errors++;
+                                    }
+                                    if (typeof data3 == "number" && isFinite(data3)) {
+                                        if (data3 < 0 || isNaN(data3)) {
+                                            const err10 = {
+                                                instancePath: instancePath +
+                                                    "/regions/" +
+                                                    i0 +
+                                                    "/shotIndices/" +
+                                                    i1,
+                                                schemaPath: "#/$defs/BundleProjectionRegion/properties/shotIndices/items/minimum",
+                                                keyword: "minimum",
+                                                params: { comparison: ">=", limit: 0 },
+                                                message: "must be >= 0",
+                                            };
+                                            if (vErrors === null) {
+                                                vErrors = [err10];
+                                            }
+                                            else {
+                                                vErrors.push(err10);
+                                            }
+                                            errors++;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                const err11 = {
+                                    instancePath: instancePath + "/regions/" + i0 + "/shotIndices",
+                                    schemaPath: "#/$defs/BundleProjectionRegion/properties/shotIndices/type",
+                                    keyword: "type",
+                                    params: { type: "array" },
+                                    message: "must be array",
+                                };
+                                if (vErrors === null) {
+                                    vErrors = [err11];
+                                }
+                                else {
+                                    vErrors.push(err11);
+                                }
+                                errors++;
+                            }
+                        }
+                    }
+                    else {
+                        const err12 = {
+                            instancePath: instancePath + "/regions/" + i0,
+                            schemaPath: "#/$defs/BundleProjectionRegion/type",
+                            keyword: "type",
+                            params: { type: "object" },
+                            message: "must be object",
+                        };
+                        if (vErrors === null) {
+                            vErrors = [err12];
+                        }
+                        else {
+                            vErrors.push(err12);
+                        }
+                        errors++;
+                    }
+                }
+            }
+            else {
+                const err13 = {
+                    instancePath: instancePath + "/regions",
+                    schemaPath: "#/properties/regions/type",
+                    keyword: "type",
+                    params: { type: "array" },
+                    message: "must be array",
+                };
+                if (vErrors === null) {
+                    vErrors = [err13];
+                }
+                else {
+                    vErrors.push(err13);
+                }
+                errors++;
+            }
+        }
+        if (data.version !== undefined) {
+            let data4 = data.version;
+            if (!(typeof data4 == "number" &&
+                !(data4 % 1) &&
+                !isNaN(data4) &&
+                isFinite(data4))) {
+                const err14 = {
+                    instancePath: instancePath + "/version",
+                    schemaPath: "#/$defs/BundleProjectionVersion/type",
+                    keyword: "type",
+                    params: { type: "integer" },
+                    message: "must be integer",
+                };
+                if (vErrors === null) {
+                    vErrors = [err14];
+                }
+                else {
+                    vErrors.push(err14);
+                }
+                errors++;
+            }
+            if (1 !== data4) {
+                const err15 = {
+                    instancePath: instancePath + "/version",
+                    schemaPath: "#/$defs/BundleProjectionVersion/const",
+                    keyword: "const",
+                    params: { allowedValue: 1 },
+                    message: "must be equal to constant",
+                };
+                if (vErrors === null) {
+                    vErrors = [err15];
+                }
+                else {
+                    vErrors.push(err15);
+                }
+                errors++;
+            }
+            if (typeof data4 == "number" && isFinite(data4)) {
+                if (data4 > 65535 || isNaN(data4)) {
+                    const err16 = {
+                        instancePath: instancePath + "/version",
+                        schemaPath: "#/$defs/BundleProjectionVersion/maximum",
+                        keyword: "maximum",
+                        params: { comparison: "<=", limit: 65535 },
+                        message: "must be <= 65535",
+                    };
+                    if (vErrors === null) {
+                        vErrors = [err16];
+                    }
+                    else {
+                        vErrors.push(err16);
+                    }
+                    errors++;
+                }
+                if (data4 < 0 || isNaN(data4)) {
+                    const err17 = {
+                        instancePath: instancePath + "/version",
+                        schemaPath: "#/$defs/BundleProjectionVersion/minimum",
+                        keyword: "minimum",
+                        params: { comparison: ">=", limit: 0 },
+                        message: "must be >= 0",
+                    };
+                    if (vErrors === null) {
+                        vErrors = [err17];
+                    }
+                    else {
+                        vErrors.push(err17);
+                    }
+                    errors++;
+                }
+            }
+        }
+    }
+    else {
+        const err18 = {
+            instancePath,
+            schemaPath: "#/type",
+            keyword: "type",
+            params: { type: "object" },
+            message: "must be object",
+        };
+        if (vErrors === null) {
+            vErrors = [err18];
+        }
+        else {
+            vErrors.push(err18);
+        }
+        errors++;
+    }
+    validate20.errors = vErrors;
+    return errors === 0;
+}
+validate20.evaluated = {
+    props: true,
+    dynamicProps: false,
+    dynamicItems: false,
+};

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

@@ -0,0 +1,25 @@
+/**
+ * Current immutable projection-plan version.
+ */
+export type BundleProjectionVersion = 1;
+/**
+ * Exact shot dependencies for every render region in output order.
+ */
+export interface BundleProjection {
+    /**
+     * @minItems 1
+     * @maxItems 10000
+     */
+    regions: [BundleProjectionRegion, ...BundleProjectionRegion[]];
+    version: BundleProjectionVersion;
+}
+/**
+ * Dense screenplay-order shots retained by one render region.
+ */
+export interface BundleProjectionRegion {
+    /**
+     * @minItems 1
+     * @maxItems 10000
+     */
+    shotIndices: [number, ...number[]];
+}

package/packages/bundler/dist/src/generated/bundle-projection.js

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

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

@@ -1,2 +1,2 @@
-export { BundleError, bundlePresentation, type BundleArtifact, type BundleErrorKind, type BundleFile, type BundleManifest, type BundleOptions, } from "./presentation.js";
+export { BundleError, bundlePresentation, type BundleArtifact, type BundleErrorKind, type BundleFile, type BundleManifest, type BundleOptions, type BundleProjection, } from "./presentation.js";
 export { BUNDLE_ASSET_DIRECTORY, BUNDLE_ENTRY_POINT, BUNDLE_MANIFEST_FILE, BUNDLE_REGION_DIRECTORY, BUNDLE_TEMPORAL_CAPABILITIES, BUNDLE_VERSION, } from "./generated/bundle-manifest.js";

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

@@ -1,5 +1,6 @@
-import type { PresentationFrameBehavior, PresentationTemporalCapability, PresentationVisualCapability } from "../../../runtime/dist/src/index.js";
+import type { PresentationFrameBehavior, PresentationVisualCapability } from "../../../runtime/dist/src/index.js";
 import { type BundleFile as WireBundleFile, type BundleManifest as WireBundleManifest } from "./generated/bundle-manifest.js";
+import type { BundleProjection as WireBundleProjection } from "./generated/bundle-projection.js";
 type Immutable<T> = T extends object ? {
     readonly [Key in keyof T]: Immutable<T[Key]>;
 } : T;
@@ -7,18 +8,24 @@ type Immutable<T> = T extends object ? {
 export type BundleFile = Immutable<WireBundleFile>;
 /** Immutable view of the versioned Rust-owned bundle manifest. */
 export type BundleManifest = Immutable<WireBundleManifest>;
-/** Explicit inputs for one authored HTML document. */
-export interface BundleOptions {
-    /** Authored document or a private snapshot containing its exact bytes. */
+/** Immutable view of Rust-owned render-region shot selection. */
+export type BundleProjection = Immutable<WireBundleProjection>;
+interface BundleControls {
     readonly document: string;
-    /** Base for inline-module imports when `document` is a private snapshot. */
     readonly resolveDirectory?: string;
     readonly outputDirectory: string;
     readonly maxOutputBytes: number;
-    readonly temporalCapability: PresentationTemporalCapability;
     readonly visualCapability: PresentationVisualCapability;
     readonly frameBehavior: PresentationFrameBehavior;
 }
+/** Explicit inputs for one authored HTML document. */
+export type BundleOptions = BundleControls & ({
+    readonly temporalCapability: "sequential";
+    readonly projection?: never;
+} | {
+    readonly temporalCapability: "randomAccess";
+    readonly projection: BundleProjection;
+});
 /** Published directory and its owned immutable manifest snapshot. */
 export interface BundleArtifact {
     readonly directory: string;

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,12 @@ 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 }),
+    }));
 }
-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 +101,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");
     }
@@ -120,20 +116,54 @@ function validateInput(options) {
         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 projection;
+}
+function snapshotProjection(projection) {
+    try {
+        projection = decodeBundleProjection(projection);
     }
-    return value;
+    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);
@@ -373,11 +403,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 +416,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 +441,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) {