@elaraai/east-ui 1.0.83 → 1.0.85

package/dist/src/layout/snap-grid/index.d.ts

@@ -0,0 +1,1291 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * SnapGrid — the 12-column snap grid of tiles (#989), its editing (#990),
+ * and the editing canvas's chrome (#995).
+ *
+ * `SnapGrid.Root(data, config)` lays the host's rows out as tiles in rows on a
+ * 12-column grid: the canvas under the Studio's builder, a published page, and
+ * — `variant: "wireframe"` — the page library's thumbnails. The host's
+ * collection is the source, as for the Sheet and the Plan: `cell` maps one row
+ * to its {@link SnapGridCellType}, reified once into an East function and called
+ * for every row, never spliced.
+ *
+ * Declared with `edit` and `editing`, the SnapGrid is the builder's canvas: a
+ * tile moves, resizes and drops as a draft of the shared editing session, and
+ * Apply sends every draft as one checked batch — from its history item, or
+ * when a host asks through a bound `apply` (#998).
+ *
+ * @packageDocumentation
+ */
+import { type BlockBuilder, type EastType, type ExprType, type SubtypeExprOrValue, type TypeOf, ArrayType, AsyncFunctionType, BlobType, BooleanType, DictType, FloatType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType } from "@elaraai/east";
+import { UIComponentType } from "../../component.js";
+import { DragEventType, LibraryRefType } from "../../contracts/drag.js";
+import { SnapGridAlignType, SnapGridApplyBindType, SnapGridApplyStateType, SnapGridPlaceType, SnapGridRequestType, SnapGridSurfaceType, SnapGridUiBindType, SnapGridUiStateType, SnapGridVariantType, SnapGridViewBindType, SnapGridViewStateType, SnapGridWidthType, type SnapGridAlignLiteral, type SnapGridSurfaceLiteral, type SnapGridVariantLiteral } from "./types.js";
+export { SnapGridAlignType, SnapGridApplyBindType, SnapGridApplyStateType, SnapGridPlaceType, SnapGridRequestType, SnapGridSurfaceType, SnapGridUiBindType, SnapGridUiStateType, SnapGridVariantType, SnapGridViewBindType, SnapGridViewStateType, SnapGridWidthType, type SnapGridAlignLiteral, type SnapGridSurfaceLiteral, type SnapGridVariantLiteral, } from "./types.js";
+/**
+ * One tile: its identity, where it sits, and what it shows.
+ *
+ * @remarks
+ * Rows order by their first appearance among the cells, and the cells of a
+ * row by their order in the SnapGrid's `data`.
+ *
+ * @property key - The cell's identity
+ * @property row - The key of the row it sits in
+ * @property span - Its width, in columns of 12
+ * @property height - Its height in px; `none` is its content's height
+ * @property minHeight - The least height a height drag leaves it, in px; `none` stops it at its content's height
+ * @property align - Where it sits in a taller row
+ * @property frame - Drawn in a tile frame, or bare
+ * @property label - Its name — the drag ghost's, the announcements' and the history's; `none` names it by its key
+ * @property icon - A Font Awesome solid icon name, which the editing canvas's selection bar shows beside its name
+ * @property meta - A line the selection bar shows after its name
+ * @property content - What it shows
+ */
+export declare const SnapGridCellType: StructType<{
+    readonly key: StringType;
+    readonly row: StringType;
+    readonly span: IntegerType;
+    readonly height: OptionType<IntegerType>;
+    readonly minHeight: OptionType<IntegerType>;
+    readonly align: import("@elaraai/east").VariantType<{
+        readonly top: NullType;
+        readonly center: NullType;
+        readonly stretch: NullType;
+    }>;
+    readonly frame: BooleanType;
+    readonly label: OptionType<StringType>;
+    readonly icon: OptionType<StringType>;
+    readonly meta: OptionType<StringType>;
+    readonly content: import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>;
+}>;
+/** Type representing a SnapGrid cell. */
+export type SnapGridCellType = typeof SnapGridCellType;
+/**
+ * A SnapGrid's editing declaration, on the wire (#990) — the shared session's
+ * fields, the entry fields a gesture writes, the drafted collection's cells,
+ * a dropped card's new entry and the author's readiness check.
+ *
+ * @internal
+ */
+export declare const SnapGridEditingType: StructType<{
+    readonly fields: StructType<{
+        readonly key: StringType;
+        readonly row: StringType;
+        readonly span: StringType;
+        readonly height: OptionType<StringType>;
+        readonly align: OptionType<StringType>;
+    }>;
+    readonly derive: FunctionType<[BlobType], ArrayType<StructType<{
+        readonly key: StringType;
+        readonly row: StringType;
+        readonly span: IntegerType;
+        readonly height: OptionType<IntegerType>;
+        readonly minHeight: OptionType<IntegerType>;
+        readonly align: import("@elaraai/east").VariantType<{
+            readonly top: NullType;
+            readonly center: NullType;
+            readonly stretch: NullType;
+        }>;
+        readonly frame: BooleanType;
+        readonly label: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+        readonly meta: OptionType<StringType>;
+        readonly content: import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>;
+    }>>>;
+    readonly create: OptionType<FunctionType<[StructType<{
+        readonly library: StringType;
+        readonly key: StringType;
+    }>, StructType<{
+        readonly key: StringType;
+        readonly row: StringType;
+    }>], BlobType>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<import("@elaraai/east").VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly onDrafted: OptionType<FunctionType<[BlobType], NullType>>;
+    readonly sourceId: StringType;
+    readonly entryType: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: import("@elaraai/east").VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly idField: OptionType<StringType>;
+    readonly draftType: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: import("@elaraai/east").VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly children: OptionType<StringType>;
+    readonly keyType: OptionType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: import("@elaraai/east").VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>>;
+    readonly snapshot: OptionType<BlobType>;
+    readonly readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+    readonly onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+    readonly onApply: OptionType<import("@elaraai/east").VariantType<{
+        readonly sync: FunctionType<[BlobType], import("@elaraai/east").VariantType<{
+            readonly applied: StructType<{
+                readonly revision: OptionType<StringType>;
+            }>;
+            readonly rejected: ArrayType<StructType<{
+                readonly entry: StringType;
+                readonly row: OptionType<IntegerType>;
+                readonly field: OptionType<StringType>;
+                readonly message: StringType;
+            }>>;
+            readonly conflict: ArrayType<StructType<{
+                readonly entry: StringType;
+                readonly row: OptionType<IntegerType>;
+                readonly field: OptionType<StringType>;
+                readonly message: StringType;
+            }>>;
+        }>>;
+        readonly async: AsyncFunctionType<[BlobType], import("@elaraai/east").VariantType<{
+            readonly applied: StructType<{
+                readonly revision: OptionType<StringType>;
+            }>;
+            readonly rejected: ArrayType<StructType<{
+                readonly entry: StringType;
+                readonly row: OptionType<IntegerType>;
+                readonly field: OptionType<StringType>;
+                readonly message: StringType;
+            }>>;
+            readonly conflict: ArrayType<StructType<{
+                readonly entry: StringType;
+                readonly row: OptionType<IntegerType>;
+                readonly field: OptionType<StringType>;
+                readonly message: StringType;
+            }>>;
+        }>>;
+    }>>;
+    readonly mode: import("@elaraai/east").VariantType<{
+        readonly batch: NullType;
+        readonly auto: NullType;
+    }>;
+}>;
+/** Type representing a SnapGrid's editing declaration. */
+export type SnapGridEditingType = typeof SnapGridEditingType;
+/**
+ * A SnapGrid's value — the named twin of the inline `SnapGrid` arm of
+ * `UIComponentType`, built by the same {@link SnapGridRootOf} over
+ * `UIComponentType`, where the arm's cells spell their content with the
+ * recursion node.
+ *
+ * @property cells - Every cell, in the order `data` holds them
+ * @property variant - Tiles (the default) or a wireframe
+ * @property width - The design width, a CSS length
+ * @property height - A pinned height, a CSS length; the grid scrolls within
+ * @property maxHeight - A height cap, a CSS length; the grid scrolls past it
+ * @property zoom - The scale the canvas draws at (`1.0` actual size)
+ * @property guides - Draw the column ruler and the column bands
+ * @property editing - The editing session (#990); `none` takes no gesture
+ * @property ui - The bound selection; `none` keeps it in the canvas
+ * @property view - The bound design width and zoom (#995); `none` keeps them in the canvas
+ * @property apply - The bound Apply request (#998); `none` takes none
+ * @property id - The drag surface's name in a drop's cell refs; `none` names one of its own
+ * @property sources - The library ids whose cards land on the canvas
+ * @property canDrop - The veto over a drop where the drag rests (the shared grammar)
+ * @property widths - The design widths the editing canvas's toolbar offers (#995)
+ * @property toolbar - The host's items in the editing canvas's toolbar: `start` leads the row, `end` closes it (#995)
+ * @property panes - The panes beside the editing canvas, under its toolbar (#995)
+ * @property surface - The editing canvas's frame (`card`, the default) or none (`shell`) (#995)
+ */
+export declare const SnapGridRootType: StructType<{
+    readonly cells: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly row: StringType;
+        readonly span: IntegerType;
+        readonly height: OptionType<IntegerType>;
+        readonly minHeight: OptionType<IntegerType>;
+        readonly align: import("@elaraai/east").VariantType<{
+            readonly top: NullType;
+            readonly center: NullType;
+            readonly stretch: NullType;
+        }>;
+        readonly frame: BooleanType;
+        readonly label: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+        readonly meta: OptionType<StringType>;
+        readonly content: import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>;
+    }>>;
+    readonly variant: OptionType<import("@elaraai/east").VariantType<{
+        readonly tiles: NullType;
+        readonly wireframe: NullType;
+    }>>;
+    readonly width: OptionType<StringType>;
+    readonly height: OptionType<StringType>;
+    readonly maxHeight: OptionType<StringType>;
+    readonly zoom: OptionType<FloatType>;
+    readonly guides: BooleanType;
+    readonly editing: OptionType<StructType<{
+        readonly fields: StructType<{
+            readonly key: StringType;
+            readonly row: StringType;
+            readonly span: StringType;
+            readonly height: OptionType<StringType>;
+            readonly align: OptionType<StringType>;
+        }>;
+        readonly derive: FunctionType<[BlobType], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly row: StringType;
+            readonly span: IntegerType;
+            readonly height: OptionType<IntegerType>;
+            readonly minHeight: OptionType<IntegerType>;
+            readonly align: import("@elaraai/east").VariantType<{
+                readonly top: NullType;
+                readonly center: NullType;
+                readonly stretch: NullType;
+            }>;
+            readonly frame: BooleanType;
+            readonly label: OptionType<StringType>;
+            readonly icon: OptionType<StringType>;
+            readonly meta: OptionType<StringType>;
+            readonly content: import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>;
+        }>>>;
+        readonly create: OptionType<FunctionType<[StructType<{
+            readonly library: StringType;
+            readonly key: StringType;
+        }>, StructType<{
+            readonly key: StringType;
+            readonly row: StringType;
+        }>], BlobType>>;
+        readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+            readonly id: StringType;
+            readonly entry: BlobType;
+        }>>], ArrayType<import("@elaraai/east").VariantType<{
+            readonly ready: NullType;
+            readonly incomplete: ArrayType<StructType<{
+                readonly field: StringType;
+                readonly message: StringType;
+            }>>;
+            readonly invalid: ArrayType<StructType<{
+                readonly field: StringType;
+                readonly message: StringType;
+            }>>;
+        }>>>>;
+        readonly onDrafted: OptionType<FunctionType<[BlobType], NullType>>;
+        readonly sourceId: StringType;
+        readonly entryType: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: import("@elaraai/east").VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly idField: OptionType<StringType>;
+        readonly draftType: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: import("@elaraai/east").VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly children: OptionType<StringType>;
+        readonly keyType: OptionType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: import("@elaraai/east").VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+        readonly snapshot: OptionType<BlobType>;
+        readonly readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        readonly onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        readonly onApply: OptionType<import("@elaraai/east").VariantType<{
+            readonly sync: FunctionType<[BlobType], import("@elaraai/east").VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: AsyncFunctionType<[BlobType], import("@elaraai/east").VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        readonly mode: import("@elaraai/east").VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>>;
+    readonly ui: OptionType<StructType<{
+        readonly read: FunctionType<[], StructType<{
+            readonly selected: OptionType<StringType>;
+            readonly request: OptionType<StructType<{
+                readonly key: StringType;
+                readonly change: import("@elaraai/east").VariantType<{
+                    readonly span: IntegerType;
+                    readonly row: IntegerType;
+                    readonly height: OptionType<IntegerType>;
+                    readonly align: import("@elaraai/east").VariantType<{
+                        readonly top: NullType;
+                        readonly center: NullType;
+                        readonly stretch: NullType;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly write: FunctionType<[StructType<{
+            readonly selected: OptionType<StringType>;
+            readonly request: OptionType<StructType<{
+                readonly key: StringType;
+                readonly change: import("@elaraai/east").VariantType<{
+                    readonly span: IntegerType;
+                    readonly row: IntegerType;
+                    readonly height: OptionType<IntegerType>;
+                    readonly align: import("@elaraai/east").VariantType<{
+                        readonly top: NullType;
+                        readonly center: NullType;
+                        readonly stretch: NullType;
+                    }>;
+                }>;
+            }>>;
+        }>], NullType>;
+        readonly has: FunctionType<[], BooleanType>;
+    }>>;
+    readonly view: OptionType<StructType<{
+        readonly read: FunctionType<[], StructType<{
+            readonly width: OptionType<StringType>;
+            readonly zoom: OptionType<FloatType>;
+        }>>;
+        readonly write: FunctionType<[StructType<{
+            readonly width: OptionType<StringType>;
+            readonly zoom: OptionType<FloatType>;
+        }>], NullType>;
+        readonly has: FunctionType<[], BooleanType>;
+    }>>;
+    readonly apply: OptionType<StructType<{
+        readonly read: FunctionType<[], import("@elaraai/east").VariantType<{
+            readonly idle: NullType;
+            readonly asked: StringType;
+            readonly applied: StringType;
+            readonly refused: StructType<{
+                readonly id: StringType;
+                readonly reason: StringType;
+            }>;
+        }>>;
+        readonly write: FunctionType<[import("@elaraai/east").VariantType<{
+            readonly idle: NullType;
+            readonly asked: StringType;
+            readonly applied: StringType;
+            readonly refused: StructType<{
+                readonly id: StringType;
+                readonly reason: StringType;
+            }>;
+        }>], NullType>;
+        readonly has: FunctionType<[], BooleanType>;
+    }>>;
+    readonly id: OptionType<StringType>;
+    readonly sources: ArrayType<StringType>;
+    readonly canDrop: OptionType<FunctionType<[import("@elaraai/east").VariantType<{
+        readonly add: StructType<{
+            readonly from: StructType<{
+                readonly library: StringType;
+                readonly key: StringType;
+            }>;
+            readonly into: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+            readonly duplicate: BooleanType;
+        }>;
+        readonly move: StructType<{
+            readonly from: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+            readonly to: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+        }>;
+        readonly remove: StructType<{
+            readonly from: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+            readonly to: import("@elaraai/east").VariantType<{
+                readonly trash: NullType;
+                readonly source: NullType;
+            }>;
+        }>;
+        readonly resize: StructType<{
+            readonly event: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+            readonly edge: import("@elaraai/east").VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+            }>;
+        }>;
+    }>], BooleanType>>;
+    readonly widths: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly icon: OptionType<StringType>;
+        readonly width: StringType;
+    }>>;
+    readonly toolbar: StructType<{
+        readonly start: ArrayType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+        readonly end: ArrayType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+    }>;
+    readonly panes: StructType<{
+        readonly start: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+        readonly end: OptionType<import("@elaraai/east").RecursiveType<import("../../component.js").UIComponentNode>>;
+    }>;
+    readonly surface: OptionType<import("@elaraai/east").VariantType<{
+        readonly card: NullType;
+        readonly shell: NullType;
+    }>>;
+}>;
+/** Type representing a SnapGrid's value. */
+export type SnapGridRootType = typeof SnapGridRootType;
+/**
+ * What a SnapGrid's `editing.onPatch` receives for rows of `R` (#990) — the
+ * shared patch event over the SnapGrid's drafts, which are whole entries
+ * (`Editing.Types.DraftField(R)`): every gesture writes a complete entry.
+ *
+ * @typeParam R - The row type
+ * @param entryType - The SnapGrid's row type
+ * @returns The patch event type
+ */
+export declare function SnapGridPatchEventTypeFor<R extends EastType>(entryType: R): StructType<{
+    readonly transactionId: StringType;
+    readonly origin: import("@elaraai/east").VariantType<{
+        readonly typed: NullType;
+        readonly pasted: NullType;
+        readonly fill: NullType;
+        readonly row: NullType;
+        readonly pattern: NullType;
+        readonly insert: NullType;
+        readonly move: NullType;
+        readonly remove: NullType;
+        readonly resize: NullType;
+        readonly drop: NullType;
+        readonly verdict: NullType;
+        readonly undo: NullType;
+        readonly redo: NullType;
+        readonly discard: NullType;
+    }>;
+    readonly label: StringType;
+    readonly draftChanges: ArrayType<StructType<{
+        readonly id: StringType;
+        readonly patch: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: OptionType<import("@elaraai/east").VariantType<{
+                    readonly missing: NullType;
+                    readonly value: R;
+                    readonly invalid: StringType;
+                }>>;
+                after: OptionType<import("@elaraai/east").VariantType<{
+                    readonly missing: NullType;
+                    readonly value: R;
+                    readonly invalid: StringType;
+                }>>;
+            }>;
+            patch: import("@elaraai/east").VariantType<{
+                none: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: NullType;
+                        after: NullType;
+                    }>;
+                }>;
+                some: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: import("@elaraai/east").VariantType<{
+                            readonly missing: NullType;
+                            readonly value: R;
+                            readonly invalid: StringType;
+                        }>;
+                        after: import("@elaraai/east").VariantType<{
+                            readonly missing: NullType;
+                            readonly value: R;
+                            readonly invalid: StringType;
+                        }>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        readonly missing: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        readonly value: R extends EastType ? import("@elaraai/east").PatchTypeOf<R> : never;
+                        readonly invalid: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+        readonly place: OptionType<import("@elaraai/east").VariantType<{
+            readonly ordered: import("@elaraai/east").VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+                readonly before: StringType;
+                readonly after: StringType;
+            }>;
+            readonly keyOrder: NullType;
+        }>>;
+    }>>;
+    readonly domainChanges: OptionType<ArrayType<StructType<{
+        readonly id: StringType;
+        readonly patch: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: OptionType<R>;
+                after: OptionType<R>;
+            }>;
+            patch: import("@elaraai/east").VariantType<{
+                none: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: NullType;
+                        after: NullType;
+                    }>;
+                }>;
+                some: R extends EastType ? import("@elaraai/east").PatchTypeOf<R> : never;
+            }>;
+        }>;
+        readonly place: OptionType<import("@elaraai/east").VariantType<{
+            readonly ordered: import("@elaraai/east").VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+                readonly before: StringType;
+                readonly after: StringType;
+            }>;
+            readonly keyOrder: NullType;
+        }>>;
+    }>>>;
+    readonly readiness: import("@elaraai/east").VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+    }>;
+}>;
+/**
+ * A whole-value bind handle (`State.bind` / `Data.bind`) over a SnapGrid's rows
+ * — accepted as `data`, read where the SnapGrid renders, and written through by
+ * `editing.onUpdate`.
+ *
+ * @typeParam C - The collection it holds: an `Array` or a `Dict` of rows
+ */
+export interface SnapGridBindHandle<C extends EastType> {
+    /** The handle's read. */
+    read: (...args: never[]) => ExprType<C>;
+}
+/**
+ * What a SnapGrid's `data` takes: an `Array` or a `Dict` of rows, inline or
+ * through a bound handle ({@link SnapGridBindHandle}). The handle's read is
+ * checked where it resolves — an expression's type is invariant in its rows,
+ * so no one handle type here admits them all.
+ */
+export type SnapGridData = SubtypeExprOrValue<ArrayType<EastType>> | SubtypeExprOrValue<DictType<EastType, EastType>> | {
+    read: (...args: never[]) => unknown;
+};
+/** The row a collection type holds — an `Array`'s element, or a `Dict`'s value. */
+type SnapGridElementOf<C> = C extends ArrayType<infer R extends EastType> ? R : C extends DictType<EastType, infer R extends EastType> ? R : never;
+/**
+ * The row a SnapGrid's `data` holds — an `Array`'s element, or a `Dict`'s
+ * value, read through a bound handle when it is one.
+ *
+ * @typeParam T - The `data` passed
+ */
+export type SnapGridRowOf<T> = T extends {
+    read: (...args: never[]) => infer E;
+} ? SnapGridElementOf<TypeOf<E>> : SnapGridElementOf<TypeOf<T>>;
+/**
+ * The names of the fields of row type `R` whose type is `T` — what `edit`
+ * names a field by.
+ *
+ * @typeParam R - The row type
+ * @typeParam T - The field type wanted
+ */
+export type SnapGridFieldOf<R, T> = R extends StructType<infer F> ? {
+    [K in keyof F & string]: F[K] extends T ? K : never;
+}[keyof F & string] : never;
+/**
+ * The fields of one cell, as {@link SnapGrid.cell} takes them.
+ *
+ * @property key - The cell's identity
+ * @property row - The key of the row it sits in
+ * @property span - Its width, in columns of 12
+ * @property height - Its height in px; omitted or `none` is its content's height
+ * @property minHeight - The least height a height drag leaves it; omitted or `none` stops it at its content's height
+ * @property align - Where it sits in a taller row; `top` when omitted
+ * @property frame - Drawn in a tile frame (the default), or bare
+ * @property label - Its name, for the drag ghost, the announcements and the history; omitted, its key
+ * @property icon - A Font Awesome solid icon name, beside its name in the editing canvas's selection bar
+ * @property meta - A line after its name in the selection bar — what it is, what it reads
+ * @property content - What it shows
+ */
+export interface SnapGridCellFields {
+    /** The cell's identity. */
+    key: SubtypeExprOrValue<StringType>;
+    /** The key of the row it sits in. */
+    row: SubtypeExprOrValue<StringType>;
+    /** Its width, in columns of 12. */
+    span: SubtypeExprOrValue<IntegerType>;
+    /** Its height in px; omitted or `none` is its content's height. */
+    height?: SubtypeExprOrValue<OptionType<IntegerType>>;
+    /** The least height a height drag leaves it, in px — a chart's plot, say; omitted or `none` stops it at its content's height. */
+    minHeight?: SubtypeExprOrValue<OptionType<IntegerType>>;
+    /** Where it sits in a taller row; `top` when omitted. */
+    align?: SnapGridAlignLiteral | SubtypeExprOrValue<SnapGridAlignType>;
+    /** Drawn in a tile frame (the default), or bare. */
+    frame?: SubtypeExprOrValue<BooleanType>;
+    /** Its name, for the drag ghost, the announcements and the history; omitted, its key. */
+    label?: SubtypeExprOrValue<OptionType<StringType>>;
+    /** A Font Awesome solid icon name, beside its name in the editing canvas's selection bar; omitted, none. */
+    icon?: SubtypeExprOrValue<OptionType<StringType>>;
+    /** A line after its name in the selection bar — what it is, what it reads; omitted, none. */
+    meta?: SubtypeExprOrValue<OptionType<StringType>>;
+    /** What it shows. */
+    content: SubtypeExprOrValue<UIComponentType>;
+}
+/**
+ * What a gesture writes into the SnapGrid's rows (#990) — the fields it names,
+ * and the new row a dropped card becomes.
+ *
+ * @typeParam R - The row type
+ */
+export interface SnapGridEditConfig<R extends EastType> {
+    /** The String identity field — what the session and `Editing.apply` address a row by. */
+    key: SnapGridFieldOf<R, StringType>;
+    /** The String field holding the row key a tile sits in. */
+    row: SnapGridFieldOf<R, StringType>;
+    /** The Integer field holding a tile's span. */
+    span: SnapGridFieldOf<R, IntegerType>;
+    /** The `Option<Integer>` field holding a tile's height; omitted, a tile's height is not edited. */
+    height?: SnapGridFieldOf<R, OptionType<IntegerType>>;
+    /** The `SnapGrid.Types.Align` field an align request writes (#996); omitted, a request to align a tile is refused. */
+    align?: SnapGridFieldOf<R, SnapGridAlignType>;
+    /**
+     * A dropped card's new row, built in the block `$` — bind a lookup once with
+     * `$.let`, as in any East function body: `card` is the drag grammar's
+     * `{ library, key }`, `at` a fresh key and the row it lands in. The canvas
+     * then writes `at.row` into `row` and holds the span to the room the row
+     * has. Omitted, no card lands.
+     */
+    create?: ($: BlockBuilder<R>, card: ExprType<LibraryRefType>, at: ExprType<SnapGridPlaceType>) => SubtypeExprOrValue<R>;
+}
+/**
+ * The SnapGrid's editing session (#990) — the Sheet's and the Plan's, over the
+ * SnapGrid's rows: every move, resize, drop and removal is a draft of the rows
+ * it changes, each gesture one undoable transaction, and Apply one checked,
+ * idempotent batch against the rows the drafts began from.
+ *
+ * @remarks
+ * The callbacks are East functions over the SnapGrid's row type `R`:
+ *
+ * - `onApply(Editing.Types.ChangeSet(R)) → Editing.Types.ApplyResult` commits
+ *   a batch — sync or async; `Record.onApply(…)` commits it to an e3 record.
+ * - `onUpdate(Array<R>)` is the inline adapter instead: with
+ *   `data={liveHandle}` each batch applies with `Editing.apply` over the
+ *   handle's latest rows and writes them whole — idempotent across retries.
+ *   Exclusive with `onApply`.
+ * - `onPatch(SnapGrid.Types.PatchEvent(R))` observes every gesture.
+ * - `onDrafted(Array<R>)` hears the rows the canvas draws (#996) — the source
+ *   with the session's drafts, exactly as Apply would leave them — once as it
+ *   mounts and whenever they change: a gesture, an undo or a redo, a Discard,
+ *   a source that moved. A pane beside the canvas reads what it shows from
+ *   them — an inspector, a palette's counts.
+ * - `ready(R) → Editing.Types.Readiness` is the author's check over one
+ *   drafted row; a refusal holds Apply and names the row.
+ *
+ * @property onApply - Commit one checked batch (sync or async)
+ * @property onUpdate - The inline adapter's writer (requires `data={liveHandle}`)
+ * @property onPatch - Observe every gesture
+ * @property onDrafted - Hear the rows the canvas draws, whenever they change
+ * @property mode - `"batch"` (Apply sends) or `"auto"` (each ready gesture goes at once)
+ * @property ready - The author's readiness check over a drafted row
+ */
+export interface SnapGridEditingConfig {
+    /** Commit one checked batch — `Fn(Editing.Types.ChangeSet(R)) → Editing.Types.ApplyResult`, sync or async. */
+    onApply?: ExprType<EastType>;
+    /** The inline adapter's writer — `Fn(Array<R>) → Null`; requires `data={liveHandle}`, exclusive with `onApply`. */
+    onUpdate?: ExprType<EastType>;
+    /** Observe every gesture — `Fn(SnapGrid.Types.PatchEvent(R)) → Null`. */
+    onPatch?: ExprType<EastType>;
+    /** Hear the rows the canvas draws, the drafts in place, as it mounts and whenever they change — `Fn(Array<R>) → Null` (#996). */
+    onDrafted?: ExprType<EastType>;
+    /** When a ready batch goes: on Apply (`"batch"`, the default), or at once (`"auto"`). */
+    mode?: "batch" | "auto";
+    /** The author's check over one drafted row — `Fn(R) → Editing.Types.Readiness`. */
+    ready?: ExprType<EastType>;
+}
+/**
+ * A SnapGrid's configuration.
+ *
+ * @typeParam R - The row `data` holds
+ */
+export interface SnapGridConfig<R extends EastType> {
+    /** Maps one row to its cell — build it with {@link SnapGrid.cell}. Reified once into an East function. */
+    cell: (row: ExprType<R>) => SubtypeExprOrValue<SnapGridCellType>;
+    /** `tiles` (the default), or `wireframe`: each cell an outline at its tile's size, its content not drawn. */
+    variant?: SnapGridVariantLiteral | SubtypeExprOrValue<SnapGridVariantType>;
+    /**
+     * The design width, a CSS length (`"1440px"`): a page's grid is that wide.
+     * On the editing canvas it is the most the grid lays out at — a narrower
+     * column lays it out at the column's width, a wider one centres it — and
+     * the toolbar reads it out.
+     */
+    width?: SubtypeExprOrValue<StringType>;
+    /** A pinned height, a CSS length; the grid scrolls within. */
+    height?: SubtypeExprOrValue<StringType>;
+    /** A height cap, a CSS length; the grid scrolls past it. */
+    maxHeight?: SubtypeExprOrValue<StringType>;
+    /** The scale the canvas draws at — `1.0` is actual size, `0.5` half. */
+    zoom?: number | SubtypeExprOrValue<FloatType>;
+    /** Draw the column ruler above the rows and the column bands behind them. */
+    guides?: boolean | SubtypeExprOrValue<BooleanType>;
+    /** What a gesture writes into the rows (#990) — give it with `editing`. */
+    edit?: SnapGridEditConfig<R>;
+    /** Where the drafts go (#990) — give it with `edit`. */
+    editing?: SnapGridEditingConfig;
+    /** The bound selection — `State.bind([SnapGrid.Types.UiState], key, SnapGrid.uiState())`; omitted, the canvas keeps it. */
+    ui?: SubtypeExprOrValue<SnapGridUiBindType>;
+    /**
+     * The bound design width and zoom (#995) — `State.bind([SnapGrid.Types.ViewState],
+     * key, SnapGrid.viewState())`: the editing canvas draws at them and writes
+     * the width preset and the zoom step the user picks. Omitted, the canvas
+     * keeps them, starting from `width` and `zoom`.
+     */
+    view?: SubtypeExprOrValue<SnapGridViewBindType>;
+    /**
+     * The bound Apply request (#998) — `State.bind([SnapGrid.Types.ApplyState],
+     * key, variant("idle", null))`: a host writes `asked` with an id of its own,
+     * and the editing canvas applies its drafts and answers under the id —
+     * `applied` once the source confirms them, or at once when it has none;
+     * `refused` with why. A publish that must not leave drafts behind asks
+     * for one. Omitted, only the history item applies.
+     */
+    apply?: SubtypeExprOrValue<SnapGridApplyBindType>;
+    /** The drag surface's name in a drop's cell refs; omitted, the canvas names one of its own. */
+    id?: string;
+    /** The library ids whose cards land on the canvas (`edit.create` builds the row). */
+    sources?: string[];
+    /** The veto over a drop where the drag rests — a card's `add`, a tile's `move` (the ⊘ stage); a throwing predicate fails open. */
+    canDrop?: SubtypeExprOrValue<FunctionType<[DragEventType], BooleanType>>;
+    /**
+     * The design widths the editing canvas's toolbar offers (#995) — a device
+     * each, such as Desktop and Tablet. The one the canvas draws at is
+     * pressed, and pressing another draws it at that width.
+     */
+    widths?: SnapGridWidthInput[];
+    /**
+     * The host's items in the editing canvas's toolbar (#995): the `start`
+     * items lead the row, before the canvas's own; the `end` items close it,
+     * after the history item and the widths. They never fold.
+     */
+    toolbar?: {
+        /** Before the canvas's own items, at the row's start. */
+        start?: SubtypeExprOrValue<ArrayType<UIComponentType>>;
+        /** After the canvas's own items, at the row's end. */
+        end?: SubtypeExprOrValue<ArrayType<UIComponentType>>;
+    };
+    /**
+     * The panes beside the editing canvas, under its toolbar (#995) — a
+     * palette, an inspector. A `<Dock>` pane collapses to its rail and the
+     * canvas takes the room.
+     */
+    panes?: {
+        /** The pane before the canvas. */
+        start?: SubtypeExprOrValue<UIComponentType>;
+        /** The pane after it. */
+        end?: SubtypeExprOrValue<UIComponentType>;
+    };
+    /** `card` (the default) draws the editing canvas's frame; `shell` draws none, inside a host's frame (#995). */
+    surface?: SnapGridSurfaceLiteral | SubtypeExprOrValue<SnapGridSurfaceType>;
+}
+/**
+ * One design width, as `widths` takes it (#995).
+ *
+ * @property label - Its name in the toolbar
+ * @property icon - A Font Awesome solid icon name beside the name
+ * @property width - The design width, a CSS length
+ */
+export interface SnapGridWidthInput {
+    /** Its name in the toolbar — `"Desktop"`. */
+    label: SubtypeExprOrValue<StringType>;
+    /** A Font Awesome solid icon name beside the name — `"desktop"`. */
+    icon?: SubtypeExprOrValue<StringType>;
+    /** The design width, a CSS length — `"1440px"`. */
+    width: SubtypeExprOrValue<StringType>;
+}
+/**
+ * Builds one cell's value, with the defaults filled in.
+ *
+ * @param fields - The cell's fields ({@link SnapGridCellFields})
+ * @returns The cell, a {@link SnapGridCellType} value
+ *
+ * @example
+ * ```tsx
+ * import { ArrayType, East, IntegerType, StringType, StructType } from "@elaraai/east";
+ * import { SnapGrid, Stat, UIComponentType } from "@elaraai/east-ui";
+ *
+ * const Kpi = StructType({ id: StringType, row: StringType, span: IntegerType, label: StringType, value: IntegerType });
+ *
+ * const kpis = East.function([], UIComponentType, ($) => {
+ *     const tiles = $.const([
+ *         { id: "orders", row: "top", span: 6n, label: "Orders", value: 128n },
+ *         { id: "returns", row: "top", span: 6n, label: "Returns", value: 4n },
+ *     ], ArrayType(Kpi));
+ *     return <SnapGrid data={tiles} cell={t => SnapGrid.cell({ key: t.id, row: t.row, span: t.span,
+ *         content: <Stat label={t.label} value={t.value} /> })} />;
+ * });
+ * ```
+ */
+declare function createCell(fields: SnapGridCellFields): ExprType<SnapGridCellType>;
+/**
+ * Builds a {@link SnapGridUiStateType} value — the seed of a bound `ui`, or
+ * what a host writes to it: a selection, and a change it asks of the editing
+ * canvas (#996).
+ *
+ * @param state - The selected tile's key, and a request; omitted, nothing selected and nothing asked
+ * @returns The state
+ *
+ * @example
+ * ```ts
+ * import { East, NullType, variant } from "@elaraai/east";
+ * import { SnapGrid, State } from "@elaraai/east-ui";
+ *
+ * const select = East.function([], NullType, ($) => {
+ *     const ui = $.const(State.bind([SnapGrid.Types.UiState], "builder.selection", SnapGrid.uiState()));
+ *     $(ui.write(SnapGrid.uiState({ selected: "revenue-trend" })));
+ * });
+ *
+ * // An inspector's edit: the canvas widens the tile to 8 columns, as one undoable gesture.
+ * const widen = East.function([], NullType, ($) => {
+ *     const ui = $.const(State.bind([SnapGrid.Types.UiState], "builder.selection", SnapGrid.uiState()));
+ *     $(ui.write(SnapGrid.uiState({
+ *         selected: "revenue-trend",
+ *         request: { key: "revenue-trend", change: variant("span", 8n) },
+ *     })));
+ * });
+ * ```
+ */
+declare function createUiState(state?: {
+    selected?: SubtypeExprOrValue<StringType>;
+    request?: SubtypeExprOrValue<SnapGridRequestType>;
+}): ExprType<SnapGridUiStateType>;
+/**
+ * Builds a {@link SnapGridViewStateType} value — the seed of a bound `view`
+ * (#995).
+ *
+ * @param state - The design width and the zoom; omitted, the SnapGrid's own `width` and `zoom`
+ * @returns The state
+ *
+ * @example
+ * ```ts
+ * import { East, NullType } from "@elaraai/east";
+ * import { SnapGrid, State } from "@elaraai/east-ui";
+ *
+ * const tablet = East.function([], NullType, ($) => {
+ *     const view = $.const(State.bind([SnapGrid.Types.ViewState], "builder.view", SnapGrid.viewState()));
+ *     $(view.write(SnapGrid.viewState({ width: "1024px", zoom: 0.8 })));
+ * });
+ * ```
+ */
+declare function createViewState(state?: {
+    width?: SubtypeExprOrValue<StringType>;
+    zoom?: number | SubtypeExprOrValue<FloatType>;
+}): ExprType<SnapGridViewStateType>;
+/**
+ * Creates a SnapGrid — the host's rows as tiles, in rows on a 12-column grid.
+ *
+ * @remarks
+ * Rows order by their first appearance among the cells, and the cells of a
+ * row by their order in `data`, a `Dict`'s by key. A row's cells sit left to
+ * right by span, with a gap between columns and between rows; a row whose
+ * spans pass 12 continues on a line below and never overlaps. A row is as
+ * tall as its tallest cell, and `align` places the shorter ones. Under a
+ * narrow container every cell takes the full width, in row order; under a
+ * medium one a span under 6 takes 6 and any other 12; from a wide one on, the
+ * spans declared.
+ *
+ * A framed tile has no header strip: the SnapGrid draws no chrome of its own and
+ * no outer border — the host draws the panel around it.
+ *
+ * With `edit` and `editing` (#990) it is an editing canvas over an `Array`
+ * source — the order of `data` is the order of its tiles, which a `Dict`
+ * cannot take: a tile is selected by a click, moved, resized, dropped from a
+ * library and removed, each gesture one draft of the shared editing session,
+ * and the history item in its toolbar undoes, redoes, discards and applies.
+ *
+ * The editing canvas is the builder's frame (#995): a toolbar across its
+ * width, then its `panes` beside a column holding the selection bar and the
+ * grid panel. The toolbar leads with the host's `toolbar.start` items, the
+ * grid chip and — once the source confirms an Apply — the time it was saved;
+ * it closes with the width readout, the zoom, the history item, the design
+ * `widths` and the host's `toolbar.end` items. The selection bar names the
+ * selected tile with its `icon`, `label` and `meta`.
+ *
+ * A pane beside the canvas works with it through the host's state (#996): it
+ * reads the rows the canvas draws, which `editing.onDrafted` hears, and asks
+ * for a change by writing a `request` to the bound `ui` — a span, a row, a
+ * height or an alignment, taken as one gesture of the session. A screen that
+ * must not leave drafts behind asks for an Apply through the bound `apply`
+ * (#998), and the canvas answers once its drafts land or cannot.
+ *
+ * @typeParam T - The `data` passed
+ * @param data - The rows: an `Array` or a `Dict`, inline or through a bound handle
+ * @param config - How a row becomes a cell, and how the SnapGrid is drawn and edited ({@link SnapGridConfig})
+ * @returns An East expression of type `UIComponentType`
+ * @throws {Error} When `data` is a paged source, or not an `Array` or a `Dict`; when the editing
+ *   declaration is inconsistent — see {@link SnapGridEditConfig} and {@link SnapGridEditingConfig};
+ *   or when the editing canvas's chrome — `view`, `apply`, `widths`, `toolbar`, `panes`, `surface` — is
+ *   given without `editing`
+ *
+ * @example
+ * ```tsx
+ * import { ArrayType, East, IntegerType, StringType, StructType } from "@elaraai/east";
+ * import { SnapGrid, Stat, UIComponentType } from "@elaraai/east-ui";
+ *
+ * const Tile = StructType({ id: StringType, row: StringType, span: IntegerType, label: StringType, value: IntegerType });
+ *
+ * const page = East.function([], UIComponentType, ($) => {
+ *     const tiles = $.const([
+ *         { id: "orders", row: "kpis", span: 4n, label: "Orders", value: 128n },
+ *         { id: "returns", row: "kpis", span: 4n, label: "Returns", value: 4n },
+ *         { id: "late", row: "kpis", span: 4n, label: "Late", value: 9n },
+ *     ], ArrayType(Tile));
+ *     return <SnapGrid data={tiles} width="1440px"
+ *         cell={t => SnapGrid.cell({ key: t.id, row: t.row, span: t.span, content: <Stat label={t.label} value={t.value} /> })} />;
+ * });
+ * ```
+ */
+declare function createSnapGrid<T extends SnapGridData>(data: T, config: SnapGridConfig<SnapGridRowOf<T>>): ExprType<UIComponentType>;
+/**
+ * The type of the {@link SnapGrid} namespace — declared explicitly so the
+ * declaration emit stays within TypeScript's serialization limit.
+ */
+export interface SnapGridNamespace {
+    /** Creates a SnapGrid ({@link createSnapGrid}). */
+    Root: typeof createSnapGrid;
+    /** Builds one cell's value, with the defaults filled in ({@link createCell}). */
+    cell: typeof createCell;
+    /** Builds the seed of a bound selection ({@link createUiState}). */
+    uiState: typeof createUiState;
+    /** Builds the seed of a bound design width and zoom ({@link createViewState}). */
+    viewState: typeof createViewState;
+    /** The SnapGrid's East types. */
+    Types: {
+        /** A SnapGrid's value ({@link SnapGridRootType}). */
+        Root: typeof SnapGridRootType;
+        /** One tile ({@link SnapGridCellType}). */
+        Cell: typeof SnapGridCellType;
+        /** Where a cell sits in a taller row ({@link SnapGridAlignType}). */
+        Align: typeof SnapGridAlignType;
+        /** Tiles or a wireframe ({@link SnapGridVariantType}). */
+        Variant: typeof SnapGridVariantType;
+        /** The bound selection's value ({@link SnapGridUiStateType}). */
+        UiState: typeof SnapGridUiStateType;
+        /** A change a host asks of the editing canvas ({@link SnapGridRequestType}). */
+        Request: typeof SnapGridRequestType;
+        /** The bound design width and zoom's value ({@link SnapGridViewStateType}). */
+        ViewState: typeof SnapGridViewStateType;
+        /** An Apply asked of the editing canvas, and its answer ({@link SnapGridApplyStateType}). */
+        ApplyState: typeof SnapGridApplyStateType;
+        /** One design width the editing canvas offers ({@link SnapGridWidthType}). */
+        Width: typeof SnapGridWidthType;
+        /** The editing canvas's frame, or none ({@link SnapGridSurfaceType}). */
+        Surface: typeof SnapGridSurfaceType;
+        /** Where a dropped card lands — `edit.create`'s second argument ({@link SnapGridPlaceType}). */
+        Place: typeof SnapGridPlaceType;
+        /** `PatchEvent(R)` — what `editing.onPatch` receives ({@link SnapGridPatchEventTypeFor}). */
+        PatchEvent: typeof SnapGridPatchEventTypeFor;
+        /** The editing declaration on the wire ({@link SnapGridEditingType}). */
+        Editing: typeof SnapGridEditingType;
+    };
+}
+/**
+ * SnapGrid — the host's rows as tiles, in rows on a 12-column grid: the Studio's
+ * canvas, a published page, and the page library's wireframe thumbnails.
+ */
+export declare const SnapGrid: SnapGridNamespace;
+//# sourceMappingURL=index.d.ts.map