@onmark/cli 0.1.3

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

@@ -0,0 +1,150 @@
+// Bounded readiness and terminal cleanup for presentation-owned resources.
+// Resources carry browser effects only; Rust-owned plan facts remain authoritative.
+import { MAX_PENDING_RESOURCE_CHARACTERS, MAX_PENDING_RESOURCES, } from "./generated/runtime-contract.js";
+import { RuntimeAdapterError } from "./session.js";
+// ── Public contract ──
+const MAX_READINESS_TIMEOUT_MILLISECONDS = 24 * 60 * 60 * 1_000;
+const MAX_RESOURCE_ID_CHARACTERS = 256;
+export const PRESENTATION_RESOURCE_KINDS = Object.freeze([
+    "image",
+    "font",
+    "texture",
+    "custom",
+]);
+/** Maximum resources retained by one presentation adapter. */
+export const MAX_PRESENTATION_RESOURCES = MAX_PENDING_RESOURCES;
+// ── Collection lifecycle ──
+/** Takes an immutable snapshot before validation or asynchronous work begins. */
+export function ownPresentationResources(resources) {
+    return Object.freeze(resources.map(ownPresentationResource));
+}
+function ownPresentationResource(resource) {
+    return Object.freeze({
+        id: resource.id,
+        kind: resource.kind,
+        dispose: resource.dispose.bind(resource),
+        prepare: resource.prepare.bind(resource),
+    });
+}
+/** Rejects resource collections that cannot fit the runtime failure contract. */
+export function validatePresentationResources(resources) {
+    if (resources.length > MAX_PRESENTATION_RESOURCES) {
+        throw new RuntimeAdapterError("operation", "presentation resource count exceeds its limit");
+    }
+    const identities = new Set();
+    for (const resource of resources) {
+        const identity = resourceIdentity(resource);
+        if (identities.has(identity)) {
+            throw new RuntimeAdapterError("operation", "presentation resource identity is duplicated");
+        }
+        identities.add(identity);
+    }
+}
+/** Waits for every resource under one bounded, deterministic failure policy. */
+export async function preparePresentationResources(resources, timeoutMilliseconds) {
+    const outcomes = await Promise.all(resources.map((resource) => prepareResource(resource, timeoutMilliseconds)));
+    let failure;
+    const pendingResources = [];
+    for (const outcome of outcomes) {
+        if (outcome.kind === "failed") {
+            failure ??= outcome.error;
+        }
+        else if (outcome.kind === "timedOut") {
+            pendingResources.push(outcome.pendingResource);
+        }
+    }
+    if (failure !== undefined) {
+        throw withPendingResources(failure, pendingResources);
+    }
+    if (pendingResources.length > 0) {
+        throw new RuntimeAdapterError("readinessTimeout", "presentation resources did not become ready", pendingResources);
+    }
+}
+function withPendingResources(failure, pendingResources) {
+    if (pendingResources.length === 0) {
+        return failure;
+    }
+    // Collection-owned identities take precedence when a custom failure already
+    // carries its own pending details; this keeps every declared resource within
+    // the protocol's fixed collection budget.
+    return new RuntimeAdapterError(failure.kind, failure.message, pendingResources);
+}
+/** Releases all owned resources while retaining the first cleanup failure. */
+export async function releasePresentationResources(resources) {
+    let failure;
+    for (const resource of resources) {
+        try {
+            await resource.dispose();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+    }
+    return failure;
+}
+/** Validates the shared browser-readiness deadline before resources are bound. */
+export function requireReadinessTimeout(timeoutMilliseconds) {
+    if (!Number.isSafeInteger(timeoutMilliseconds) ||
+        timeoutMilliseconds <= 0 ||
+        timeoutMilliseconds > MAX_READINESS_TIMEOUT_MILLISECONDS) {
+        throw new TypeError("readiness timeout must be a positive integer no greater than one day");
+    }
+}
+// ── Individual readiness ──
+async function prepareResource(resource, timeoutMilliseconds) {
+    const pendingResource = `${resourceIdentity(resource)}:prepare`;
+    let deadline;
+    const timeout = new Promise((resolve) => {
+        deadline = setTimeout(() => resolve({ kind: "timedOut", pendingResource }), timeoutMilliseconds);
+    });
+    const preparation = observePreparation(resource, pendingResource);
+    try {
+        return await Promise.race([preparation, timeout]);
+    }
+    finally {
+        clearTimeout(deadline);
+    }
+}
+async function observePreparation(resource, pendingResource) {
+    try {
+        // Install every resource deadline before author code can run.
+        await Promise.resolve();
+        await resource.prepare();
+        return { kind: "ready" };
+    }
+    catch (error) {
+        return {
+            kind: "failed",
+            error: resourceFailure(error, pendingResource),
+        };
+    }
+}
+function resourceIdentity(resource) {
+    if (typeof resource.id !== "string") {
+        throw new RuntimeAdapterError("operation", "presentation resource id must be a string");
+    }
+    if (!PRESENTATION_RESOURCE_KINDS.includes(resource.kind)) {
+        throw new RuntimeAdapterError("operation", "presentation resource kind is invalid");
+    }
+    if (resource.id.length === 0 || resource.id !== resource.id.trim()) {
+        throw new RuntimeAdapterError("operation", "presentation resource id must be nonblank and trimmed");
+    }
+    let characters = 0;
+    for (const _character of resource.id) {
+        characters += 1;
+        if (characters > MAX_RESOURCE_ID_CHARACTERS) {
+            throw new RuntimeAdapterError("operation", "presentation resource id exceeds its character limit");
+        }
+    }
+    const identity = `${resource.kind}:${resource.id}`;
+    if ([...`${identity}:prepare`].length > MAX_PENDING_RESOURCE_CHARACTERS) {
+        throw new RuntimeAdapterError("operation", "presentation resource identity exceeds the protocol limit");
+    }
+    return identity;
+}
+function resourceFailure(error, pendingResource) {
+    if (error instanceof RuntimeAdapterError) {
+        return error;
+    }
+    return new RuntimeAdapterError("operation", `${pendingResource} failed to prepare`);
+}

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

@@ -0,0 +1,43 @@
+import type { BrowserPlan, BrowserRequest } from "./generated/browser-request.js";
+import type { BrowserResponse } from "./generated/browser-response.js";
+import { type RuntimeFrame } from "./clock.js";
+type Immutable<T> = T extends object ? {
+    readonly [Key in keyof T]: Immutable<T[Key]>;
+} : T;
+/** Immutable browser-plan view owned by one runtime session. */
+export type RuntimePlan = Immutable<BrowserPlan>;
+/**
+ * Browser-owned operations sequenced by one runtime session.
+ *
+ * Implementations bound every asynchronous wait and report expected browser
+ * failures through `RuntimeAdapterError`.
+ */
+export interface RuntimeAdapter {
+    /** Installs one owned snapshot of the immutable browser plan. */
+    load(plan: RuntimePlan): Promise<void>;
+    /** Resolves only after resources at the evaluation start are stable. */
+    prepare(frame: RuntimeFrame): Promise<void>;
+    /** Stages one exact frame and registers media presentation observers. */
+    seek(frame: RuntimeFrame): Promise<void>;
+    /** Verifies media presentation after native compositor capture. */
+    confirm(frame: RuntimeFrame): Promise<void>;
+    /** Releases all resources owned by this adapter. */
+    dispose(): Promise<void>;
+}
+export type RuntimeAdapterFailureKind = "operation" | "readinessTimeout";
+/** Expected failure reported by a browser adapter. */
+export declare class RuntimeAdapterError extends Error {
+    readonly kind: RuntimeAdapterFailureKind;
+    readonly pendingResources: readonly string[];
+    constructor(kind: RuntimeAdapterFailureKind, message: string, pendingResources?: readonly string[]);
+    /** Preserves typed failures and contains untyped browser exceptions. */
+    static fromUnknown(error: unknown, message: string): RuntimeAdapterError;
+}
+/** Sequential browser protocol session. */
+export declare class RuntimeSession {
+    #private;
+    constructor(adapter: RuntimeAdapter);
+    /** Executes one decoded request without introducing an unbounded queue. */
+    dispatch(request: BrowserRequest): Promise<BrowserResponse>;
+}
+export {};

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

@@ -0,0 +1,450 @@
+// Sequential browser protocol session.
+// Owns command ordering and state while a narrow adapter owns browser effects;
+// this split keeps protocol behavior deterministic and directly testable.
+import { decodeBrowserResponse } from "./generated/codec.js";
+import { MAX_FAILURE_MESSAGE_CHARACTERS, MAX_PENDING_RESOURCE_CHARACTERS, MAX_PENDING_RESOURCES, } from "./generated/runtime-contract.js";
+import { runtimeFrameAt } from "./clock.js";
+/** Expected failure reported by a browser adapter. */
+export class RuntimeAdapterError extends Error {
+    kind;
+    pendingResources;
+    constructor(kind, message, pendingResources = []) {
+        const failureMessage = boundedText(message, "adapter failure message", MAX_FAILURE_MESSAGE_CHARACTERS);
+        super(failureMessage);
+        this.name = "RuntimeAdapterError";
+        this.kind = kind;
+        this.pendingResources = boundedPendingResources(pendingResources);
+    }
+    /** Preserves typed failures and contains untyped browser exceptions. */
+    static fromUnknown(error, message) {
+        return error instanceof RuntimeAdapterError
+            ? error
+            : new RuntimeAdapterError("operation", message);
+    }
+}
+// ── Protocol session ──
+/** Sequential browser protocol session. */
+export class RuntimeSession {
+    #adapter;
+    #state = { kind: "empty" };
+    #busy = false;
+    constructor(adapter) {
+        this.#adapter = adapter;
+    }
+    /** Executes one decoded request without introducing an unbounded queue. */
+    async dispatch(request) {
+        if (this.#busy) {
+            return invalidRequest(request.requestId, "another browser command is still in progress");
+        }
+        this.#busy = true;
+        try {
+            return await this.#execute(request);
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+    #execute(request) {
+        switch (request.command.type) {
+            case "load":
+                return this.#load(request.requestId, request.command.plan);
+            case "prepare":
+                return this.#prepare(request.requestId, request.command.evaluationStart);
+            case "seek":
+                return this.#seek(request.requestId, request.command.frame);
+            case "confirm":
+                return this.#confirm(request.requestId, request.command.frame);
+            case "dispose":
+                return this.#dispose(request.requestId);
+        }
+    }
+    async #load(requestId, plan) {
+        if (this.#state.kind !== "empty") {
+            return invalidRequest(requestId, "load requires an empty browser session");
+        }
+        const violation = planViolation(plan);
+        if (violation !== undefined) {
+            return invalidRequest(requestId, violation);
+        }
+        const ownedPlan = snapshotPlan(plan);
+        const nextState = loadedState(ownedPlan);
+        try {
+            await this.#adapter.load(ownedPlan);
+        }
+        catch (error) {
+            // Loading may have entered author code and partially mutated its owned
+            // browser state. Only terminal disposal is safe after that boundary.
+            this.#state = { kind: "failed" };
+            return operationFailure(requestId, "loadFailed", error);
+        }
+        this.#state = nextState;
+        return response(requestId, { type: "loaded" });
+    }
+    async #prepare(requestId, evaluationStart) {
+        if (this.#state.kind !== "loaded") {
+            return invalidRequest(requestId, "prepare requires a loaded browser plan");
+        }
+        if (evaluationStart !== this.#state.evaluationStart) {
+            return invalidRequest(requestId, "prepare must use the plan evaluation start");
+        }
+        try {
+            await this.#adapter.prepare(runtimeFrameAt(evaluationStart, this.#state.frameRate));
+        }
+        catch (error) {
+            // Preparation may have started author-owned asynchronous work that the
+            // generic adapter cannot cancel. Make the session terminal so a retry
+            // cannot overlap that work with a second preparation phase.
+            this.#state = { kind: "failed" };
+            return readinessFailure(requestId, "prepareFailed", error);
+        }
+        this.#state = { ...this.#state, kind: "ready" };
+        return response(requestId, { type: "prepared", evaluationStart });
+    }
+    async #seek(requestId, frame) {
+        if (this.#state.kind !== "ready") {
+            return invalidRequest(requestId, "seek requires a prepared browser session");
+        }
+        if (frame < this.#state.evaluationStart ||
+            frame >= this.#state.evaluationEnd) {
+            return invalidRequest(requestId, "seek frame falls outside the evaluation interval");
+        }
+        try {
+            await this.#adapter.seek(runtimeFrameAt(frame, this.#state.frameRate));
+        }
+        catch (error) {
+            // A failed adapter seek may have partially changed author-owned DOM or
+            // effect state. Only terminal disposal is safe after that boundary.
+            this.#state = { kind: "failed" };
+            return readinessFailure(requestId, "seekFailed", error);
+        }
+        this.#state = { ...this.#state, kind: "staged", frame };
+        return response(requestId, { type: "frameStaged", frame });
+    }
+    async #confirm(requestId, frame) {
+        if (this.#state.kind !== "staged") {
+            return invalidRequest(requestId, "confirm requires a staged browser frame");
+        }
+        if (frame !== this.#state.frame) {
+            return invalidRequest(requestId, "confirm must use the staged frame");
+        }
+        try {
+            await this.#adapter.confirm(runtimeFrameAt(frame, this.#state.frameRate));
+        }
+        catch (error) {
+            // Confirmation consumes staged media observers and may succeed for only
+            // a prefix of videos. Retrying cannot reconstruct that transaction.
+            this.#state = { kind: "failed" };
+            return readinessFailure(requestId, "confirmFailed", error);
+        }
+        this.#state = { ...this.#state, kind: "ready" };
+        return response(requestId, { type: "frameReady", frame });
+    }
+    async #dispose(requestId) {
+        if (this.#state.kind === "disposed") {
+            return invalidRequest(requestId, "browser session is already disposed");
+        }
+        // A disposal attempt is terminal even when browser cleanup reports an
+        // error; partially released resources must never be used again.
+        this.#state = { kind: "disposed" };
+        try {
+            await this.#adapter.dispose();
+            return response(requestId, { type: "disposed" });
+        }
+        catch (error) {
+            return operationFailure(requestId, "internal", error);
+        }
+    }
+}
+function response(requestId, event) {
+    return decodeBrowserResponse({ version: 1, requestId, event });
+}
+function invalidRequest(requestId, message) {
+    return response(requestId, {
+        type: "failed",
+        code: "invalidRequest",
+        message,
+        pendingResources: [],
+    });
+}
+function operationFailure(requestId, operationCode, error) {
+    if (!(error instanceof RuntimeAdapterError)) {
+        return response(requestId, {
+            type: "failed",
+            code: "internal",
+            message: "runtime adapter threw an untyped error",
+            pendingResources: [],
+        });
+    }
+    return response(requestId, {
+        type: "failed",
+        code: operationCode,
+        message: error.message,
+        pendingResources: [...error.pendingResources],
+    });
+}
+function readinessFailure(requestId, operationCode, error) {
+    if (error instanceof RuntimeAdapterError &&
+        error.kind === "readinessTimeout") {
+        return response(requestId, {
+            type: "failed",
+            code: "readinessTimeout",
+            message: error.message,
+            pendingResources: [...error.pendingResources],
+        });
+    }
+    return operationFailure(requestId, operationCode, error);
+}
+function planViolation(plan) {
+    if (plan.timeline.start >= plan.timeline.end) {
+        return "plan timeline interval is empty or reversed";
+    }
+    if (plan.evaluation.start > plan.evaluation.end) {
+        return "plan evaluation interval is reversed";
+    }
+    if (!insideInterval(plan.evaluation, plan.timeline)) {
+        return "plan evaluation interval falls outside timeline";
+    }
+    if (plan.output.start >= plan.output.end) {
+        return "plan output interval is empty or reversed";
+    }
+    if (plan.output.start < plan.evaluation.start ||
+        plan.output.end > plan.evaluation.end) {
+        return "plan output interval falls outside evaluation";
+    }
+    if (!hasCanonicalNodeOrder(plan.scenes) ||
+        !hasCanonicalNodeOrder(plan.shots) ||
+        !hasCanonicalNodeOrder(plan.videos) ||
+        !hasCanonicalNodeOrder(plan.overlays)) {
+        return "plan node collection is not in canonical order";
+    }
+    const nodeIds = new Set();
+    const authoredIds = new Set();
+    const filmViolation = claimNode(plan.film, nodeIds, authoredIds);
+    if (filmViolation !== undefined) {
+        return filmViolation;
+    }
+    const sceneIntervals = new Map();
+    for (const scene of plan.scenes) {
+        const nodeViolation = claimNode(scene.node, nodeIds, authoredIds);
+        if (nodeViolation !== undefined) {
+            return nodeViolation;
+        }
+        if (!validPlacement(scene.interval, plan.timeline, plan.evaluation)) {
+            return "plan scene interval is invalid for this evaluation";
+        }
+        sceneIntervals.set(scene.node.nodeId, scene.interval);
+    }
+    const shotIntervals = new Map();
+    for (const shot of plan.shots) {
+        const nodeViolation = claimNode(shot.node, nodeIds, authoredIds);
+        if (nodeViolation !== undefined) {
+            return nodeViolation;
+        }
+        const sceneInterval = sceneIntervals.get(shot.sceneId);
+        if (sceneInterval === undefined) {
+            return "plan shot names an unknown scene";
+        }
+        if (!validPlacement(shot.interval, plan.timeline, plan.evaluation)) {
+            return "plan shot interval is invalid for this evaluation";
+        }
+        if (!insideInterval(shot.interval, sceneInterval)) {
+            return "plan shot interval falls outside its scene";
+        }
+        shotIntervals.set(shot.node.nodeId, shot.interval);
+    }
+    for (const video of plan.videos) {
+        const nodeViolation = claimNode(video.node, nodeIds, authoredIds);
+        if (nodeViolation !== undefined) {
+            return nodeViolation;
+        }
+        const shotInterval = shotIntervals.get(video.shotId);
+        if (shotInterval === undefined) {
+            return "plan video names an unknown shot";
+        }
+        if (!insideEvaluation(video.interval, plan.evaluation)) {
+            return "plan video interval falls outside evaluation";
+        }
+        if (!insideInterval(video.interval, shotInterval)) {
+            return "plan video interval falls outside its shot";
+        }
+    }
+    for (const overlay of plan.overlays) {
+        const nodeViolation = claimNode(overlay.node, nodeIds, authoredIds);
+        if (nodeViolation !== undefined) {
+            return nodeViolation;
+        }
+        const parentViolation = overlayParentViolation(overlay, shotIntervals);
+        if (parentViolation !== undefined) {
+            return parentViolation;
+        }
+        if (!validPlacement(overlay.interval, plan.timeline, plan.evaluation)) {
+            return "plan overlay interval is invalid for this evaluation";
+        }
+    }
+    if (!hasDenseNodeIdentity(nodeIds)) {
+        return "plan node identity is not dense";
+    }
+    return undefined;
+}
+function hasDenseNodeIdentity(identities) {
+    for (let expected = 0; expected < identities.size; expected += 1) {
+        if (!identities.has(expected)) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasCanonicalNodeOrder(entries) {
+    let previous;
+    for (const { node } of entries) {
+        if (previous !== undefined && node.nodeId <= previous) {
+            return false;
+        }
+        previous = node.nodeId;
+    }
+    return true;
+}
+function overlayParentViolation(overlay, shotIntervals) {
+    if (overlay.kind === "caption") {
+        return overlay.shotId === undefined || overlay.shotId === null
+            ? undefined
+            : "plan caption names a structural parent";
+    }
+    if (overlay.shotId === undefined || overlay.shotId === null) {
+        return "plan overlay names an unknown shot";
+    }
+    const shotInterval = shotIntervals.get(overlay.shotId);
+    if (shotInterval === undefined) {
+        return "plan overlay names an unknown shot";
+    }
+    if (!insideInterval(overlay.interval, shotInterval)) {
+        return "plan overlay interval falls outside its shot";
+    }
+    return undefined;
+}
+function insideInterval(interval, parent) {
+    return interval.start >= parent.start && interval.end <= parent.end;
+}
+function claimNode(node, identities, authoredIdentities) {
+    if (identities.has(node.nodeId)) {
+        return "plan node identity is duplicated";
+    }
+    identities.add(node.nodeId);
+    if (node.authoredId === undefined || node.authoredId === null) {
+        return undefined;
+    }
+    if (node.authoredId.length === 0 || /[\t\n\f\r ]/u.test(node.authoredId)) {
+        return "plan authored node identity is invalid";
+    }
+    if (authoredIdentities.has(node.authoredId)) {
+        return "plan authored node identity is duplicated";
+    }
+    authoredIdentities.add(node.authoredId);
+    return undefined;
+}
+function insideEvaluation(interval, evaluation) {
+    return (interval.start < interval.end &&
+        interval.start >= evaluation.start &&
+        interval.end <= evaluation.end);
+}
+function validPlacement(interval, timeline, evaluation) {
+    return (interval.start < interval.end &&
+        insideInterval(interval, timeline) &&
+        intervalsIntersect(interval, evaluation));
+}
+function intervalsIntersect(left, right) {
+    return left.start < right.end && right.start < left.end;
+}
+function snapshotPlan(plan) {
+    // Listing every generated field makes a schema addition fail compilation
+    // instead of silently falling outside the immutable adapter snapshot.
+    const frameRate = Object.freeze({ ...plan.frameRate });
+    const timeline = Object.freeze({ ...plan.timeline });
+    const evaluation = Object.freeze({ ...plan.evaluation });
+    const output = Object.freeze({ ...plan.output });
+    const film = snapshotNode(plan.film);
+    const scenes = Object.freeze(plan.scenes.map(snapshotScene));
+    const shots = Object.freeze(plan.shots.map(snapshotShot));
+    const videos = Object.freeze(plan.videos.map(snapshotVideo));
+    const overlays = Object.freeze(plan.overlays.map(snapshotOverlay));
+    return Object.freeze({
+        timelineVersion: plan.timelineVersion,
+        frameRate,
+        timeline,
+        evaluation,
+        output,
+        film,
+        scenes,
+        shots,
+        videos,
+        overlays,
+    });
+}
+function snapshotScene(scene) {
+    return Object.freeze({
+        node: snapshotNode(scene.node),
+        interval: Object.freeze({ ...scene.interval }),
+    });
+}
+function snapshotShot(shot) {
+    return Object.freeze({
+        node: snapshotNode(shot.node),
+        sceneId: shot.sceneId,
+        interval: Object.freeze({ ...shot.interval }),
+    });
+}
+function snapshotVideo(video) {
+    return Object.freeze({
+        node: snapshotNode(video.node),
+        shotId: video.shotId,
+        assetId: video.assetId,
+        interval: Object.freeze({ ...video.interval }),
+        sourceFrameRate: Object.freeze({ ...video.sourceFrameRate }),
+    });
+}
+function snapshotOverlay(overlay) {
+    return Object.freeze({
+        node: snapshotNode(overlay.node),
+        shotId: overlay.shotId ?? null,
+        kind: overlay.kind,
+        text: overlay.text,
+        interval: Object.freeze({ ...overlay.interval }),
+    });
+}
+function snapshotNode(node) {
+    return Object.freeze({
+        nodeId: node.nodeId,
+        authoredId: node.authoredId ?? null,
+    });
+}
+function loadedState(plan) {
+    return {
+        kind: "loaded",
+        evaluationStart: plan.evaluation.start,
+        evaluationEnd: plan.evaluation.end,
+        frameRate: plan.frameRate,
+    };
+}
+function boundedPendingResources(resources) {
+    if (resources.length > MAX_PENDING_RESOURCES) {
+        throw new TypeError("adapter failure has too many pending resources");
+    }
+    return resources.map((resource) => boundedText(resource, "pending resource", MAX_PENDING_RESOURCE_CHARACTERS));
+}
+function boundedText(value, role, limit) {
+    const text = nonBlank(value, role);
+    let characters = 0;
+    for (const _character of text) {
+        characters += 1;
+        if (characters > limit) {
+            throw new TypeError(`${role} exceeds the protocol character limit`);
+        }
+    }
+    return text;
+}
+function nonBlank(value, role) {
+    if (value.trim().length === 0) {
+        throw new TypeError(`${role} cannot be blank`);
+    }
+    return value;
+}

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

@@ -0,0 +1,6 @@
+export type { RuntimeFrame } from "./clock.js";
+export type { RuntimeVideo } from "./media.js";
+export type { PresentationFrameBehavior, PresentationTemporalCapability, PresentationVisualCapability, } from "./generated/bundle-layout.js";
+export type { RuntimePlan } from "./session.js";
+export type { ContainerPresentation, FrameEffect, OverlayPresentation, PresentationBindings, PresentationExtensions, RuntimeOverlay, RuntimeNode, RuntimeScene, RuntimeShot, VideoPresentation, } from "./presentation.js";
+export type { PresentationResource, PresentationResourceKind, } from "./resource.js";

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

@@ -0,0 +1,2 @@
+// Type-only public contracts consumed by higher browser product layers.
+export {};