efficient-easel 27.0.0 → 27.2.0

package/dist/AddSidePanel-DoCx-ZrM.d.ts

@@ -0,0 +1,1994 @@
+import * as react from 'react';
+import { ReactNode, MouseEvent, ComponentType } from 'react';
+import { M as MeasuredCanvas, C as CanvasDragModel, D as DragSession } from './CanvasDragLayer-DXeQGrwJ.js';
+import { SectionTemplate } from './screen/lib/section-template-types.js';
+import { SharedSectionUse, SharedSection } from './screen/lib/shared-section-types.js';
+import { BlockChoice } from './screen/lib/document/block-choice.js';
+import { Data, Config } from './blocks/index.js';
+import { C as CanvasTarget } from './watch-Unf6SfUf.js';
+import { D as DeviceOption } from './types-SrGNzYeO.js';
+import { P as Place } from './types-Dq180WRV.js';
+import { R as RepeatCopy } from './copy-place-CQIemdtU.js';
+import { E as EaselContextMenuItem } from './types-BbOBWXMP.js';
+import { E as EaselRailItem } from './types-Cy7rdmXt.js';
+import { StyleRow } from './style-clipboard/index.js';
+import { f as TreeRowMark } from './types-CoUTWUwB.js';
+import { q as AnyScreenTarget } from './ScreenDocumentContext-JQr4hTeP.js';
+import { HostProduct } from './screen/lib/host-chrome.js';
+import { EaselSession } from './screen/lib/session.js';
+import { SlotConfigView, SlotChild } from './screen/lib/document/content-tree.js';
+
+/**
+ * A component type's own `defaultProps`, looked up in the old library's config.
+ *
+ * Handed IN rather than imported: `lib/document/config` imports the seed
+ * registry's neighbours, and a seed registry that reached back into the config
+ * would close the loop. Both callers of `seeds()` already hold the config
+ * (`components/ScreenChrome`, `components/StandaloneSectionEditor`),
+ * so the lookup travels the short way.
+ *
+ * ⚠️ IT IS OPTIONAL, AND THE FIVE SPECS THAT PREDATE IT IGNORE IT. They
+ * seed ONE flat child whose every field is content, so a missing default changes
+ * nothing they draw. Image & Text Columns seeds a Box holding blocks, and a Box
+ * without its `direction` / `justify` / `align` / `wrap` is a different shape on
+ * the page — see `boxColumnSeed` in lib/document/slot-specs.
+ */
+type NodeDefaults$1 = (type: string) => Record<string, unknown>;
+interface SlotSectionSpec {
+    /** The primary slot field on the section (e.g. Hero's `slides`). */
+    slot: string;
+    /** The child component type the slot holds. */
+    childType: string;
+    /** The "Add …" affordance label. */
+    addLabel: string;
+    /**
+     * The children ARE the section, and no surface offers to add one.
+     *
+     * ⚠️ NOT THE SAME THING AS `addBlocked`, AND THE DIFFERENCE IS WHY IT EXISTS.
+     * `addBlocked` is a reason adding is impossible RIGHT NOW — a hero anchor
+     * already holds four — so the row stays, greyed, with the sentence on it, and
+     * the merchant can act on it (re-place a group and Add comes back). A fixed
+     * set has no such state: the row would be permanently dead furniture, and
+     * `NodeContextMenu`'s own rule says it plainest — a row must never be a button
+     * that does nothing.
+     *
+     * Both surfaces that draw an Add row read this. `addBlocked` is still declared
+     * beside it, because the DROP path asks that one and never this.
+     */
+    fixed?: boolean;
+    /** Children render as a HORIZONTAL slider (selection must advance it). */
+    slider?: boolean;
+    /**
+     * What ONE new child of this slot is, when it is more than `childType`'s
+     * defaults: a node with its own slot children inline, built with the
+     * screen's maker (the config's defaults, the screen's fresh ids) — the
+     * contract `ScreenBlockRules.newSectionNode` keeps for a top-level section.
+     * Every door that adds `childType` to this slot (the Layers row, the Add
+     * panel's press and drop, the settings panel list, the one-section editor's
+     * card and list) lays it down with ONE `insertNode`, so one Undo takes it
+     * back. A choice of the slot other than `childType` is inserted as before.
+     * The ids `make.newNodeId` mints are the contract: the screen does not
+     * re-mint them. Absent: the type's defaults, as before.
+     */
+    newChild?: (make: ScreenNodeMaker) => ScreenNewNode;
+    /**
+     * What one prepared child is called on the Add panel's tile (a noun, the
+     * host's own words: "Scrolling bar"), read only with `newChild`. The tile
+     * puts its own "Add" in front, so this is never cut out of `addLabel`, whose
+     * words a host may translate. Absent: the tile keeps the type's own word.
+     */
+    childLabel?: string;
+    /**
+     * Prop bags for the default children a fresh section is seeded with.
+     *
+     * `defaultsFor` is {@link NodeDefaults} — present when the caller holds the
+     * config, absent otherwise, and every spec that seeds a plain content child
+     * simply declines it.
+     */
+    seeds: (defaultsFor?: NodeDefaults$1) => Record<string, unknown>[];
+    /**
+     * Convert a section's LEGACY props (an older inline-array field) into slot
+     * children at load-time — the chrome-only migration for pages saved before the
+     * field became a slot. Returns [] when there's nothing to migrate, in which
+     * case the seeder falls back to `seeds()`.
+     */
+    legacy?: (props: Record<string, unknown>) => Record<string, unknown>[];
+    /**
+     * Why this section cannot take another child right now — a sentence the
+     * merchant reads — or `null` when it can (card 66189).
+     *
+     * Optional, and only the Hero slide answers it today: a group is placed on one
+     * of nine anchors, an anchor stacks at most four, and a fifth would be drawn
+     * ON TOP of the fourth. The rule lives on the SPEC rather than inside
+     * `SlotChildRows` because the list is shared by five sections and this is one
+     * section's arithmetic — the list asks, the spec answers.
+     */
+    addBlocked?: (children: readonly unknown[], incoming?: unknown) => string | null;
+    /**
+     * Why this section must NOT be seeded at all, read off its OWN stored props.
+     *
+     * The seeder's existing guard is "the slot already has children" — right for a
+     * section whose only shape is the slot, and blind to a section that still
+     * carries an OLDER one. Image & Text Columns is the first of those: its
+     * columns used to be a `steps` ARRAY, the owner ruled on 2026-09-05 that
+     * nothing is migrated, and a stored page therefore has a full `steps` and an
+     * empty `boxes`. Without this the seeder would drop three fresh Boxes into a
+     * published page that already draws three columns, and the merchant would find
+     * six.
+     *
+     * Deliberately a question about the PARENT'S props, not about the slot — the
+     * slot is what the existing guard already reads, and answering "is there an
+     * older shape here" from the same place is what makes this a second question
+     * rather than a second opinion on the first.
+     */
+    skipSeed?: (props: Record<string, unknown>) => boolean;
+    /**
+     * What the list says about the children it ALREADY holds, or `null`.
+     *
+     * The counterpart to `addBlocked`, and deliberately a second question rather
+     * than a second answer from the first: `addBlocked` is about a group that has
+     * not arrived yet, this is about the ones that are already here and cannot all
+     * be drawn. A section that cannot get into that state simply declares neither.
+     */
+    notice?: (children: readonly unknown[]) => string | null;
+}
+
+/** Which registry answered — the discriminator three of the four decisions read. */
+type AddTargetSource = "section" | "footer" | "container";
+/**
+ * What a parent can take, and everything the four decisions below need to act on
+ * it.
+ *
+ * ⚠️ THE LOOKUP DECIDES FOUR THINGS, NOT ONE. Wiring only the choice list ships
+ * a menu with wrong row names, wrong handlers, and unreachable on an empty
+ * container — which is why this returns a record rather than a list:
+ *
+ *   1  the CHOICE LIST — {@link AddTarget.choices}, what the Add menu offers, or
+ *      `null` where the parent adds ONE child type from a button instead.
+ *   2  the ROW NAME    — `rowNamerFor` (components/SlotChildRows) reads
+ *      {@link AddTarget.source} to pick the FOOTER's block-label rule over
+ *      lib/document/slot-child-name.ts. It must ask "is this a FOOTER block", NOT
+ *      "does this parent use a menu": a Box adds from a menu too and
+ *      keeps the slot-child rule, or its Headings, Texts and Buttons all fall
+ *      through to a rule that reads a heading, a bound menu and first-words.
+ *   3  WHICH HANDLERS  — SectionScreenShell's adapter reads `source` to choose
+ *      which pair of host handlers a row presses. Keyed the other way round it
+ *      answered null for a Box, whose rows then pressed and did nothing.
+ *   4  REACHABILITY    — `Boolean(canAddTo(type))` feeds `nestState`, and a row
+ *      folds open only if it has children OR an add affordance. An EMPTY
+ *      container with no caret cannot be opened to reach its own menu — and
+ *      empty is exactly the state a merchant is in when adding the first block.
+ */
+interface AddTarget {
+    /** Which of the three registries answered. */
+    source: AddTargetSource;
+    /**
+     * The slot this parent keeps its children on.
+     *
+     * RETURNED rather than defaulted, so a caller can never reach it by falling
+     * through another mechanism's constant — the rule container-blocks states for
+     * its own lookup, kept here because this is now the one that is asked. A Flex
+     * listed on the Footer's `blocks` would draw its rows off `undefined`.
+     */
+    slot: string;
+    /** The registry's own choice list, or `null` for a single-type "Add …" button. */
+    choices: BlockChoice[] | null;
+    /**
+     * The section's own spec — its `addLabel`, `childType`, `seeds`, `addBlocked`,
+     * `notice` and `slider`. Non-null exactly when `source === "section"`.
+     *
+     * Carried so a caller that needs a section's own arithmetic (the Hero slide's
+     * anchor cap, the seed-on-load effect) reaches it through this one seam rather
+     * than importing the registry beside it and gaining a second opinion.
+     */
+    spec: SlotSectionSpec | null;
+}
+
+/**
+ * WHAT THE WEBSITE HANDS THE EDITOR'S SCREEN — the parts of the screen that
+ * know there is a website, given to it instead of imported by it
+ * (doc/adr/0003).
+ *
+ * The screen — the frame, the panels, the tree, the add panel, the inspector —
+ * is being made to hold nothing a website has that an email does not: no page,
+ * no site theme, no pinned header, no chat bubble. What it used to import and
+ * wire itself, the website layer now wires and hands over here, and a screen
+ * mounted with no layer above it draws none of it.
+ *
+ * This is NOT `EaselChrome` (lib/host-chrome): that is what a HOST stands
+ * round the editor — the storefront's cart, its header's settings — built in
+ * the host and absent on the ambient session. These parts are the builder's
+ * own website layer, the same for every host, and present on every mount of
+ * the screen (`ScreenStoreProvider` supplies them, from whoever mounts it).
+ *
+ * Fixed for the life of a mount, like the session: `useBridges`,
+ * `useStandaloneBridges`, `useDocumentPass` and `blockLook.useProducts` are
+ * called as hooks, and `Canvas` and `Inspector` are rendered as element types,
+ * so the provider's value must not change while the screen is mounted.
+ */
+/** A node of the document as the screen hands it to a layer: its type and its
+ *  props, its id among them. */
+interface ScreenNode {
+    type: string;
+    props: {
+        id: string;
+        [key: string]: unknown;
+    };
+}
+/**
+ * A panel of the layer's own, as the screen holds it: a kind, and whatever
+ * else the layer put beside it to say WHICH one (the node a panel is about).
+ * The screen stores it and hands it back, and reads no further into it than
+ * `kind`.
+ */
+type ScreenInspectorMode = {
+    kind: string;
+};
+/**
+ * THE SELECTION'S OWN PANEL — the one mode the screen names for itself. In it
+ * the inspector follows the selection: a node's settings, or the document's
+ * with nothing selected. Every other mode is a panel of a layer's, which the
+ * screen stores and hands back; this is the one it puts the inspector back to
+ * when the selection changes, and on every press of a row of its own.
+ *
+ * ONE object for the module's life, so setting it while it is the mode already
+ * bails out of the state update. A layer whose inspector names this mode names
+ * THIS object (the website's `SELECTION_MODE`, components/SectionEditor, is it), so
+ * "is the panel showing the selection's own?" has one answer on both sides.
+ * The kind is `"selection"`; its old spelling went in easel 22.0.0.
+ */
+declare const SELECTION_MODE: {
+    readonly kind: "selection";
+};
+/** Is this the selection's own panel? */
+declare function isSelectionMode(mode: {
+    kind: string;
+}): boolean;
+/** The inspector drilled into one PART of a node (lib/document/part-id): the mode
+ *  the screen's part bridge (components/usePartBridge) opens and closes. The
+ *  website's inspector modes include it (components/SectionEditor
+ *  `InspectorMode`). */
+type ScreenPartMode = {
+    kind: "part";
+    nodeId: string;
+    propKey: string;
+};
+/** Are two panels the same panel: the same kind, about the same thing? Asked
+ *  member by member, so the screen can answer without knowing what a layer
+ *  keeps beside the kind. */
+declare function sameInspectorMode(a: ScreenInspectorMode, b: ScreenInspectorMode): boolean;
+/**
+ * A SLOT's own panel (0.105.0): the mode the screen opens when the row of a
+ * slot it draws as a rung is pressed (`ScreenSlot.panel`) — the campaign
+ * designer's Column inspector. `kind` is the layer's (`panel`), and beside it
+ * the node the slot is a slot of and the slot's own name. The screen makes it
+ * and hands it back to the layer's inspector; a layer may name one itself to
+ * `ScreenInspector.select`.
+ */
+interface ScreenSlotMode extends ScreenInspectorMode {
+    nodeId: string;
+    slot: string;
+}
+/** Is a panel a slot's own ({@link ScreenSlotMode}) — about a node's slot, not
+ *  the node? */
+declare function isSlotMode(mode: ScreenInspectorMode): mode is ScreenSlotMode;
+/** An address of a node the screen selects, as its own ops spell one: its
+ *  index, in the list `zone` names (left out for the top-level list); or null,
+ *  for nothing selected. */
+type ScreenSelector = {
+    index: number;
+    zone?: string;
+} | null;
+/** The inspector, as far as a layer needs it: which panel it shows, and how to
+ *  show one of the layer's own. */
+interface ScreenInspector {
+    /** The kind of panel showing now. */
+    kind: string;
+    /** The panel showing now, whole: what `open` was handed, given back. */
+    mode: ScreenInspectorMode;
+    /** Show a panel of the layer's own and reveal the inspector, leaving the
+     *  selection where it is. The same panel already showing stays, as the
+     *  object it was (`sameInspectorMode`). */
+    open: (mode: ScreenInspectorMode) => void;
+    /**
+     * Put a panel of the layer's own in the inspector and leave the inspector as
+     * it stands, in view or hidden: with `reveal` after it, what a press on one
+     * of the screen's own rows does. `open` is for a handler registered once: it
+     * never changes identity, so it cannot ask whether the inspector is hidden
+     * and brings it out every time.
+     */
+    show: (mode: ScreenInspectorMode) => void;
+    /** Bring the inspector into view if it is hidden. What it shows stays. */
+    reveal: () => void;
+    /**
+     * Move the selection AND put a panel of the layer's own in the inspector, in
+     * one step (0.105.0): what the campaign designer's Column needs, which is a
+     * slot and not a node — nothing is selected (`null`) and the Column
+     * inspector shows. `show` then a selection would not hold: the screen puts
+     * the inspector back to the selection's own panel whenever the selection
+     * changes, so the mode is kept pending and that reset honours it for this
+     * one change. The inspector is left as it stands, in view or hidden, as
+     * `show` leaves it. A slot's own panel ({@link ScreenSlotMode}) for a slot
+     * the tree draws as a rung also unfolds the tree to that rung's row.
+     */
+    select: (selector: ScreenSelector, mode: ScreenInspectorMode) => void;
+}
+/**
+ * What the screen hands THE INSPECTOR it mounts in its right panel
+ * (`ScreenParts.Inspector`): the panel to show, the ways out of a panel,
+ * and what the screen's own furniture offers one. The names are the ones the
+ * screen has always passed, two of them in a website's words: they are the
+ * doors the bridges hand back (`openSettings`, `openStyles`).
+ */
+interface ScreenInspectorPanelProps {
+    /** The panel to show: the selection's own (`SELECTION_MODE`), or one of the
+     *  layer's, handed back as the screen was handed it. */
+    mode: ScreenInspectorMode;
+    /** The way to the settings of the whole document, from a panel that edits
+     *  one part of it (`ScreenBridges.openSettings`). */
+    onOpenWebsiteSettings: () => void;
+    /** The way to the styles a part of a block can follow, from that part's own
+     *  panel (`ScreenBridges.openStyles`). Omitted where there is nowhere to
+     *  keep them, and the panel draws no door. */
+    onOpenSiteStyles?: () => void;
+    /** The way to THIS document's own styles (`ScreenBridges.openPageStyles`),
+     *  for a panel with nothing selected to point at. Omitted where the layer
+     *  hands none. */
+    onOpenPageStyles?: () => void;
+    /** Select a node and show ITS OWN settings: the way out of a panel that was
+     *  scoped down to part of that node. */
+    onSelectNode: (nodeId: string) => void;
+    /** Withhold the head's duplicate and remove. Set by the screen whose
+     *  document is ONE node, which a second node or none would break. */
+    hideNodeActions?: boolean;
+    /** Say one line through the screen's toast. Omitted by a screen with none. */
+    onNotify?: (msg: string, tone?: "success" | "error") => void;
+    /** Hide the panel: the last button of its head. Omitted by a screen whose
+     *  inspector is always in view. */
+    onHidePanel?: () => void;
+    /**
+     * Which of the head's two node actions the selected node's BLOCK allows
+     * (0.103.0): its config's `permissions.duplicate` and `permissions.delete`,
+     * each true unless the config says false — the answer the screen's own tree
+     * rows and menu honour, handed on so the head the layer draws honours it
+     * too, hiding or greying a refused one. With nothing selected both are true.
+     * Handed by the page screen; a layer that never reads it draws its head as
+     * it did.
+     */
+    nodeActions?: ScreenNodeActions;
+}
+/** What a block's config allows of the two actions that make another node or
+ *  take one away (`ComponentConfig.permissions`): `false` only where the config
+ *  says so (lib/document/content-tree `blockNodeActions`). */
+interface ScreenNodeActions {
+    duplicate: boolean;
+    delete: boolean;
+}
+/**
+ * The document and its tree of rows, as far as a layer needs them to wire and
+ * draw the parts of ONE block that are not nodes of their own: what is
+ * selected, where a node sits, and the three things a press on such a part's
+ * row does to the node it belongs to. Handed to the bridges on every render,
+ * so each member is that render's.
+ */
+interface ScreenTree {
+    /** The document, as the rules are handed it. */
+    data: unknown;
+    /** The node selected now, or null. */
+    selected: ScreenNode | null;
+    /** The key of the list a node sits in, by the node's id. */
+    zoneOf: (id: string) => string | undefined;
+    /** Somebody else holds the document: nothing may be moved. */
+    readOnly: boolean;
+    /** Select the top-level node at `index` the way a press on its row does: the
+     *  inspector goes back to the selection's own panel, then the selection
+     *  moves. */
+    select: (index: number) => void;
+    /** Write the top-level node at `index` back, whole. */
+    replace: (index: number, node: ScreenNode) => void;
+    /** Bring the canvas to a node, as selecting its row does. */
+    scrollTo: (id: string) => void;
+}
+/**
+ * The canvas, as far as a layer needs it: which device it is being looked at
+ * on, and how often its frame has been rebuilt. The switch, its state and the
+ * Refresh are the screen's; a layer whose own fields or preview ask "which
+ * view is this?", or which puts the canvas somewhere of its own accord, is
+ * told here. Handed to the bridges on every render.
+ */
+interface ScreenCanvas {
+    /** The id of the device the switch is on: one of the layer's own
+     *  (`ScreenDevices.options`). */
+    device: string;
+    /** How many times the screen has rebuilt the canvas's frame (its Refresh).
+     *  It changes with each one and with nothing else: a layer that put the
+     *  canvas somewhere as the document opened lists it as a dependency, and
+     *  puts it there again in the fresh frame. */
+    refreshes: number;
+}
+/**
+ * The left panel, as far as a layer needs it: to put it on a view and to bring
+ * it out. Which view it is on, whether it is open and what a press on the rail
+ * does to either are the screen's. Handed to the bridges on every render.
+ */
+interface ScreenLeftPanel {
+    /** Put the panel on a view, by its id: one of the layer's own
+     *  (`ScreenLeftView`) or one of the screen's. Whether the panel is in view
+     *  stays, and the screen keeps the choice as it keeps any other. */
+    setView: (view: string) => void;
+    /** Bring the panel into view if it is hidden. What it shows stays. */
+    reveal: () => void;
+}
+/**
+ * What a line of the screen's toast may carry besides its words (owner
+ * 2026-10-14: a delete goes at once and its toast offers "Undo" for 8 s). The
+ * shell's `toast` takes all three (`efficient-shell` 7.24); a host's own
+ * `notify` is handed them and should pass them on, or the Undo is lost.
+ */
+interface ScreenToastExtra {
+    /** One action after the words: "Undo". */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    /** How long the line stays, in ms. */
+    duration?: number;
+    /** Told once how the line went: its action, its time, or a tap. */
+    onClose?: (how: "action" | "timeout" | "dismissed") => void;
+}
+/** What a view of the layer's is handed when the left panel draws it: what the
+ *  screen hands the heads of its own views. */
+interface ScreenLeftViewFrame {
+    /** Hide the whole left panel: the last button of every view's head. */
+    onHide: () => void;
+    /** Say one line through the screen's toast — with its Undo and its time
+     *  where it has them (`extra`, 7.0.0: a page deleted from the layer's own
+     *  Pages panel offers Undo through the same door as a section). */
+    notify: (msg: string, tone?: "success" | "error", extra?: ScreenToastExtra) => void;
+}
+/**
+ * A VIEW of the left panel that is the layer's own: a button in the rail, and
+ * what the panel shows while the view is the one it is on. The screen lights
+ * the button and switches to the view exactly as it does for its own Layers,
+ * and draws no frame round what `panel` returns: a view draws its own head.
+ */
+interface ScreenLeftView {
+    /** The view's id: what the screen holds as the view the panel is on, and
+     *  what is kept between mounts (`ScreenLeftViewRules`), so one in use is
+     *  never renamed. The rail button's id as well. */
+    id: string;
+    /** The rail button's name. */
+    label: string;
+    /** …and its glyph. */
+    icon: ReactNode;
+    /** The view, for the screen to place in the left panel as it comes back. A
+     *  function called where the panel is drawn and not a component of its own:
+     *  what it returns is mounted in the screen's place, with nothing between. */
+    panel: (frame: ScreenLeftViewFrame) => ReactNode;
+}
+/**
+ * What a layer stands in the rail: a view of its own, or a button that is NOT
+ * a view of the left panel — one that opens something of the layer's
+ * elsewhere. That one is the engine's own rail item (efficient-easel/rail),
+ * drawn as it is handed: the layer says whether it is lit and what a press
+ * does.
+ */
+type ScreenRailItem = ScreenLeftView | EaselRailItem;
+/**
+ * The screen's own writes of the document, as far as a layer's pass over a
+ * document needs them. They are the writes every surface of the screen makes
+ * (lib/document/use-section-ops), refused the same way while somebody else holds
+ * the document, and ONE object from render to render until that changes — so a
+ * pass may list it as a dependency and run no oftener for it.
+ *
+ * Every write is FOLDED into the history entry it happens in (1.0.1,
+ * `foldIntoHistory`): what a pass gives a document as it opens is part of the
+ * document the history starts at, never an undo step that one Undo takes back
+ * out. Autosave still hears each write.
+ */
+interface ScreenDocumentOps {
+    /** Replace the whole working document, unrecorded. */
+    setDocument: (data: Data) => void;
+    /** Insert a node of `type`, as its own defaults, into the top-level list;
+     *  returns the id it was given. */
+    insertSection: (type: string, index: number) => string;
+    /** Insert a FULL node — its type and its props, slot children inline — into
+     *  the list `zone` names; returns the id it was given. */
+    insertNode: (zone: string, index: number, node: ScreenNode) => string;
+    /** Write the node at a place back, whole. */
+    replaceComponent: (zone: string, index: number, node: ScreenNode) => void;
+}
+/** What the tree lends a layer that draws a row in it: the row's own click,
+ *  for a pointer landing outside its name. */
+interface ScreenTreeRows {
+    rowClick: (select: () => void) => (e: MouseEvent<HTMLElement>) => void;
+}
+/** …and, for a layer that draws rows which fold, the tree's own fold state.
+ *  The ids are the layer's to make; the tree keeps them with its own. */
+interface ScreenTreeFolds extends ScreenTreeRows {
+    isCollapsed: (id: string) => boolean;
+    toggleCollapse: (id: string) => void;
+}
+/**
+ * A layer's main action, as data (`ScreenBridges.mainAction`, 8.0.0). The
+ * screen draws it; the layer draws nothing. Words are the layer's, already in
+ * its language.
+ */
+interface ScreenMainAction {
+    /** The main half's word: "Publish", "Save and close". */
+    label: string;
+    /** Its Tooltip while it can be pressed ("Saves your changes and goes back to
+     *  the campaign. Nothing is sent."). */
+    tooltip?: string;
+    /** What a press does. */
+    onPress: () => void;
+    /**
+     * The quiet form, while there is nothing for the action to do: the main
+     * half becomes secondary, with a check glyph, these words, and off with
+     * `reason` ("Published" / "Everything is live"). The chevron still opens.
+     * Absent or null: never quiet.
+     */
+    quiet?: {
+        label: string;
+        reason: string;
+    } | null;
+    /** A reason of the layer's own to turn the main half off, besides the
+     *  screen's (a lock, a refused save, offline, a failed save). */
+    disabledReason?: string | null;
+    /** What the menu's status row says after the save ("Saved 2 seconds ago ·
+     *  Changes not live yet"): "Changes not live yet", "Everything is live",
+     *  "Never published", "Draft, nothing is sent". */
+    status?: string | null;
+    /**
+     * What the action will put live, one short line each, in the layer's words
+     * ("Home", "Site styles", "Main menu"): the website editor's one Publish
+     * puts the whole site live, and the merchant sees what it holds before the
+     * press. The save menu draws each line as a status row (the shell's
+     * `status` entry: muted, not a menu item) under the status row. Absent or
+     * empty: no list.
+     */
+    goingLive?: readonly string[];
+    /**
+     * The layer's own rows of the ▾ menu ("Version history"): drawn last, under
+     * Save now and one divider, as the shell's menu items. A press closes the
+     * menu, then runs `onSelect`. Absent or empty: the menu is as before, with
+     * no divider of their own.
+     */
+    menuItems?: readonly ScreenMenuItem[];
+    /** The action is running: the main half shows the shell's spinner. */
+    busy?: boolean;
+}
+/** One of the layer's rows in the ▾ menu ({@link ScreenMainAction.menuItems}). */
+interface ScreenMenuItem {
+    /** Unique among the layer's rows. */
+    key: string;
+    /** The row's words, in the layer's language ("Version history"). */
+    label: string;
+    /** The shell glyph before the words. */
+    icon?: ReactNode;
+    /** What a press does, after the menu has closed. */
+    onSelect: () => void;
+    /** Turns the row off. */
+    disabled?: boolean;
+}
+/** What a layer's bridges give back for the screen to place. */
+interface ScreenBridges {
+    /** A row under the Add panel's tiles, for something that is not a block.
+     *  Handed the way to leave Add, for a row that opens a panel. */
+    addPanelRow?: (leaveAdd: () => void) => ReactNode;
+    /**
+     * Rows at the END of a top-level node's own children, for a part of that
+     * block which is not a node: "layer, do you draw anything under this row?".
+     * Asked only where the node's child rows are drawn, and what comes back is
+     * placed as it is — the layer draws with the tree's own row.
+     */
+    partRows?: (node: ScreenNode, rows: ScreenTreeRows) => ReactNode;
+    /**
+     * Does the layer draw a subtree of its OWN under this top-level node — rows
+     * for things the block keeps in its props and not in a slot? Such a row
+     * folds like any other, so the screen asks before it draws the caret.
+     */
+    hasOwnRows?: (node: ScreenNode) => boolean;
+    /** That subtree's rows, for the node at `index`. Asked only when
+     *  `hasOwnRows` said yes and the row is unfolded. */
+    ownRows?: (node: ScreenNode, index: number, rows: ScreenTreeFolds) => ReactNode;
+    /**
+     * The row of a top-level node was pressed, and the screen has selected it:
+     * a layer that keeps a focus of its own INSIDE one block puts it back to the
+     * block. Called between the selection and the canvas's scroll. The node is
+     * the one at the pressed index, if there is one.
+     */
+    sectionPressed?: (node: ScreenNode | undefined) => void;
+    /**
+     * The layer's own controls in the top bar's right cluster. The screen draws
+     * that cluster as the save icon and the main button (8.0.0; it was the save
+     * pill, Refresh and the main button); a layer has two places in it.
+     * `barLead` stands FIRST among the actions, right after the save icon:
+     * something done with the whole document that only the layer has. What
+     * comes back is placed as it is, and a layer with nothing to offer just now
+     * returns nothing.
+     */
+    barLead?: () => ReactNode;
+    /** …and `barTrail` stands just before the main button: a way out to where
+     *  the document is read (the website's Preview, the email designer's "Send
+     *  a test email"). */
+    barTrail?: () => ReactNode;
+    /** …and `barView` stands in the CENTRE cluster, right after Refresh: a way
+     *  to look at the document drawn as an icon beside the preview's own
+     *  controls (the website's Preview, owner 2026-10-25). A layer that has one
+     *  hands it here instead of `barTrail`. */
+    barView?: () => ReactNode;
+    /**
+     * …and `barMain` IS the main button, in its place at the end of the cluster
+     * (0.103.0): the layer's own way to finish with the document — the campaign
+     * designer's Done — where the screen draws Publish (a document that
+     * publishes) or Save. What comes back is placed as it is, nothing round it,
+     * and returning nothing leaves the place empty. Absent, the screen draws its
+     * own button, as it always has.
+     */
+    barMain?: () => ReactNode;
+    /**
+     * THE MAIN ACTION, AS DATA (8.0.0, card [DESIGN] A Clearer Save In Both
+     * Editors): what the layer's main button says and does, for the screen to
+     * draw as the shell's `SplitButton` with the save menu on its chevron. The
+     * website's is Publish (quiet as "Published" while everything is live); the
+     * email designer's is Save and close. The screen turns the main half off,
+     * with the reason, while the document is locked, frozen, refused, offline or
+     * holding a failed save; the chevron always opens. Handed back each render,
+     * so it follows the layer's state. Wins over `barMain`; with neither, the
+     * screen's own Done (`screen.done`) stands in the same split button.
+     */
+    mainAction?: ScreenMainAction | null;
+    /**
+     * The layer's own buttons in the rail. The screen draws the rail as Add, its
+     * own Layers and the host's Media library; a layer has two places in it.
+     * `railLead` stands between Add and Layers. Each list is the buttons THIS
+     * document has, in the order they are drawn: one it does not have is left
+     * out, and a view left out is a view the panel cannot be on.
+     */
+    railLead?: ReadonlyArray<ScreenRailItem>;
+    /** …and `railTrail` stands between Layers and Media. */
+    railTrail?: ReadonlyArray<ScreenRailItem>;
+    /**
+     * Which view the left panel ACTUALLY shows, given the one it is set to: the
+     * view kept from another document may be one this document does not have,
+     * and the panel then shows the screen's Layers. The layer answers, because
+     * some of the views are its own and which of them a document has is its to
+     * know. The screen has no media view (the media library is a popup,
+     * harness UI-20): a stored "media" view resolves to Layers like any other
+     * view this document does not have.
+     */
+    resolveLeftView?: (view: string) => string;
+    /**
+     * A tool of the layer's own at the foot of the Layers tree, under the last
+     * row: something that reads the whole document and is not a row of it.
+     * Placed as it comes back.
+     */
+    treeFoot?: () => ReactNode;
+    /**
+     * Two doors out of the inspector's panels, onto wherever the layer keeps what
+     * they lead to: a view of its own in the left panel, a panel of its own in
+     * the inspector. The screen hands them to the inspector it mounts and does
+     * not know where they go. `openSettings` is the way to the settings of the
+     * whole document, from a panel that edits one part of it. The inspector
+     * cannot do without it, so with no layer it is handed one that leads nowhere.
+     */
+    openSettings?: () => void;
+    /** …and `openStyles` the way to the styles a part of a block can follow,
+     *  from that part's own panel. A layer with nowhere to keep them hands none,
+     *  and the panel draws no door. */
+    openStyles?: () => void;
+    /**
+     * The way to THIS document's own styles — the website's Styles ▸ Basics, the This page group,
+     * the email's Styles — from the tree ground's menu (`screen.pageStyles`).
+     * The tree keeps no row for the document's settings (Lewis, 2026-10-26:
+     * the tree's first row goes), so this is the menu's one door to them. A layer
+     * that hands none gets no row.
+     */
+    openPageStyles?: () => void;
+    /**
+     * THE LAYER'S OWN ROWS IN A NODE'S RIGHT-CLICK MENU (0.105.0), by the group
+     * each joins (`ScreenMenuRows`): the campaign designer's "Check this image
+     * loads" and its phone rows. Asked of the node the menu was opened on, and
+     * where it sits, every time the menu is drawn; what comes back is placed at
+     * the end of its group, after the screen's own rows, as it is handed — a row
+     * that writes runs a component or an op of the layer's that reaches the
+     * document itself. Nothing handed back adds nothing. Absent: the screen's
+     * rows alone, as the menu has always drawn them.
+     */
+    menuRows?: (node: ScreenNode, zone: string, index: number) => ScreenMenuRows | null | undefined;
+    /**
+     * THE ROW'S OWN ACTIONS ON A DRAWN COPY (card copy typing, 2026-10-30). A
+     * card template is drawn once per row of its owner's data, each copy in a
+     * `data-sf-repeat` wrapper; the rows are the layer's, never the document's.
+     * Given, a right-click on a block in a copy offers, in the node's one menu,
+     * Add item after, Move item earlier, Move item later (the way a row cannot
+     * go greyed) and Delete item, and a press comes here with the copy's place.
+     * Withheld while nothing may be written. Absent: the menu is as before.
+     */
+    onCopyItem?: (request: CopyItemRequest) => void;
+    /** The layer's own context, stood round the whole screen. What it is handed
+     *  is the screen; what it returns is rendered in the screen's place. */
+    wrap?: (screen: ReactNode) => ReactNode;
+}
+/** The document's half of a shared section (`ScreenPinnedNodes.shared`). */
+interface ScreenSharedSections {
+    /** The pages that use this top-level node, this page among them, when it is
+     *  a shared section; null when it is this page's own, or the header or
+     *  footer. */
+    usedOn: (node: ScreenNode) => readonly SharedSectionUse[] | null;
+    /** Open one of those pages (a press in On N pages ▸). */
+    openPage: (page: SharedSectionUse) => void;
+    /** MAKE SHARED: the store made `section` from `node`. From now on the layer
+     *  holds `node`, where it stands, as that shared section; the page looks the
+     *  same, and its row turns green. */
+    adopt: (node: ScreenNode, section: SharedSection) => void;
+    /** What Add puts on the page for `section` — the node the layer holds as it
+     *  — or null when it cannot go on this page: it is on it already (once per
+     *  page). */
+    nodeOf: (section: SharedSection) => ScreenNode | null;
+    /** DETACH FROM SHARED: this page's own copy of the shared `node`, every id
+     *  fresh (efficient-easel/data `copyNode`). The screen puts it in the node's
+     *  place, one undo step, and the layer holds it as the page's own from then
+     *  on. The other pages keep the shared section. */
+    detach: (node: ScreenNode) => ScreenNode;
+    /** A shared section was deleted: every page that used it now holds its own
+     *  copy, this one included, and the layer takes that in. Optional. */
+    removed?: (section: SharedSection) => void;
+}
+/** What a press on a drawn copy's item row asks (`ScreenBridges.onCopyItem`). */
+type CopyItemAction = "addAfter" | "moveEarlier" | "moveLater" | "delete";
+/** The copy a row was pressed on, and what to do to its row. */
+interface CopyItemRequest {
+    /** The block whose slot is drawn once per row. */
+    ownerId: string;
+    /** That slot (`template`). */
+    slot: string;
+    /** The row the copy is drawn for; 0 is the main copy. */
+    index: number;
+    /** The copy of an outer template this copy's owner is drawn in, when
+     *  there is one (`RepeatCopy.outer`, `efficient-easel/easel`): the inner
+     *  index alone names no row. */
+    outer?: RepeatCopy;
+    action: CopyItemAction;
+}
+/** A layer's own rows in a node's menu, by the group of the menu each goes at
+ *  the end of (efficient-easel/node-ops `nodeMenuItems`' `extras`): `pick`
+ *  (Select layer), `make` (Duplicate … Paste), `change` (Rename, Hide …) and
+ *  `remove` (Delete). */
+type ScreenMenuRows = Partial<Record<"pick" | "make" | "change" | "remove", EaselContextMenuItem[]>>;
+/** A block type's own default props, read off the config the screen holds.
+ *  The screen's to look up and a layer's to be lent: a layer that reached into
+ *  the config for itself would be holding a second copy of it. */
+type NodeDefaults = (type: string) => Record<string, unknown>;
+/** What the screen lends a rule that builds a node. All four are the screen's
+ *  own and none is a block's: the rule states the node, the screen says what a
+ *  type defaults to, what its next id is, what it is called and whether the
+ *  host offers it. */
+interface ScreenNodeMaker {
+    /** A type's default props, from the config. */
+    nodeDefaults: NodeDefaults;
+    /** A fresh id for one node of a type. Called once per node, in the order the
+     *  nodes are written. */
+    newNodeId: (type: string) => string;
+    /** What a top-level node of a type is called, as the tree and the toast say
+     *  it. */
+    sectionLabel: (type: string) => string;
+    /** Does this editor's host offer the type? A rule that would lay down a block
+     *  the host left out asks first. */
+    blockIsOffered: (type: string) => boolean;
+}
+/** A node as a rule hands it back: a type and its props, slot children inline
+ *  in them. The screen inserts it whole. */
+interface ScreenNewNode {
+    type: string;
+    props: Record<string, unknown>;
+}
+/** The node a `canAddTo` question is asked of: its id, and the document it is in. */
+interface ScreenNodeAt {
+    id: string;
+    data: unknown;
+}
+/**
+ * The rules of particular blocks, asked by the screen and never stated in it:
+ * the screen is handed nodes and is not told which blocks exist. Plain
+ * functions of what they are passed, and the same object for the life of a
+ * mount, so the screen may call them anywhere without listing them as a
+ * dependency.
+ */
+interface ScreenBlockRules {
+    /** A block that is what its section IS: it may be selected and edited, and
+     *  never removed, hidden, duplicated or dragged. `node` is the node itself,
+     *  where the screen asks of one (every place it does, since 18.1.0): a rule
+     *  that locks ONE node, not a whole type — a shared section another tab
+     *  holds (Shared section design v4). A rule that reads the type alone locks
+     *  by type, as it always did. */
+    isLockedBlock: (type: string | undefined, node?: ScreenNode) => boolean;
+    /** Why a second one of this node cannot be made in this document, or null —
+     *  a rule of the block's own. */
+    duplicateBlocked: (data: unknown, node: unknown) => string | null;
+    /**
+     * How many nodes of its own kind the node with `id` already sits inside, for
+     * a block that limits its own nesting; 0 for every other. It is the depth the
+     * add lookup is asked at, so every surface that adds into one node offers the
+     * same list.
+     */
+    nestDepth: (data: unknown, type: string, id: string) => number;
+    /**
+     * What a new top-level section of `type` STARTS AS, when that is more than
+     * its own defaults — an arrangement of several blocks, or a prop no default
+     * carries — as ONE node for the screen to insert in one step; or null, and
+     * the screen inserts the type by itself. Where it goes, selecting it and
+     * announcing it stay the screen's.
+     */
+    newSectionNode: (type: string, make: ScreenNodeMaker) => ScreenNewNode | null;
+    /**
+     * What can go in a node of `nodeType`, sitting `nestDepth` nodes of its own
+     * kind deep (0 when not said): the slot its children are kept on, and the
+     * menu's rows or the one child type a button adds — or null for a node that
+     * takes no children. THE ONE ANSWER every add surface of the screen asks (the
+     * tree, the panel, the menu, the Add panel), so no two of them can come to
+     * offer one node different lists; what each of the layer's blocks takes is
+     * the layer's catalogue, and the screen is not told it.
+     *
+     * `slot` (0.105.0) is asked where the screen means ONE slot of a node that
+     * has several: a gap or an empty slot in the tree, a slot place Add was
+     * opened at, a drop into a slot. The answer is that slot's (the campaign
+     * designer's Column 2 answers `col2`); a layer that keeps one slot per node
+     * may ignore it, and the screen then offers that slot alone, as before.
+     *
+     * `at` (24.2.0) is the ONE node asked of, where the screen means one: its
+     * id and the document it is in (Add opened in it, its rows in the tree, a
+     * drop or an insert into it). Two nodes of one type may take different
+     * children — the campaign designer's Box takes any email block, a Box in a
+     * Banner only what the Banner's bake can draw. A layer whose nodes of one
+     * type all take the same may ignore it. Absent where the question is about
+     * a type, not a node (the Add panel's catalogue).
+     */
+    canAddTo: (nodeType: string, nestDepth?: number, slot?: string, at?: ScreenNodeAt) => AddTarget | null;
+    /**
+     * THE SLOTS OF A NODE, IN ORDER, AS THE SCREEN DRAWS THEM (0.105.0). A slot
+     * that is a `rung` is a row of its own in the Layers tree, with its children
+     * under it, a level of the Select layer flyout and a place of its own in a
+     * drag: the campaign designer's section draws Column 1 and Column 2 so from
+     * two columns up, and its lone column not at all. Every other slot's children
+     * hang straight off the node's row, as they do today. A slot left out of the
+     * answer is not drawn (a column the section's layout hides). The tree, the
+     * Add panel's "Adding to …", the drag and the flyout read it; where a node's
+     * children are FOUND (the menu, a write, a drop's checks) is still every
+     * slot field.
+     *
+     * Answered for every node the tree draws; null or undefined for one is the
+     * screen's own reading of it, so a layer may answer for its sections alone.
+     * Absent: every slot field the config declares, in its order, none of them a
+     * rung — the tree the website has.
+     */
+    slotsOf?: (node: ScreenNode) => ReadonlyArray<ScreenSlot> | null | undefined;
+    /**
+     * A RUNG MOVED (0.105.0): the rung at `from` in the node's run of rungs (its
+     * place among `slotsOf`'s rungs) dropped so it rests at `to` — a drag in the
+     * tree, or ⌥↑ / ⌥↓ on its row. The layer writes the move (the campaign
+     * designer swaps two columns' blocks, or reorders the phone stack) and may
+     * answer the slot to select after it, which the screen selects as a press
+     * on that rung's row does. Absent: no rung is picked up.
+     */
+    moveSlot?: (nodeId: string, from: number, to: number) => string | null | void;
+    /**
+     * What a rung's row offers besides its fold (0.105.0): the campaign
+     * designer's Duplicate and Delete of a column, drawn in the order handed,
+     * among the row's actions. The screen confirms nothing: what a press asks
+     * first (Delete a column that still holds blocks) is the layer's `run`.
+     * Withheld while the document is read-only. Absent, or nothing handed: the
+     * row has none.
+     */
+    slotActions?: (node: ScreenNode, slot: string) => ReadonlyArray<ScreenSlotAction> | null | undefined;
+    /**
+     * Does the host of this editor offer the type? Asked of the editor's own
+     * session where the screen holds it, else of the editor on the page. Where
+     * no host chose its blocks, every type is.
+     */
+    blockIsOffered: (type: string, session?: EaselSession) => boolean;
+    /**
+     * Is a new block RESOLVED as it goes in (0.103.0)? With true, every insert
+     * the screen makes — a section, a block into a slot, a saved template, a
+     * seeded slot child — is followed by `easel.resolveNode(id, { trigger:
+     * 'insert' })`, as the campaign designer's own inserts are: the block's
+     * `resolveData` runs the moment it arrives (seeding its children, stamping a
+     * default), in the insert's own undo step, not at its first edit or the next
+     * time the document opens. Absent, false: an insert runs no resolver, as
+     * the website's never has.
+     */
+    resolveOnInsert?: boolean;
+    /**
+     * CLEAN A COPY (0.106.0): handed every node the screen COPIES into the
+     * document — the menu's Duplicate and Paste, ⌘V (a cut block pasted back
+     * too), a saved section put in from Add — one node at a time, a copied
+     * section's blocks each as well, and it answers the node as the copy should
+     * hold it: what only the original may hold taken out. The campaign
+     * designer's image block releases the hosted picture it baked (`bakedId`):
+     * the next bake deletes the asset that id names, so two blocks holding one
+     * would destroy each other's picture. It must keep the node's id (the copy's
+     * own, already fresh) and its type. Absent: a copy is its original, prop for
+     * prop, but its ids, as before.
+     */
+    stripCopy?: (node: ScreenNode) => ScreenNode;
+}
+/**
+ * ONE SLOT OF A NODE, as the screen draws it (`ScreenBlockRules.slotsOf`,
+ * 0.105.0). Only `slot` and `rung` are read of a slot that is not a rung.
+ */
+interface ScreenSlot {
+    /** The slot field's name (`col2`): its children are `props[slot]`, its list
+     *  is `${nodeId}:${slot}`. */
+    slot: string;
+    /** What the rung's row says ("Column 2"), and the flyout, and Add's
+     *  "Adding to …". */
+    label: string;
+    /** The rung's glyph, drawn as handed. Absent: none. */
+    glyph?: ReactNode;
+    /** Drawn as a row of its own, its children under it. False: its children
+     *  hang straight off the node's row. */
+    rung: boolean;
+    /**
+     * The kind of the layer's panel this rung is edited in (the Column
+     * inspector): a press on its row selects nothing and shows that panel, as a
+     * {@link ScreenSlotMode} naming the node and the slot, and the row is lit
+     * while it shows; the flyout lists it as a level. Absent: the rung only
+     * folds, its press selects the node it is a slot of, and the flyout leaves
+     * it out.
+     */
+    panel?: string;
+    /** A pill after the name ("2 of 3", the phone stack's place). */
+    badge?: ReactNode;
+    /** The hint the row shows when it may be dragged. Absent: the tree's own. */
+    dragHint?: string;
+    /** Drawn above the rung's row, as handed: the campaign designer's "Phone
+     *  order" label over its first column. */
+    heading?: ReactNode;
+    /** False: the rung keeps its place, and is not picked up (a pinned
+     *  section's columns). Absent: it moves where `moveSlot` is handed. */
+    movable?: boolean;
+}
+/** What a rung's row offers (`ScreenBlockRules.slotActions`, 0.105.0). */
+interface ScreenSlotAction {
+    /** Which action: the screen draws its glyph, and the delete in its red. */
+    kind: "duplicate" | "delete";
+    /** Its tooltip and accessible name: "Duplicate Column 2", or why not. */
+    label: string;
+    /** Drawn, and not pressed: the label says why. */
+    disabled?: boolean;
+    /**
+     * The action, the layer's whole: it asks what it must ask first and writes.
+     * It may answer the slot to select after it (the copy, the column that took
+     * a deleted one's place), which the screen selects as a press on that rung's
+     * row does; nothing, and the selection stays.
+     */
+    run: () => string | null | void | Promise<string | null | void>;
+}
+/**
+ * The slot fields of `node` whose row the panel shows, in the config's order —
+ * THE ONE READER of "does a slot follow its row" (plan 2026-10-23 §6.0, "Batch
+ * 3 must do" item 2, GG 2026-10-26). A slot field that carries the shell's
+ * show-when rule (`./fields` `fieldIsShown`) and reads false for the node's own
+ * values is left out: the panel hides that row, so no Layers tree lists blocks
+ * the section no longer draws (the Product Grid's hand-picked products once its
+ * content is a Category). Nothing is deleted; the blocks come back with the row.
+ *
+ * Every Layers tree reads it: {@link screenSlotsOf} (the page editor's), the
+ * page tree's run with no `slotsOf`, and the one-section editor's. Where a
+ * node's children are FOUND — a drop, the address map, dedupe — is still
+ * content-tree's `childSlotsOf`, every slot field.
+ */
+declare function shownSlotFieldsOf(config: SlotConfigView, node: ScreenNode): string[];
+/** The children a Layers tree lists under `node`: those of its shown slots
+ *  ({@link shownSlotFieldsOf}), addressed as `childSlotsOf` addresses them. */
+declare function shownChildSlotsOf(config: SlotConfigView, node: ScreenNode): SlotChild[];
+/**
+ * The slots of `node` as the screen draws them: the layer's answer
+ * (`slotsOf`), else — with no `slotsOf`, or none for this node — the slots
+ * {@link shownSlotFieldsOf} answers, in the config's order, none of them a rung.
+ */
+declare function screenSlotsOf(rules: ScreenBlockRules, config: SlotConfigView, node: ScreenNode): ReadonlyArray<ScreenSlot>;
+/** The tier a node is NAMED at: a node at the top of the document is a section,
+ *  a node inside another is a block. */
+type ScreenNodeLevel = "section" | "block";
+/**
+ * How the layer's blocks are NAMED AND DRAWN in the screen: the tree's rows and
+ * the Add panel's tiles put a word, a glyph and a cover on a block, and which
+ * word and which drawing is known only to the layer that knows every block it
+ * has. The screen is handed a type and asks.
+ *
+ * The same object for the life of a mount, and its two components the same two
+ * functions throughout: the screen renders them as element types, and a type
+ * that changed identity would remount every row and tile that wears one.
+ */
+interface ScreenBlockLook {
+    /**
+     * What a node of `type` is called at a level, given `base` — the label the
+     * config holds for the type, which is the name of every node the layer does
+     * not name by where it sits.
+     */
+    labelAtLevel: (type: string, level: ScreenNodeLevel, base: string) => string;
+    /** The Add panel's one-line blurb for a section, by type. A type with none
+     *  has no entry. */
+    descriptions: Record<string, string>;
+    /** The Add panel's short heading for a group of sections, by the group's
+     *  key, where the layer has one; undefined, and the registry's own title for
+     *  the group is its heading. */
+    categoryLabel: (id: string) => string | undefined;
+    /** The blank section: the Add panel offers it first in its own group, with
+     *  the ungrouped blocks after it, and the blocks it takes (and they take)
+     *  are the blocks Add offers beyond the catalogue (11.0.0). Null: every
+     *  section stands in its group in the catalogue's order, and the blocks are
+     *  what every section takes. */
+    firstSection: string | null;
+    /**
+     * What the row of a block says when the block is named by its own content
+     * and not by the slot-child rule (lib/document/slot-child-name): the layer reads
+     * the content, and `compLabel` — the config's label for a type, lent by the
+     * screen — is the word for a block it has no rule for.
+     */
+    blockRowName: (child: {
+        type: string;
+        props: Record<string, unknown>;
+    }, compLabel: (type: string) => string) => string;
+    /**
+     * The plain words of a block's stored copy, every mark of the layer's markup
+     * unwrapped: what a tree row prints of a name the author typed, where no mark
+     * can be drawn (lib/document/slot-child-name `slotChildRowName`). Which marks
+     * there are is the layer's grammar — a website's is not an email's.
+     */
+    plainText: (copy: string) => string;
+    /** The glyph of a block or section type, as a tree row and a block tile wear
+     *  it. */
+    Icon: ComponentType<{
+        type: string;
+        size?: number;
+        className?: string;
+    }>;
+    /** The cover picture of a section type, filling the Add panel's card — or
+     *  of a preset row, asked with the preset's key (`presets`). */
+    Thumbnail: ComponentType<{
+        type: string;
+    }>;
+    /**
+     * ADD ROWS THAT ARE PRESETS, NOT BLOCK TYPES (GG ruling 2026-10-30, owner
+     * item C36): each with its own key, label, group, blurb and cover, and an
+     * `insert` that builds the node it lays down, in one step. Searched,
+     * pressed after a ➕ and dragged like a section's row; it goes in the page's
+     * own list only. Absent: every row is a block type, as before
+     * (lib/document/palette-sections `PalettePreset`).
+     */
+    presets?: readonly PalettePreset[];
+    /**
+     * The products a row may be named after when its block holds only a
+     * product's handle: null until they arrive, and for good when there are
+     * none. A HOOK — the one member here that is — called once per render where
+     * the screen read the products itself, so its effect keeps its place.
+     */
+    useProducts: () => readonly HostProduct[] | null;
+    /**
+     * THE LAYER'S LAST WORD ON WHAT A LAYERS ROW SAYS (0.103.0): handed a node,
+     * the level it is named at and `fallback` — what the screen's own naming
+     * rule answered (lib/document/slot-child-name: a name the node carries, else its
+     * type's label; a pinned row's word) — it answers the row's name. Asked of
+     * every node row the page screen's Layers tree draws, and of the menu's
+     * Select layer flyout, a block's canvas handle and a section's own list of
+     * its children in the inspector, which say the same words. The campaign
+     * designer's rows read its own labels ("Section 2", "Header"). Absent: the
+     * screen's rule, as it named every row.
+     */
+    rowName?: (node: ScreenNode, level: ScreenNodeLevel, fallback: string) => string;
+    /**
+     * THE PROP A RENAME WRITES, by the layer (0.105.0; owner ruling R11, Victor
+     * Mau, 2026-10-09: Rename works on top-level sections in both editors). The
+     * write side of `rowName`: handed a node, the level it is named at and
+     * `base` — what the screen's own rule answered (lib/document/slot-child-name
+     * `slotChildRenameProp` for a block, `sectionRenameProp` for a section) — it
+     * answers the prop the Layers row's rename box writes, or null for a node
+     * that has no name of its own, which takes Rename out of its menu. Answer the
+     * prop `rowName` reads, so a renamed row says its new name: the campaign
+     * designer's sections are named by their `label` ("Section name"). Asked of
+     * every node the menu opens on, a pinned node and a section group's too.
+     * Absent: the screen's rule — a block's declared name, and a section's
+     * `name`, which its row reads.
+     */
+    renamePropOf?: (node: ScreenNode, level: ScreenNodeLevel, base: string | null) => string | null;
+    /**
+     * The quieter words a node row draws after its name (`TreeRow`'s
+     * `preview`): a node's own first words, so a tree of rows all called
+     * "Section" can be told apart by eye. The layer chooses and shortens them;
+     * nothing (null, undefined, "") draws nothing. Absent: no row has any.
+     */
+    rowPreview?: (node: ScreenNode) => string | null | undefined;
+    /**
+     * The small marks a node row draws right after its name (`TreeRow`'s
+     * `marks`): a state the row only SHOWS, such as "Shown on phones only".
+     * Absent, or nothing handed back: no marks.
+     */
+    rowMarks?: (node: ScreenNode) => ReadonlyArray<TreeRowMark> | null | undefined;
+    /**
+     * The layer's own buttons on a node row, by the node and where it sits:
+     * `TreeRowAction`s (efficient-easel/tree), placed between the screen's trash
+     * and its eye — the campaign designer's phone switch. Asked of every node
+     * row, a locked one and a pinned one too, so the layer decides; what comes
+     * back is placed as it is, and nothing draws nothing. A button that writes
+     * renders a component of the layer's that reaches the document itself.
+     * Absent: the screen's two, as it drew them.
+     */
+    rowActions?: (node: ScreenNode, zone: string, index: number) => ReactNode;
+}
+/**
+ * THE DEVICES the canvas can be looked at on. That the top bar has a switch,
+ * and that the canvas is fitted to the pane and framed, is the screen's: any
+ * editor's canvas is looked at on more than one. WHICH devices there are, what
+ * each is called and how wide it is drawn is the layer's — a website has three
+ * view tiers where an email has two.
+ *
+ * The same object for the life of a mount: the screen reads the device it
+ * starts on from it once, and draws the switch from it on every render.
+ */
+interface ScreenDevices {
+    /** What the switch offers, in the order it draws them: an id, a name and a
+     *  glyph each (efficient-easel/chrome `DeviceSwitch`). */
+    options: ReadonlyArray<DeviceOption>;
+    /** The device a mount starts on. */
+    initial: string;
+    /**
+     * The ONE device with no width of its own: the canvas draws it at the
+     * pane's width, so it reflows as the pane is dragged, where every other is
+     * a fixed width scaled to fit the pane. Its frame is the plain one; every
+     * other device's wears a class named for its id.
+     */
+    fluid: string;
+    /** The width each device is drawn at, in CSS px, by id. For `fluid` it is
+     *  only the width of the frame before the pane has been measured. */
+    widths: Readonly<Record<string, number>>;
+    /**
+     * How a fixed device is fitted to the pane (0.105.0). `"fill"`: scaled to
+     * the pane's width, up to twice its size, so a phone reads big and clear in
+     * a wide pane — the website's view tiers. `"shrink"`: scaled DOWN when the
+     * pane is narrower than the device and never up, so a device is drawn at its
+     * real size or smaller — the campaign designer's phone, a mail preview of
+     * the width the recipient's phone has. The fluid device is drawn at the
+     * pane's width either way. Absent: `"fill"`.
+     */
+    fit?: "fill" | "shrink";
+}
+/**
+ * WHAT A DRAG ON THE PAGE SCREEN CARRIES (0.105.0): a node of the document —
+ * its id, the list it sits in (a zone key, `<parentId>:<slot>`), its index
+ * there and its type — or, with `add`, a NEW one from the Add panel, which
+ * has no place yet. One kind of thing for the ONE drag the Layers tree, the
+ * canvas and the Add panel share, so a block picked up on one lands on
+ * another. A layer's own canvas sources (`ScreenCanvasDrag.model`) carry it
+ * too; a thing of the layer's that is not a node (the campaign designer's
+ * column) is told apart by a `zone` and a `type` of the layer's own — a list
+ * the document has none of, so the screen's writes find no node there and
+ * do nothing, and the Layers tree, which draws no gap in it, takes none. A
+ * layer that offers one answers for it on the canvas (`canDrop`, `drop`,
+ * `pick`).
+ */
+interface ScreenDragItem {
+    id: string;
+    zone: string;
+    index: number;
+    type: string;
+    add?: AddKey;
+    /** A slot the Layers tree draws as a row of its own (`slotsOf`, a rung),
+     *  picked up by its row: `index` is its place in its node's run of rungs. */
+    rung?: {
+        nodeId: string;
+        slot: string;
+    };
+    /** A file carried out of the host's media popup (`ScreenCanvasDrag.media`):
+     *  `add` is what it becomes between things, and a drop on a thing that
+     *  takes it puts it there instead. */
+    media?: true;
+}
+/** A file from the host's media library, dropped on the canvas (harness
+ *  UI-20, 2026-10-23), as the host's pick path gave it back (`MediaPlace`):
+ *  `url` is what draws. */
+interface ScreenMediaFile {
+    id: string;
+    url: string;
+    kind: "image" | "video";
+    name: string;
+}
+/**
+ * A FILE FROM THE MEDIA POPUP, DROPPED ON THE CANVAS (`ScreenCanvasDrag.media`,
+ * harness UI-20, owner decision Lewis 2026-10-23). The drag is the screen's:
+ * it hears a file carried out of the host's popup, offers the places a new
+ * picture may go — the lines Add's tiles get — and outlines a thing the file
+ * may land ON. What a picture IS in this document is the layer's; what the
+ * file becomes in the host first is the host's (`MediaPanelProvider` `place`,
+ * its pick path: a website copies in a file another website holds).
+ */
+interface ScreenMediaDrop {
+    /** What a file dropped BETWEEN things becomes: Add's entry for the layer's
+     *  picture block, offered at exactly the places Add would offer it. */
+    adds: {
+        kind: "section" | "block";
+        type: string;
+    };
+    /** May a file land ON this node, its picture replaced by it? */
+    takes: (node: ScreenNode) => boolean;
+    /** The node's props with the file as its picture. */
+    replace: (node: ScreenNode, file: ScreenMediaFile) => Record<string, unknown>;
+    /** A new node of `adds` holding the file, for a drop between things, made
+     *  with what the screen lends a rule that builds a node (its defaults, its
+     *  ids). */
+    create: (file: ScreenMediaFile, maker: ScreenNodeMaker) => ScreenNode;
+}
+/**
+ * What the screen tells a layer's canvas drag each time it asks
+ * (`ScreenCanvasDrag`, 0.105.0). Its rules are plain functions, the same for
+ * the life of the mount like the block rules, so what they reason about is
+ * handed to them: the document as it stands, the device the canvas is drawn
+ * as, and — for a drop or a pick that does what the screen's own would not —
+ * the screen's writes and its inspector.
+ */
+interface ScreenCanvasDragContext {
+    /** The working document (`{ root, content, zones }`), as the store holds it
+     *  now: what the measure and the model are of. */
+    data: unknown;
+    /** The device the canvas is drawn as, one of the layer's own
+     *  (`ScreenDevices.options`): a phone may stack what a desktop lays across. */
+    device: string;
+    /** The screen's writes (`ScreenDocumentOps`, refused while somebody else
+     *  holds the document), for a drop of the layer's own. */
+    ops: ScreenDocumentOps;
+    /** The inspector, for a drop or a pick that opens a panel of the layer's
+     *  own on what it moved or named (a column's). */
+    inspector: ScreenInspector;
+}
+/**
+ * THE CANVAS DRAG, AS A LAYER HAS IT (`ScreenParts.canvasDrag`, 0.105.0).
+ * That there is a drag on the canvas — the handle on the smallest box under
+ * the pointer, the one drop line, the catch surface, the session it shares
+ * with the Layers tree and the Add panel — is the screen's
+ * (efficient-easel/drag `CanvasDragLayer`). How the canvas is MEASURED, what
+ * may be picked up on it and what may land where on it may be the layer's: an
+ * email lays its sections out in columns, measured from cells of its own, and
+ * a column is grabbed by a strip down its edge that is the column's and not its
+ * blocks'.
+ *
+ * Each member is optional and falls back on the screen's own; each is handed
+ * the screen's own answer (`base`) as well, so a layer may add to it, narrow it
+ * or answer only for what is its own and leave the rest to the screen. They
+ * answer for the canvas only: a drop on the Layers tree is the tree's rules',
+ * whatever surface the thing was picked up on.
+ *
+ * Plain functions, the same object for the life of the mount, like the block
+ * rules; what they reason about is handed to them (`ScreenCanvasDragContext`).
+ */
+interface ScreenCanvasDrag {
+    /** How the canvas is measured into boxes, in the coordinates of `layer`
+     *  (the element the drag layer draws in). Absent: the old library's markers, the slots
+     *  and the blocks directly in them (efficient-easel/drag `measureCanvas`). */
+    measure?: (canvas: CanvasTarget, layer: Element, context: ScreenCanvasDragContext) => MeasuredCanvas;
+    /**
+     * What may be picked up on what was measured, and which lists take drops,
+     * handed the screen's own model of it (`base`: every node but the pinned
+     * ones — asked through `isPinnedFirst` / `isPinnedLast` — a locked block, a
+     * group of sections, and a section with nothing to trade places with). It
+     * is asked of an EMPTY measure too, before the frame is first measured.
+     * Absent: `base`.
+     */
+    model?: (measured: MeasuredCanvas, base: CanvasDragModel<ScreenDragItem>, context: ScreenCanvasDragContext) => CanvasDragModel<ScreenDragItem>;
+    /** May the thing in hand land at `to` on the canvas? Handed the screen's
+     *  own rule (`base`, the Layers tree's). Absent: `base`. */
+    canDrop?: (item: ScreenDragItem, to: Place, base: (item: ScreenDragItem, to: Place) => boolean, context: ScreenCanvasDragContext) => boolean;
+    /** Land it, at a place `canDrop` said yes to. Handed the screen's own write
+     *  (`base`, the tree's: a section moved, a block moved, a new one added).
+     *  Absent: `base`. */
+    drop?: (item: ScreenDragItem, to: Place, base: (item: ScreenDragItem, to: Place) => void, context: ScreenCanvasDragContext) => void;
+    /** A handle CLICKED, not dragged: select what it names. Handed the screen's
+     *  own (`base`: the node, as a press on its row selects it). Absent: `base`. */
+    pick?: (item: ScreenDragItem, base: (item: ScreenDragItem) => void, context: ScreenCanvasDragContext) => void;
+    /** A file carried out of the host's media popup lands on the canvas
+     *  (`ScreenMediaDrop`). Absent: the canvas takes no such file. */
+    media?: ScreenMediaDrop;
+}
+/** What a layer's head over the canvas is handed (`ScreenParts.CanvasHead`,
+ *  0.105.0): the device the canvas is drawn as, so it can say what is the
+ *  device's (the campaign designer's mail-app switch is desktop's only). */
+interface ScreenCanvasHeadProps {
+    device: string;
+}
+/**
+ * WHAT IS PINNED in the document's top-level list. That the list has a BAND
+ * its sections keep to — one node pinned ahead of it at most, and one behind —
+ * is the screen's: where a new section lands, where a dragged one may be put
+ * down, which nodes the canvas offers a handle on and what the menu withholds
+ * are all read off that band, and the arithmetic of it is written once, in the
+ * screen. WHICH types are pinned is the layer's: a website pins its Header
+ * first and its Footer last, where an email pins nothing.
+ *
+ * And the layer's GROUPS OF SECTIONS, if it has them: a pinned top-level node
+ * whose one list holds ordinary sections, which move among the groups' lists
+ * and nowhere else. The screen draws a group's row and keeps its sections to
+ * those lists; which types are groups, and what a group's list is keyed by,
+ * it asks.
+ *
+ * And THE PANEL A PINNED NODE IS EDITED IN, where that is not the selection's
+ * own: a node the layer pins may carry no fields, the layer keeping its
+ * settings and showing them in a panel of the layer's. Which node, and which
+ * panel, is the layer's to say; the screen asks by type where a node is
+ * selected and where a pinned node's row is pressed, and shows what it is
+ * handed.
+ *
+ * And HOW THE LAYERS TREE FRAMES THEM (0.103.0): which node is pinned where it
+ * is not one type (`isFirst`, `isLast` — the campaign designer's Header and
+ * Footer are both sections, told apart by a prop), how the first one's row is
+ * drawn (`firstRow`) and what the band of sections between them looks like
+ * (`band`). Each is optional, and its default is the tree the website has.
+ *
+ * The same object for the life of a mount, its functions plain functions of
+ * what they are passed: the screen reads it anywhere, inside the callbacks and
+ * effects it does not rebuild for it.
+ */
+interface ScreenPinnedNodes {
+    /** The type of the node pinned FIRST: the band starts after it. Null when
+     *  the layer pins none. */
+    first: string | null;
+    /** The type of the node pinned LAST: the band ends at it. */
+    last: string | null;
+    /**
+     * Is this top-level node the one pinned first (0.103.0)? Where every node
+     * of the pinned type is not pinned — the campaign designer's Header is an
+     * `EmailSection` with `_region: "header"`, beside body sections of the same
+     * type — the layer says which. The page screen asks it wherever it tested
+     * a node against `first`: the band, the tree, the canvas handles, the menu.
+     * (The section screen, which holds one node, still asks the type.) The
+     * first node that answers yes is the one. Absent: a node of type `first`.
+     */
+    isFirst?: (node: ScreenNode) => boolean;
+    /** …and the one pinned last (the Footer). Absent: a node of type `last`. */
+    isLast?: (node: ScreenNode) => boolean;
+    /**
+     * May a block cross into and out of the node pinned LAST (0.106.0) — dragged
+     * in the Layers tree or on the canvas, or pasted? Absent or false, the
+     * website's Footer: its blocks reorder within their own slot and nothing
+     * from the page's sections lands in it, nor leaves it. True, the campaign
+     * designer's Footer, a section whose columns hold any block: its slots are
+     * lists like every other's, asked what they take (the slot's own list, the
+     * depth, never into itself). The node itself stays pinned either way.
+     */
+    lastIsOpen?: boolean;
+    /**
+     * How the Layers tree draws the node pinned first (0.103.0). `"panel"`: a
+     * row of its own that opens the layer's panel for it (`panelOf`), drawn
+     * whether or not the document holds the node, and none of its children —
+     * the website's Header, whose settings are a panel. `"node"`: the node
+     * itself, selected by its row and folding open into its children, exactly
+     * as the node pinned last is drawn — the campaign designer's Header, a
+     * section with blocks in it. Absent: `"panel"`.
+     */
+    firstRow?: "panel" | "node";
+    /** What the band of sections between the two pins looks like in the tree
+     *  (0.103.0). Absent: a group label in the screen's words, the sections at
+     *  the tree's own depth, and no row after them. */
+    band?: ScreenPinnedBand;
+    /**
+     * HEADER AND FOOTER EDITED IN PLACE (8.2.0, owner 2026-10-15). The words of
+     * the canvas TAB on a pinned node — "Header · on every page" — or null for
+     * a node that has none. Asked of each node pinned first or last and of each
+     * group of sections. The screen draws the tab on the band's top edge while
+     * the pointer is anywhere in it or anything in it is selected, at its true
+     * size whatever the device is scaled by, kept inside the canvas when the
+     * band starts above it; a click on the tab selects the band. Handing it
+     * also makes a group of sections NO STEP of the canvas's click-through
+     * chain: a click inside walks from the group's sections in, as on the page.
+     * Absent: no tab, and the click chain as it was.
+     */
+    groupTab?: (node: ScreenNode) => string | null;
+    /**
+     * …the badge on the Layers row of each pinned node and group ("Every
+     * page"). Handing it draws the in-place tree: the header and footer are
+     * their own rows, with no "Header" / "Footer" group labels over them, and
+     * no row that opens the footer somewhere else. Hidden while the left panel
+     * is narrower than 240px, where the name needs the room. Absent: the tree
+     * as it was.
+     */
+    groupBadge?: string;
+    /**
+     * SHARED, AND HOW FAR (Shared section design v4, Lewis 2026-10-21): how far
+     * a top-level node reaches when many pages use it live — "On every page",
+     * "On 3 pages" — or null for a node that is this page's own. Asked of each
+     * top-level node, the header and footer and their groups included. For a
+     * node it answers, the screen draws ONE look, green with the shell's
+     * `shared` mark, colour never alone:
+     *   · its Layers row in the shell's shared tone, the mark at the row's end
+     *     and these words in the mark's Tooltip — in place of `groupBadge`;
+     *   · its canvas tab, while it or anything in it is selected or under the
+     *     pointer: the green badge with the mark and the row's name, these words
+     *     in the tab's Tooltip — in place of `groupTab`'s words;
+     *   · its selected and hover outline on the canvas in green
+     *     (`CanvasSharedContext`).
+     * `groupTab` and `groupBadge` still say what they switch (the in-place tree,
+     * the click chain). Absent: nothing is shared, and the screen is as it was.
+     */
+    sharedReach?: (node: ScreenNode) => string | null;
+    /**
+     * …and the DOCUMENT'S HALF of a shared section (Shared section design v4,
+     * Lewis 2026-10-21): the layer holds which top-level nodes are shared
+     * sections, and how a page's document stores them (a reference in its top
+     * level, the section in a document of its own). The screen draws the rows
+     * and asks the store (lib/shared-sections); what changes in the document is
+     * asked here. Handed with a store (`SessionBackend.sharedSections`), the
+     * screen offers:
+     *   · a page's own section's menu: Make shared — a name asked in a dialog,
+     *     the store makes the shared section, `adopt` takes the node in;
+     *   · a shared section's menu: On N pages ▸ (`usedOn`, a press `openPage`),
+     *     Detach from shared (`detach`), and Remove from this page in place of
+     *     Delete, its Layers trash saying so too;
+     *   · Add's "Shared sections" group above "Your templates": a card puts
+     *     `nodeOf` on the page (a reference, never a copy), and the card's menu
+     *     deletes the shared section (`removed`).
+     * Absent: none of these. The header and footer are shared (`sharedReach`)
+     * but answer `usedOn` with null: they keep the menu they have.
+     */
+    shared?: ScreenSharedSections;
+    /**
+     * …what the screen says ONCE per editing session (the easel session), the
+     * first time an edit changes a pinned node or a group of sections: the
+     * shell's toast, with Undo ("Changed on every page"). A seed, a load or an
+     * undo says nothing. Absent: nothing is said.
+     */
+    changeNotice?: string;
+    /**
+     * WHAT A GROUP OF SECTIONS TAKES (8.3.0): may a section of `sectionType` go
+     * into a group of `groupType` that holds `countNow` sections BEFORE it goes
+     * in? Asked of every way a section arrives in a group: a new one from Add (a
+     * click on a tile, a drag of one, and which tiles Add shows), a section dragged
+     * there from the other group, and a paste. A section moved within its own group
+     * is not asked: nothing arrives. The website's header takes up to 3 light
+     * sections and its footer up to 6. Absent: a group takes any section, as before.
+     */
+    groupAccepts?: (groupType: string, sectionType: string, countNow: number) => boolean;
+    /** The type of the group of sections pinned first, ahead of everything. */
+    firstGroup: string | null;
+    /** …and of the one pinned last. */
+    lastGroup: string | null;
+    /** Is a node of this type a group of sections? */
+    isSectionGroup: (type: string | undefined) => boolean;
+    /** The key of the list a group keeps its sections in, by the group's id. */
+    sectionGroupZone: (groupId: string) => string;
+    /**
+     * The panel of the layer's own that a node of this type is edited in, or
+     * null: the node is edited by its own fields, in the selection's own panel
+     * (`SELECTION_MODE`). What comes back is what the screen stores, so it is
+     * the SAME object every time the same type is asked about. Asked with no
+     * type where nothing is selected, and answered null.
+     */
+    panelOf: (type: string | null | undefined) => ScreenInspectorMode | null;
+}
+/**
+ * THE BAND, AS THE LAYERS TREE FRAMES IT (`ScreenPinnedNodes.band`, 0.103.0):
+ * the sections between the two pins. Where the band starts and ends is the
+ * screen's arithmetic either way; this is only how it is drawn.
+ */
+interface ScreenPinnedBand {
+    /** What the band is called. Absent: the screen's words, `screen.pageSections`
+     *  ("Page") on a document with the edit guard and
+     *  `screen.templateSections` ("Template") on one without. */
+    label?: string;
+    /** The band is a ROW that folds, its sections under it — the campaign
+     *  designer's Body. Absent or false: a group label over the sections, which
+     *  sit at the tree's own depth. */
+    foldable?: boolean;
+}
+/** Is `node` the one the layer pins FIRST — its own test (`isFirst`), else a
+ *  node of the `first` type, the test the screen has always made. */
+declare function isPinnedFirst(pinned: ScreenPinnedNodes, node: ScreenNode): boolean;
+/** …and LAST (`isLast`, else a node of the `last` type). */
+declare function isPinnedLast(pinned: ScreenPinnedNodes, node: ScreenNode): boolean;
+/**
+ * THE VIEW THE LEFT PANEL IS ON, from one mount to the next. That the panel
+ * has views, that one of them is current and that the choice is kept is the
+ * screen's: it holds the view in state and mirrors it from ONE effect, the
+ * only writer. WHERE it is kept, which view a first mount opens on and what a
+ * selection does to it are the layer's — a website opens on its page list,
+ * and keeps the choice under a key of its own.
+ *
+ * The same object for the life of a mount: the screen seeds its state from
+ * `read` once, and calls the other two from an effect and a callback it does
+ * not rebuild for them.
+ */
+interface ScreenLeftViewRules {
+    /** The view a mount opens on: the one kept, or the layer's first. */
+    read: () => string;
+    /** Keep the view for the next mount. */
+    write: (view: string) => void;
+    /** What a change of the selection does to the view: handed the id of the
+     *  node selected, if one is, and the view the panel is on, it answers the
+     *  view to be on. */
+    forSelection: (selectedId: string | null | undefined, current: string) => string;
+}
+/** What a style clipboard's scope is read off (`ScreenStyleClipboard.scope`):
+ *  the document the screen has open. */
+interface ScreenStyleDocument {
+    /** What the screen is pointed at: a website's page, or a host's own
+     *  document (`{ kind: "document", record }`). */
+    target: AnyScreenTarget;
+    /** The website the page belongs to, or null. */
+    siteId: string | null;
+    /** The backend's id of the loaded document, or null while it loads. */
+    docId: string | null;
+}
+/** What a Paste style onto one node would do: its new props, whether they
+ *  changed, how many rows were pasted, and the words the merchant reads. */
+interface ScreenStylePastePlan {
+    props: Record<string, unknown>;
+    changed: boolean;
+    pasted: number;
+    message: string;
+}
+/**
+ * COPY STYLE / PASTE STYLE, where it is the layer's (0.105.0, seam E10). The
+ * clipboard, the matching rule, the menu rows, their words and the ⌥⌘C / ⌥⌘V
+ * keys are efficient-easel/style-clipboard's and the screen's; WHICH rows of a
+ * node are its look, and how far a copied look travels (its scope), are the
+ * layer's — the website's look is its Style and Layout tabs and travels across
+ * one site's pages, the campaign designer's is its own panels' and stays in
+ * one campaign. Each member is optional, and one left out is the website's
+ * (lib/document/style-clipboard): a layer may hand only its scope. Plain functions,
+ * the same object for the life of the mount.
+ */
+interface ScreenStyleClipboard {
+    /** The clipboard's scope for the open document: in another scope nothing is
+     *  held. Absent: `siteStyleScope(siteId)`, one site across its pages. */
+    scope?: (doc: ScreenStyleDocument) => string;
+    /** A node's look, as rows the clipboard holds and matches. Absent: the
+     *  website's (`nodeStyleRows`), the Style and Layout tabs. */
+    rows?: (config: unknown, node: ScreenNode) => StyleRow[];
+    /** Copy a node's look into `scope`, named `label` (the menu's word for it).
+     *  Absent: its `rows`, copied as they are stored. */
+    copy?: (scope: string, node: ScreenNode, label: string, config: unknown) => void;
+    /** What a paste onto a node would do, or null when nothing is held in
+     *  `scope`. The screen writes `props` through its one replace op when
+     *  `changed`, and always shows `message`. Absent: the held look laid over the
+     *  node's `rows` (efficient-easel/style-clipboard `planPaste`). */
+    plan?: (scope: string, node: ScreenNode, label: string, config: unknown) => ScreenStylePastePlan | null;
+}
+interface ScreenParts {
+    /**
+     * The name a panel's head gives what is being edited — the website's name,
+     * a campaign's — as the hook the head calls, through `useScreenOwnerName`.
+     */
+    useOwnerName?: () => string;
+    /**
+     * The Layers head's context line — what the open document is, under the
+     * word "Layers" — as the hook the head calls (0.103.0). The campaign
+     * designer's names the campaign and its variant. Absent: the document's
+     * address, `/${slug}`, as the website's head has always said it.
+     */
+    useDocumentLabel?: () => string;
+    /**
+     * The layer's wiring between the inspector and what the layer draws in the
+     * canvas, as ONE hook the screen calls where it used to hold that wiring: a
+     * click on the layer's furniture in the canvas opens its panel, and the open
+     * panel outlines the furniture. And its wiring for the parts of one block
+     * that are not nodes: what selecting one does, and the rows it has in the
+     * tree. And its own controls in the top bar, with whatever they run on. And
+     * its buttons in the rail, with the views of the left panel they open.
+     */
+    useBridges?: (inspector: ScreenInspector, tree: ScreenTree, canvas: ScreenCanvas, left: ScreenLeftPanel) => ScreenBridges;
+    /**
+     * The same, for the screen that holds ONE node as its whole document
+     * (SectionScreenShell). A hook of its own and not `useBridges` with less
+     * handed in: that screen wired less — no site-wide furniture, no tree of
+     * sections — and a hook cannot leave out half of itself by what it is
+     * passed.
+     */
+    useStandaloneBridges?: (inspector: ScreenInspector) => ScreenBridges;
+    /**
+     * The layer's own pass over a document as it opens: what it lays down in one
+     * that lacks it, and takes out of one that holds it twice. A hook of its own
+     * and not one more thing the bridges run, because of WHERE it must run: the
+     * bridges stand early among the screen's hooks, and this pass writes the
+     * document, so it is called LAST of the screen's own passes over it — after
+     * the slot seeding and the duplicate-id heal, which address top-level nodes
+     * by index and would be thrown out by a node laid down ahead of them. Lent
+     * the screen's writes and the config it holds, for the engine's node maker.
+     */
+    useDocumentPass?: (ops: ScreenDocumentOps, config: unknown) => void;
+    /**
+     * The layer's block rules. Handed here and NOT registered at import: what a
+     * registry holds depends on which modules have loaded, and that order is not
+     * the same in the app and in a script that loads one file, so a rule could
+     * answer in one and be absent in the other.
+     */
+    blockRules?: ScreenBlockRules;
+    /** How the layer's blocks are named and drawn. Handed here for the reason
+     *  the rules are. */
+    blockLook?: ScreenBlockLook;
+    /** The devices the layer's canvas is looked at on. Data, and handed here
+     *  for the reason the rules are. */
+    devices?: ScreenDevices;
+    /** Where the left panel's view is kept, and which one a mount opens on.
+     *  Plain functions, and handed here for the reason the rules are. */
+    leftView?: ScreenLeftViewRules;
+    /** Which node types are pinned in the top-level list, which are groups of
+     *  sections, and which are edited in a panel of the layer's. Data and three
+     *  plain functions, and handed here for the reason the rules are. */
+    pinned?: ScreenPinnedNodes;
+    /**
+     * May the operator pause the autosave (0.103.0)? Since 8.0.0 the switch is
+     * the save menu's Auto-save check box (the main button's ▾), where it was
+     * the save pill; a layer whose editor always saves says false, and the menu
+     * offers Save now alone. "Retry now" stays after a failed save either way.
+     * Absent, true: the switch, as both editors have it.
+     */
+    saveSwitch?: boolean;
+    /**
+     * Does a field's media pick give way to a change of selection (0.103.0)? A
+     * field of the selected block asks the host's panel to choose (lib/
+     * media-panel); with true, selecting another block, or none, while it waits
+     * leaves pick mode and settles the field with null, as Cancel would — the
+     * campaign designer's picker belongs to the block it was opened for. Absent,
+     * false: a pick outlives a change of selection, as the website's does.
+     */
+    pickFollowsSelection?: boolean;
+    /**
+     * WHERE A PERSON'S PANEL WIDTHS AND TREE FOLDS ARE KEPT (0.106.0): the
+     * first part of the two `localStorage` keys, `<namespace>-panel-widths` and
+     * `<namespace>-collapsed-sections`, so an editor beside the website's keeps
+     * its own — the campaign designer's panels and folds are not the website
+     * editor's. Read once, as the screen mounts. Absent (or empty): the website
+     * editor's keys, `sf-editor-panel-widths` and
+     * `sf-editor-collapsed-sections`, so a website's layout is what it was.
+     */
+    storageNamespace?: string;
+    /** Copy style / Paste style's scope and a node's look, where they are the
+     *  layer's (0.105.0; `ScreenStyleClipboard`). Absent: the website's. */
+    styleClipboard?: ScreenStyleClipboard;
+    /**
+     * Do ⌘C / ⌘X / ⌘V (Ctrl on Windows) copy, cut and paste the SELECTED block
+     * (0.105.0)? The keyboard door to the menu's Copy, Cut and Paste rows, which
+     * print these keys beside them: the menu's rules, the menu's place for a
+     * paste, and a paste with nowhere to go there refused aloud
+     * (`screen.pasteRefused`). Heard on the editor and in the canvas frame, never
+     * where a person types or has words selected, nor with ⌥ (Copy style) or ⇧
+     * held. Nothing is cut or pasted on a document this editor cannot write; a
+     * copy is allowed there.
+     *
+     * Owner ruling R12/R13 (Victor Mau, 2026-10-09): Copy and Paste work the same
+     * way in both editors. So the keys are on unless the layer says false.
+     */
+    nodeKeys?: boolean;
+    /**
+     * THE HOST'S OWN TOASTS (0.105.0; owner ruling R17, Victor Mau, 2026-10-09).
+     * Every line the screen would say in its toast — "Copied Text", "Added
+     * “Hero” section", a refused paste, a pasted style, what a panel of the
+     * layer's or the inspector says through the screen's toast — goes to the host
+     * instead, with its tone: `"error"` for what went wrong, `"info"` for the
+     * rest; and the screen draws no toast of its own. The campaign designer
+     * hands the admin portal's toast, so the designer's lines stand where every
+     * other window's do. Called as each line is said, so it may change between
+     * renders. Absent: the shell's `toast` (efficient-shell/ui, harness UI-24;
+     * up to 0.106.0 the screen drew a toast of its own, `.sf-toast`).
+     */
+    notify?: (message: string, tone: "info" | "error", extra?: ScreenToastExtra) => void;
+    /**
+     * THE CANVAS the screen frames: the engine's, as the layer dresses it — the
+     * layer's own sheet and theme in the frame, its own say over the outline
+     * round a block. The screen places it in the pane it has measured, hands it
+     * nothing, and remounts it by key to rebuild the frame; where the frame
+     * stands, how it is fitted and what is laid over it are the screen's.
+     *
+     * ONE function for the life of a mount: the screen renders it as an element
+     * type, and a type that changed identity would remount the whole canvas.
+     *
+     * The frame it draws is published to it, and to the head over it
+     * (`CanvasHead`), as the screen found it: `useScreenCanvasTarget()`.
+     */
+    Canvas?: ComponentType;
+    /**
+     * A HEAD OVER THE CANVAS (0.105.0): the layer's own row above the frame, in
+     * the canvas's well and at its own size — never scaled with a device — such
+     * as the campaign designer's Subject line, its mail-app switch and its dark
+     * mail app's bar, which sit above the email the way an inbox shows them. The
+     * frame fills what is left of the well under it, and is fitted to that. It is
+     * handed the device the canvas is drawn as. Absent: nothing is drawn above
+     * the frame, and the frame fills the well.
+     *
+     * ONE function for the life of a mount, for the reason `Canvas` is.
+     */
+    CanvasHead?: ComponentType<ScreenCanvasHeadProps>;
+    /**
+     * The canvas drag's measure, model and rules, where they are the layer's
+     * (0.105.0; `ScreenCanvasDrag`). Each member absent, and the whole object
+     * absent, is the screen's own: the old library's markers, every node but the pinned
+     * ones, the Layers tree's rules. Plain functions, and handed here for the
+     * reason the rules are.
+     */
+    canvasDrag?: ScreenCanvasDrag;
+    /**
+     * THE INSPECTOR the screen mounts in its right panel: the panel of whatever
+     * is selected and, in its place, each panel of the layer's own — frame, head
+     * and body, since the screen draws nothing round it. The screen holds WHICH
+     * panel is showing and hands it over (`mode`), with the ways out of a panel
+     * and its own toast and Hide button; what a mode draws is the layer's.
+     *
+     * ONE function for the life of a mount: the screen renders it as an element
+     * type, and a type that changed identity would remount the panel and drop
+     * what a merchant has open in it.
+     */
+    Inspector?: ComponentType<ScreenInspectorPanelProps>;
+}
+declare function ScreenPartsProvider({ parts, children }: {
+    parts: ScreenParts;
+    children?: ReactNode;
+}): react.JSX.Element;
+/** The layer's parts; none when the screen stands by itself. */
+declare function useScreenParts(): ScreenParts;
+/** The layer's bridges, run in the screen. With no layer, nothing runs. */
+/** The name a panel's head gives what is being edited (`useOwnerName`). */
+declare function useScreenOwnerName(): string;
+/** The Layers head's context line (`useDocumentLabel`), or null with no
+ *  layer's, and the screen says the document's address. */
+declare function useScreenDocumentLabel(): string | null;
+declare function useScreenBridges(inspector: ScreenInspector, tree: ScreenTree, canvas: ScreenCanvas, left: ScreenLeftPanel): ScreenBridges;
+/** The layer's bridges for the screen that holds one node by itself. With no
+ *  layer, nothing runs. */
+declare function useStandaloneScreenBridges(inspector: ScreenInspector): ScreenBridges;
+/** The layer's pass over a document as it opens, run in the screen. With no
+ *  layer, nothing runs. */
+declare function useScreenDocumentPass(ops: ScreenDocumentOps, config: unknown): void;
+/** The layer's block rules. With no layer, the rules of an editor that has no
+ *  blocks of its own. */
+declare function useScreenBlockRules(): ScreenBlockRules;
+/** How the layer's blocks are named and drawn. With no layer, by what the
+ *  config says of them and with no drawing. */
+declare function useScreenBlockLook(): ScreenBlockLook;
+/** The devices the layer's canvas is looked at on. With no layer, the one that
+ *  fills the pane. */
+declare function useScreenDevices(): ScreenDevices;
+/** Where the layer keeps the left panel's view. With no layer, nowhere: every
+ *  mount opens on the Layers tree. */
+declare function useScreenLeftView(): ScreenLeftViewRules;
+/** Which node types the layer pins in the top-level list, and which are its
+ *  groups of sections. With no layer, none. */
+declare function useScreenPinned(): ScreenPinnedNodes;
+/** Whether the save pill is the autosave's switch. With no layer, it is, as
+ *  the screen has always drawn it. */
+declare function useScreenSaveSwitch(): boolean;
+/** Leave a field's pick when `selection` changes, if the layer says a pick
+ *  follows the selection (`pickFollowsSelection`). With no layer, a pick
+ *  outlives a change of selection, as it always has. */
+declare function useScreenPickFollowsSelection(selection: unknown): void;
+/** Where widths and folds are kept (`storageNamespace`), or undefined: the
+ *  website editor's keys. */
+declare function useScreenStorageNamespace(): string | undefined;
+/** The layer's style clipboard (`styleClipboard`), or null: the website's. */
+declare function useScreenStyleClipboard(): ScreenStyleClipboard | null;
+/** Whether ⌘C / ⌘X / ⌘V reach the selected block (`nodeKeys`). They do
+ *  unless the layer says not (owner ruling R12/R13). */
+declare function useScreenNodeKeys(): boolean;
+/** The host's toast (`notify`), or null: with none, the screen says its lines
+ *  in its own (R17). */
+declare function useScreenNotify(): ((message: string, tone: "info" | "error", extra?: ScreenToastExtra) => void) | null;
+/** The canvas the layer dresses for the screen to frame. With no layer, the
+ *  engine's plain one. */
+declare function useScreenCanvasFrame(): ComponentType;
+/** The layer's head over the canvas (`CanvasHead`), or null: with no layer's,
+ *  nothing is drawn above the frame. */
+declare function useScreenCanvasHead(): ComponentType<ScreenCanvasHeadProps> | null;
+/** The layer's canvas drag (`canvasDrag`), or null: with no layer's, every
+ *  answer is the screen's own. */
+declare function useScreenCanvasDrag(): ScreenCanvasDrag | null;
+/** Publishes the frame the page screen found. The screen's own: it stands round
+ *  the chrome, and adds nothing to the page. */
+declare function ScreenCanvasTargetProvider({ target, children }: {
+    target: CanvasTarget | null;
+    children?: ReactNode;
+}): react.JSX.Element;
+/** The canvas frame the page screen found: its frame, document and window, or
+ *  null while there is none — and always null outside the page screen (the
+ *  section screen watches for no frame). */
+declare function useScreenCanvasTarget(): CanvasTarget | null;
+/** The inspector the layer draws for the screen to mount. With no layer, the
+ *  engine's plain rows for the selection. */
+declare function useScreenInspectorPanel(): ComponentType<ScreenInspectorPanelProps>;
+
+/**
+ * A PALETTE ROW THAT IS A PRESET, NOT A BLOCK TYPE (GG ruling 2026-10-30,
+ * owner item C36). The website's Contact / Locations section is offered as TWO
+ * rows, "City pictures" and "City maps": each lays down its own arrangement of
+ * ordinary blocks, and there is no block type behind either. So a row may be a
+ * preset — its own key, label, group, blurb and cover — and pressing it lays
+ * down what `insert` builds, in ONE insert, so one Undo takes it back (the way
+ * a splittable section's press already lands: `newSectionNode`).
+ *
+ * The layer hands these in (`PaletteLook.presets`); the screen states none.
+ * What the arrangement IS stays where the layer keeps arrangements (the
+ * website: `SECTION_PRESETS`); this says only where the row sits and what it
+ * is called.
+ */
+interface PalettePreset {
+    /** The row's own key, unique among presets. It names NO block type: a
+     *  preset whose key is a registered type is not offered (a type row and a
+     *  preset row would be one key with two meanings). The cover is the layer's
+     *  `Thumbnail`, asked with this key. */
+    key: string;
+    /** What the row is called. Also what the toast says when it is added. */
+    label: string;
+    /** The key of the category (`config.categories`) it is grouped under. A
+     *  category the config does not have, or does not offer, offers no preset. */
+    cat: string;
+    /** The block type in that category the row follows; absent, or not in the
+     *  category, and the row closes its group. */
+    after?: string;
+    /** The one-line blurb, shown and searched. */
+    desc?: string;
+    /** More words it is found by, searched but never shown. */
+    alias?: string;
+    /** The node it lays down — one node, slot children inline, every id fresh
+     *  from `make.newNodeId` — or null, and nothing is added. Lent the same
+     *  four things `newSectionNode` is. */
+    insert: (make: ScreenNodeMaker) => ScreenNewNode | null;
+}
+/** One offerable section, with the category it is grouped under. */
+type PaletteSection = {
+    /** The block type — or, on a preset row, the preset's key (`preset`). */
+    type: string;
+    cat: string;
+    name: string;
+    desc: string;
+    /**
+     * The heading of the category this section sits under, resolved once at build
+     * time — SEARCHED, and already SHOWN as the nav row this card sits beneath.
+     *
+     * ⚠️ IT IS HERE BECAUSE THE NAV AND THE SEARCH DISAGREED. Seven of the
+     * thirteen category names returned NOTHING when typed: "Blog & journal" reads
+     * 5 in the nav, and "blog" found 0, because not one of Issue Header, Featured
+     * Cover, Article Text, Recurring Columns or Latest Posts carries the word. Same
+     * for shop, about, promotions, navigation, legal and layout. A merchant reads
+     * the word off the screen, types it, and is told no section matches.
+     *
+     * Resolved HERE, not in `matchesQuery`, because the label needs the `config`
+     * (`categoryLabel`) and the matcher is given only a section — passing config
+     * into the matcher would make every caller carry it.
+     */
+    catLabel: string;
+    /**
+     * Another word this section is known by, searched but never shown.
+     *
+     * ⚠️ THIS EXISTS FOR ONE NODE AND ONE REASON. `Flex` is offered here as
+     * "Blank section" and is called "Box" everywhere it is nested — so a merchant
+     * who met it in a Layers row, or in last week's handoff, types "box" and must
+     * still find it. Without this they would find NOTHING: the card is pinned out
+     * of its group, so a search that misses it misses it completely.
+     */
+    alias?: string;
+    /** Set on a PRESET row only: the preset it lays down. Absent on every
+     *  type row, so a type row is the row it always was. */
+    preset?: PalettePreset;
+};
+/**
+ * What the layer says of its sections for the palette: the word for a type at
+ * a level, a group's short heading where it has one, and the blurbs. The
+ * screen's `blockLook` is one (lib/screen-parts); so is the website's own
+ * (lib/document/add-palette).
+ */
+interface PaletteLook {
+    /** What a node of `type` is called at a level, given the label the config
+     *  holds for it. */
+    labelAtLevel: (type: string, level: "section" | "block", base: string) => string;
+    /** A group's short heading, by its key, where the layer has one; undefined,
+     *  and the config's own title is the heading. */
+    categoryLabel: (id: string) => string | undefined;
+    /** The one-line blurb for a section, by type. */
+    descriptions: Record<string, string>;
+    /** Rows that are presets, not block types (`PalettePreset`). Absent: every
+     *  row is a type, as before. */
+    presets?: readonly PalettePreset[];
+}
+/**
+ * Flatten `config.categories` into an ordered section list.
+ *
+ * Grouping and order ARE the category order in the config — which is the
+ * catalog's order — so this adds no opinion of its own. A component listed in a
+ * category but absent from `components` is skipped: a stale catalog row cannot
+ * render and certainly cannot insert, so offering it would be a card that fails
+ * on click.
+ *
+ * Child-only blocks (HeroSlide / CollectionCard / ProductRef) and the four
+ * generic primitives (Heading / Text / ImageBlock / ButtonBlock) sit in NO
+ * category on purpose, so they never appear here — they are added from their
+ * parent's slot instead. See the note above `categories:` in lib/document/config.tsx.
+ *
+ * A category the config marks `visible: false` is NOT offered (0.105.0, seam
+ * E9): it is a registry's way of keeping blocks it has out of the picker — the
+ * campaign designer's Product parts, its retired blocks, its Sections — and a
+ * palette that listed them would offer things that may not be put on a page.
+ * The old library's own palette read the flag the same way. No website category carries
+ * it, so the website's palette is the list it was.
+ */
+declare function buildPaletteSections(config: Config, look: PaletteLook): PaletteSection[];
+/** A category's display label — the layer's short one where there is one, else the config's title. */
+declare function categoryLabel(config: Config, id: string, shortLabel: (id: string) => string | undefined): string;
+/**
+ * Does a section match a search query?
+ *
+ * The query is matched against the NAME, any ALIAS, the blurb, the component
+ * TYPE and the CATEGORY HEADING — the type because a merchant who knows the
+ * section by the word they saw in a handoff should still find it, the alias
+ * because one node is called something else everywhere it is nested (see
+ * `PaletteSection.alias`), and the category because it is PRINTED IN THE NAV
+ * BESIDE THE RESULTS: seven of thirteen headings used to match nothing at all
+ * (see `PaletteSection.catLabel`). A word a merchant can read off this screen
+ * must find what it is labelling.
+ *
+ * `q` is expected already lower-cased and trimmed; an empty query matches
+ * everything.
+ */
+declare function matchesQuery(s: PaletteSection, q: string): boolean;
+/** The pinned section, or `null` if the layer pins none or the config does not offer it. */
+declare function pinnedSection(sections: PaletteSection[], pinned: string | null): PaletteSection | null;
+/** Every OTHER section — what the grouped grid below the pinned card draws. */
+declare function paletteWithoutPinned(sections: PaletteSection[], pinned: string | null): PaletteSection[];
+
+/** What a tile adds, parsed back out of its key. */
+type AddKey = {
+    kind: "section";
+    type: string;
+} | {
+    kind: "template";
+    template: SectionTemplate;
+} | {
+    kind: "shared";
+    section: SharedSection;
+}
+/** A row that is a preset, not a block type (the layer's `presets`): what
+ *  it lays down is its `insert`'s. */
+ | {
+    kind: "preset";
+    preset: PalettePreset;
+} | {
+    kind: "block";
+    type: string;
+};
+declare const sectionKey: (type: string) => string;
+declare const blockKey: (type: string) => string;
+declare const templateKey: (id: string) => string;
+declare const sharedKey: (id: string) => string;
+declare const presetKey: (key: string) => string;
+type AddSidePanelProps<I> = {
+    /** Where the next thing goes, when the panel was opened at a place. */
+    at?: {
+        label: string;
+        onClear: () => void;
+    };
+    /** At a place in a list of blocks: the blocks that list takes. They are in
+     *  the one list whatever the catalogue holds, so a place can always be
+     *  filled from it. */
+    placeBlocks?: readonly BlockChoice[];
+    /** At a place: what a tile is called THERE, by type, where the place lays
+     *  down more than the type (a slot whose spec prepares its child,
+     *  `SlotSectionSpec.newChild`). A type not in it keeps its own word. */
+    placeNames?: ReadonlyMap<string, string>;
+    /** At a place: may what a tile names go there? Null when it may, else why
+     *  not, in the panel's words — the tile is then dimmed and says so. Absent
+     *  (no place): every tile is offered, to drag. */
+    canTake?: (key: AddKey) => string | null;
+    /** At a place: put what a pressed tile names there. Absent (no place): a
+     *  press adds nothing, and a tile is only dragged. */
+    onPick?: (key: AddKey) => void;
+    /** The drag item for what a tile names — a drag in the editor's session. */
+    itemFor: (key: AddKey) => I;
+    session: DragSession<I>;
+    /** A row under the tiles for something that is not a block, drawn by the
+     *  layer that owns it (the website: the Live chat bubble). */
+    siteWide?: ReactNode;
+    /** Leave Add — back to the view underneath (the head's "Done"). */
+    onClose: () => void;
+    /** Hide the left panel (the head's last button, as on every panel). */
+    onHide?: () => void;
+    readOnly?: boolean;
+};
+declare function AddSidePanel<I>({ at, placeBlocks, placeNames, canTake, onPick, itemFor, session, siteWide, onClose, onHide, readOnly, }: AddSidePanelProps<I>): react.JSX.Element;
+
+export { isSelectionMode as $, type ScreenNodeActions as A, type ScreenNodeAt as B, type CopyItemAction as C, type ScreenNodeLevel as D, type ScreenNodeMaker as E, type ScreenPartMode as F, type ScreenParts as G, ScreenPartsProvider as H, type ScreenPinnedBand as I, type ScreenPinnedNodes as J, type ScreenRailItem as K, type ScreenSelector as L, type ScreenSharedSections as M, type NodeDefaults as N, type ScreenSlot as O, type ScreenSlotAction as P, type ScreenSlotMode as Q, type ScreenStyleClipboard as R, SELECTION_MODE as S, type ScreenStyleDocument as T, type ScreenStylePastePlan as U, type ScreenToastExtra as V, type ScreenTree as W, type ScreenTreeFolds as X, type ScreenTreeRows as Y, isPinnedFirst as Z, isPinnedLast as _, type CopyItemRequest as a, isSlotMode as a0, sameInspectorMode as a1, screenSlotsOf as a2, shownChildSlotsOf as a3, shownSlotFieldsOf as a4, useScreenBlockLook as a5, useScreenBlockRules as a6, useScreenBridges as a7, useScreenCanvasDrag as a8, useScreenCanvasFrame as a9, matchesQuery as aA, paletteWithoutPinned as aB, pinnedSection as aC, type AddKey as aD, type AddSidePanelProps as aE, blockKey as aF, AddSidePanel as aG, presetKey as aH, sectionKey as aI, sharedKey as aJ, templateKey as aK, useScreenCanvasHead as aa, useScreenCanvasTarget as ab, useScreenDevices as ac, useScreenDocumentLabel as ad, useScreenDocumentPass as ae, useScreenInspectorPanel as af, useScreenLeftView as ag, useScreenNodeKeys as ah, useScreenNotify as ai, useScreenOwnerName as aj, useScreenParts as ak, useScreenPickFollowsSelection as al, useScreenPinned as am, useScreenSaveSwitch as an, useScreenStorageNamespace as ao, useScreenStyleClipboard as ap, useStandaloneScreenBridges as aq, type SlotSectionSpec as ar, type NodeDefaults$1 as as, type AddTarget as at, type AddTargetSource as au, type PaletteLook as av, type PalettePreset as aw, type PaletteSection as ax, buildPaletteSections as ay, categoryLabel as az, type ScreenBlockLook as b, type ScreenBlockRules as c, type ScreenBridges as d, type ScreenCanvas as e, type ScreenCanvasDrag as f, type ScreenCanvasDragContext as g, type ScreenCanvasHeadProps as h, ScreenCanvasTargetProvider as i, type ScreenDevices as j, type ScreenDocumentOps as k, type ScreenDragItem as l, type ScreenInspector as m, type ScreenInspectorMode as n, type ScreenInspectorPanelProps as o, type ScreenLeftPanel as p, type ScreenLeftView as q, type ScreenLeftViewFrame as r, type ScreenLeftViewRules as s, type ScreenMainAction as t, type ScreenMediaDrop as u, type ScreenMediaFile as v, type ScreenMenuItem as w, type ScreenMenuRows as x, type ScreenNewNode as y, type ScreenNode as z };