@onmark/cli 0.3.0 → 0.5.0

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

@@ -25,11 +25,10 @@ export type BundleVersion = 1;
 /**
  * Proven relationship between browser presentation pixels and primary media.
  *
- * Unknown presentation code requires `BrowserComposite`. A separable overlay
- * is an explicit claim that the browser output is a transparent foreground
- * independent of the primary video beneath it.
+ * Unknown presentation code requires `BrowserComposite`. A separable layer
+ * explicitly limits browser ownership to one side of native media.
  */
-export type PresentationVisualCapability = "browserComposite" | "separableOverlay";
+export type PresentationVisualCapability = "browserComposite" | "separableBackdrop" | "separableOverlay";
 /**
  * Stable description of one immutable presentation artifact.
  */
@@ -57,7 +56,7 @@ export interface BundleFile {
 }
 export declare const BUNDLE_VERSION: 1;
 export declare const BUNDLE_TEMPORAL_CAPABILITIES: readonly ["sequential", "randomAccess"];
-export declare const BUNDLE_VISUAL_CAPABILITIES: readonly ["browserComposite", "separableOverlay"];
+export declare const BUNDLE_VISUAL_CAPABILITIES: readonly ["browserComposite", "separableBackdrop", "separableOverlay"];
 export declare const BUNDLE_FRAME_BEHAVIORS: readonly ["perFrame", "placementBounded"];
 export declare const BUNDLE_ENTRY_POINT: "index.html";
 export declare const BUNDLE_MANIFEST_FILE: "manifest.json";

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

@@ -6,6 +6,7 @@ export const BUNDLE_TEMPORAL_CAPABILITIES = Object.freeze([
 ]);
 export const BUNDLE_VISUAL_CAPABILITIES = Object.freeze([
     "browserComposite",
+    "separableBackdrop",
     "separableOverlay",
 ]);
 export const BUNDLE_FRAME_BEHAVIORS = Object.freeze([

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 {};

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 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;