@field/cascade 0.8.0 → 0.11.0

package/dist/contracts/definition.d.ts

@@ -1,4 +1,5 @@
 import type { CapabilityMap, CascadeAbortSignal, NodeCapabilityName, ProgressReporter } from "./capabilities.js";
+import type { BundleFieldDefinition, BundleFieldDefinitions } from "./bundle.js";
 import type { CascadeType, CoreType, JsonValue, NamespacedType, SerializableValueForType, ValueForType } from "./values.js";
 export type RuntimeEnvironment = "portable" | "browser" | "server";
 export type CapabilityForEnvironment<E extends RuntimeEnvironment> = E extends "portable" ? "assets" | "media" | "gpu" : E extends "browser" ? "assets" | "media" | "gpu" : "files" | "assets" | "media" | "python" | "shell" | "gpu";
@@ -70,6 +71,27 @@ type SelectMetadata<T extends CascadeType> = {
     readonly control: Extract<ControlFor<T>, "select">;
     readonly options?: readonly SelectOption<T>[];
 };
+/**
+ * Bundle ports name an optional `schema`, and declare fields from both ends:
+ * a producer declares what it carries (`fields: { dpi: "float" }`), a consumer
+ * the fields it reads (`fields: ["dpi"]`). A consumer that declares its fields
+ * sees only those and, in Studio, re-cooks only when one of them changed. See
+ * `bundle.ts`.
+ */
+type BundleInputMetadata<T extends CascadeType> = T extends "bundle" ? {
+    readonly schema?: string;
+    readonly fields?: readonly string[];
+} : {
+    readonly schema?: never;
+    readonly fields?: never;
+};
+type BundleOutputMetadata<T extends CascadeType> = T extends "bundle" ? {
+    readonly schema?: string;
+    readonly fields?: BundleFieldDefinitions;
+} : {
+    readonly schema?: never;
+    readonly fields?: never;
+};
 export interface TriggerInputDefinition {
     readonly kind: "trigger";
     readonly description?: string;
@@ -80,7 +102,7 @@ export type DataInputDefinition<T extends CascadeType> = {
     readonly default?: SerializableValueForType<T>;
     readonly description?: string;
     readonly variadic?: boolean;
-} & NumericMetadata<T> & AcceptMetadata<T> & SelectMetadata<T>;
+} & NumericMetadata<T> & AcceptMetadata<T> & SelectMetadata<T> & BundleInputMetadata<T>;
 export type InputDefinitionFor<E extends RuntimeEnvironment> = TriggerInputDefinition | {
     [T in DataTypeForEnvironment<E>]: DataInputDefinition<T>;
 }[DataTypeForEnvironment<E>];
@@ -88,11 +110,11 @@ export interface TriggerOutputDefinition {
     readonly kind: "trigger";
     readonly description?: string;
 }
-export interface DataOutputDefinition<T extends CascadeType> {
+export type DataOutputDefinition<T extends CascadeType> = {
     readonly kind: "data";
     readonly type: T;
     readonly description?: string;
-}
+} & BundleOutputMetadata<T>;
 export type OutputDefinitionFor<E extends RuntimeEnvironment> = TriggerOutputDefinition | {
     [T in DataTypeForEnvironment<E>]: DataOutputDefinition<T>;
 }[DataTypeForEnvironment<E>];
@@ -168,6 +190,14 @@ export interface NodeDefinitionForEnvironment<E extends RuntimeEnvironment> {
      */
     readonly container?: "subnet" | "feedback";
     readonly capabilities?: readonly CapabilityForEnvironment<E>[];
+    /**
+     * `live` marks a node that reads data from outside the graph — an archive,
+     * a CLI, a cache, body data, the filesystem or a network. `cascade export`
+     * never ships one: the author freezes it into a snapshot of chosen values or
+     * the export fails. Server nodes and nodes declaring `files`, `python` or
+     * `shell` are treated as live whether or not they say so.
+     */
+    readonly source?: "live";
     readonly label?: string;
     readonly description?: string;
     readonly icon?: string;
@@ -191,11 +221,32 @@ export interface TriggerEvent {
     }>;
 }
 type Entries<D, K extends "inputs" | "outputs" | "props"> = D extends Record<K, infer R> ? R : Record<never, never>;
-type InputValue<I> = I extends TriggerInputDefinition ? TriggerEvent | undefined : I extends DataInputDefinition<infer T> ? I extends {
+/** The value a declared bundle field holds. */
+type BundleFieldValue<F> = F extends CascadeType ? ValueForType<F> : F extends {
+    readonly type: infer T extends CascadeType;
+} ? ValueForType<T> : unknown;
+/** A bundle output's value, typed from its declared fields. Every field is
+ *  optional: a producer may leave one unset, and a consumer then reads none. */
+type BundleOutputValue<O> = O extends {
+    readonly fields: infer F extends Readonly<Record<string, BundleFieldDefinition>>;
+} ? {
+    readonly [K in keyof F]?: BundleFieldValue<F[K]>;
+} : Readonly<Record<string, unknown>>;
+/** A bundle input's value: only the declared fields, when it declares any. */
+type BundleInputValue<I> = I extends {
+    readonly fields: readonly (infer K extends string)[];
+} ? {
+    readonly [P in K]?: unknown;
+} : Readonly<Record<string, unknown>>;
+type InputValue<I> = I extends TriggerInputDefinition ? TriggerEvent | undefined : I extends DataInputDefinition<"bundle"> ? I extends {
+    readonly default: unknown;
+} ? BundleInputValue<I> : BundleInputValue<I> | undefined : I extends DataInputDefinition<infer T> ? I extends {
     readonly variadic: true;
 } ? readonly ValueForType<T>[] : "default" extends keyof I ? ValueForType<T> : ValueForType<T> | undefined : never;
 type OutputValue<O> = O extends TriggerOutputDefinition ? {
     trigger(payload?: JsonValue): void;
+} : O extends DataOutputDefinition<"bundle"> ? {
+    set(value: BundleOutputValue<O>): void;
 } : O extends DataOutputDefinition<infer T> ? {
     set(value: ValueForType<T>): void;
 } : never;
@@ -228,6 +279,18 @@ export interface NodeExecutionContext<D extends NodeDefinition> {
     readonly capabilities: DeclaredCapabilities<D>;
     readonly signal: CascadeAbortSignal;
     readonly progress: ProgressReporter;
+    /**
+     * This node's seed, derived from the graph's `seed` and the node id
+     * (`nodeSeed` in `@cascade/runtime`). Every host computes it the same way,
+     * so a seeded node draws the same thing headless and in Studio. Pass it on
+     * to anything random, including a Python stage's args.
+     */
+    readonly seed: number;
+    /**
+     * A stream of floats in [0, 1) seeded with `seed`, starting afresh at every
+     * cook. Use it instead of `Math.random`, which no host can reproduce.
+     */
+    readonly random: () => number;
 }
 export type NodeExecute<D extends NodeDefinition = NodeDefinition> = (context: NodeExecutionContext<D>) => void | Promise<void>;
 export {};

package/dist/contracts/document.d.ts

@@ -1,3 +1,4 @@
+import type { EditorDeclaration } from "./editor.js";
 import type { SerializableValue } from "./values.js";
 export interface CascadeDocumentNode {
     readonly id: string;
@@ -54,6 +55,34 @@ export interface CascadeDocument {
     readonly nodes: readonly CascadeDocumentNode[];
     readonly annotations?: readonly CascadeDocumentAnnotation[];
     readonly connections?: readonly CascadeDocumentConnection[];
+    /** The shareable editor this graph declares; ignored by the runtime. See `editor.ts`. */
+    readonly editor?: EditorDeclaration;
+    /**
+     * The graph seed, an unsigned 32-bit integer; 0 when absent. Each node's
+     * `context.seed` is derived from it and the node id, so changing it
+     * reshuffles every seeded node at once.
+     */
+    readonly seed?: number;
+    /** The timeline the graph is played and rendered over. See `TimelineSettings`. */
+    readonly timeline?: TimelineSettings;
+}
+/**
+ * The frame rate, range and looping a graph is made for, saved with it.
+ *
+ * Without it every graph opened at 30 fps and frames 1-250, and a piece made
+ * for 24 fps over 594 frames (cloud-wall's H1 flipbook) had to be set up by
+ * hand on every open. Studio's timeline reads and writes it, the runtime takes
+ * its `fps` as the graph's own rate, and `cascade run --frames timeline`
+ * renders `start`-`end`. Every field is optional; absent ones keep the
+ * defaults (30 fps, 1-250, looping).
+ */
+export interface TimelineSettings {
+    readonly fps?: number;
+    /** First frame, inclusive. */
+    readonly start?: number;
+    /** Last frame, inclusive. */
+    readonly end?: number;
+    readonly loop?: boolean;
 }
 export interface CascadePreset {
     readonly version: 1;

package/dist/contracts/documentFormat.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compact-array JSON formatting for .cascade files — ported unchanged
+ * from the original routes/projects.ts (real design work: keeps small
+ * arrays like [x, y] coordinates and [from, to] connections on one line
+ * instead of exploding them across many, so a saved graph stays readable
+ * and diffable in git — which matters now that every save is a commit.
+ *
+ * The one copy: Studio's save and download (src/utils/fileSystem.ts), the
+ * server's graph route and the CLI's graph edits all write through it, so a
+ * file saved by any of them diffs cleanly against the others.
+ */
+/**
+ * Format JSON string with compact arrays (keeps small arrays on single lines)
+ * This function finds multi-line arrays with 2-4 elements and compacts them
+ * Handles both numeric arrays and arrays containing small arrays (like connections)
+ */
+export declare function formatCompactJSON(jsonString: string, indent?: number): string;
+//# sourceMappingURL=documentFormat.d.ts.map

package/dist/contracts/documentFormat.js

@@ -0,0 +1,195 @@
+/**
+ * Compact-array JSON formatting for .cascade files — ported unchanged
+ * from the original routes/projects.ts (real design work: keeps small
+ * arrays like [x, y] coordinates and [from, to] connections on one line
+ * instead of exploding them across many, so a saved graph stays readable
+ * and diffable in git — which matters now that every save is a commit.
+ *
+ * The one copy: Studio's save and download (src/utils/fileSystem.ts), the
+ * server's graph route and the CLI's graph edits all write through it, so a
+ * file saved by any of them diffs cleanly against the others.
+ */
+/**
+ * Format JSON string with compact arrays (keeps small arrays on single lines)
+ * This function finds multi-line arrays with 2-4 elements and compacts them
+ * Handles both numeric arrays and arrays containing small arrays (like connections)
+ */
+export function formatCompactJSON(jsonString, indent = 2) {
+    // Process multiple passes to handle nested arrays
+    let result = jsonString;
+    let previousResult = '';
+    // Keep processing until no more changes (handles nested arrays)
+    while (result !== previousResult) {
+        previousResult = result;
+        result = formatCompactJSONPass(result, indent);
+    }
+    return result;
+}
+/**
+ * Single pass of compact formatting
+ */
+function formatCompactJSONPass(jsonString, indent = 2) {
+    const lines = jsonString.split('\n');
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Check if this line starts an array (pattern: "key": [ or just [)
+        if (trimmed.endsWith('[') && (trimmed.includes(':') || trimmed === '[')) {
+            // Collect lines until we find the closing bracket
+            let arrayLines = [line];
+            let bracketDepth = 1;
+            let j = i + 1;
+            while (j < lines.length && bracketDepth > 0) {
+                const currentLine = lines[j];
+                arrayLines.push(currentLine);
+                // Count bracket depth
+                for (const char of currentLine) {
+                    if (char === '[')
+                        bracketDepth++;
+                    if (char === ']')
+                        bracketDepth--;
+                }
+                j++;
+            }
+            // Extract array content (lines between opening and closing brackets)
+            // Handle nested arrays by extracting complete array elements
+            const arrayContent = [];
+            let k = 1;
+            while (k < arrayLines.length - 1) {
+                const currentLine = arrayLines[k].trim();
+                // Check if this line starts a nested array
+                if (currentLine.endsWith('[') || (currentLine.startsWith('[') && !currentLine.endsWith(']'))) {
+                    // Extract the complete nested array
+                    let nestedArrayLines = [arrayLines[k]];
+                    let nestedDepth = 1;
+                    let m = k + 1;
+                    while (m < arrayLines.length - 1 && nestedDepth > 0) {
+                        nestedArrayLines.push(arrayLines[m]);
+                        for (const char of arrayLines[m]) {
+                            if (char === '[')
+                                nestedDepth++;
+                            if (char === ']')
+                                nestedDepth--;
+                        }
+                        m++;
+                    }
+                    // Join nested array lines into a single compact representation
+                    const nestedContent = [];
+                    for (let n = 1; n < nestedArrayLines.length - 1; n++) {
+                        const nestedLine = nestedArrayLines[n].trim().replace(/,$/, '').trim();
+                        if (nestedLine) {
+                            nestedContent.push(nestedLine);
+                        }
+                    }
+                    // Create compact nested array string
+                    const nestedArray = '[' + nestedContent.map(c => c.trim()).join(', ') + ']';
+                    arrayContent.push(nestedArray);
+                    k = m;
+                }
+                else {
+                    // Simple element
+                    const content = currentLine.replace(/,$/, '').trim();
+                    if (content) {
+                        arrayContent.push(content);
+                    }
+                    k++;
+                }
+            }
+            // Check if it's a small numeric array (2-4 elements)
+            const isSmallNumericArray = arrayContent.length >= 2 &&
+                arrayContent.length <= 4 &&
+                arrayContent.every(item => {
+                    const trimmed = item.trim();
+                    return /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(trimmed);
+                });
+            // Check if it's an array containing small arrays (like connections: [[a, b], [c, d]])
+            // Look for patterns where each element is a small array (2-4 elements)
+            // This handles both already-compacted arrays and multi-line nested arrays
+            let isArrayOfSmallArrays = false;
+            if (arrayContent.length >= 2 && arrayContent.length <= 20) { // Reasonable limit for connections
+                // Check if elements are arrays (either compact or multi-line)
+                const allAreArrays = arrayContent.every(item => {
+                    const trimmed = item.trim();
+                    // Already compact array like [a, b] or ["a", 0]
+                    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                        const inner = trimmed.slice(1, -1).trim();
+                        const parts = inner.split(',').map(p => p.trim()).filter(p => p);
+                        return parts.length >= 2 && parts.length <= 4;
+                    }
+                    // Multi-line array - check if this line starts an array
+                    if (trimmed.endsWith('[')) {
+                        return true; // This will be handled in a later pass
+                    }
+                    return false;
+                });
+                if (allAreArrays) {
+                    // Check if inner arrays are small (2-4 elements each)
+                    // For multi-line arrays, we'll need to extract their content
+                    let allSmall = true;
+                    for (const item of arrayContent) {
+                        const trimmed = item.trim();
+                        if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                            // Already compact - check size
+                            const inner = trimmed.slice(1, -1).trim();
+                            const parts = inner.split(',').map(p => p.trim()).filter(p => p);
+                            if (parts.length < 2 || parts.length > 4) {
+                                allSmall = false;
+                                break;
+                            }
+                        }
+                        else if (trimmed.endsWith('[')) {
+                            // Multi-line array - will be compacted in next pass, assume it's small for now
+                            // We'll handle this in the multi-pass approach
+                        }
+                        else {
+                            allSmall = false;
+                            break;
+                        }
+                    }
+                    isArrayOfSmallArrays = allSmall;
+                }
+            }
+            if (isSmallNumericArray || isArrayOfSmallArrays) {
+                // Compact format: put entire array on one line
+                const indentLevel = (line.match(/^(\s*)/)?.[1] || '').length;
+                // Extract the key part (everything before the opening bracket)
+                const keyMatch = trimmed.match(/^(.+?)\s*\[\s*$/);
+                const keyPart = keyMatch ? keyMatch[1] : '';
+                // Check if the closing bracket line has a comma (last line in arrayLines)
+                const closingLine = arrayLines[arrayLines.length - 1];
+                const hasComma = closingLine.trim().endsWith(',');
+                // Format array content
+                let formattedContent;
+                if (isArrayOfSmallArrays) {
+                    // For arrays of arrays, each element should be compact
+                    // If an element is a multi-line array (ends with [), we can't compact it yet
+                    // Otherwise, use the already-compact form
+                    formattedContent = arrayContent.map(c => {
+                        const trimmed = c.trim();
+                        // If it's already compact, use it as-is
+                        if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                            return trimmed;
+                        }
+                        // If it's a multi-line array start, we'll need another pass
+                        // For now, return as-is (will be handled in next pass)
+                        return trimmed;
+                    }).join(', ');
+                }
+                else {
+                    // Simple numeric array
+                    formattedContent = arrayContent.map(c => c.trim()).join(', ');
+                }
+                const compactArray = keyPart + ' [' + formattedContent + ']' + (hasComma ? ',' : '');
+                result.push(' '.repeat(indentLevel) + compactArray);
+                i = j; // Skip the processed lines
+                continue;
+            }
+        }
+        result.push(line);
+        i++;
+    }
+    return result.join('\n');
+}
+//# sourceMappingURL=documentFormat.js.map

package/dist/contracts/editor.d.ts

@@ -0,0 +1,189 @@
+import type { SelectOption } from "./definition.js";
+import type { JsonValue } from "./values.js";
+/**
+ * The shareable editor a graph declares: which parameters someone else may
+ * change, which outputs they may export, the presets they may start from, and
+ * the assets that are allowed to leave the project with it.
+ *
+ * It sits beside `nodes` in the document, like Houdini's parameter interface on
+ * a digital asset sits beside its network. The runtime ignores it: a published
+ * parameter is an ordinary prop with a label, so a headless render, Studio and
+ * the exported editor cook the same graph. Only `cascade export`, the editor
+ * shell and scene files read it.
+ *
+ * Everything here is an allowlist. A parameter, output or asset that is not
+ * named does not reach the exported site, and a scene file carries values for
+ * named parameters only. That is the boundary a share relies on: an export is
+ * the selected subgraph plus the selected assets, never the project.
+ */
+export interface EditorDeclaration {
+    /** Stable identity of the editor, written into every scene. `cloud-type`. */
+    readonly id: string;
+    readonly title?: string;
+    readonly description?: string;
+    /** Group names in display order. Groups not listed follow, in first-use order. */
+    readonly groups?: readonly string[];
+    readonly parameters?: readonly PublishedParameter[];
+    readonly outputs?: readonly PublishedOutput[];
+    readonly presets?: readonly EditorPreset[];
+    /**
+     * Project-relative files the author selects to ship. Literal asset values of
+     * published parameters are included too; nothing else is. A path inside a
+     * `licensed/` directory, a hidden file, or a gitignored file is refused.
+     */
+    readonly assets?: readonly string[];
+    /**
+     * Data-source nodes replaced by a snapshot of chosen values. A live source
+     * (server, files, Python, shell or a `source: "live"` definition) still wired
+     * into the exported subgraph fails the export.
+     */
+    readonly freeze?: readonly FrozenSource[];
+    /** Optional project panel module that extends or replaces the generated UI. */
+    readonly panel?: EditorPanelDeclaration;
+    /** The read-only stage view. On unless the author turns it off. */
+    readonly inspect?: boolean;
+    /**
+     * Fonts the exported editor ships and loads, in the page and in the engine
+     * worker, so a panel or a canvas that names the family draws with it rather
+     * than the system fallback. Open-licensed only: each one states its licence
+     * (`OFL-1.1`), and a file under `licensed/` is refused like any other asset.
+     */
+    readonly fonts?: readonly EditorFont[];
+    /**
+     * Parameter ids a phone keeps in reach at the bottom sheet's lowest snap
+     * point (the text, a Reroll). Defaults to the first text and seed parameters.
+     */
+    readonly peek?: readonly string[];
+    /**
+     * Values cooked while a slider is being dragged on a phone, for a quicker
+     * preview: a lower density, say. They never enter a scene or an export, and
+     * the real values cook again on release.
+     */
+    readonly draft?: Readonly<Record<string, JsonValue>>;
+}
+export interface EditorFont {
+    /** The CSS family name the project's code uses (`DM Mono`). */
+    readonly family: string;
+    /** Project-relative font file: `.woff2`, `.woff`, `.ttf` or `.otf`. */
+    readonly file: string;
+    /** SIL Open Font License. Anything else is refused at export. */
+    readonly license: "OFL-1.1";
+    readonly weight?: string | number;
+    readonly style?: "normal" | "italic";
+}
+export type PublishedControl = "number" | "slider" | "int" | "bool" | "select" | "text" | "textarea" | "color" | "file" | "seed" | "vec2";
+export interface PublishedParameter {
+    /** Scene key. Stable across renames of the node or the prop it targets. */
+    readonly id: string;
+    /** The node and prop whose value this parameter sets. */
+    readonly node: string;
+    readonly prop: string;
+    readonly label?: string;
+    readonly group?: string;
+    readonly order?: number;
+    readonly help?: string;
+    readonly unit?: string;
+    /** Overrides the control the prop's type implies. */
+    readonly control?: PublishedControl;
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly options?: readonly SelectOption<"string">[] | readonly SelectOption<"float">[];
+    /** File parameters: accepted extensions or media types (`.otf`, `image/*`). */
+    readonly accept?: readonly string[];
+    /**
+     * File parameters: whether a dropped file may travel inside a scene.
+     * `never` keeps it to a name and a hash (licensed fonts); `auto` embeds files
+     * up to 2 MB. Dropped files never leave the viewer's browser otherwise.
+     */
+    readonly embed?: "never" | "auto";
+    /** Shown only when other parameters have these values; a list must all hold. */
+    readonly visibleWhen?: VisibleWhen | readonly VisibleWhen[];
+}
+export type VisibleWhen = Readonly<{
+    param: string;
+    equals?: JsonValue;
+    in?: readonly JsonValue[];
+    not?: readonly JsonValue[];
+}>;
+export type PublishedOutputFormat = "png" | "svg" | "json" | "text";
+export interface PublishedOutput {
+    readonly id: string;
+    readonly node: string;
+    readonly port: string;
+    readonly label?: string;
+    readonly format: PublishedOutputFormat;
+    /** Download name; `{id}` and `{scene}` are replaced. */
+    readonly filename?: string;
+    /** Published parameter ids shown beside this output's button (dpi, ground). */
+    readonly parameters?: readonly string[];
+    /** The output shown in the viewer. One output should set it. */
+    readonly view?: boolean;
+}
+export interface EditorPreset {
+    readonly id: string;
+    readonly label: string;
+    /** Published parameter id to value. Missing parameters take their defaults. */
+    readonly values: Readonly<Record<string, JsonValue>>;
+    /** Parameters the preset leaves as they are (colour, pen) instead of resetting them. */
+    readonly keep?: readonly string[];
+}
+export interface FrozenSource {
+    /** The live node the snapshot replaces. Everything upstream of it is dropped. */
+    readonly node: string;
+    readonly output: string;
+    /** Project-relative snapshot written by `cascade freeze`. */
+    readonly snapshot: string;
+}
+export interface EditorPanelDeclaration {
+    /** Project-relative module exporting `mount(target, api)`. */
+    readonly module: string;
+    /** `extend` (default) mounts it above the generated parameters. */
+    readonly placement?: "extend" | "replace";
+}
+/** What `cascade freeze` writes: exactly the chosen values, nothing else. */
+export interface FrozenSnapshot {
+    readonly format: "cascade.frozen";
+    readonly version: 1;
+    readonly node: string;
+    readonly output: string;
+    readonly fields: readonly string[];
+    /** Fields the author marked as personal, flagged in every export plan. */
+    readonly personal?: readonly string[];
+    readonly value: JsonValue;
+    /** Project-relative files the value refers to, copied beside the snapshot. */
+    readonly files?: readonly string[];
+    readonly frozenAt: string;
+}
+/**
+ * A scene: what someone changed in an editor, as a file that opens onto the
+ * same graph in Studio, the CLI or the exported editor.
+ *
+ * It holds published parameter values and the files the person dropped, and
+ * nothing from the project. Version mismatches degrade: unknown parameters are
+ * ignored with a warning, missing ones take the graph's defaults.
+ */
+export interface CascadeScene {
+    readonly format: "cascade.scene";
+    readonly version: 1;
+    readonly graph: Readonly<{
+        id: string;
+        version: string;
+    }>;
+    readonly name?: string;
+    readonly values: Readonly<Record<string, JsonValue>>;
+    /** Files for `file` parameters, by parameter id. */
+    readonly files?: Readonly<Record<string, SceneFile>>;
+    readonly savedAt?: string;
+}
+export interface SceneFile {
+    readonly name: string;
+    readonly mediaType?: string;
+    readonly size: number;
+    /** Hex SHA-256 of the bytes, to match a file the receiver already has. */
+    readonly sha256: string;
+    /** Base64 bytes, present only when the parameter allows embedding. */
+    readonly data?: string;
+}
+export declare const SCENE_EMBED_LIMIT: number;
+//# sourceMappingURL=editor.d.ts.map

package/dist/contracts/editor.js

@@ -0,0 +1,2 @@
+export const SCENE_EMBED_LIMIT = 2 * 1024 * 1024;
+//# sourceMappingURL=editor.js.map

package/dist/contracts/index.d.ts

@@ -1,9 +1,12 @@
 export * from "./animation.js";
+export * from "./bundle.js";
 export * from "./camera.js";
 export * from "./capabilities.js";
 export * from "./color.js";
 export * from "./definition.js";
 export * from "./document.js";
+export * from "./documentFormat.js";
+export * from "./editor.js";
 export * from "./geometry.js";
 export * from "./particles.js";
 export * from "./scene.js";

package/dist/contracts/index.js

@@ -1,9 +1,12 @@
 export * from "./animation.js";
+export * from "./bundle.js";
 export * from "./camera.js";
 export * from "./capabilities.js";
 export * from "./color.js";
 export * from "./definition.js";
 export * from "./document.js";
+export * from "./documentFormat.js";
+export * from "./editor.js";
 export * from "./geometry.js";
 export * from "./particles.js";
 export * from "./scene.js";