@scrawl-board/board 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/index.d.ts

@@ -1,17 +1,6 @@
 import * as react from 'react';
 import { ReactNode, ComponentType, CSSProperties } from 'react';
 
-declare const documentIdBrand: unique symbol;
-declare const strokeIdBrand: unique symbol;
-type DocumentId = string & {
-    readonly [documentIdBrand]: "DocumentId";
-};
-type StrokeId = string & {
-    readonly [strokeIdBrand]: "StrokeId";
-};
-declare function documentId(value: string): DocumentId;
-declare function strokeId(value: string): StrokeId;
-
 /** Wire grammar: `asset:<namespace>:<opaque-id>`. Interpreted only by the Host. */
 type AssetRef = string;
 declare const ASSET_REF_PATTERN: RegExp;
@@ -184,6 +173,21 @@ interface CustomObjectDefinition<Props extends JsonValue = JsonValue> {
     /** One pure, synchronous step per consecutive schema version. */
     migrate?: Readonly<Record<number, (oldProps: JsonValue) => JsonValue>>;
     describe(object: ReadonlyCustomObject<Props>, context: ObjectDescribeContext): BoardScene;
+    /**
+     * Optional point-level hit-test precision (Phase 8). Every custom object
+     * hit-tests against its bounding box (`fallback.bounds`) by default — this
+     * lets a non-rectangular shape (e.g. a circular card, an L-shaped region)
+     * reject a point that's inside that box but outside its actual visible
+     * silhouette, tightening a click/marquee/raycast hit to the shape's real
+     * outline. `point` is in this object's own local space — the same
+     * untransformed space `describe`'s returned geometry already lives in
+     * (the caller inverse-transforms the pointer's board point through
+     * `object.transform` before calling this). Absent means every point
+     * inside the bounding box hits, matching pre-Phase-8 behavior exactly.
+     * Rejecting a point here does not fall through to whatever's underneath —
+     * the gesture simply misses this object, same as clicking empty space.
+     */
+    hitTest?(object: ReadonlyCustomObject<Props>, point: BoardPoint): boolean;
 }
 interface SceneNodeBase {
     key: string;
@@ -217,6 +221,15 @@ interface SceneGroup extends SceneNodeBase {
     kind: "group";
     children: readonly BoardScene[];
 }
+/**
+ * **No renderer or SVG-export interpreter exists for this node kind yet**
+ * (tracked as deferred work — see `renderer/shapes/customObjects.ts`'s
+ * `"path"` case). Returning a `ScenePath` from `describe()` renders nothing,
+ * exports nothing, and contributes no hit-test bounds — it neither errors
+ * nor emits a diagnostic. Until an interpreter ships, build custom shapes
+ * from `SceneRect`/`SceneEllipse`/`SceneGroup`/`SceneText`/`SceneImage`
+ * instead.
+ */
 interface ScenePath extends SceneNodeBase {
     kind: "path";
     /** SVG-style path data, board-local coordinates. */
@@ -389,8 +402,23 @@ declare function canUnlockItem(item: Lockable | undefined, userId: string | unde
 /** Wire fields for a locked item; omitted entirely when unlocked. */
 declare function serializeLock(item: Lockable): Lockable;
 
+/**
+ * Per-object visibility (Phase 8) — mirrors `itemLock.ts`'s `Lockable`
+ * pattern exactly, but simpler: unlike a lock, hidden state carries no
+ * holder/ownership concept, so there's no analogue to `LockHolder`/
+ * `canUnlockItem`. A hidden object stays fully present in the Document
+ * (still serializes, persists, syncs, undoes/redoes) — it just skips
+ * rendering and hit-testing/selection candidacy. `hidden` absent or
+ * `false` means visible; this keeps every pre-Phase-8 document (which has
+ * no `hidden` field on any object at all) implicitly fully visible with
+ * zero migration needed.
+ */
+interface Hideable {
+    hidden?: boolean;
+}
+
 /** A kitchen timer sitting on the board. Remaining time is derived, not ticked. */
-interface KitchenTimer extends Lockable {
+interface KitchenTimer extends Lockable, Hideable {
     id: string;
     x: number;
     y: number;
@@ -415,6 +443,173 @@ declare function toggleTimer(timer: KitchenTimer, now: number): KitchenTimer;
 declare function setTimerDuration(timer: KitchenTimer, durationMs: number): KitchenTimer;
 declare function formatTimer(ms: number): string;
 
+declare const SHAPE_MIN_SIZE = 0.5;
+/**
+ * Centralized shape style defaults (Phase 8) — one object a Host can read
+ * to know (or, by not relying on the standalone constants below, override
+ * via its own UI state) what a newly drawn Rectangle/Ellipse/Line/Arrow/
+ * Polygon/Star/Heart starts with when the user hasn't picked a stroke/width
+ * yet. `shapeTool.ts` (commit-time), `renderer/shapes/lines.ts` (render-time
+ * fallback for an object missing these fields), and
+ * `persistence/serialization/svg.ts` (export-time fallback) all read from
+ * here — the two standalone constants below are kept for source
+ * compatibility and simply mirror this object's values, not a second
+ * source of truth.
+ */
+declare const SHAPE_STYLE_DEFAULTS: {
+    readonly stroke: "#1C1C1E";
+    readonly strokeWidth: 0.3;
+};
+declare const SHAPE_DEFAULT_STROKE: "#1C1C1E";
+declare const SHAPE_DEFAULT_STROKE_WIDTH: 0.3;
+interface RectangleObject extends Lockable, Hideable {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    /** Corner radius in board units; clamped to at most half the shorter side at render time. */
+    cornerRadius?: number;
+    /** `[0, 1]`; undefined means fully opaque (Phase 4). */
+    opacity?: number;
+    /**
+     * Radians, about the shape's own center `(x + width/2, y - height/2)`.
+     * Undefined means 0 (Phase 3). `x`/`y`/`width`/`height` stay in the
+     * shape's own unrotated local frame — rotation is a separate, applied-last
+     * transform, not baked into them, matching how Stroke/CustomBoardObject
+     * keep geometry and placement independent via their own `matrix`.
+     */
+    rotation?: number;
+}
+interface EllipseObject extends Lockable, Hideable {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    /** `[0, 1]`; undefined means fully opaque (Phase 4). */
+    opacity?: number;
+    /** Radians, about the shape's own center — see RectangleObject's `rotation` doc. */
+    rotation?: number;
+}
+declare function cloneRectangle(rect: RectangleObject): RectangleObject;
+declare function cloneEllipse(ellipse: EllipseObject): EllipseObject;
+/** `"none"` is a plain line with no arrowhead; today's only real head shape is `"triangle"`. New head shapes extend this union without touching `ArrowObject`'s own fields. */
+type ArrowHeadStyle = "triangle" | "none";
+interface LineObject extends Lockable, Hideable {
+    id: string;
+    start: BoardPoint;
+    end: BoardPoint;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+}
+/** An endpoint anchored to a normalized position on another object's bounds. */
+interface ConnectorBinding {
+    objectId: string;
+    /** Horizontal and vertical fractions of the target's axis-aligned bounds. */
+    x: number;
+    y: number;
+}
+interface ArrowObject extends Lockable, Hideable {
+    /** Omitted for legacy arrows. Connectors share Arrow's persistence/history contract. */
+    routing?: "straight" | "curved" | "polyline";
+    /** Intermediate board-space vertices for a multi-point connector. */
+    waypoints?: BoardPoint[];
+    startBinding?: ConnectorBinding;
+    endBinding?: ConnectorBinding;
+    id: string;
+    start: BoardPoint;
+    end: BoardPoint;
+    head?: ArrowHeadStyle;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+}
+/**
+ * Triangle(3)/Diamond(4)/Pentagon(5)/Hexagon(6)/Octagon(8) as one shared
+ * type instead of five near-duplicate interfaces — a regular N-gon
+ * inscribed in the same `x`/`y`/`width`/`height`/`rotation` bounding box
+ * Rectangle already uses, parameterized by `sides`. Diamond is exactly a
+ * 4-sided regular polygon with vertex 0 pointing right (not up, like
+ * Triangle/Pentagon/Hexagon) — see `polygonGeometry.ts`'s
+ * `polygonStartAngle`, which encodes each side count's own vertex
+ * orientation so the outline always matches the legacy drag-preview shape.
+ */
+interface PolygonObject extends Lockable, Hideable {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    sides: 3 | 4 | 5 | 6 | 8;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+    /** Radians, about the shape's own center — see RectangleObject's `rotation` doc. */
+    rotation?: number;
+}
+declare function clonePolygon(polygon: PolygonObject): PolygonObject;
+/** Same bounding-box/rotation convention as Rectangle; a 5-pointed star with a tuned inner-radius ratio, matching the legacy tool's own default (see `polygonGeometry.ts`'s `starPoints`). */
+interface StarObject extends Lockable, Hideable {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Vertex count; today's only shipped preset is 5, matching the legacy tool. */
+    points: number;
+    /** `(0, 1)` — inner vertex radius as a fraction of the outer radius. */
+    innerRadiusRatio: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+    rotation?: number;
+}
+declare function cloneStar(star: StarObject): StarObject;
+/** Same bounding-box/rotation convention as Rectangle; the standard parametric heart curve (see `polygonGeometry.ts`'s `heartPoints`), no extra parameters beyond the shared shape fields. */
+interface HeartObject extends Lockable, Hideable {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+    rotation?: number;
+}
+declare function cloneHeart(heart: HeartObject): HeartObject;
+declare function cloneLine(line: LineObject): LineObject;
+declare function cloneArrow(arrow: ArrowObject): ArrowObject;
+/**
+ * A logical grouping of other board objects (Phase 3 — Selection,
+ * Transformation & Grouping). Deliberately has no `x`/`y`/`transform` of its
+ * own — a group's bounds are always derived on demand from its (recursively
+ * resolved) children, and "moving/rotating/scaling the group" is exactly a
+ * multi-object transform applied to those children, nothing more. A group
+ * has no renderer/mesh of its own; its only visual presence is the
+ * selection gizmo's bounding box while it's the current selection.
+ *
+ * `children` may itself contain other group ids (nested groups) — expanding
+ * a group into its leaf members is always done by the caller (recursively,
+ * with cycle protection), never assumed here.
+ */
+interface GroupObject extends Lockable, Hideable {
+    id: string;
+    children: string[];
+}
+declare function cloneGroup(group: GroupObject): GroupObject;
+
 interface BoardPoint {
     x: number;
     y: number;
@@ -428,9 +623,14 @@ interface StrokePoint extends BoardPoint {
      */
     erase?: number;
 }
-/** Which drawing tool made a stroke; undefined means marker (back-compat). */
-type StrokeTool = "marker" | "highlighter";
-interface Stroke extends Lockable {
+/**
+ * Which drawing tool made a stroke; undefined means marker (back-compat).
+ * `"shape"` (rect/ellipse/line/arrow/polygon/star/heart) renders at its
+ * exact configured width with no pressure variance or end taper — a
+ * geometric outline, not an expressive ink mark.
+ */
+type StrokeTool = "marker" | "highlighter" | "shape";
+interface Stroke extends Lockable, Hideable {
     id: string;
     color: string;
     baseWidth: number;
@@ -449,7 +649,7 @@ interface Stroke extends Lockable {
 declare const ERASE_THRESHOLD = 0.95;
 declare function cloneStroke(stroke: Stroke): Stroke;
 type SerializedPoint = [number, number, number, number];
-interface SerializedStroke extends Lockable {
+interface SerializedStroke extends Lockable, Hideable {
     id: string;
     color: string;
     baseWidth: number;
@@ -459,7 +659,36 @@ interface SerializedStroke extends Lockable {
     matrix?: [number, number, number, number, number, number];
     clusterId?: string;
 }
+/** A named notebook containing sections. */
+interface BoardNotebook {
+    readonly id: string;
+    readonly name: string;
+    readonly color: string;
+}
+/** A named section containing pages. */
+interface BoardSection {
+    readonly id: string;
+    readonly notebookId: string;
+    readonly name: string;
+    readonly color: string;
+}
+/** An additional page. The first page remains in the document's top-level collections. */
+interface SerializedBoardPage {
+    id: string;
+    sectionId?: string;
+    name: string;
+    content: SerializedDocument;
+}
 interface SerializedDocument {
+    /** Notebook and section metadata. Older boards use an implicit default of each. */
+    notebooks?: BoardNotebook[];
+    sections?: BoardSection[];
+    /** Section of the original first page; defaults to `default`. */
+    pageSectionId?: string;
+    /** Display name of the first page (id `default`). */
+    pageName?: string;
+    /** Additional pages, in sidebar order. Nested pages are not allowed. */
+    pages?: SerializedBoardPage[];
     /** Absent in every historical document; current saves always write 1. */
     schemaVersion?: 1;
     strokes: SerializedStroke[];
@@ -475,6 +704,31 @@ interface SerializedDocument {
     timers?: KitchenTimer[];
     /** Absent in documents saved before Custom board objects existed (ticket #22). */
     customObjects?: CustomBoardObject[];
+    /** Absent in documents saved before semantic Rectangle objects existed (Phase 2). */
+    rectangles?: RectangleObject[];
+    /** Absent in documents saved before semantic Ellipse objects existed (Phase 2). */
+    ellipses?: EllipseObject[];
+    /** Absent in documents saved before Groups existed (Phase 3). */
+    groups?: GroupObject[];
+    /** Absent in documents saved before semantic Line objects existed (Phase 4). */
+    lines?: LineObject[];
+    /** Absent in documents saved before semantic Arrow objects existed (Phase 4). */
+    arrows?: ArrowObject[];
+    /** Absent in documents saved before semantic Polygon objects existed (Phase 4). */
+    polygons?: PolygonObject[];
+    /** Absent in documents saved before semantic Star objects existed (Phase 4). */
+    stars?: StarObject[];
+    /** Absent in documents saved before semantic Heart objects existed (Phase 4). */
+    hearts?: HeartObject[];
+    /**
+     * Every content-object id (every type above except comments, which are
+     * host-synced and never enter this schema) in paint order, back to front.
+     * Absent in documents saved before per-object z-order existed (Phase 3) —
+     * migration synthesizes a default order preserving the old fixed-Z-band
+     * visual stacking exactly, so an existing document never visibly changes
+     * on load; only an explicit reorder action touches this from then on.
+     */
+    objectOrder?: string[];
 }
 declare const INK_COLORS: {
     readonly black: "#1C1C1E";
@@ -483,16 +737,28 @@ declare const INK_COLORS: {
     readonly green: "#16A34A";
 };
 declare const HIGHLIGHT_COLORS: {
+    readonly yellow: "#FACC15";
+    readonly green: "#4ADE80";
+    readonly pink: "#F472B6";
+    readonly blue: "#60A5FA";
+};
+declare const NOTE_COLORS: {
     readonly yellow: "#FDE047";
-    readonly green: "#86EFAC";
+    readonly amber: "#FACC15";
+    readonly orange: "#FB923C";
+    readonly peach: "#FDBA74";
+    readonly red: "#FB7185";
+    readonly rose: "#FDA4AF";
     readonly pink: "#F9A8D4";
+    readonly magenta: "#F472B6";
+    readonly purple: "#C084FC";
+    readonly lavender: "#C4B5FD";
     readonly blue: "#93C5FD";
-};
-declare const NOTE_COLORS: {
-    readonly yellow: "#FDE68A";
-    readonly pink: "#FBCFE8";
-    readonly blue: "#BFDBFE";
-    readonly green: "#BBF7D0";
+    readonly cornflower: "#60A5FA";
+    readonly sky: "#38BDF8";
+    readonly cyan: "#67E8F9";
+    readonly green: "#86EFAC";
+    readonly mint: "#4ADE80";
 };
 /**
  * One collaborator's vote on a note. One per person; toggling removes it.
@@ -506,7 +772,7 @@ interface NoteVote {
  * A sticky note: content floating above the board at a z-offset (pillar 3 —
  * depth as an organizational axis). Center position in board space.
  */
-interface StickyNote extends Lockable {
+interface StickyNote extends Lockable, Hideable {
     id: string;
     x: number;
     y: number;
@@ -524,7 +790,7 @@ interface StickyNote extends Lockable {
  * top-left corner; lines flow downward (-y). Text joins the clustering
  * system like handwriting (build prompt §6.4).
  */
-interface TextBlock extends Lockable {
+interface TextBlock extends Lockable, Hideable {
     id: string;
     x: number;
     y: number;
@@ -554,7 +820,7 @@ declare function cloneNote(note: StickyNote): StickyNote;
  * Interactive structured table on the board. Position (x, y) is top-left in board units.
  * Cells are indexed as `${row},${col}` keys mapping to cell text content.
  */
-interface TableBlock extends Lockable {
+interface TableBlock extends Lockable, Hideable {
     id: string;
     x: number;
     y: number;
@@ -580,7 +846,7 @@ declare const FOG_COLOR = "#FFFFFF";
  * An imported image block on the board plane.
  * Coordinates (x, y) represent the center of the image in board space.
  */
-interface ImageBlock extends Lockable {
+interface ImageBlock extends Lockable, Hideable {
     id: string;
     /**
      * A legacy, read-only data URL (or, historically, an arbitrary string) —
@@ -604,13 +870,29 @@ interface ImageBlock extends Lockable {
 }
 declare function cloneImage(img: ImageBlock): ImageBlock;
 
+declare const documentIdBrand: unique symbol;
+declare const strokeIdBrand: unique symbol;
+type DocumentId = string & {
+    readonly [documentIdBrand]: "DocumentId";
+};
+type StrokeId = string & {
+    readonly [strokeIdBrand]: "StrokeId";
+};
+declare function documentId(value: string): DocumentId;
+declare function strokeId(value: string): StrokeId;
+
 declare const CURRENT_DOCUMENT_SCHEMA_VERSION: 1;
 type CurrentSerializedStroke = Omit<SerializedStroke, "id"> & {
     id: StrokeId;
 };
-interface CurrentSerializedDocument extends Required<SerializedDocument> {
+interface CurrentSerializedDocument extends Required<Omit<SerializedDocument, "pages" | "pageName" | "notebooks" | "sections" | "pageSectionId">> {
     schemaVersion: typeof CURRENT_DOCUMENT_SCHEMA_VERSION;
     strokes: CurrentSerializedStroke[];
+    pageName?: string;
+    notebooks?: BoardNotebook[];
+    sections?: BoardSection[];
+    pageSectionId?: string;
+    pages?: SerializedBoardPage[];
 }
 type DocumentRecoveryCode = "DOCUMENT_JSON_INVALID" | "DOCUMENT_VALIDATION_FAILED" | "DOCUMENT_VERSION_UNSUPPORTED";
 declare class DocumentRecoveryError extends Error {
@@ -630,6 +912,15 @@ type DocumentLoadResult = {
 declare function loadDocumentBytes(originalBytes: string): DocumentLoadResult;
 declare function migrateDocument(raw: unknown): DocumentLoadResult;
 declare function serializeDocument(document: unknown): string;
+/**
+ * A Document's serialized size in bytes (Phase 5) — UTF-8, not UTF-16
+ * `string.length`, since a Document with non-ASCII note/text content (most
+ * of them, eventually) would otherwise under-report. Useful for a Host
+ * deciding when to warn about an unusually large board, or for logging/
+ * telemetry around save size — not consulted by anything inside this
+ * package itself, which has no size limit of its own.
+ */
+declare function documentSize(document: CurrentSerializedDocument): number;
 
 interface SearchableComment {
     id: string;
@@ -664,6 +955,18 @@ interface SearchableBoard {
  */
 declare function searchBoard(query: string, board: SearchableBoard): SearchHit[];
 
+interface ConnectorBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+/** A bindable object's footprint: its bounds and whether its outline is the box or the ellipse inside it. */
+interface ConnectorTarget {
+    box: ConnectorBox;
+    outline: "box" | "ellipse";
+}
+
 /**
  * The one place a live Stroke becomes its wire representation — in
  * particular, points collapse from {x,y,pressure,erase?} objects into
@@ -714,6 +1017,60 @@ interface DocumentChange {
     /** Ids of removed custom objects. */
     customObjectsRemoved: string[];
     customObjectsUpdated: CustomBoardObject[];
+    /** Semantic Rectangle objects (Phase 2). */
+    rectanglesAdded: RectangleObject[];
+    /** Ids of removed rectangles. */
+    rectanglesRemoved: string[];
+    rectanglesUpdated: RectangleObject[];
+    /** Semantic Ellipse objects (Phase 2). */
+    ellipsesAdded: EllipseObject[];
+    /** Ids of removed ellipses. */
+    ellipsesRemoved: string[];
+    ellipsesUpdated: EllipseObject[];
+    /** Groups (Phase 3). */
+    groupsAdded: GroupObject[];
+    /** Ids of removed groups (ungrouping, or deleting a group). */
+    groupsRemoved: string[];
+    groupsUpdated: GroupObject[];
+    /** Semantic Line objects (Phase 4). */
+    linesAdded: LineObject[];
+    /** Ids of removed lines. */
+    linesRemoved: string[];
+    linesUpdated: LineObject[];
+    /** Semantic Arrow objects (Phase 4). */
+    arrowsAdded: ArrowObject[];
+    /** Ids of removed arrows. */
+    arrowsRemoved: string[];
+    arrowsUpdated: ArrowObject[];
+    /** Semantic Polygon objects (Phase 4) — Triangle/Diamond/Pentagon/Hexagon/Octagon. */
+    polygonsAdded: PolygonObject[];
+    /** Ids of removed polygons. */
+    polygonsRemoved: string[];
+    polygonsUpdated: PolygonObject[];
+    /** Semantic Star objects (Phase 4). */
+    starsAdded: StarObject[];
+    /** Ids of removed stars. */
+    starsRemoved: string[];
+    starsUpdated: StarObject[];
+    /** Semantic Heart objects (Phase 4). */
+    heartsAdded: HeartObject[];
+    /** Ids of removed hearts. */
+    heartsRemoved: string[];
+    heartsUpdated: HeartObject[];
+    /**
+     * The full current paint order (back to front) of every flat content
+     * object — strokes, texts, tables, images, rectangles, ellipses, lines,
+     * arrows, custom objects, and groups. Populated whenever `objectOrder`
+     * actually changed:
+     * an explicit reorder (`bringForward` etc.), or any add/remove that
+     * touches it — a removal shifts every id after it down one rank, not
+     * just the removed one, so renderers need this to resync everyone, not
+     * only the ids the same change's own `*Added`/`*Removed`/`*Updated`
+     * fields name. Notes (their own `zOffset` peel depth) and Kitchen Timers
+     * (genuine 3D objects, not a flat layer) are intentionally not part of
+     * this order at all.
+     */
+    orderChanged: readonly string[];
 }
 type Listener = (change: DocumentChange) => void;
 declare class BoardDocument {
@@ -728,12 +1085,78 @@ declare class BoardDocument {
     private readonly timers;
     /** All Custom board object types share one map, keyed by id — the envelope is already uniform. */
     private readonly customObjects;
+    private readonly rectangles;
+    private readonly ellipses;
+    private readonly groups;
+    private readonly lines;
+    private readonly arrows;
+    private readonly polygons;
+    private readonly stars;
+    private readonly hearts;
     private readonly bboxes;
     private readonly listeners;
+    /** Paint order (back to front) of every flat content object — see `DocumentChange.orderChanged`'s doc comment. */
+    private objectOrder;
+    private orderIndex;
     constructor(id: DocumentId);
+    private reindexOrder;
+    /** The full current paint order, back to front. */
+    order(): readonly string[];
+    /** This object's rank in the paint order, or -1 if it doesn't participate (unknown id, a note, or a timer). */
+    orderRank(id: string): number;
+    private bringForward;
+    private sendBackward;
+    private bringToFront;
+    private sendToBack;
+    /** Reorders `id` relative to its current neighbors. A no-op for an id that doesn't participate in paint order (see `orderRank`). */
+    reorder(id: string, direction: "forward" | "backward" | "front" | "back"): void;
+    /**
+     * Overwrites the paint order directly — used only when loading a document
+     * that already carries a persisted `objectOrder`; every other order
+     * mutation goes through `reorder`/the automatic append-on-add tracking in
+     * `emit`. Ids not present in the document are dropped; ids present in the
+     * document but missing from `order` are appended at the back, so a
+     * partially-stale order (e.g. from a schema migration) never silently
+     * drops an object from paint order entirely.
+     */
+    private setOrder;
     get(id: string): Stroke | undefined;
     all(): IterableIterator<Stroke>;
-    bbox(id: string): BBox | undefined;
+    /**
+     * World-space bounds for any content object, of any type. Strokes hit
+     * their cached-on-mutation fast path (`bboxes`, populated by
+     * `addStrokes`/`transformStrokes` — many points, worth caching); every
+     * other type computes on demand via `objectBounds.ts` (cheap arithmetic,
+     * no caching needed). A group's bounds are the union of its (recursively
+     * resolved) children — `seen` guards against a cycle in nested groups.
+     */
+    /**
+     * What a connector can attach to at `id`: its bounds and outline shape.
+     * Connectors, lines and groups aren't targets (that would allow cycles).
+     */
+    connectorTarget(id: string): ConnectorTarget | undefined;
+    bbox(id: string, seen?: Set<string>): BBox | undefined;
+    /**
+     * True if `id` exists and is locked, for any type — the same per-type
+     * probe pattern as `bbox`, for interactive gestures (drag/transform) that
+     * need to gate on lock state regardless of what's selected. Custom
+     * objects are deliberately excluded: their `lock` field is a different
+     * shape (`{holderId, acquiredAt}`, no display name) with no interactive
+     * lock UI yet, matching the existing, deliberate "always unlockable,
+     * never gates a drag" treatment already established elsewhere (e.g.
+     * `getSelectedItemInfo`'s custom branch hardcodes `isLocked: false`).
+     */
+    isLocked(id: string): boolean;
+    /**
+     * True if `id` exists and is hidden, for any type — the same per-type
+     * probe pattern as {@link isLocked} (Phase 8). Custom objects are
+     * excluded for the same reason `isLocked` excludes them: they have no
+     * `Hideable` field at all, so "hidden" isn't a concept that applies to
+     * them yet. Used by marquee selection (`selectTool.ts`) to keep a hidden
+     * object out of a rubber-band selection even for object types whose own
+     * renderer doesn't yet suppress click-based hit-testing.
+     */
+    isHidden(id: string): boolean;
     subscribe(listener: Listener): () => void;
     addStrokes(strokes: Stroke[]): void;
     removeStrokes(ids: string[]): void;
@@ -776,6 +1199,54 @@ declare class BoardDocument {
     removeCustomObjects(ids: string[]): void;
     /** Replace a custom object's contents under the same id. */
     setCustomObject(object: CustomBoardObject): void;
+    getRectangle(id: string): RectangleObject | undefined;
+    allRectangles(): IterableIterator<RectangleObject>;
+    addRectangles(rectangles: RectangleObject[]): void;
+    removeRectangles(ids: string[]): void;
+    /** Replace a rectangle's contents (move, resize, restyle) under the same id. */
+    setRectangle(rect: RectangleObject): void;
+    getEllipse(id: string): EllipseObject | undefined;
+    allEllipses(): IterableIterator<EllipseObject>;
+    addEllipses(ellipses: EllipseObject[]): void;
+    removeEllipses(ids: string[]): void;
+    /** Replace an ellipse's contents (move, resize, restyle) under the same id. */
+    setEllipse(ellipse: EllipseObject): void;
+    getGroup(id: string): GroupObject | undefined;
+    allGroups(): IterableIterator<GroupObject>;
+    addGroups(groups: GroupObject[]): void;
+    removeGroups(ids: string[]): void;
+    /** Replace a group's contents (its children list) under the same id. */
+    setGroup(group: GroupObject): void;
+    getLine(id: string): LineObject | undefined;
+    allLines(): IterableIterator<LineObject>;
+    addLines(lines: LineObject[]): void;
+    removeLines(ids: string[]): void;
+    /** Replace a line's contents (move, restyle) under the same id. */
+    setLine(line: LineObject): void;
+    getArrow(id: string): ArrowObject | undefined;
+    allArrows(): IterableIterator<ArrowObject>;
+    addArrows(arrows: ArrowObject[]): void;
+    removeArrows(ids: string[]): void;
+    /** Replace an arrow's contents (move, restyle, change head) under the same id. */
+    setArrow(arrow: ArrowObject): void;
+    getPolygon(id: string): PolygonObject | undefined;
+    allPolygons(): IterableIterator<PolygonObject>;
+    addPolygons(polygons: PolygonObject[]): void;
+    removePolygons(ids: string[]): void;
+    /** Replace a polygon's contents (move, resize, rotate, restyle) under the same id. */
+    setPolygon(polygon: PolygonObject): void;
+    getStar(id: string): StarObject | undefined;
+    allStars(): IterableIterator<StarObject>;
+    addStars(stars: StarObject[]): void;
+    removeStars(ids: string[]): void;
+    /** Replace a star's contents (move, resize, rotate, restyle) under the same id. */
+    setStar(star: StarObject): void;
+    getHeart(id: string): HeartObject | undefined;
+    allHearts(): IterableIterator<HeartObject>;
+    addHearts(hearts: HeartObject[]): void;
+    removeHearts(ids: string[]): void;
+    /** Replace a heart's contents (move, resize, rotate, restyle) under the same id. */
+    setHeart(heart: HeartObject): void;
     setStrokeLocked(id: string, locked: boolean, by?: LockHolder | null): void;
     setStrokesLocked(ids: string[], locked: boolean, by?: LockHolder | null): void;
     setNoteLocked(id: string, locked: boolean, by?: LockHolder | null): void;
@@ -783,18 +1254,69 @@ declare class BoardDocument {
     setTableLocked(id: string, locked: boolean, by?: LockHolder | null): void;
     setImageLocked(id: string, locked: boolean, by?: LockHolder | null): void;
     setTimerLocked(id: string, locked: boolean, by?: LockHolder | null): void;
+    setRectangleLocked(id: string, locked: boolean, by?: LockHolder | null): void;
+    setEllipseLocked(id: string, locked: boolean, by?: LockHolder | null): void;
+    setGroupLocked(id: string, locked: boolean, by?: LockHolder | null): void;
+    setLineLocked(id: string, locked: boolean, by?: LockHolder | null): void;
+    setArrowLocked(id: string, locked: boolean, by?: LockHolder | null): void;
+    setPolygonLocked(id: string, locked: boolean, by?: LockHolder | null): void;
+    setStarLocked(id: string, locked: boolean, by?: LockHolder | null): void;
+    setHeartLocked(id: string, locked: boolean, by?: LockHolder | null): void;
     /** Replace all content (initial load). Does not touch `version`. */
-    replaceAll(strokes: Stroke[], notes: StickyNote[], texts: TextBlock[], tables?: TableBlock[], images?: ImageBlock[], timers?: KitchenTimer[], customObjects?: CustomBoardObject[]): void;
+    replaceAll(strokes: Stroke[], notes: StickyNote[], texts: TextBlock[], tables?: TableBlock[], images?: ImageBlock[], timers?: KitchenTimer[], customObjects?: CustomBoardObject[], rectangles?: RectangleObject[], ellipses?: EllipseObject[], groups?: GroupObject[], lines?: LineObject[], arrows?: ArrowObject[], polygons?: PolygonObject[], stars?: StarObject[], hearts?: HeartObject[], 
+    /** Persisted paint order; absent for a document saved before Phase 3, in which case one is synthesized (see `ORDERED_ADDED_FIELDS`'s doc comment). */
+    objectOrder?: readonly string[]): void;
     /** Apply incremental real-time change received from a remote collaborator over WebSocket. */
     applyRemoteChange(change: Partial<DocumentChange>): void;
     toJSON(): SerializedDocument;
+    static deserializeGroups(data: SerializedDocument): GroupObject[];
+    static deserializeLines(data: SerializedDocument): LineObject[];
+    static deserializeArrows(data: SerializedDocument): ArrowObject[];
+    static deserializePolygons(data: SerializedDocument): PolygonObject[];
+    static deserializeStars(data: SerializedDocument): StarObject[];
+    static deserializeHearts(data: SerializedDocument): HeartObject[];
     static deserializeCustomObjects(data: SerializedDocument): CustomBoardObject[];
+    static deserializeRectangles(data: SerializedDocument): RectangleObject[];
+    static deserializeEllipses(data: SerializedDocument): EllipseObject[];
     static deserializeImages(data: SerializedDocument): ImageBlock[];
     static deserializeTimers(data: SerializedDocument): KitchenTimer[];
     static deserializeNotes(data: SerializedDocument): StickyNote[];
     static deserializeTexts(data: SerializedDocument): TextBlock[];
     static deserializeTables(data: SerializedDocument): TableBlock[];
-    static deserializeStrokes(data: SerializedDocument): Stroke[];
+    /**
+     * `onSkip` (Phase 9) replaces an unconditional `console.error` — `core`
+     * must never do raw console I/O (no dev-gate, no way for a Host to
+     * suppress or redirect it), so a skipped stroke is now reported only if
+     * the caller asks for it, via whatever diagnostic channel it already
+     * has (e.g. `controller-internal.ts` routes this into the same typed
+     * `"error"` event every other diagnostic already uses). Silent by
+     * default, matching how every other `deserialize*` method here already
+     * behaves (no diagnostics at all).
+     */
+    static deserializeStrokes(data: SerializedDocument, onSkip?: (id: string, cause: unknown) => void): Stroke[];
+    /**
+     * Every mutation funnels through here, so paint-order tracking lives in
+     * exactly one place rather than at every individual add/remove call site
+     * (18 of them, times `replaceAll`/`applyRemoteChange`) — new ids are
+     * appended to the back (front-most) of `objectOrder`, removed ids are
+     * spliced out. An explicit reorder (`reorder`/`setOrder`) updates
+     * `objectOrder` itself before calling this, so this step is a no-op for
+     * ids already tracked (idempotent by construction: `orderIndex.has` gates
+     * every append).
+     *
+     * `orderChanged` (Phase 9) reports exactly the ids whose rank actually
+     * changed, using `orderIndex` throughout instead of `indexOf` — a pure
+     * append never shifts any existing id's rank (new ids land at the tail,
+     * already covered by this same change's own `Added` field, so
+     * `orderChanged` stays unset), while a removal shifts every id at-or-
+     * after the lowest removed rank down by one, computed in a single O(n)
+     * filter pass (not one `indexOf`+`splice` per removed id) regardless of
+     * how many ids this one change removes. Every renderer's `onChange` now
+     * looks up only the ids actually in `orderChanged` instead of walking
+     * its entire mesh map on any order-touching change — a broad, unfiltered
+     * `orderChanged` here would silently defeat that fix, not just waste
+     * cycles here.
+     */
     private emit;
 }
 
@@ -830,12 +1352,33 @@ interface Command {
     apply(doc: BoardDocument): void;
     revert(doc: BoardDocument): void;
 }
+/**
+ * Several commands applied/reverted together as one undo step (Phase 3
+ * consolidation — this exact class used to be hand-duplicated as a private
+ * `CommandBatch` in `controller-internal.ts` and an exported
+ * `ExtensionCommandBatch` in `interaction/tools/customTool.ts`; both now
+ * import this one instead). Revert runs in reverse order, so a batch that
+ * depends on ordering (e.g. add-then-reference) undoes cleanly.
+ */
+declare class CommandBatch implements Command {
+    readonly label: string;
+    private readonly commands;
+    constructor(label: string, commands: readonly Command[]);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
 /** How a command reached the document — undo/redo are audited distinctly. */
 type CommandKind = "do" | "undo" | "redo";
 declare class History {
     private readonly doc;
     private readonly undoStack;
     private readonly redoStack;
+    private scope;
+    private readonly scopes;
+    /** Switch independent page histories while retaining the same document instance. */
+    setScope(id: string): void;
+    /** Discard all page histories after replacing a saved document. */
+    clearScopes(): void;
     /**
      * Observer for every mutation, in one place: all board edits funnel
      * through record/undo/redo. The audit trail listens here.
@@ -894,6 +1437,40 @@ declare class TransformCommand implements Command {
     revert(doc: BoardDocument): void;
     private compose;
 }
+/**
+ * One move gesture over a mixed-type selection (Phase 3) — the general
+ * successor to `TransformCommand` for translation. `TransformCommand`
+ * itself stays as-is (still used for scale/rotate, which remain stroke-only
+ * this phase — see `interaction/tools/selectTool.ts`'s `TransformState`):
+ * its own per-id `doc.get(id)` check already no-ops safely for any id that
+ * isn't a stroke, so it doesn't need touching for that narrower case.
+ *
+ * `delta` here is always a pure translation (never scale/rotate), so
+ * `apply(delta, point)` is a safe, uniform way to move every position-only
+ * type's `x`/`y` — translating commutes trivially regardless of a shape's
+ * own rotation. Matrix-carrying types (stroke, Custom) instead compose
+ * `delta` onto their existing matrix/transform, matching `TransformCommand`.
+ *
+ * A group id in `ids` is expanded into its (recursively resolved, cycle-
+ * safe) children every time `compose` runs — deterministic, since group
+ * membership never changes mid-command — so moving a selected group means
+ * moving every one of its members by the same delta. This expansion is
+ * `TransformObjectsCommand`'s own responsibility precisely so a caller that
+ * doesn't itself expand groups (e.g. `ScrawlEngine.nudgeSelection`) still
+ * gets correct behavior; `interaction/tools/selectTool.ts`'s `TransformState`
+ * separately expands for its own reason (live per-child drag preview), which
+ * makes this a no-op re-expansion for that caller, not a conflict.
+ */
+declare class TransformObjectsCommand implements Command {
+    private readonly ids;
+    private readonly delta;
+    readonly label = "move selection";
+    private readonly inverse;
+    constructor(ids: readonly string[], delta: Mat2x3);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+    private compose;
+}
 declare class AddNoteCommand implements Command {
     readonly label = "add note";
     private readonly note;
@@ -1015,8 +1592,213 @@ declare class DeleteTimerCommand implements Command {
     apply(doc: BoardDocument): void;
     revert(doc: BoardDocument): void;
 }
+/** Add/update/delete for semantic Rectangle objects (Phase 2). */
+declare class AddRectangleCommand implements Command {
+    readonly label = "add rectangle";
+    private readonly rect;
+    constructor(rect: RectangleObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class UpdateRectangleCommand implements Command {
+    readonly label = "update rectangle";
+    private readonly before;
+    private readonly after;
+    constructor(before: RectangleObject, after: RectangleObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class DeleteRectangleCommand implements Command {
+    readonly label = "delete rectangle";
+    private readonly rect;
+    constructor(rect: RectangleObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+/** Add/update/delete for semantic Ellipse objects (Phase 2). */
+declare class AddEllipseCommand implements Command {
+    readonly label = "add ellipse";
+    private readonly ellipse;
+    constructor(ellipse: EllipseObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class UpdateEllipseCommand implements Command {
+    readonly label = "update ellipse";
+    private readonly before;
+    private readonly after;
+    constructor(before: EllipseObject, after: EllipseObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class DeleteEllipseCommand implements Command {
+    readonly label = "delete ellipse";
+    private readonly ellipse;
+    constructor(ellipse: EllipseObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+/** Add/update/delete for semantic Line objects (Phase 4). */
+declare class AddLineCommand implements Command {
+    readonly label = "add line";
+    private readonly line;
+    constructor(line: LineObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class UpdateLineCommand implements Command {
+    readonly label = "update line";
+    private readonly before;
+    private readonly after;
+    constructor(before: LineObject, after: LineObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class DeleteLineCommand implements Command {
+    readonly label = "delete line";
+    private readonly line;
+    constructor(line: LineObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+/** Add/update/delete for semantic Arrow objects (Phase 4). */
+declare class AddArrowCommand implements Command {
+    readonly label = "add arrow";
+    private readonly arrow;
+    constructor(arrow: ArrowObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class UpdateArrowCommand implements Command {
+    readonly label = "update arrow";
+    private readonly before;
+    private readonly after;
+    constructor(before: ArrowObject, after: ArrowObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class DeleteArrowCommand implements Command {
+    readonly label = "delete arrow";
+    private readonly arrow;
+    constructor(arrow: ArrowObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+/** Add/update/delete for semantic Polygon objects (Phase 4) — Triangle/Diamond/Pentagon/Hexagon/Octagon. */
+declare class AddPolygonCommand implements Command {
+    readonly label = "add polygon";
+    private readonly polygon;
+    constructor(polygon: PolygonObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class UpdatePolygonCommand implements Command {
+    readonly label = "update polygon";
+    private readonly before;
+    private readonly after;
+    constructor(before: PolygonObject, after: PolygonObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class DeletePolygonCommand implements Command {
+    readonly label = "delete polygon";
+    private readonly polygon;
+    constructor(polygon: PolygonObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+/** Add/update/delete for semantic Star objects (Phase 4). */
+declare class AddStarCommand implements Command {
+    readonly label = "add star";
+    private readonly star;
+    constructor(star: StarObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class UpdateStarCommand implements Command {
+    readonly label = "update star";
+    private readonly before;
+    private readonly after;
+    constructor(before: StarObject, after: StarObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class DeleteStarCommand implements Command {
+    readonly label = "delete star";
+    private readonly star;
+    constructor(star: StarObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+/** Add/update/delete for semantic Heart objects (Phase 4). */
+declare class AddHeartCommand implements Command {
+    readonly label = "add heart";
+    private readonly heart;
+    constructor(heart: HeartObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class UpdateHeartCommand implements Command {
+    readonly label = "update heart";
+    private readonly before;
+    private readonly after;
+    constructor(before: HeartObject, after: HeartObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class DeleteHeartCommand implements Command {
+    readonly label = "delete heart";
+    private readonly heart;
+    constructor(heart: HeartObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+/** Add/update/delete for Groups (Phase 3). */
+declare class AddGroupCommand implements Command {
+    readonly label = "group";
+    private readonly group;
+    constructor(group: GroupObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class UpdateGroupCommand implements Command {
+    readonly label = "update group";
+    private readonly before;
+    private readonly after;
+    constructor(before: GroupObject, after: GroupObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+declare class DeleteGroupCommand implements Command {
+    readonly label = "ungroup";
+    private readonly group;
+    constructor(group: GroupObject);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
+type ReorderDirection = "forward" | "backward" | "front" | "back";
+/**
+ * Bring-forward / send-backward / bring-to-front / send-to-back (Phase 3) —
+ * one command family covering all four directions rather than four
+ * near-identical classes, since the only difference between them is which
+ * `BoardDocument.reorder` direction to replay. Captures the full paint order
+ * on first `apply` rather than in the constructor — `BoardDocument.order()`
+ * needs the doc, which a `Command` only ever receives via `apply`/`revert` —
+ * so `revert` can restore it exactly; redo re-runs the same `reorder` call,
+ * which is deterministic because `revert` always restores the identical
+ * starting order first.
+ */
+declare class ReorderObjectCommand implements Command {
+    private readonly id;
+    private readonly direction;
+    readonly label: string;
+    private before;
+    constructor(id: string, direction: ReorderDirection);
+    apply(doc: BoardDocument): void;
+    revert(doc: BoardDocument): void;
+}
 interface LockTarget {
-    type: "stroke" | "note" | "text" | "table" | "image" | "timer";
+    type: "stroke" | "note" | "text" | "table" | "image" | "timer" | "rectangle" | "ellipse" | "group" | "line" | "arrow" | "polygon" | "star" | "heart";
     id: string;
     locked: boolean;
     lockedBy?: string;
@@ -1033,7 +1815,7 @@ declare class LockItemsCommand implements Command {
     private applyLock;
 }
 
-type OpCollection = "strokes" | "notes" | "textBlocks" | "tables" | "images" | "timers" | "customObjects";
+type OpCollection = "strokes" | "notes" | "textBlocks" | "tables" | "images" | "timers" | "rectangles" | "ellipses" | "groups" | "lines" | "arrows" | "polygons" | "stars" | "hearts" | "customObjects";
 type Op = {
     kind: "upsert";
     collection: OpCollection;
@@ -1064,15 +1846,23 @@ interface RibbonEdgePoint {
     /** 1 = intact ink, 0 = fully erased (from the erasure channel). */
     alpha: number;
 }
-declare function ribbonEdges(points: StrokePoint[], baseWidth: number): RibbonEdgePoint[];
+/**
+ * @param handDrawn Default `true`: ink's organic feel — width follows
+ * per-point pressure, and both ends taper. Pass `false` for a geometric
+ * shape outline, which has no real pressure signal and isn't a pen stroke
+ * with a lift-off: it renders at the exact `baseWidth`, uniformly, with no
+ * taper at its start/end (which, for a closed shape, is the same point —
+ * tapering it would visibly pinch just that one corner).
+ */
+declare function ribbonEdges(points: StrokePoint[], baseWidth: number, handDrawn?: boolean): RibbonEdgePoint[];
 
 declare class SpatialIndex {
     private readonly doc;
     private readonly cells;
-    private readonly strokeCells;
+    private readonly objectCells;
     private readonly unsubscribe;
     constructor(doc: BoardDocument);
-    /** Ids of strokes whose bbox may overlap the query rect. */
+    /** Ids of content objects (any type except groups) whose bbox may overlap the query rect. */
     query(minX: number, minY: number, maxX: number, maxY: number): Set<string>;
     dispose(): void;
     private insert;
@@ -1121,6 +1911,539 @@ declare function placePresenceBeacon(screen: {
     height: number;
 }, inset?: ViewportInset): PresencePlacement;
 
+interface IconDefinition {
+    /** Stable, set-prefixed id (`lucide:rocket`), also what an ImageBlock stores in its `stamp` field. */
+    readonly name: string;
+    readonly label: string;
+    readonly category: string;
+    /** Inner SVG markup for a 24x24 viewBox; strokes use `currentColor`. */
+    readonly body: string;
+}
+declare const ICON_LIBRARY: readonly [{
+    readonly name: "lucide:check";
+    readonly label: "Check";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M20 6L9 17l-5-5\"/>";
+}, {
+    readonly name: "lucide:x";
+    readonly label: "Cross";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M18 6L6 18M6 6l12 12\"/>";
+}, {
+    readonly name: "lucide:star";
+    readonly label: "Star";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M11.525 2.295a.53.53 0 0 1 .95 0l2.31 4.679a2.12 2.12 0 0 0 1.595 1.16l5.166.756a.53.53 0 0 1 .294.904l-3.736 3.638a2.12 2.12 0 0 0-.611 1.878l.882 5.14a.53.53 0 0 1-.771.56l-4.618-2.428a2.12 2.12 0 0 0-1.973 0L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.12 2.12 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.12 2.12 0 0 0 1.597-1.16z\"/>";
+}, {
+    readonly name: "lucide:heart";
+    readonly label: "Heart";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M2 9.5a5.5 5.5 0 0 1 9.591-3.676a.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 2.29-1.5 4-3 5.5l-5.492 5.313a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5\"/>";
+}, {
+    readonly name: "lucide:flag";
+    readonly label: "Flag";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 22V4a1 1 0 0 1 .4-.8A6 6 0 0 1 8 2c3 0 5 2 7.333 2q2 0 3.067-.8A1 1 0 0 1 20 4v10a1 1 0 0 1-.4.8A6 6 0 0 1 16 16c-3 0-5-2-8-2a6 6 0 0 0-4 1.528\"/>";
+}, {
+    readonly name: "lucide:bookmark";
+    readonly label: "Bookmark";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M17 3a2 2 0 0 1 2 2v15a1 1 0 0 1-1.496.868l-4.512-2.578a2 2 0 0 0-1.984 0l-4.512 2.578A1 1 0 0 1 5 20V5a2 2 0 0 1 2-2z\"/>";
+}, {
+    readonly name: "lucide:bell";
+    readonly label: "Bell";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M10.268 21a2 2 0 0 0 3.464 0m-10.47-5.674A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326\"/>";
+}, {
+    readonly name: "lucide:info";
+    readonly label: "Info";
+    readonly category: "Status";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><circle cx=\"12\" cy=\"12\" r=\"10\"/><path d=\"M12 16v-4m0-4h.01\"/></g>";
+}, {
+    readonly name: "lucide:circle-alert";
+    readonly label: "Alert";
+    readonly category: "Status";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><circle cx=\"12\" cy=\"12\" r=\"10\"/><path d=\"M12 8v4m0 4h.01\"/></g>";
+}, {
+    readonly name: "lucide:circle-question-mark";
+    readonly label: "Question";
+    readonly category: "Status";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><circle cx=\"12\" cy=\"12\" r=\"10\"/><path d=\"M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3m.08 4h.01\"/></g>";
+}, {
+    readonly name: "lucide:thumbs-up";
+    readonly label: "Thumbs up";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15 5.88L14 10h5.83a2 2 0 0 1 1.92 2.56l-2.33 8A2 2 0 0 1 17.5 22H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2h2.76a2 2 0 0 0 1.79-1.11L12 2a3.13 3.13 0 0 1 3 3.88M7 10v12\"/>";
+}, {
+    readonly name: "lucide:thumbs-down";
+    readonly label: "Thumbs down";
+    readonly category: "Status";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M9 18.12L10 14H4.17a2 2 0 0 1-1.92-2.56l2.33-8A2 2 0 0 1 6.5 2H20a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.76a2 2 0 0 0-1.79 1.11L12 22a3.13 3.13 0 0 1-3-3.88M17 14V2\"/>";
+}, {
+    readonly name: "lucide:arrow-up";
+    readonly label: "Arrow up";
+    readonly category: "Arrows";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"m5 12l7-7l7 7m-7 7V5\"/>";
+}, {
+    readonly name: "lucide:arrow-down";
+    readonly label: "Arrow down";
+    readonly category: "Arrows";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 5v14m7-7l-7 7l-7-7\"/>";
+}, {
+    readonly name: "lucide:arrow-left";
+    readonly label: "Arrow left";
+    readonly category: "Arrows";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"m12 19l-7-7l7-7m7 7H5\"/>";
+}, {
+    readonly name: "lucide:arrow-right";
+    readonly label: "Arrow right";
+    readonly category: "Arrows";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M5 12h14m-7-7l7 7l-7 7\"/>";
+}, {
+    readonly name: "lucide:arrow-up-right";
+    readonly label: "Arrow up-right";
+    readonly category: "Arrows";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M7 7h10v10M7 17L17 7\"/>";
+}, {
+    readonly name: "lucide:refresh-cw";
+    readonly label: "Refresh";
+    readonly category: "Arrows";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M3 12a9 9 0 0 1 9-9a9.75 9.75 0 0 1 6.74 2.74L21 8\"/><path d=\"M21 3v5h-5m5 4a9 9 0 0 1-9 9a9.75 9.75 0 0 1-6.74-2.74L3 16\"/><path d=\"M8 16H3v5\"/></g>";
+}, {
+    readonly name: "lucide:move";
+    readonly label: "Move";
+    readonly category: "Arrows";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 2v20m3-3l-3 3l-3-3M19 9l3 3l-3 3M2 12h20M5 9l-3 3l3 3M9 5l3-3l3 3\"/>";
+}, {
+    readonly name: "lucide:shuffle";
+    readonly label: "Shuffle";
+    readonly category: "Arrows";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"m18 14l4 4l-4 4m0-20l4 4l-4 4\"/><path d=\"M2 18h1.973a4 4 0 0 0 3.3-1.7l5.454-8.6a4 4 0 0 1 3.3-1.7H22M2 6h1.972a4 4 0 0 1 3.6 2.2M22 18h-6.041a4 4 0 0 1-3.3-1.8l-.359-.45\"/></g>";
+}, {
+    readonly name: "lucide:user";
+    readonly label: "User";
+    readonly category: "People";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M19 21v-2a4 4 0 0 0-4-4H9a4 4 0 0 0-4 4v2\"/><circle cx=\"12\" cy=\"7\" r=\"4\"/></g>";
+}, {
+    readonly name: "lucide:users";
+    readonly label: "Users";
+    readonly category: "People";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2M16 3.128a4 4 0 0 1 0 7.744M22 21v-2a4 4 0 0 0-3-3.87\"/><circle cx=\"9\" cy=\"7\" r=\"4\"/></g>";
+}, {
+    readonly name: "lucide:briefcase";
+    readonly label: "Briefcase";
+    readonly category: "People";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M16 20V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16\"/><rect width=\"20\" height=\"14\" x=\"2\" y=\"6\" rx=\"2\"/></g>";
+}, {
+    readonly name: "lucide:building";
+    readonly label: "Building";
+    readonly category: "People";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M12 10h.01M12 14h.01M12 6h.01M16 10h.01M16 14h.01M16 6h.01M8 10h.01M8 14h.01M8 6h.01M9 22v-3a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v3\"/><rect width=\"16\" height=\"20\" x=\"4\" y=\"2\" rx=\"2\"/></g>";
+}, {
+    readonly name: "lucide:calendar";
+    readonly label: "Calendar";
+    readonly category: "People";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M8 2v3m8-3v3\"/><rect width=\"18\" height=\"18\" x=\"3\" y=\"3\" rx=\"2\"/><path d=\"M3 9h18\"/></g>";
+}, {
+    readonly name: "lucide:clock";
+    readonly label: "Clock";
+    readonly category: "People";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><circle cx=\"12\" cy=\"12\" r=\"10\"/><path d=\"M12 6v6l4 2\"/></g>";
+}, {
+    readonly name: "lucide:mail";
+    readonly label: "Mail";
+    readonly category: "People";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"m22 7l-8.991 5.727a2 2 0 0 1-2.009 0L2 7\"/><rect width=\"20\" height=\"16\" x=\"2\" y=\"4\" rx=\"2\"/></g>";
+}, {
+    readonly name: "lucide:message-circle";
+    readonly label: "Message";
+    readonly category: "People";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092a10 10 0 1 0-4.777-4.719\"/>";
+}, {
+    readonly name: "lucide:file";
+    readonly label: "File";
+    readonly category: "Objects";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z\"/><path d=\"M14 2v5a1 1 0 0 0 1 1h5\"/></g>";
+}, {
+    readonly name: "lucide:folder";
+    readonly label: "Folder";
+    readonly category: "Objects";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z\"/>";
+}, {
+    readonly name: "lucide:image";
+    readonly label: "Image";
+    readonly category: "Objects";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><rect width=\"18\" height=\"18\" x=\"3\" y=\"3\" rx=\"2\" ry=\"2\"/><circle cx=\"9\" cy=\"9\" r=\"2\"/><path d=\"m21 15l-3.086-3.086a2 2 0 0 0-2.828 0L6 21\"/></g>";
+}, {
+    readonly name: "lucide:link";
+    readonly label: "Link";
+    readonly category: "Objects";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71\"/><path d=\"M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71\"/></g>";
+}, {
+    readonly name: "lucide:paperclip";
+    readonly label: "Paperclip";
+    readonly category: "Objects";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"m16 6l-8.414 8.586a2 2 0 0 0 2.829 2.829l8.414-8.586a4 4 0 1 0-5.657-5.657l-8.379 8.551a6 6 0 1 0 8.485 8.485l8.379-8.551\"/>";
+}, {
+    readonly name: "lucide:pin";
+    readonly label: "Pin";
+    readonly category: "Objects";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 17v5M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1a2 2 0 0 0 0-4H8a2 2 0 0 0 0 4a1 1 0 0 1 1 1z\"/>";
+}, {
+    readonly name: "lucide:map-pin";
+    readonly label: "Map pin";
+    readonly category: "Objects";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0\"/><circle cx=\"12\" cy=\"10\" r=\"3\"/></g>";
+}, {
+    readonly name: "lucide:search";
+    readonly label: "Search";
+    readonly category: "Objects";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"m21 21l-4.34-4.34\"/><circle cx=\"11\" cy=\"11\" r=\"8\"/></g>";
+}, {
+    readonly name: "lucide:settings";
+    readonly label: "Settings";
+    readonly category: "Objects";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M9.671 4.136a2.34 2.34 0 0 1 4.659 0a2.34 2.34 0 0 0 3.319 1.915a2.34 2.34 0 0 1 2.33 4.033a2.34 2.34 0 0 0 0 3.831a2.34 2.34 0 0 1-2.33 4.033a2.34 2.34 0 0 0-3.319 1.915a2.34 2.34 0 0 1-4.659 0a2.34 2.34 0 0 0-3.32-1.915a2.34 2.34 0 0 1-2.33-4.033a2.34 2.34 0 0 0 0-3.831A2.34 2.34 0 0 1 6.35 6.051a2.34 2.34 0 0 0 3.319-1.915\"/><circle cx=\"12\" cy=\"12\" r=\"3\"/></g>";
+}, {
+    readonly name: "lucide:trash-2";
+    readonly label: "Trash";
+    readonly category: "Objects";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M10 11v6m4-6v6m5-11v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6M3 6h18M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2\"/>";
+}, {
+    readonly name: "lucide:lock";
+    readonly label: "Lock";
+    readonly category: "Objects";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><rect width=\"18\" height=\"11\" x=\"3\" y=\"11\" rx=\"2\" ry=\"2\"/><path d=\"M7 11V7a5 5 0 0 1 10 0v4\"/></g>";
+}, {
+    readonly name: "lucide:key";
+    readonly label: "Key";
+    readonly category: "Objects";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"m15.5 7.5l2.3 2.3a1 1 0 0 0 1.4 0l2.1-2.1a1 1 0 0 0 0-1.4L19 4m2-2l-9.6 9.6\"/><circle cx=\"7.5\" cy=\"15.5\" r=\"5.5\"/></g>";
+}, {
+    readonly name: "lucide:code";
+    readonly label: "Code";
+    readonly category: "Tech";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"m16 18l6-6l-6-6M8 6l-6 6l6 6\"/>";
+}, {
+    readonly name: "lucide:database";
+    readonly label: "Database";
+    readonly category: "Tech";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><ellipse cx=\"12\" cy=\"5\" rx=\"9\" ry=\"3\"/><path d=\"M3 5v14a9 3 0 0 0 18 0V5\"/><path d=\"M3 12a9 3 0 0 0 18 0\"/></g>";
+}, {
+    readonly name: "lucide:server";
+    readonly label: "Server";
+    readonly category: "Tech";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><rect width=\"20\" height=\"8\" x=\"2\" y=\"2\" rx=\"2\" ry=\"2\"/><rect width=\"20\" height=\"8\" x=\"2\" y=\"14\" rx=\"2\" ry=\"2\"/><path d=\"M6 6h.01M6 18h.01\"/></g>";
+}, {
+    readonly name: "lucide:cloud";
+    readonly label: "Cloud";
+    readonly category: "Tech";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9\"/>";
+}, {
+    readonly name: "lucide:git-branch";
+    readonly label: "Branch";
+    readonly category: "Tech";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M15 6a9 9 0 0 0-9 9V3\"/><circle cx=\"18\" cy=\"6\" r=\"3\"/><circle cx=\"6\" cy=\"18\" r=\"3\"/></g>";
+}, {
+    readonly name: "lucide:terminal";
+    readonly label: "Terminal";
+    readonly category: "Tech";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M12 19h8M4 17l6-6l-6-6\"/>";
+}, {
+    readonly name: "lucide:cpu";
+    readonly label: "CPU";
+    readonly category: "Tech";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M12 20v2m0-20v2m5 16v2m0-20v2M2 12h2m-2 5h2M2 7h2m16 5h2m-2 5h2M20 7h2M7 20v2M7 2v2\"/><rect width=\"16\" height=\"16\" x=\"4\" y=\"4\" rx=\"2\"/><rect width=\"8\" height=\"8\" x=\"8\" y=\"8\" rx=\"1\"/></g>";
+}, {
+    readonly name: "lucide:bug";
+    readonly label: "Bug";
+    readonly category: "Tech";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M12 20v-9m2-4a4 4 0 0 1 4 4v3a6 6 0 0 1-12 0v-3a4 4 0 0 1 4-4zm.12-3.12L16 2\"/><path d=\"M21 21a4 4 0 0 0-3.81-4M21 5a4 4 0 0 1-3.55 3.97M22 13h-4M3 21a4 4 0 0 1 3.81-4M3 5a4 4 0 0 0 3.55 3.97M6 13H2M8 2l1.88 1.88M9 7.13V6a3 3 0 1 1 6 0v1.13\"/></g>";
+}, {
+    readonly name: "lucide:lightbulb";
+    readonly label: "Idea";
+    readonly category: "Ideas";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15 14c.2-1 .7-1.7 1.5-2.5c1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5c.7.7 1.3 1.5 1.5 2.5m0 4h6m-5 4h4\"/>";
+}, {
+    readonly name: "lucide:zap";
+    readonly label: "Zap";
+    readonly category: "Ideas";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M15.914 4a1.5 1.5 0 0 0-2.474-1.561l-9 9A1.5 1.5 0 0 0 5.5 14h4.002a.5.5 0 0 1 .471.666L8.086 20a1.5 1.5 0 0 0 2.475 1.56l9-9A1.5 1.5 0 0 0 18.5 10h-3.997a.5.5 0 0 1-.472-.667z\"/>";
+}, {
+    readonly name: "lucide:target";
+    readonly label: "Target";
+    readonly category: "Ideas";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><circle cx=\"12\" cy=\"12\" r=\"10\"/><circle cx=\"12\" cy=\"12\" r=\"6\"/><circle cx=\"12\" cy=\"12\" r=\"2\"/></g>";
+}, {
+    readonly name: "lucide:rocket";
+    readonly label: "Rocket";
+    readonly category: "Ideas";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M12 15v5s3.03-.55 4-2c1.08-1.62 0-5 0-5M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09\"/><path d=\"M9 12a22 22 0 0 1 2-3.95A12.88 12.88 0 0 1 22 2c0 2.72-.78 7.5-6 11a22.4 22.4 0 0 1-4 2z\"/><path d=\"M9 12H4s.55-3.03 2-4c1.62-1.08 5 .05 5 .05\"/></g>";
+}, {
+    readonly name: "lucide:trophy";
+    readonly label: "Trophy";
+    readonly category: "Ideas";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M10 14.66V17a1 1 0 0 1-1 1a2 2 0 0 0-2 2v2m7-7.34V17a1 1 0 0 0 1 1a2 2 0 0 1 2 2v2m.916-12H19.5A2.5 2.5 0 0 0 22 7.5V5a1 1 0 0 0-1-1h-3M4 22h16\"/><path d=\"M6 9a6 6 0 0 0 12 0V3a1 1 0 0 0-1-1H7a1 1 0 0 0-1 1z\"/><path d=\"M6.084 10H4.5A2.5 2.5 0 0 1 2 7.5V5a1 1 0 0 1 1-1h3\"/></g>";
+}, {
+    readonly name: "lucide:gift";
+    readonly label: "Gift";
+    readonly category: "Ideas";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><path d=\"M12 7v14m8-10v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-8m3.5-4a1 1 0 0 1 0-5A4.8 8 0 0 1 12 7a4.8 8 0 0 1 4.5-5a1 1 0 0 1 0 5\"/><rect width=\"18\" height=\"4\" x=\"3\" y=\"7\" rx=\"1\"/></g>";
+}, {
+    readonly name: "lucide:coffee";
+    readonly label: "Coffee";
+    readonly category: "Ideas";
+    readonly body: "<path fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M10 2v2m4-2v2m2 4a1 1 0 0 1 1 1v8a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1h14a4 4 0 1 1 0 8h-1M6 2v2\"/>";
+}, {
+    readonly name: "lucide:smile";
+    readonly label: "Smile";
+    readonly category: "Ideas";
+    readonly body: "<g fill=\"none\" stroke=\"currentColor\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\"><circle cx=\"12\" cy=\"12\" r=\"10\"/><path d=\"M8 14s1.5 2 4 2s4-2 4-2M9 9h.01M15 9h.01\"/></g>";
+}];
+/** Every vendored icon's id, as a literal union. */
+type IconName = (typeof ICON_LIBRARY)[number]["name"];
+
+/**
+ * Emoji stickers. Unlike the icon library there's no artwork to vendor: each
+ * is a Unicode character, drawn by the platform's own colour-emoji font when
+ * its SVG is rasterised — so an emoji looks native to each viewer's OS
+ * (Apple, Segoe, Noto), the same way it would in a chat app.
+ */
+interface EmojiDefinition {
+    /** Stable, set-prefixed id (`emoji:fire`), also what an ImageBlock stores in its `stamp` field. */
+    readonly name: string;
+    readonly label: string;
+    readonly category: string;
+    readonly char: string;
+}
+declare const EMOJI_LIBRARY: readonly [{
+    readonly name: "emoji:grinning";
+    readonly label: "Grinning face";
+    readonly category: "Smileys";
+    readonly char: "😀";
+}, {
+    readonly name: "emoji:joy";
+    readonly label: "Tears of joy";
+    readonly category: "Smileys";
+    readonly char: "😂";
+}, {
+    readonly name: "emoji:smiling";
+    readonly label: "Smiling face";
+    readonly category: "Smileys";
+    readonly char: "😊";
+}, {
+    readonly name: "emoji:heart-eyes";
+    readonly label: "Heart eyes";
+    readonly category: "Smileys";
+    readonly char: "😍";
+}, {
+    readonly name: "emoji:thinking";
+    readonly label: "Thinking face";
+    readonly category: "Smileys";
+    readonly char: "🤔";
+}, {
+    readonly name: "emoji:sunglasses";
+    readonly label: "Sunglasses";
+    readonly category: "Smileys";
+    readonly char: "😎";
+}, {
+    readonly name: "emoji:crying";
+    readonly label: "Crying face";
+    readonly category: "Smileys";
+    readonly char: "😢";
+}, {
+    readonly name: "emoji:angry";
+    readonly label: "Angry face";
+    readonly category: "Smileys";
+    readonly char: "😡";
+}, {
+    readonly name: "emoji:sleeping";
+    readonly label: "Sleeping face";
+    readonly category: "Smileys";
+    readonly char: "😴";
+}, {
+    readonly name: "emoji:mind-blown";
+    readonly label: "Mind blown";
+    readonly category: "Smileys";
+    readonly char: "🤯";
+}, {
+    readonly name: "emoji:grimacing";
+    readonly label: "Grimacing face";
+    readonly category: "Smileys";
+    readonly char: "😬";
+}, {
+    readonly name: "emoji:partying";
+    readonly label: "Partying face";
+    readonly category: "Smileys";
+    readonly char: "🥳";
+}, {
+    readonly name: "emoji:thumbs-up";
+    readonly label: "Thumbs up emoji";
+    readonly category: "Gestures";
+    readonly char: "👍";
+}, {
+    readonly name: "emoji:thumbs-down";
+    readonly label: "Thumbs down emoji";
+    readonly category: "Gestures";
+    readonly char: "👎";
+}, {
+    readonly name: "emoji:clap";
+    readonly label: "Clapping hands";
+    readonly category: "Gestures";
+    readonly char: "👏";
+}, {
+    readonly name: "emoji:raised-hands";
+    readonly label: "Raised hands";
+    readonly category: "Gestures";
+    readonly char: "🙌";
+}, {
+    readonly name: "emoji:folded-hands";
+    readonly label: "Folded hands";
+    readonly category: "Gestures";
+    readonly char: "🙏";
+}, {
+    readonly name: "emoji:eyes";
+    readonly label: "Eyes";
+    readonly category: "Gestures";
+    readonly char: "👀";
+}, {
+    readonly name: "emoji:muscle";
+    readonly label: "Flexed biceps";
+    readonly category: "Gestures";
+    readonly char: "💪";
+}, {
+    readonly name: "emoji:wave";
+    readonly label: "Waving hand";
+    readonly category: "Gestures";
+    readonly char: "👋";
+}, {
+    readonly name: "emoji:red-heart";
+    readonly label: "Red heart";
+    readonly category: "Symbols";
+    readonly char: "❤️";
+}, {
+    readonly name: "emoji:fire";
+    readonly label: "Flame";
+    readonly category: "Symbols";
+    readonly char: "🔥";
+}, {
+    readonly name: "emoji:star";
+    readonly label: "Medium star";
+    readonly category: "Symbols";
+    readonly char: "⭐";
+}, {
+    readonly name: "emoji:check";
+    readonly label: "Check mark button";
+    readonly category: "Symbols";
+    readonly char: "✅";
+}, {
+    readonly name: "emoji:cross";
+    readonly label: "Cross mark";
+    readonly category: "Symbols";
+    readonly char: "❌";
+}, {
+    readonly name: "emoji:warning";
+    readonly label: "Warning sign";
+    readonly category: "Symbols";
+    readonly char: "⚠️";
+}, {
+    readonly name: "emoji:question";
+    readonly label: "Red question mark";
+    readonly category: "Symbols";
+    readonly char: "❓";
+}, {
+    readonly name: "emoji:hundred";
+    readonly label: "Hundred points";
+    readonly category: "Symbols";
+    readonly char: "💯";
+}, {
+    readonly name: "emoji:light-bulb";
+    readonly label: "Light bulb";
+    readonly category: "Symbols";
+    readonly char: "💡";
+}, {
+    readonly name: "emoji:bullseye";
+    readonly label: "Bullseye";
+    readonly category: "Symbols";
+    readonly char: "🎯";
+}, {
+    readonly name: "emoji:party-popper";
+    readonly label: "Party popper";
+    readonly category: "Objects";
+    readonly char: "🎉";
+}, {
+    readonly name: "emoji:rocket";
+    readonly label: "Rocket emoji";
+    readonly category: "Objects";
+    readonly char: "🚀";
+}, {
+    readonly name: "emoji:trophy";
+    readonly label: "Trophy emoji";
+    readonly category: "Objects";
+    readonly char: "🏆";
+}, {
+    readonly name: "emoji:pushpin";
+    readonly label: "Pushpin";
+    readonly category: "Objects";
+    readonly char: "📌";
+}, {
+    readonly name: "emoji:memo";
+    readonly label: "Memo";
+    readonly category: "Objects";
+    readonly char: "📝";
+}, {
+    readonly name: "emoji:calendar";
+    readonly label: "Tear-off calendar";
+    readonly category: "Objects";
+    readonly char: "📅";
+}, {
+    readonly name: "emoji:alarm-clock";
+    readonly label: "Alarm clock";
+    readonly category: "Objects";
+    readonly char: "⏰";
+}, {
+    readonly name: "emoji:speech-balloon";
+    readonly label: "Speech balloon";
+    readonly category: "Objects";
+    readonly char: "💬";
+}];
+type EmojiName = (typeof EMOJI_LIBRARY)[number]["name"];
+declare function isEmojiName(value: unknown): value is EmojiName;
+declare function emojiDefinition(name: string): EmojiDefinition | undefined;
+/** An emoji as a standalone SVG data URL, sized to rasterise sharply (see icons.ts). */
+declare function emojiDataUrl(name: string): string;
+
+/**
+ * What the stamp tool will drop next: one of the six built-in stamp-pad
+ * stickers, an emoji, or any vendored icon. All land on the board the same way
+ * — as an image whose `stamp` field records which one it was (see `placeStamp`).
+ */
+type StickerKind = StampKind | EmojiName | IconName;
+declare function isIconName(value: unknown): value is IconName;
+declare function iconDefinition(name: string): IconDefinition | undefined;
+/** The vendored icons grouped for a picker, in the order they were vendored. */
+declare function iconCategories(): {
+    category: string;
+    icons: readonly IconDefinition[];
+}[];
+/**
+ * An icon as a standalone SVG data URL, drawn in `color`.
+ *
+ * The library's art strokes in `currentColor`, which has no meaning once the
+ * markup is detached into a data URL — an `<img>`/texture has no inherited
+ * colour to resolve it against — so the colour is substituted in rather than
+ * inherited.
+ */
+declare function iconDataUrl(name: string, color: string): string;
+declare function isStickerKind(value: unknown): value is StickerKind;
+/** Human-readable name for any sticker kind — what a placed sticker is called and searched by. */
+declare function stickerLabel(kind: StickerKind): string;
+/**
+ * The image `src` for whichever sticker kind is selected. Stamp-pad stamps
+ * and emoji carry their own colours, so only icons take the Host's colour.
+ */
+declare function stickerDataUrl(kind: StickerKind, color: string): string;
+
 interface ExtensionRegistry {
     readonly extensions: readonly ScrawlExtension[];
     tool(id: ToolId): CustomToolDefinition | undefined;
@@ -1192,16 +2515,37 @@ interface BoardStyle {
     readonly noteColor: string;
     readonly tableRows: number;
     readonly tableCols: number;
-    readonly stampKind: StampKind;
+    /** A stamp-pad kind or any vendored icon name (see `ICON_LIBRARY`). */
+    readonly stampKind: StickerKind;
     readonly timerDurationMs: number;
 }
+/** A page listed in the Board navigator. `default` is the original first page. */
+interface BoardPage {
+    readonly id: string;
+    readonly name: string;
+    readonly sectionId: string;
+}
 interface BoardSnapshot {
+    readonly notebooks: readonly BoardNotebook[];
+    readonly sections: readonly BoardSection[];
+    readonly activeNotebookId: string;
+    readonly activeSectionId: string;
+    readonly pages: readonly BoardPage[];
+    readonly activePageId: string;
     readonly status: "loading" | "ready" | "disposed";
     readonly documentId: string;
     readonly tool: BuiltInTool | (string & {});
     readonly zoom: number;
     readonly readOnly: boolean;
     readonly selection: readonly string[];
+    readonly focusedItem: FocusedItem | null;
+    /**
+     * What an inline editor currently covers, as last set through
+     * `view.setInlineEditing` — a text block (`{ id }`) or a table cell
+     * (`{ id, row, col }`), else null. Chrome uses it to stay out of an open
+     * editor's way.
+     */
+    readonly inlineEditing: InlineEditingTarget | null;
     readonly strokeCount: number;
     readonly objectCount: number;
     readonly canUndo: boolean;
@@ -1212,6 +2556,39 @@ interface BoardSnapshot {
         readonly collaboration: CollaborationSnapshot;
     };
 }
+/**
+ * `selection` collapsed into the one thing a selected-object toolbar needs:
+ * what's selected, its lock state, and where to anchor above it. `null`
+ * when nothing is selected, or when the selection mixes types/objects that
+ * don't resolve to a single focus (anything but one object, or several
+ * strokes sharing a `clusterId` — a multi-stroke shape).
+ *
+ * Raw lock fields, not a derived `canUnlock` — this API has no notion of
+ * "the local user" to judge that against (see `canUnlockItem` in `../core`,
+ * which takes a `userId` the Host already owns). A Custom object's lock
+ * shape doesn't carry a holder name, so it always reports `locked: false`
+ * here, matching the engine's own internal selection-badge behavior.
+ */
+/** Axis-aligned bounds in board space (y up). */
+interface BoardBounds {
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+}
+interface InlineEditingTarget {
+    readonly id: string;
+    readonly row?: number;
+    readonly col?: number;
+}
+interface FocusedItem {
+    readonly type: "stroke" | "note" | "text" | "table" | "image" | "timer" | "rectangle" | "ellipse" | "group" | "line" | "arrow" | "polygon" | "star" | "heart" | "custom";
+    readonly id: string;
+    readonly locked: boolean;
+    readonly lockedBy?: string;
+    readonly lockedByName?: string;
+    readonly screenPosition?: ScreenPoint;
+}
 interface BoardControllerError {
     source: "controller" | "renderer" | "persistence" | "collaboration";
     code: string;
@@ -1220,6 +2597,9 @@ interface BoardControllerError {
 }
 interface BoardEventMap {
     change: BoardSnapshot;
+    "page-changing": {
+        pageId: string;
+    };
     "tool-change": {
         tool: string;
     };
@@ -1286,6 +2666,8 @@ interface BoardEventMap {
     "asset-diagnostic": AssetDiagnostic;
     /** A batch of Ops was reconciled (not applied as-sent) by the persistence adapter (ticket #24). */
     "persistence-diagnostic": PersistenceDiagnostic;
+    /** The collaboration server has confirmed receipt of these op ids (Phase 7) — observability only; the Document was already correct via optimistic local apply before this ever fires. */
+    "collaboration-ops-acknowledged": CollaborationAckDiagnostic;
     audit: unknown;
     error: BoardControllerError;
     disposed: undefined;
@@ -1305,6 +2687,27 @@ interface BoardView {
     y: number;
     zoom: number;
 }
+/**
+ * The rendered board surface's color, reference grid, and shape stroke
+ * width — the subset of {@link ScrawlTheme} that reaches the rendering
+ * engine directly (everything else is UI-chrome-only, applied as CSS). Any
+ * field left unset keeps its current value.
+ */
+interface BoardThemeOptions {
+    /** The board/canvas background color — distinct from UI chrome panels. */
+    surface?: string;
+    /** `"flat"` (default): a plain, uniform board surface. `"textured"`: a subtle "melamine" micro-noise + satin sheen, like a physical whiteboard. */
+    surfaceTexture?: "flat" | "textured";
+    /** `"none"` (default) keeps the board a plain surface; `"line"`/`"dot"` draw a zoom-adaptive reference grid. */
+    gridMode?: "none" | "line" | "dot";
+    gridColor?: string;
+    /** Grid spacing in board units at 100% zoom. Ignored when `gridMode` is `"none"`. */
+    gridSpacing?: number;
+    /** On-screen grid line/dot width in CSS pixels — stays this width at any zoom, since the grid is a reference aid, not content. */
+    gridLineWidth?: number;
+    /** Shape (rectangle, ellipse, arrow, ...) border width, in board units — scales with zoom like ink, since it's part of the drawn content. */
+    shapeStrokeWidth?: number;
+}
 /**
  * A Host-owned comment, summarized for Board-side search and marker
  * rendering. Comments are not Document content — they carry no undo
@@ -1328,9 +2731,12 @@ interface PresenceView {
     readonly height: number;
 }
 /**
- * A Host-owned collaborator, synced in for cursor/roster rendering only.
- * Presence is ephemeral — it never touches the Document, Ops, undo/redo,
- * or persistence — so this is a read/query capability, not an adapter.
+ * A collaborator, synced in for cursor/roster rendering only. Presence is
+ * ephemeral — it never touches the Document, Ops, undo/redo, or persistence
+ * (ADR 0006/0007). Two ways a roster gets populated (`presence.sync`
+ * directly, or a `CollaborationAdapter`'s optional presence channel —
+ * Phase 6, ADR 0015) both feed the exact same read/query capability below;
+ * a Host picks one, not both, for a given controller.
  */
 interface PresenceUser {
     readonly id: string;
@@ -1339,6 +2745,14 @@ interface PresenceUser {
     readonly tool?: string;
     readonly cursor?: PresenceCursor;
     readonly view?: PresenceView;
+    /** Host-supplied extras (avatar URL, role, etc.) — opaque to Scrawl, never interpreted. */
+    readonly metadata?: Record<string, unknown>;
+}
+/** This client's own local presence, published via `presence.broadcast()` (Phase 6). */
+interface LocalPresence {
+    readonly cursor?: PresenceCursor | null;
+    readonly view?: PresenceView | null;
+    readonly tool?: string;
 }
 /**
  * The Custom arm wraps `CustomBoardObject` under the same `type` discriminant
@@ -1366,6 +2780,22 @@ type BoardObject = ({
 } & ImageBlock) | ({
     type: "timer";
 } & KitchenTimer) | ({
+    type: "rectangle";
+} & RectangleObject) | ({
+    type: "ellipse";
+} & EllipseObject) | ({
+    type: "group";
+} & GroupObject) | ({
+    type: "line";
+} & LineObject) | ({
+    type: "arrow";
+} & ArrowObject) | ({
+    type: "polygon";
+} & PolygonObject) | ({
+    type: "star";
+} & StarObject) | ({
+    type: "heart";
+} & HeartObject) | ({
     type: "custom";
     customType: ObjectType;
 } & Omit<CustomBoardObject, "type">);
@@ -1394,6 +2824,30 @@ type BoardObjectInput = {
     type: "timer";
     id?: string;
 } & Omit<KitchenTimer, "id">) | ({
+    type: "rectangle";
+    id?: string;
+} & Omit<RectangleObject, "id">) | ({
+    type: "ellipse";
+    id?: string;
+} & Omit<EllipseObject, "id">) | ({
+    type: "group";
+    id?: string;
+} & Omit<GroupObject, "id">) | ({
+    type: "line";
+    id?: string;
+} & Omit<LineObject, "id">) | ({
+    type: "arrow";
+    id?: string;
+} & Omit<ArrowObject, "id">) | ({
+    type: "polygon";
+    id?: string;
+} & Omit<PolygonObject, "id">) | ({
+    type: "star";
+    id?: string;
+} & Omit<StarObject, "id">) | ({
+    type: "heart";
+    id?: string;
+} & Omit<HeartObject, "id">) | ({
     type: "custom";
     id?: string;
     customType: ObjectType;
@@ -1424,10 +2878,34 @@ type LoadResult = {
 } | {
     state: "missing";
 };
+/**
+ * Result of a whole-document `PersistenceAdapter.replace()` call (ADR 0006:
+ * "Whole-document writes survive only for create, clear-board and import,
+ * where replacing everything is the actual intent"). Revision-gated, unlike
+ * `applyOps` — `conflict` means `baseRevision` was stale (someone else's
+ * write landed first); the caller must reload and never overwrites blind.
+ */
+type ReplaceResult = {
+    state: "applied";
+    revision: string;
+} | {
+    state: "conflict";
+    currentRevision: string;
+};
+/**
+ * The one sanctioned seam for persisting a Board's Document to a Host's own
+ * storage — implement this against a database, an HTTP API, IndexedDB
+ * (see `@scrawl-board/board/local`'s `createIndexedDBPersistence`), or
+ * anything else. `load()` fetches the current state on connect; `applyOps()`
+ * streams incremental Ops as edits happen; `replace()` is only for
+ * whole-document writes (create, clear-board, import — see ADR 0006) and is
+ * revision-gated so a stale write never silently clobbers a newer one.
+ * Passed via `createBoardController({ adapters: { persistence } })`.
+ */
 interface PersistenceAdapter {
     load(context: DocumentContext): Promise<LoadResult>;
     applyOps(context: DocumentContext, ops: readonly ControllerOp[]): Promise<ApplyOpsResult>;
-    replace(context: DocumentContext, document: CurrentSerializedDocument, baseRevision: string): Promise<unknown>;
+    replace(context: DocumentContext, document: CurrentSerializedDocument, baseRevision: string): Promise<ReplaceResult>;
 }
 /**
  * `"reconcile"` (ticket #24) means the server authoritatively resolved the
@@ -1451,14 +2929,61 @@ interface PersistenceDiagnostic {
     rejectedOpIds: readonly string[];
     revision: string;
 }
+/** Emitted as `"collaboration-ops-acknowledged"` (Phase 7) — the server has confirmed receipt of these op ids on the live pipe. */
+interface CollaborationAckDiagnostic {
+    opIds: readonly string[];
+}
 interface ControllerOp {
     id: string;
     schemaVersion: 1;
     kind: "upsert" | "restore" | "remove";
-    objectType: "stroke" | "note" | "text" | "table" | "image" | "timer" | "custom";
+    objectType: "stroke" | "note" | "text" | "table" | "image" | "timer" | "rectangle" | "ellipse" | "group" | "line" | "arrow" | "polygon" | "star" | "heart" | "custom"
+    /**
+     * A whole-document paint-order sync (Phase 3), not a per-object type —
+     * `objectId` is always the fixed sentinel `"order"` and `payload` is
+     * `{ order: string[] }`. The only `objectType` with no matching
+     * `BoardObject`/document collection; kept in this same union (rather
+     * than a separate wire message) so it flows through the existing
+     * `PersistenceAdapter`/`CollaborationAdapter` opaquely, unchanged.
+     */
+     | "order" | "page" | "notebook" | "section";
+    /** Absent for the original page; scopes content and order Ops to an additional page. */
+    pageId?: string;
     objectId: string;
     payload?: unknown;
+    /**
+     * This op's position in its own originating client's local sequence
+     * (Phase 7) — 1, 2, 3, ... per controller instance, distinct from `id`
+     * (an opaque, globally-unique identifier used for dedup/ack, not
+     * ordering) and from a server's own authoritative ordering (e.g.
+     * `referenceCollaborationServer.ts`'s per-room `version` counter).
+     * Present on every op this SDK originates locally; a remote peer's op
+     * carries whatever its own origin set, unchanged — never renumbered in
+     * transit. Absent on an op minted by decoding the legacy wire envelope
+     * (`scrawlOpEnvelope.ts`), which predates this field and has no
+     * per-client sequence concept of its own.
+     */
+    clientSequence?: number;
+    /**
+     * The `CollaboratorIdentity.id` of this op's originating client (Phase
+     * 7) — set for every op this SDK originates locally when `identity` is
+     * configured, omitted entirely otherwise (never sent as `undefined`).
+     * The explicit foundation for a future per-author undo filter (a local
+     * user's own undo should only ever touch their own ops) — no undo-stack
+     * behavior itself changes this phase.
+     */
+    clientId?: string;
 }
+/**
+ * The one sanctioned seam for real-time multiplayer — implement this against
+ * a Host's own collaboration backend (WebSocket relay, CRDT server, etc.).
+ * `connect()` is called once per controller with the local user's
+ * `identity` and a `receive` callback the adapter invokes with incoming
+ * Ops, presence updates, acks, and connection status; it resolves with a
+ * `CollaborationSession` the controller uses to send local Ops and presence
+ * back out. Passed via `createBoardController({ adapters: { collaboration } })`;
+ * omit it entirely to run single-player.
+ */
 interface CollaborationAdapter {
     connect(options: DocumentContext & {
         identity: CollaboratorIdentity;
@@ -1469,14 +2994,72 @@ interface CollaboratorIdentity {
     id: string;
     name: string;
     color?: string;
+    /** Host-supplied extras (avatar URL, role, etc.) — opaque to Scrawl, forwarded into any resulting `PresenceUser` unread and never interpreted. */
+    metadata?: Record<string, unknown>;
 }
 interface CollaborationReceiver {
     ops(ops: readonly ControllerOp[]): void;
+    /**
+     * The current presence roster (Phase 6, ADR 0015) — always a full
+     * replacement, never a delta, matching `presence.sync`'s existing
+     * semantics exactly (an adapter that aggregates wire deltas into a full
+     * roster before calling this is the adapter's own job, not the
+     * controller's). Required on this interface (not optional) because a
+     * Host only ever *consumes* `CollaborationReceiver` — never implements
+     * it — so adding a required method here cannot break an existing custom
+     * `CollaborationAdapter`. An adapter with no presence support simply
+     * never calls it.
+     */
+    presence(users: readonly PresenceUser[]): void;
+    /**
+     * The server has confirmed receipt of these op ids (Phase 7) —
+     * distinguishes "sent" from "server accepted," which `sendOps` alone
+     * (fire-and-forget) cannot. Required for the same reason `presence` is:
+     * Hosts only ever consume this interface, never implement it, so this
+     * cannot break an existing custom `CollaborationAdapter`. An adapter with
+     * no ack support simply never calls it — the collaboration pipe still
+     * works exactly as it did before this existed, just without the
+     * bookkeeping/observability this enables.
+     */
+    acknowledged(opIds: readonly string[]): void;
     status(state: "online" | "reconnecting" | "offline"): void;
     error(cause: unknown): void;
 }
+/**
+ * Result of `CollaborationSession.requestSync()` (Phase 7). `"ops"` means
+ * the adapter's own live-pipe cache fully covered the gap since the
+ * caller's last known revision — apply `ops` and the client is caught up,
+ * no persistence reload needed. `"unavailable"` means it couldn't (gap too
+ * large, server restarted, or the adapter has no retained history at all)
+ * — the caller must fall back to a persistence-backed reload. This is a
+ * best-effort *liveness* cache, deliberately never a durable source of
+ * truth (ADR 0006's "collaboration is never a second source of document
+ * truth" — see ADR 0015's own extension of that principle to presence,
+ * now extended once more, the same way, to this).
+ */
+type CollaborationSyncResult = {
+    state: "ops";
+    ops: readonly ControllerOp[];
+    serverRevision: string;
+} | {
+    state: "unavailable";
+};
 interface CollaborationSession {
     sendOps(ops: readonly ControllerOp[]): void;
+    /**
+     * Publishes this client's own local presence (Phase 6, ADR 0015) —
+     * best-effort, unordered, never persisted, never an Op. Optional: an
+     * adapter that doesn't support presence simply omits this method, and
+     * `presence.broadcast()` becomes a silent no-op.
+     */
+    updatePresence?(presence: LocalPresence): void;
+    /**
+     * Requests an incremental catch-up after a reconnect (Phase 7) — optional;
+     * an adapter that doesn't support this simply omits the method, and the
+     * caller (`resyncAfterReconnect`) goes straight to its existing
+     * persistence-backed full reload, unchanged from Phase 6.
+     */
+    requestSync?(): Promise<CollaborationSyncResult>;
     close(): Promise<void>;
 }
 interface CreateBoardControllerOptions {
@@ -1515,14 +3098,114 @@ interface CreateBoardControllerOptions {
      * changes via `boardTheme.set` below — a headless/browser-tier Host that
      * doesn't use the React theme system can set this directly instead.
      */
-    boardTheme?: {
-        surface?: string;
-        gridMode?: "none" | "line" | "dot";
-        gridColor?: string;
-        gridSpacing?: number;
+    boardTheme?: BoardThemeOptions;
+    /**
+     * Debounced auto-flush of pending persistence Ops after document changes
+     * settle (Phase 5). Enabled by default (1000ms debounce) whenever
+     * `adapters.persistence` is configured — today, without this, a Host must
+     * call `flush()` manually after every edit for anything to persist. Pass
+     * `false` to opt out entirely and drive `flush()` yourself, preserving
+     * prior behavior exactly. Never fires on a per-change basis — rapid edits
+     * coalesce into one flush of their final state (ADR 0006).
+     */
+    autosave?: boolean | {
+        debounceMs?: number;
     };
+    /**
+     * Throttle for `presence.broadcast()` (Phase 6, ADR 0015) — the minimum
+     * interval between outgoing presence updates sent via the configured
+     * `CollaborationAdapter`. Defaults to 50ms. A trailing throttle: the
+     * latest value passed to `broadcast()` always eventually sends, even if
+     * calls arrive faster than this interval.
+     */
+    presenceThrottleMs?: number;
+    /**
+     * Caps how many `ControllerOp`s can sit queued, unsent, for the
+     * persistence pipe (`pendingOps`) or the collaboration pipe
+     * (`pendingCollaborationOps`) at once (Phase 7) — each pipe is capped
+     * independently. Prevents unbounded memory growth from a long-lived
+     * offline session or a stuck adapter. Exceeding it never fails or drops
+     * the local edit itself (the Document already applied it optimistically)
+     * — only queueing for that one pipe is skipped, and a
+     * `{code:"queue-overflow", retryable:false}` error is emitted so a Host
+     * can react. Defaults to 1000 — the Phase 9 collaboration coalescing
+     * above (`collaborationCoalesceMs`) already keeps a busy drag from
+     * approaching this on its own, so hitting it in practice means a pipe
+     * has been offline/stuck for a genuinely long editing session.
+     *
+     * **Recovery** (Phase 9): the dropped op itself is gone from that one
+     * pipe's queue — there is no automatic backfill, and the live
+     * controller keeps running with that pipe now silently missing one
+     * edit. Two things stay true regardless: (1) the in-memory Document is
+     * never affected — a queue-overflow can never corrupt or roll back a
+     * local edit, only skip sending it; (2) staleness is per-object, not
+     * permanent — any *later* edit to that same object produces a brand
+     * new, undropped Op carrying its full current state, which naturally
+     * supersedes the gap (the Op model is already last-write-wins/
+     * idempotent, so a superseding Op doesn't need the earlier one to have
+     * arrived). The real risk is an object that's dropped and never edited
+     * again before the controller is disposed or the page reloads — a Host
+     * that needs strict durability should treat `queue-overflow` as a
+     * signal to check `persistence.state`/`pendingOps` pressure (via
+     * `usePersistenceStatus`/`getSnapshot().connection.persistence`)
+     * before disposing, not assume disposing and reconnecting alone
+     * repairs the gap (a fresh `load()` only returns what the backend
+     * already has, which is exactly what's missing the dropped edit).
+     */
+    maxPendingOps?: number;
+    /**
+     * Coalescing window (ms) for outgoing collaboration Ops (Phase 9) — same
+     * trailing-throttle shape as `presenceThrottleMs`: the first Op after an
+     * idle period sends immediately, and subsequent Ops for the *same*
+     * object within this window replace each other (latest value wins,
+     * matching the already-idempotent Op model) rather than each triggering
+     * its own send. A multi-second drag that previously sent one full Op per
+     * pointer-move now sends at most one per window per touched object.
+     * Persistence (`pendingOps`) is unaffected — it already debounces via
+     * `autosave`, so this option only changes live collaboration traffic.
+     * Defaults to 50ms.
+     */
+    collaborationCoalesceMs?: number;
+    /**
+     * Caps how many resolved objects a single `content.copy`/`content.cut`
+     * (or their Cmd/Ctrl+C/X keyboard equivalents) will hold in the
+     * in-memory clipboard at once (Phase 9) — `expandSelection` recursively
+     * expands groups, so an unbounded selection (a huge group, or thousands
+     * of individually selected strokes) could otherwise clone and retain an
+     * arbitrarily large snapshot indefinitely, until the next copy/cut
+     * replaces it. Exceeding it rejects the whole copy/cut (nothing is
+     * cloned, and — for cut — nothing is removed from the Document either,
+     * never a partial copy of an arbitrary subset) and emits a
+     * `{code:"clipboard-overflow", retryable:false}` error. Defaults to
+     * 5000.
+     */
+    maxClipboardItems?: number;
 }
 interface BoardController {
+    readonly notebooks: {
+        /** Create a notebook containing one section and an empty page; select it. */
+        add(name?: string): string;
+        select(id: string): void;
+        rename(id: string, name: string): void;
+        list(): readonly BoardNotebook[];
+        current(): string;
+    };
+    readonly sections: {
+        /** Create a section in the current or specified notebook, with one empty page. */
+        add(name?: string, notebookId?: string): string;
+        select(id: string): void;
+        rename(id: string, name: string): void;
+        list(notebookId?: string): readonly BoardSection[];
+        current(): string;
+    };
+    readonly pages: {
+        /** Add an empty page and switch to it. */
+        add(name?: string, sectionId?: string): string;
+        select(id: string): void;
+        rename(id: string, name: string): void;
+        list(sectionId?: string): readonly BoardPage[];
+        current(): string;
+    };
     readonly document: ReadonlyBoardDocument;
     readonly tools: {
         select(tool: BuiltInTool | (string & {})): void;
@@ -1537,7 +3220,7 @@ interface BoardController {
             noteColor: string;
             tableRows: number;
             tableCols: number;
-            stampKind: StampKind;
+            stampKind: StickerKind;
             timerDurationMs: number;
         }>): void;
         current(): BoardStyle;
@@ -1547,18 +3230,34 @@ interface BoardController {
         redo(): void;
     };
     readonly boardTheme: {
-        /** Live update of the board surface color/grid — the controller's identity stays fixed across theme changes. */
-        set(theme: {
-            surface?: string;
-            gridMode?: "none" | "line" | "dot";
-            gridColor?: string;
-            gridSpacing?: number;
-        }): void;
+        /** Live update of the board surface color/grid/shape-stroke-width — the controller's identity stays fixed across theme changes. */
+        set(theme: BoardThemeOptions): void;
     };
     readonly view: {
         fit(): void;
+        /**
+         * Frame the current selection (Phase 8), the same way `fit()` frames the
+         * whole board. A no-op with nothing selected — deliberately doesn't fall
+         * back to `fit()`'s "frame everything," which would be a surprising
+         * result for an empty selection. On a headless board this can only
+         * re-center the view (no viewport to compute a real zoom-to-fit from),
+         * matching `fit()`'s own headless limitation exactly.
+         */
+        zoomToSelection(): void;
         zoomTo(value: number): void;
         centerOn(point: BoardPoint): void;
+        /**
+         * Tell the canvas an inline text editor is open over a text block (`{ id }`)
+         * or a table cell (`{ id, row, col }`), so it stops drawing that text until
+         * the editor closes (`null`) and the two copies don't overlap. The default
+         * UI's inline editors call this; a Host with its own editors should too.
+         * Presentation only — never touches the Document. A no-op when headless.
+         */
+        setInlineEditing(target: {
+            id: string;
+            row?: number;
+            col?: number;
+        } | null): void;
         get(): BoardView;
         boardToScreen(point: BoardPoint): ScreenPoint;
         screenToBoard(point: ScreenPoint): BoardPoint;
@@ -1567,6 +3266,75 @@ interface BoardController {
         add(input: BoardObjectInput): string;
         update(id: string, patch: BoardObjectPatch): void;
         remove(ids: readonly string[]): void;
+        /**
+         * Clone each given object as a new, unlocked copy offset by a small
+         * fixed cascade (matching the Duplicate affordance's established Host
+         * convention), as one undoable step. Order-preserving: `result[i]` is
+         * the clone of `ids[i]`. Strokes that share a `clusterId` among the
+         * given ids get a single fresh shared `clusterId` in the result, so
+         * duplicating a whole multi-stroke shape (e.g. an arrow's shaft + head)
+         * keeps it one shape — pass every member's id together, not just one.
+         * Unknown ids are silently skipped, matching `remove`'s convention.
+         */
+        duplicate(ids: readonly string[]): readonly string[];
+        /**
+         * Creates a new Group referencing `ids` as its children and returns its
+         * id, as one undoable step. Unknown ids are silently skipped, matching
+         * `duplicate`/`remove`'s convention. A child id that's itself a group
+         * makes a nested group — expanding nested groups into their leaf
+         * members is always the caller's job, never assumed here (matches the
+         * document-model `GroupObject` itself).
+         */
+        group(ids: readonly string[]): string;
+        /**
+         * Dissolves one group, returning its immediate children's ids (a nested
+         * subgroup among them stays intact, itself still a group) — the group
+         * record itself is removed, the children are untouched. A no-op
+         * (returns `[]`) if `groupId` isn't a group.
+         */
+        ungroup(groupId: string): readonly string[];
+        /**
+         * Aligns every given object's matching edge/center to the corresponding
+         * edge/center of their combined bounding box, as one undoable step.
+         * `"top"`/`"bottom"` follow board space's Y-up convention (`"top"` is
+         * the larger Y). Ids that don't resolve, or resolve to a Group (which
+         * has no position of its own), are skipped. A no-op under 2 resolvable
+         * ids — there's nothing to align relative to.
+         */
+        align(ids: readonly string[], edge: "left" | "right" | "top" | "bottom" | "centerX" | "centerY"): void;
+        /**
+         * Spaces the middle objects' centers evenly between the first and last
+         * (sorted along `axis`), as one undoable step — the two endpoints don't
+         * move. Ids that don't resolve, or resolve to a Group, are skipped. A
+         * no-op under 3 resolvable ids — there's no "middle" to distribute.
+         */
+        distribute(ids: readonly string[], axis: "x" | "y"): void;
+        /**
+         * Snapshots `ids` (recursively expanded through any group, same as
+         * `duplicate`) into an internal in-memory clipboard — never
+         * `navigator.clipboard`, scoped to this one controller instance and
+         * replaced wholesale by the next `copy`/`cut`. Read-only; works even
+         * on a read-only board.
+         */
+        copy(ids: readonly string[]): void;
+        /** `copy`, then removes every resolved object (recursively through any group) as one undoable step. */
+        cut(ids: readonly string[]): void;
+        /**
+         * Clones the current clipboard contents onto the board as one undoable
+         * step, offset the same small cascade `duplicate` uses (no cursor
+         * position to paste relative to yet). Returns the new top-level ids —
+         * a pasted group's own id stands for its (also-pasted) children, which
+         * aren't listed separately. `[]` when the clipboard is empty.
+         */
+        paste(): readonly string[];
+        /**
+         * Select every top-level object (Phase 8) — a group's own id stands for
+         * its children, which aren't selected separately, matching `paste`'s own
+         * "what the user sees" id list. Hidden objects are excluded, consistent
+         * with them already being excluded from marquee selection. Works with
+         * no canvas/engine, same as {@link toggleSelectionVisibility}.
+         */
+        selectAll(): void;
         table: {
             addRow(tableId: string): void;
             addCol(tableId: string): void;
@@ -1577,15 +3345,42 @@ interface BoardController {
         };
         select(ids: readonly string[]): void;
         import(document: SerializedBoardDocument): readonly string[];
+        /**
+         * Toggle lock state for the current selection (or focused note/text/
+         * table/image/timer), matching whatever a single Host lock/unlock
+         * control already does per object type. A no-op with nothing selected,
+         * on a headless board, or when every actionable target is locked by
+         * another collaborator who isn't the current lock holder.
+         */
+        toggleSelectionLock(): void;
+        /**
+         * Toggle hidden state for the current selection, as one undo entry
+         * (Phase 8). If any selected object is hidden, shows every selected
+         * object; otherwise hides them all — same "any wins" semantics as
+         * {@link toggleSelectionLock}. Hidden objects stay fully present in the
+         * document (they still serialize, persist, sync, undo/redo) — they just
+         * stop rendering and stop being hit-testable/selectable via pointer
+         * interaction. Unlike `toggleSelectionLock`, this works on a headless
+         * board too: it only touches `selection`/the document, no canvas or
+         * engine involved. Custom objects have no visibility concept (no
+         * `Hideable` field) and are silently skipped, matching how
+         * `toggleSelectionLock` already excludes them. A no-op with nothing
+         * selected or when the selection is only custom objects.
+         */
+        toggleSelectionVisibility(): void;
     };
     readonly query: {
         get(id: string): DeepReadonly<BoardObject> | undefined;
         all(): readonly DeepReadonly<BoardObject>[];
         search(query: string): readonly SearchHit[];
+        /** An object's axis-aligned board-space bounds (y up), or undefined for an unknown id. */
+        bounds(id: string): BoardBounds | undefined;
     };
     /** Host-owned comments, synced in for search and marker rendering only — see CommentMarker. */
     readonly comments: {
         sync(comments: readonly CommentMarker[]): void;
+        /** The markers last passed to `sync`, in the order given. */
+        list(): readonly CommentMarker[];
         open(id: string): void;
         setActive(id: string | null): void;
     };
@@ -1605,6 +3400,15 @@ interface BoardController {
         follow(view: PresenceView): void;
         /** Ease the camera to a peer's view; returns false (no-op) while mid-stroke. */
         gather(view: PresenceView): boolean;
+        /**
+         * Publishes this client's own cursor/tool/view for other collaborators
+         * (Phase 6, ADR 0015), via the configured `CollaborationAdapter` —
+         * throttled internally (`presenceThrottleMs` option, default 50ms) so
+         * a raw pointermove stream never becomes a message-per-event flood. A
+         * no-op if no collaboration adapter is configured, or if the
+         * configured one doesn't implement `updatePresence`.
+         */
+        broadcast(local: LocalPresence): void;
     };
     readonly export: {
         svg(): string;
@@ -1630,7 +3434,19 @@ interface BoardController {
     }>;
     dispose(): Promise<void>;
 }
+/**
+ * Creates a {@link BoardController} — the SDK's canonical, capability-grouped
+ * entry point (`content`, `tools`, `style`, `history`, `view`, `query`,
+ * `comments`, `presence`, `export`, `assets`, plus top-level `getSnapshot`/
+ * `subscribe`/`on`/`setReadOnly`/`flush`/`dispose`) for driving a Board
+ * imperatively from any JS/TS runtime. Supply a `canvas` to render, or omit
+ * it to run headless (SSR, tests, or a document/history-only integration).
+ * Persistence and Collaboration are opt-in via `options.adapters` — without
+ * them the controller runs entirely in memory. Call `dispose()` when done to
+ * release the renderer, adapters, and any pending timers.
+ */
 declare function createBoardController(options: CreateBoardControllerOptions): BoardController;
+/** @deprecated Use `BoardController.getSnapshot()`'s return type instead. */
 type LocalBoardSnapshot = {
     documentId: string;
     selectedStrokeId: string | null;
@@ -1639,10 +3455,12 @@ type LocalBoardSnapshot = {
     canRedo: boolean;
     disposed: boolean;
 };
+/** @deprecated Use `CreateBoardControllerOptions` with `createBoardController` instead. */
 type LocalBoardOptions = {
     documentId: string;
     initialDocument?: SerializedBoardDocument;
 };
+/** @deprecated Use `BoardController` (from `createBoardController`) instead — this stroke-only, single-tool surface predates the full capability-grouped controller. */
 type LocalBoard = {
     drawStroke(stroke: Stroke): void;
     selectAt(point: BoardPoint): string | null;
@@ -1653,42 +3471,100 @@ type LocalBoard = {
     subscribe(listener: () => void): () => void;
     dispose(): Promise<void>;
 };
+/** @deprecated Use `createBoardController` instead — this is a thin, stroke-only wrapper kept for the original Phase 1 tracer's compatibility. */
 declare function createLocalBoard(options: LocalBoardOptions): LocalBoard;
 
+interface CreateMemoryPersistenceOptions {
+    /** Pre-seeded documents, keyed by document id — as if a prior session had already saved them. Seeded documents start at revision "1". */
+    seed?: Record<string, CurrentSerializedDocument>;
+}
+/**
+ * Creates a real, in-memory `PersistenceAdapter`. One instance can back
+ * multiple documents (keyed by `DocumentContext.documentId`, like every
+ * other adapter in this package). State lives only in this instance —
+ * discarded on garbage collection, never written to disk.
+ */
+declare function createMemoryPersistence(options?: CreateMemoryPersistenceOptions): PersistenceAdapter;
+
 type ScrawlThemePreset = "light" | "dark";
 type ScrawlDensity = "comfortable" | "compact";
 type ScrawlGridMode = "none" | "line" | "dot";
+type ScrawlSurfaceTexture = "flat" | "textured";
+/**
+ * Every field is optional — anything you don't set falls back to the
+ * chosen `preset` ("light" or "dark", see {@link resolveScrawlTheme}).
+ * Overrides are semantic, board-local runtime configuration: they never
+ * get written into the Document or into exports, so switching themes is
+ * always non-destructive.
+ */
 interface ScrawlTheme {
+    /** UI chrome background — toolbar/panel base surface. Distinct from `boardSurface` (the canvas itself). */
     surface?: string;
+    /** UI chrome background, one step up from `surface` — popovers, dropdowns, elevated panels. */
     surfaceRaised?: string;
+    /** UI chrome background, one step down from `surface` — subtle fills, hover states. */
     surfaceMuted?: string;
+    /** Primary UI text color. Checked for contrast against `surface`. */
     text?: string;
+    /** Secondary/de-emphasized UI text color. Checked for contrast against `surface`. */
     textMuted?: string;
+    /** Borders and dividers between UI chrome elements. */
     edge?: string;
+    /**
+     * Brand accent color. Drives the active/selected state of toolbar
+     * controls (e.g. the active tool button): its icon/text render in this
+     * color, and its background is automatically derived as a light tint of
+     * it (via `color-mix`) — set this one token and both follow.
+     */
+    primary?: string;
+    /** Focus ring color. Checked for contrast against `surface`. */
     focus?: string;
+    /** Selection highlight color (e.g. selected list items, not board object selection). */
     selection?: string;
+    /** Destructive/error state color (delete confirmations, error text). */
     danger?: string;
+    /** Warning state color. */
     warning?: string;
+    /** Success/confirmation state color. */
     success?: string;
+    /** Font stack for UI chrome (toolbar labels, menus, dialogs). */
     uiFontFamily?: string;
+    /** Font stack for board content and data (e.g. table cell text). */
     dataFontFamily?: string;
+    /** Base UI font size in px. Range: 12–24. */
     baseFontSize?: number;
+    /** Regular UI font weight. Range: 300–900. */
     regularWeight?: number;
+    /** Emphasized UI font weight (headings, active states). Range: 300–900. */
     strongWeight?: number;
+    /** Corner radius for small controls (buttons, inputs) in px. Range: 0–32. */
     controlRadius?: number;
+    /** Corner radius for panels/dialogs in px. Range: 0–32. */
     panelRadius?: number;
+    /** CSS `box-shadow` value for subtle elevation (e.g. toolbar). */
     elevationLow?: string;
+    /** CSS `box-shadow` value for prominent elevation (e.g. modals). */
     elevationHigh?: string;
+    /** UI transition duration in ms. Range: 0–500. */
     motionDuration?: number;
+    /** CSS easing function for UI transitions. */
     motionEasing?: string;
+    /** UI chrome spacing/sizing scale. */
     density?: ScrawlDensity;
     /** The rendered board/canvas surface color — distinct from `surface` (UI chrome panels). */
     boardSurface?: string;
+    /** `"flat"` (default): a plain, uniform board surface. `"textured"`: a subtle "melamine" micro-noise + satin sheen, like a physical whiteboard. */
+    boardSurfaceTexture?: ScrawlSurfaceTexture;
     /** `"none"` (default) keeps the board a plain surface; `"line"`/`"dot"` draw a zoom-adaptive reference grid. */
     gridMode?: ScrawlGridMode;
+    /** Grid line/dot color. Ignored when `gridMode` is `"none"`. */
     gridColor?: string;
     /** Grid spacing in board units at 100% zoom. Ignored when `gridMode` is `"none"`. */
     gridSpacing?: number;
+    /** On-screen grid line/dot width in CSS pixels. Range: 0.5–8. A reference aid, so unlike shape/ink strokes it stays this width at any zoom. */
+    gridLineWidth?: number;
+    /** Shape (rectangle, ellipse, arrow, ...) border width, in board units. Range: 0.01–5. Scales with zoom like ink, since it's part of the drawn content. */
+    shapeStrokeWidth?: number;
 }
 type ResolvedScrawlTheme = Required<ScrawlTheme>;
 interface ScrawlThemeDiagnostic {
@@ -1705,6 +3581,67 @@ declare const scrawlThemePresets: Readonly<Record<ScrawlThemePreset, Readonly<Re
 declare function validateScrawlTheme(theme: ScrawlTheme | Record<string, unknown>): ScrawlThemeDiagnostic[];
 declare function resolveScrawlTheme(preset?: ScrawlThemePreset, theme?: ScrawlTheme | Record<string, unknown>): ScrawlResolvedTheme;
 
+/** Access levels, shown as View / Edit / Admin. Map your backend's roles onto these. */
+type BoardRole = "viewer" | "editor" | "admin";
+interface BoardMember {
+    id: string;
+    name: string;
+    email?: string;
+    avatarUrl?: string;
+    online?: boolean;
+    role: BoardRole;
+}
+interface BoardRoleChange {
+    memberId: string;
+    role: BoardRole;
+}
+interface BoardPermissions {
+    members: readonly BoardMember[];
+    /** Marks "(you)" and keeps your own access level from being changed here. */
+    currentUserId?: string;
+    /** Whether "Manage permissions" is offered at all — your rule, from your backend. */
+    canManage: boolean;
+    /**
+     * Called with every pending change when Save is pressed. Resolve once your
+     * backend accepted them; reject to show the error and keep them pending.
+     * Nothing changes until your backend says so — update `members` afterwards.
+     */
+    onSave(changes: readonly BoardRoleChange[]): Promise<void>;
+}
+type BoardActivityKind = "added" | "removed" | "updated" | "commented" | "shared" | "exported";
+interface BoardActivityEntry {
+    id: string;
+    kind: BoardActivityKind;
+    /** e.g. "Added a sticky note". */
+    title: string;
+    actorName?: string;
+    /** When it happened (ms since epoch or ISO string). */
+    at: number | string;
+    /** Board point to jump to, if the action has a place on the board. */
+    location?: BoardPoint;
+}
+interface BoardActivityFeed {
+    /** Newest first. Omit to show this session's own actions instead. */
+    entries?: readonly BoardActivityEntry[];
+    unreadCount?: number;
+    onMarkAllRead?(): void;
+}
+interface BoardCommentFeed {
+    unreadCount?: number;
+    onMarkAllRead?(): void;
+}
+interface BoardMenuItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    onSelect(): void;
+}
+
+interface CommentAuthor {
+    name: string;
+    color?: string;
+}
+
 interface DefaultBoardChromeProps {
     controller: BoardController;
     snapshot: BoardSnapshot;
@@ -1713,8 +3650,42 @@ interface DefaultBoardChromeProps {
     style?: React.CSSProperties;
     regions?: Partial<Record<DefaultUIRegion, boolean>>;
     slots?: DefaultUISlots;
+    /**
+     * Override any built-in tool icon. Tools without an override keep the
+     * SDK's outline icon. Accessible labels and shortcut tooltips are preserved.
+     */
+    icons?: Partial<Record<BuiltInTool, ReactNode>>;
+    /** Name (and pin colour) shown on comments left through the default comment UI. Defaults to "You". */
+    commentAuthor?: CommentAuthor;
+    /**
+     * Sharing is the Host's own (links, permissions, backends), so the board
+     * actions only offer a Share button when this is supplied.
+     */
+    onShare?(): void;
+    /**
+     * Your backend's activity feed for the Recent Activity drawer. Without
+     * `entries`, the drawer lists this session's own board actions.
+     */
+    activity?: BoardActivityFeed;
+    /** Unread state for the Comments drawer's badge and "Mark all as read". */
+    commentFeed?: BoardCommentFeed;
+    /**
+     * Members and access levels from your backend, for the permissions drawer
+     * (offered in the More menu when `canManage`). The SDK never changes a role
+     * itself: Save calls `onSave`, and your backend decides.
+     */
+    permissions?: BoardPermissions;
+    /** Extra More-menu actions your app provides (board settings, version history, duplicate…). */
+    menuItems?: readonly BoardMenuItem[];
 }
-type DefaultUIRegion = "tools" | "history" | "view" | "style" | "search" | "import" | "export" | "inlineEditing" | "styleShelf";
+
+/**
+ * `comments` is the built-in comment composer/thread, which keeps comments for
+ * the session; `images` is the Image tool's file picker plus drag-and-drop.
+ * Turn either off when the Host handles `comment-draft-request`/
+ * `comment-open-request` or `import-request` itself.
+ */
+type DefaultUIRegion = "tools" | "history" | "view" | "style" | "search" | "import" | "export" | "inlineEditing" | "styleShelf" | "focusedItemToolbar" | "emptyState" | "pages" | "comments" | "images" | "activity";
 /** Props for the toolbar/topBar/stylePanel/contextMenu slots. */
 interface BoardSlotProps {
     controller: BoardController;
@@ -1742,7 +3713,7 @@ interface DefaultUISlots {
      */
     contextMenu?: ComponentType<BoardSlotProps> | null;
 }
-declare function DefaultBoardChrome({ controller, snapshot, renderPortal, className, style, regions, slots }: DefaultBoardChromeProps): react.JSX.Element;
+declare function DefaultBoardChrome({ controller, snapshot, renderPortal, className, style, regions, slots, icons, commentAuthor, onShare, activity, commentFeed, permissions, menuItems }: DefaultBoardChromeProps): react.JSX.Element;
 
 interface InlineEditorsProps {
     controller: BoardController;
@@ -1767,12 +3738,70 @@ interface MultiplayerCursorsProps {
  */
 declare function MultiplayerCursors({ controller, onSelectUser, onJumpToUser }: MultiplayerCursorsProps): react.JSX.Element | null;
 
+interface FocusedItemToolbarProps {
+    controller: BoardController;
+    snapshot: BoardSnapshot;
+}
+/**
+ * Floating toolbar above the focused note, shape, text block, or semantic
+ * Rectangle/Ellipse — Colour, Size (note/text) or Width (shape), Fill/Stroke
+ * (Rectangle/Ellipse), Lock/Unlock, Duplicate, Delete. Images (photos and
+ * placed emoji/icons) and tables get Lock/Duplicate/Delete only — each
+ * already has its own resize affordance (the native gizmo for images, edge
+ * handles for tables), and a table's row/column actions live in its cell
+ * editor. Timer/custom objects and plain (non-shape) ink strokes never get a
+ * toolbar here — out of scope for this destination.
+ *
+ * Rectangle/Ellipse (Phase 2) are a second, parallel "shape" concept from
+ * the legacy ink-stroke shape below: both draw from the same toolbar
+ * buttons and look the same to a user, but a Rectangle/Ellipse is a real
+ * BoardObject with its own resize handles (independent width/height,
+ * `ShapeResizeHandle`), while a legacy shape-stroke keeps going through the
+ * native selection gizmo. This duality is deliberate and temporary — see
+ * docs/reports/phase-2-document-object-model.md.
+ *
+ * Lock/Unlock carries no per-user ownership gating: nothing else in this
+ * SDK enforces lock ownership either (`content.update` never checks
+ * `locked`, and the engine's own internal unlock check has no way for a
+ * Host to ever supply a real user id) — locking is advisory UI state
+ * throughout, and this toolbar matches that rather than inventing an
+ * enforcement story alone.
+ *
+ * A shape can be several strokes sharing one `clusterId` (e.g. an arrow's
+ * shaft + head) — every action here applies to the whole cluster. Resolved
+ * via `query.all()` + `clusterId`, not `snapshot.selection`: a canvas click
+ * on one member selects every member internally, but the public selection
+ * bridge only ever reports one id (`FocusedItem.id` is singular by design),
+ * so reconstructing the cluster from the document is the reliable path
+ * regardless of how the selection was made.
+ *
+ * A focused note also gets drag-to-resize corner handles — notes have no
+ * gizmo of their own (the native selection gizmo is ink-stroke/shape-only),
+ * so this is that capability's default-ui-owned equivalent. Proportional
+ * (always-square) resize from the note's own centre, clamped to
+ * `[MIN_SIZE, MAX_SIZE]`, independent of which corner is grabbed.
+ */
+declare function FocusedItemToolbar({ controller, snapshot }: FocusedItemToolbarProps): react.JSX.Element | null;
+
 interface StyleShelfProps {
     controller: BoardController;
     snapshot: BoardSnapshot;
+    /**
+     * Root-relative point beside the active tool. DefaultBoardChrome supplies
+     * this automatically and keeps the shelf within the board bounds.
+     */
+    anchor?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Called after an option is picked (not while typing table dimensions or a
+     * sticker search). DefaultBoardChrome uses it to close the shelf.
+     */
+    onChoose?(): void;
 }
 /** Contextual per-tool style controls — visible while a styleable tool is active. */
-declare function StyleShelf({ controller, snapshot }: StyleShelfProps): react.JSX.Element | null;
+declare function StyleShelf({ controller, snapshot, anchor, onChoose }: StyleShelfProps): react.JSX.Element | null;
 
 type ThemeStyle = CSSProperties & Record<`--scrawl-${string}`, string | number | undefined>;
 interface ScrawlProviderProps {
@@ -1786,6 +3815,16 @@ interface ScrawlProviderProps {
     className?: string;
     style?: ThemeStyle;
 }
+/**
+ * Wraps a Board `controller` you created yourself (via `createBoardController`)
+ * so its descendants can use `useScrawlController`/`useScrawlSnapshot`/etc.
+ * and render its default UI pieces (`DefaultBoardChrome`, `StyleShelf`, ...).
+ * Prefer `Scrawl` unless you need to construct or own the controller's
+ * lifecycle yourself (e.g. you create it outside React, or need it before
+ * first render). Set `disposeOnUnmount` to have this provider call
+ * `controller.dispose()` on unmount; otherwise disposal remains your own
+ * responsibility.
+ */
 declare function ScrawlProvider({ controller, children, preset, theme, portalContainer: customPortal, disposeOnUnmount, onThemeDiagnostic, className, style }: ScrawlProviderProps): react.JSX.Element;
 interface ScrawlProps extends Omit<CreateBoardControllerOptions, "canvas"> {
     children?: ReactNode;
@@ -1799,8 +3838,35 @@ interface ScrawlProps extends Omit<CreateBoardControllerOptions, "canvas"> {
     onThemeDiagnostic?: (diagnostic: ScrawlThemeDiagnostic) => void;
     /** Provide null for a headless Board, or an existing canvas to control its identity. */
     canvas?: HTMLCanvasElement | null;
+    /**
+     * Per-tool icon override for the default toolbar and More tools buttons —
+     * only applies when you don't supply `children` (i.e. you're using the
+     * SDK's default UI). See DefaultBoardChromeProps.icons.
+     */
+    icons?: Partial<Record<BuiltInTool, ReactNode>>;
+    /** Offer a Share button in the default UI's board actions — see DefaultBoardChromeProps.onShare. */
+    onShare?(): void;
+    /** Your backend's activity feed — see DefaultBoardChromeProps.activity. */
+    activity?: BoardActivityFeed;
+    /** Unread state for the Comments drawer — see DefaultBoardChromeProps.commentFeed. */
+    commentFeed?: BoardCommentFeed;
+    /** Members and access levels from your backend — see DefaultBoardChromeProps.permissions. */
+    permissions?: BoardPermissions;
+    /** Extra More-menu actions — see DefaultBoardChromeProps.menuItems. */
+    menuItems?: readonly BoardMenuItem[];
 }
-declare function Scrawl({ children, preset, theme, portalContainer, className, style, onReady, onError, onThemeDiagnostic, canvas: suppliedCanvas, ...options }: ScrawlProps): react.JSX.Element;
+/**
+ * The fastest path to an embedded Board: creates and owns a
+ * `BoardController` for you (constructed once, disposed on unmount) and
+ * renders it into a canvas. Render with no `children` to get the SDK's
+ * default toolbar/UI chrome, or supply your own `children` (using the
+ * `useScrawlController`/`useScrawlSnapshot` hooks, or the exported
+ * `DefaultBoardChrome`/`StyleShelf`/etc. pieces) to build a custom UI on
+ * top of the same controller. Accepts every `CreateBoardControllerOptions`
+ * field except `canvas` (pass `canvas={null}` for a headless board, or an
+ * existing `<canvas>` element to control its identity yourself).
+ */
+declare function Scrawl({ children, preset, theme, portalContainer, className, style, onReady, onError, onThemeDiagnostic, canvas: suppliedCanvas, icons, onShare, activity, commentFeed, permissions, menuItems, ...options }: ScrawlProps): react.JSX.Element;
 interface ScrawlCanvasProps {
     element?: HTMLCanvasElement;
     className?: string;
@@ -1815,14 +3881,60 @@ interface ScrawlDefaultUIProps {
     regions?: Partial<Record<DefaultUIRegion, boolean>>;
     /** Replace (component) or hide (null) a coarse region; omit for the SDK default. */
     slots?: DefaultUISlots;
-}
-declare function ScrawlDefaultUI({ className, style, regions, slots }: ScrawlDefaultUIProps): react.JSX.Element;
+    /** Per-tool icon override for the toolbar and More tools buttons — see DefaultBoardChromeProps.icons. */
+    icons?: Partial<Record<BuiltInTool, ReactNode>>;
+    /** Author shown on comments left through the default comment UI — see DefaultBoardChromeProps.commentAuthor. */
+    commentAuthor?: CommentAuthor;
+    /** Supply to offer a Share button in the board actions — see DefaultBoardChromeProps.onShare. */
+    onShare?(): void;
+    /** Your backend's activity feed — see DefaultBoardChromeProps.activity. */
+    activity?: BoardActivityFeed;
+    /** Unread state for the Comments drawer — see DefaultBoardChromeProps.commentFeed. */
+    commentFeed?: BoardCommentFeed;
+    /** Members and access levels from your backend — see DefaultBoardChromeProps.permissions. */
+    permissions?: BoardPermissions;
+    /** Extra More-menu actions — see DefaultBoardChromeProps.menuItems. */
+    menuItems?: readonly BoardMenuItem[];
+}
+declare function ScrawlDefaultUI({ className, style, regions, slots, icons, commentAuthor, onShare, activity, commentFeed, permissions, menuItems }: ScrawlDefaultUIProps): react.JSX.Element;
 declare function ScrawlPortal({ children }: {
     children: ReactNode;
 }): react.ReactPortal | null;
 declare function useScrawlController(): BoardController;
 declare function useScrawlTheme(): ScrawlResolvedTheme;
 declare function useScrawlSnapshot(): BoardSnapshot;
+/**
+ * A thin, purely-derived convenience over
+ * `useScrawlSnapshot().connection.persistence` (Phase 5) — for a Host
+ * component that only cares about save status (e.g. a
+ * "Saving…"/"Saved"/"Offline" indicator) and would otherwise re-derive
+ * this same field access itself. Adds no state and no behavior of its
+ * own: React still owns none of persistence, exactly as before — this
+ * hook only re-reads what the controller already tracks.
+ *
+ * Deliberately does *not* go through `useScrawlSnapshot()` (Phase 9):
+ * `changed()` rebuilds the whole `BoardSnapshot` — including a fresh
+ * `connection.persistence` object — on every document mutation, even ones
+ * that never touch persistence at all, so a component using only this
+ * hook would otherwise re-render on every stroke draw. `useSyncStatus`
+ * below memoizes on the value (`state`/`error`), not just the object
+ * reference, and returns the same cached value across renders where
+ * nothing relevant changed — the same shape `usePresence` already uses
+ * for its own independently-scoped store.
+ */
+declare function usePersistenceStatus(): PersistenceSnapshot;
+/** The `CollaborationSnapshot` equivalent of `usePersistenceStatus` (Phase 6) — same value-memoized convenience over `useScrawlSnapshot().connection.collaboration` (Phase 9: see `usePersistenceStatus`'s doc comment for why it doesn't derive from the full snapshot). */
+declare function useCollaborationStatus(): CollaborationSnapshot;
+/**
+ * The current presence roster (Phase 6), live-updating — wraps
+ * `controller.presence.list()`/`subscribe` the same way `useScrawlSnapshot`
+ * wraps the controller's main snapshot, via `useSyncExternalStore`. Does
+ * not re-render on every remote pointer move by itself; it re-renders
+ * whenever the roster the controller already tracks changes, at whatever
+ * rate that arrives at (throttled adapter-side, per `presenceThrottleMs`).
+ */
+declare function usePresence(): readonly PresenceUser[];
+/** @deprecated Use `Scrawl` instead — this predates the full capability-grouped `BoardController` and only exposes the stroke-only `LocalBoard` surface. */
 type ScrawlBoardProps = {
     documentId: string;
     initialDocument?: SerializedBoardDocument;
@@ -1830,7 +3942,8 @@ type ScrawlBoardProps = {
     className?: string;
     style?: CSSProperties;
 };
+/** @deprecated Use `Scrawl` instead — this predates the full capability-grouped `BoardController` and only exposes the stroke-only `LocalBoard` surface. */
 declare function ScrawlBoard({ documentId, initialDocument, onReady, className, style }: ScrawlBoardProps): react.JSX.Element;
 
-export { ASSET_CACHE_BYTES_DEFAULT, ASSET_CACHE_BYTES_MAX, ASSET_CACHE_BYTES_MIN, ASSET_EXPORT_MAX_DECODED_MEGAPIXELS, ASSET_EXPORT_MAX_ENCODED_BYTES, ASSET_MAX_CONCURRENT_RESOLUTIONS, ASSET_MAX_DECODED_MEGAPIXELS, ASSET_MAX_DIMENSION_PX, ASSET_MAX_ENCODED_BYTES, ASSET_REF_MAX_BYTES, ASSET_REF_PATTERN, AddImageCommand, AddNoteCommand, AddStrokesCommand, AddTableCommand, AddTextCommand, AddTimerCommand, AssetResolutionError, BEACON_INSET, BoardDocument, CURRENT_DOCUMENT_SCHEMA_VERSION, ClusterStore, DefaultBoardChrome, DeleteImageCommand, DeleteNoteCommand, DeleteStrokesCommand, DeleteTableCommand, DeleteTextCommand, DeleteTimerCommand, DocumentRecoveryError, END_TAPER, ERASE_THRESHOLD, EraseCommand, FOG_COLOR, HIGHLIGHT_COLORS, History, IDENTITY, INK_COLORS, InlineEditors, LockItemsCommand, MIN_WIDTH_FACTOR, MultiplayerCursors, NOTE_COLORS, NOTE_DEFAULT_SIZE, NOTE_DEFAULT_Z, NOTE_MAX_Z, NOTE_MIN_Z, NOTE_PEEL_STEP, SDK_DEVELOPMENT_VERSION, SDK_PACKAGE_NAME, STAMPS, STAMP_SIZE, SUPPORTED_ASSET_MEDIA_TYPES, Scrawl, ScrawlBoard, ScrawlCanvas, ScrawlDefaultUI, ScrawlPortal, ScrawlProvider, SpatialIndex, StyleShelf, TABLE_DEFAULT_CELL_HEIGHT, TABLE_DEFAULT_CELL_WIDTH, TABLE_DEFAULT_FONT_SIZE, TEXT_DEFAULT_SIZE, TIMER_DEFAULT_DURATION_MS, TIMER_DEFAULT_SIZE, TIMER_PRESETS_MS, TransformCommand, UpdateImageCommand, UpdateNoteCommand, UpdateTableCommand, UpdateTextCommand, UpdateTimerCommand, apply, applyItemLock, assetRef, avgScale, canUnlockItem, changeToOps, clampAssetCacheBytes, cloneCustomObject, cloneImage, cloneNote, cloneStroke, cloneTable, cloneText, cloneTimer, createBoardController, createLocalBoard, documentId, documentToSVG, formatTimer, invert, isAssetRef, isIdentity, isStampKind, loadDocumentBytes, measureTable, measureTextBlock, migrateDocument, mul, pauseTimer, placePresenceBeacon, resolveScrawlTheme, ribbonEdges, rotationAbout, scalingAbout, scrawlThemePresets, searchBoard, serializeDocument, serializeLock, serializeStroke, setTimerDuration, stampDataUrl, startTimer, strokeId, timerExpired, timerRemaining, toggleTimer, translation, useScrawlController, useScrawlSnapshot, useScrawlTheme, validateScrawlTheme };
-export type { ApplyOpsResult, AssetDiagnostic, AssetIngestRequest, AssetIngestResult, AssetIngestor, AssetKind, AssetPurpose, AssetRef, AssetResolutionErrorCode, AssetResolveRequest, AssetResolveResult, AssetResolver, BBox, BoardController, BoardControllerError, BoardEventMap, BoardKeyInput, BoardObject, BoardObjectInput, BoardObjectPatch, BoardPoint, BoardPointerInput, BoardScene, BoardSlotProps, BoardSnapshot, BoardStroke, BoardStyle, BoardView, BuiltInTool, ClusterIdFactory, CollaborationAdapter, CollaborationReceiver, CollaborationSession, CollaborationSnapshot, CollaboratorIdentity, Command, CommandKind, CommentMarker, ControllerOp, CreateBoardControllerOptions, CurrentSerializedDocument, CurrentSerializedStroke, CustomBoardObject, CustomObjectAddInput, CustomObjectDefinition, CustomTool, CustomToolDefinition, DeepReadonly, DefaultBoardChromeProps, DefaultUIRegion, DefaultUISlot, DefaultUISlots, DialogSlotProps, DocumentChange, DocumentContext, DocumentId, DocumentLoadResult, DocumentRecoveryCode, ExtensionCommand, ExtensionDiagnostic, ExtensionHitResult, ExtensionId, ExtensionRequirement, ImageBlock, InlineEditorsProps, InputModifiers, JsonObject, JsonValue, KitchenTimer, LoadResult, LocalBoard, LocalBoardOptions, LocalBoardSnapshot, LockHolder, LockTarget, Lockable, Mat2x3, MultiplayerCursorsProps, NoteVote, ObjectDescribeContext, ObjectIntent, ObjectType, Op, OpCollection, PersistenceAdapter, PersistenceDiagnostic, PersistenceSnapshot, PresenceCursor, PresencePlacement, PresenceUser, PresenceView, QueryableBoardObject, ReadonlyBoardDocument, ReadonlyCustomObject, ReadonlyDocumentChange, RibbonEdgePoint, SceneEllipse, SceneGroup, SceneImage, ScenePath, SceneRect, SceneText, ScrawlBoardProps, ScrawlCanvasProps, ScrawlDefaultUIProps, ScrawlDensity, ScrawlExtension, ScrawlGridMode, ScrawlProps, ScrawlProviderProps, ScrawlResolvedTheme, ScrawlTheme, ScrawlThemeDiagnostic, ScrawlThemePreset, ScreenPoint, ScreenRect, SearchHit, SearchHitKind, SearchableBoard, SearchableComment, SerializedBoardDocument, SerializedBoardStroke, SerializedPoint, SerializedStroke, StampKind, StickyNote, Stroke, StrokeId, StrokePoint, StrokeTool, StyleShelfProps, SupportedAssetMediaType, TableBlock, TextBlock, ToolCancelReason, ToolCapabilities, ToolCursor, ToolId, ViewportInset };
+export { ASSET_CACHE_BYTES_DEFAULT, ASSET_CACHE_BYTES_MAX, ASSET_CACHE_BYTES_MIN, ASSET_EXPORT_MAX_DECODED_MEGAPIXELS, ASSET_EXPORT_MAX_ENCODED_BYTES, ASSET_MAX_CONCURRENT_RESOLUTIONS, ASSET_MAX_DECODED_MEGAPIXELS, ASSET_MAX_DIMENSION_PX, ASSET_MAX_ENCODED_BYTES, ASSET_REF_MAX_BYTES, ASSET_REF_PATTERN, AddArrowCommand, AddEllipseCommand, AddGroupCommand, AddHeartCommand, AddImageCommand, AddLineCommand, AddNoteCommand, AddPolygonCommand, AddRectangleCommand, AddStarCommand, AddStrokesCommand, AddTableCommand, AddTextCommand, AddTimerCommand, AssetResolutionError, BEACON_INSET, BoardDocument, CURRENT_DOCUMENT_SCHEMA_VERSION, ClusterStore, CommandBatch, DefaultBoardChrome, DeleteArrowCommand, DeleteEllipseCommand, DeleteGroupCommand, DeleteHeartCommand, DeleteImageCommand, DeleteLineCommand, DeleteNoteCommand, DeletePolygonCommand, DeleteRectangleCommand, DeleteStarCommand, DeleteStrokesCommand, DeleteTableCommand, DeleteTextCommand, DeleteTimerCommand, DocumentRecoveryError, EMOJI_LIBRARY, END_TAPER, ERASE_THRESHOLD, EraseCommand, FOG_COLOR, FocusedItemToolbar, HIGHLIGHT_COLORS, History, ICON_LIBRARY, IDENTITY, INK_COLORS, InlineEditors, LockItemsCommand, MIN_WIDTH_FACTOR, MultiplayerCursors, NOTE_COLORS, NOTE_DEFAULT_SIZE, NOTE_DEFAULT_Z, NOTE_MAX_Z, NOTE_MIN_Z, NOTE_PEEL_STEP, ReorderObjectCommand, SDK_DEVELOPMENT_VERSION, SDK_PACKAGE_NAME, SHAPE_DEFAULT_STROKE, SHAPE_DEFAULT_STROKE_WIDTH, SHAPE_MIN_SIZE, SHAPE_STYLE_DEFAULTS, STAMPS, STAMP_SIZE, SUPPORTED_ASSET_MEDIA_TYPES, Scrawl, ScrawlBoard, ScrawlCanvas, ScrawlDefaultUI, ScrawlPortal, ScrawlProvider, SpatialIndex, StyleShelf, TABLE_DEFAULT_CELL_HEIGHT, TABLE_DEFAULT_CELL_WIDTH, TABLE_DEFAULT_FONT_SIZE, TEXT_DEFAULT_SIZE, TIMER_DEFAULT_DURATION_MS, TIMER_DEFAULT_SIZE, TIMER_PRESETS_MS, TransformCommand, TransformObjectsCommand, UpdateArrowCommand, UpdateEllipseCommand, UpdateGroupCommand, UpdateHeartCommand, UpdateImageCommand, UpdateLineCommand, UpdateNoteCommand, UpdatePolygonCommand, UpdateRectangleCommand, UpdateStarCommand, UpdateTableCommand, UpdateTextCommand, UpdateTimerCommand, apply, applyItemLock, assetRef, avgScale, canUnlockItem, changeToOps, clampAssetCacheBytes, cloneArrow, cloneCustomObject, cloneEllipse, cloneGroup, cloneHeart, cloneImage, cloneLine, cloneNote, clonePolygon, cloneRectangle, cloneStar, cloneStroke, cloneTable, cloneText, cloneTimer, createBoardController, createLocalBoard, createMemoryPersistence, documentId, documentSize, documentToSVG, emojiDataUrl, emojiDefinition, formatTimer, iconCategories, iconDataUrl, iconDefinition, invert, isAssetRef, isEmojiName, isIconName, isIdentity, isStampKind, isStickerKind, loadDocumentBytes, measureTable, measureTextBlock, migrateDocument, mul, pauseTimer, placePresenceBeacon, resolveScrawlTheme, ribbonEdges, rotationAbout, scalingAbout, scrawlThemePresets, searchBoard, serializeDocument, serializeLock, serializeStroke, setTimerDuration, stampDataUrl, startTimer, stickerDataUrl, stickerLabel, strokeId, timerExpired, timerRemaining, toggleTimer, translation, useCollaborationStatus, usePersistenceStatus, usePresence, useScrawlController, useScrawlSnapshot, useScrawlTheme, validateScrawlTheme };
+export type { ApplyOpsResult, ArrowHeadStyle, ArrowObject, AssetDiagnostic, AssetExportFailure, AssetIngestRequest, AssetIngestResult, AssetIngestor, AssetKind, AssetPurpose, AssetRef, AssetResolutionErrorCode, AssetResolveRequest, AssetResolveResult, AssetResolver, BBox, BoardActivityEntry, BoardActivityFeed, BoardActivityKind, BoardBounds, BoardCommentFeed, BoardController, BoardControllerError, BoardEventMap, BoardKeyInput, BoardMember, BoardMenuItem, BoardNotebook, BoardObject, BoardObjectInput, BoardObjectPatch, BoardPage, BoardPermissions, BoardPoint, BoardPointerInput, BoardRole, BoardRoleChange, BoardScene, BoardSection, BoardSlotProps, BoardSnapshot, BoardStroke, BoardStyle, BoardThemeOptions, BoardView, BuiltInTool, ClusterIdFactory, CollaborationAckDiagnostic, CollaborationAdapter, CollaborationReceiver, CollaborationSession, CollaborationSnapshot, CollaborationSyncResult, CollaboratorIdentity, Command, CommandKind, CommentAuthor, CommentMarker, ConnectorBinding, ConnectorBox, ConnectorTarget, ControllerOp, CreateBoardControllerOptions, CreateMemoryPersistenceOptions, CurrentSerializedDocument, CurrentSerializedStroke, CustomBoardObject, CustomObjectAddInput, CustomObjectDefinition, CustomTool, CustomToolDefinition, DeepReadonly, DefaultBoardChromeProps, DefaultUIRegion, DefaultUISlot, DefaultUISlots, DialogSlotProps, DocumentChange, DocumentContext, DocumentId, DocumentLoadResult, DocumentRecoveryCode, EllipseObject, EmojiDefinition, EmojiName, ExportDocumentSVGOptions, ExportDocumentSVGResult, ExtensionCommand, ExtensionDiagnostic, ExtensionHitResult, ExtensionId, ExtensionRequirement, FocusedItem, FocusedItemToolbarProps, GroupObject, HeartObject, IconDefinition, IconName, ImageBlock, InlineEditingTarget, InlineEditorsProps, InputModifiers, JsonObject, JsonValue, KitchenTimer, LineObject, LoadResult, LocalBoard, LocalBoardOptions, LocalBoardSnapshot, LocalPresence, LockHolder, LockTarget, Lockable, Mat2x3, MultiplayerCursorsProps, NoteVote, ObjectDescribeContext, ObjectIntent, ObjectType, Op, OpCollection, PersistenceAdapter, PersistenceDiagnostic, PersistenceSnapshot, PolygonObject, PresenceCursor, PresencePlacement, PresenceUser, PresenceView, QueryableBoardObject, ReadonlyBoardDocument, ReadonlyCustomObject, ReadonlyDocumentChange, RectangleObject, ReorderDirection, ReplaceResult, RibbonEdgePoint, SceneEllipse, SceneGroup, SceneImage, ScenePath, SceneRect, SceneText, ScrawlBoardProps, ScrawlCanvasProps, ScrawlDefaultUIProps, ScrawlDensity, ScrawlExtension, ScrawlGridMode, ScrawlProps, ScrawlProviderProps, ScrawlResolvedTheme, ScrawlSurfaceTexture, ScrawlTheme, ScrawlThemeDiagnostic, ScrawlThemePreset, ScreenPoint, ScreenRect, SearchHit, SearchHitKind, SearchableBoard, SearchableComment, SerializedBoardDocument, SerializedBoardPage, SerializedBoardStroke, SerializedPoint, SerializedStroke, StampKind, StarObject, StickerKind, StickyNote, Stroke, StrokeId, StrokePoint, StrokeTool, StyleShelfProps, SupportedAssetMediaType, TableBlock, TextBlock, ToolCancelReason, ToolCapabilities, ToolCursor, ToolId, ViewportInset };