efficient-easel 0.103.0 → 0.105.0

package/dist/screen/lib/screen-parts.d.ts

@@ -1,26 +1,41 @@
 import * as react from 'react';
 import { ReactNode, MouseEvent, ComponentType } from 'react';
 import { Data } from '../../blocks/index.js';
+import { C as CanvasTarget } from '../../watch-BTYOJpQU.js';
 import { D as DeviceOption } from '../../types-CqY85foL.js';
+import { P as Place } from '../../types-41704JE4.js';
+import { M as MeasuredCanvas, C as CanvasDragModel } from '../../CanvasDragLayer-zgYT1xwY.js';
+import { E as EaselContextMenuItem } from '../../types-Djdq6Xkd.js';
 import { a as EaselRailItem } from '../../types-DWS-s9z-.js';
+import { StyleRow } from '../../style-clipboard/index.js';
+import { T as TreeRowMark } from '../../types-DJDBtdB2.js';
+import { AddKey } from '../components/AddSidePanel.js';
+import { k as AnyScreenTarget } from '../../host-BQ_b9Qzk.js';
 import { HostProduct } from './host-chrome.js';
 import { EaselSession } from './session.js';
 import { AddTarget } from './puck/add-target-types.js';
+import { SlotConfigView } from './puck/content-tree.js';
 import '../../types-E3HrTPg2.js';
 import '../../data/index.js';
-import '../../types-41704JE4.js';
 import '../../resolve-D68pb3Bx.js';
 import '../../plan-DChbUXdS.js';
 import '../../edit-lock/index.js';
 import '../../panelWidths-D9hTLR25.js';
+import '../../session-DSQFmIvx.js';
+import '../../words-BDignMl_.js';
 import '../../wordFit-D4S36PvB.js';
+import '../../words-CnnHb9jo.js';
+import '../../words-DgHcY5qB.js';
+import './section-template-types.js';
+import './puck/block-choice.js';
+import './document-contract.js';
+import './document-switch.js';
+import '../../engine-DBxp_v6B.js';
+import './admin-bridge.js';
+import './backend-error.js';
 import './links/link-filters.js';
 import '../../LinkPicker-W2Rtxetz.js';
-import './document-contract.js';
 import './document-hooks.js';
-import './section-template-types.js';
-import './puck/content-tree.js';
-import './puck/block-choice.js';
 import './puck/slot-section-spec.js';
 
 /**
@@ -92,6 +107,28 @@ type ScreenPartMode = {
  *  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 {
@@ -113,6 +150,18 @@ interface ScreenInspector {
     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
@@ -143,6 +192,23 @@ interface ScreenInspectorPanelProps {
     /** 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/puck/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
@@ -374,10 +440,26 @@ interface ScreenBridges {
      * scroll; absent, the screen scrolls.
      */
     holdCanvasOn?: (id: string) => 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 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;
 }
+/** 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. */
@@ -442,15 +524,126 @@ interface ScreenBlockRules {
      * 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.
+     */
+    canAddTo: (nodeType: string, nestDepth?: number, slot?: string) => 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.
      */
-    canAddTo: (nodeType: string, nestDepth?: number) => AddTarget | null;
+    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;
 }
+/**
+ * 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 slots of `node` as the screen draws them: the layer's answer
+ * (`slotsOf`), else — with no `slotsOf`, or none for this node — every slot
+ * field the config declares, in its 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";
@@ -516,6 +709,56 @@ interface ScreenBlockLook {
      * 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/puck/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/puck/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,
@@ -543,6 +786,116 @@ interface ScreenDevices {
     /** 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;
+    };
+}
+/**
+ * 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: Puck'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;
+}
+/** 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
@@ -566,9 +919,15 @@ interface ScreenDevices {
  * selected and where a pinned node's row is pressed, and shows what it is
  * handed.
  *
- * The same object for the life of a mount, its three functions plain functions
- * of what they are passed: the screen reads it anywhere, inside the callbacks
- * and effects it does not rebuild for it.
+ * 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
@@ -576,6 +935,32 @@ interface ScreenPinnedNodes {
     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;
+    /**
+     * 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;
     /** The type of the group of sections pinned first, ahead of everything. */
     firstGroup: string | null;
     /** …and of the one pinned last. */
@@ -593,6 +978,31 @@ interface ScreenPinnedNodes {
      */
     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`
+     *  ("Template · Home page") on a document with the edit guard and
+     *  `screen.templateSections` ("Template · 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;
+    /** The band ends with an "Add section" row (`screen.addSection`) that opens
+     *  Add at the end of the band, where the band's last "+" does. Hidden while
+     *  the document is read-only, as every "+" is. Absent or false: the band ends
+     *  at its last gap. */
+    addAtEnd?: 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
@@ -615,6 +1025,100 @@ interface ScreenLeftViewRules {
      *  view to be on. */
     forSelection: (selectedId: string | null | undefined, current: string) => string;
 }
+/**
+ * THE SELECTION, as the screen hands it to a rule that asks where it is
+ * (`ScreenAdd.railTarget`, 0.105.0): the node selected, and the panel the
+ * inspector is showing — the selection's own (`SELECTION_MODE`), or one of the
+ * layer's, such as the campaign designer's column, which is a slot and no
+ * node.
+ */
+interface ScreenSelection {
+    node: ScreenNode | null;
+    mode: ScreenInspectorMode;
+}
+/**
+ * WHERE ADD PUTS WHAT IT ADDS, where that is the layer's to say (0.105.0, seam
+ * E9). That there is an Add panel, what it lists and where a tile dragged out
+ * of it may land are the screen's. Plain data and a plain function, the same
+ * for the life of a mount, for the reason the block rules are.
+ */
+interface ScreenAdd {
+    /**
+     * Where the rail's "+" aims Add: handed the working document and the
+     * selection, the place a BLOCK the panel adds goes — the campaign designer's
+     * last body section's first column, at its end, where its own drawer put a
+     * block — or null for the screen's own. Asked as the panel draws while it is
+     * open at no place of its own (from the rail, or after its place was
+     * cleared), so a place at the end of a list stays at its end as blocks go in.
+     * A place in a slot heads the panel with what that slot takes ("Inside
+     * Section 3"), and a block tile pressed lands there; the sections still
+     * follow, and land where they always did. A place in the top-level list is
+     * where a section or a saved one lands. No "Adding to …" line is drawn for it:
+     * that line is for a place a "+" named. Absent, or null: the rail's "+" opens
+     * Add at no place — the selected container's blocks, then the blank section,
+     * the saved sections and the sections — as it always has.
+     */
+    railTarget?: (data: unknown, selection: ScreenSelection) => Place | null;
+    /**
+     * Is Add a picker of BLOCKS first, as the campaign designer's drawer is? With
+     * true, where Add offers the blocks of a container — the rail's target, or
+     * the container selected — those blocks are the whole panel, with no
+     * section catalogue after them; and a gap between two sections, where what
+     * goes in is a new section, offers the catalogue alone, with no container's
+     * blocks before it. So one panel never lists the same blocks twice, under the
+     * same headings, for two different places (a container's runs and the
+     * catalogue's groups). A place a "+" names in a slot offers that slot's
+     * blocks alone either way. Absent, false: a container's blocks, then the
+     * catalogue, wherever there is a container to offer — as it always has.
+     */
+    blocksFirst?: boolean;
+}
+/** 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/puck/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,
@@ -622,6 +1126,13 @@ interface ScreenParts {
      * reads it (components/MediaSidePanel), 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
@@ -680,6 +1191,47 @@ interface ScreenParts {
      * website has 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 Add puts what it adds, and whether it is a picker of blocks first
+     *  (0.105.0; `ScreenAdd`). Absent: the screen's Add, as it always was. */
+    add?: ScreenAdd;
+    /** 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 screen's own toast (`.sf-toast`), as before.
+     */
+    notify?: (message: string, tone: "info" | "error") => 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
@@ -689,8 +1241,31 @@ interface ScreenParts {
      *
      * 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: Puck'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
@@ -713,6 +1288,9 @@ 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. */
@@ -738,11 +1316,42 @@ 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 Add puts what it adds (`add`). With no layer's, nothing: the
+ *  screen's own Add. */
+declare function useScreenAdd(): ScreenAdd;
+/** 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") => 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>;
 
-export { type NodeDefaults, SELECTION_MODE, type ScreenBlockLook, type ScreenBlockRules, type ScreenBridges, type ScreenCanvas, type ScreenDevices, type ScreenDocumentOps, type ScreenInspector, type ScreenInspectorMode, type ScreenInspectorPanelProps, type ScreenLeftPanel, type ScreenLeftView, type ScreenLeftViewFrame, type ScreenLeftViewRules, type ScreenNewNode, type ScreenNode, type ScreenNodeLevel, type ScreenNodeMaker, type ScreenPartMode, type ScreenParts, ScreenPartsProvider, type ScreenPinnedNodes, type ScreenRailItem, type ScreenTree, type ScreenTreeFolds, type ScreenTreeRows, sameInspectorMode, useScreenBlockLook, useScreenBlockRules, useScreenBridges, useScreenCanvasFrame, useScreenDevices, useScreenDocumentPass, useScreenInspectorPanel, useScreenLeftView, useScreenOwnerName, useScreenParts, useScreenPinned, useScreenSaveSwitch, useStandaloneScreenBridges };
+export { type NodeDefaults, SELECTION_MODE, type ScreenAdd, type ScreenBlockLook, type ScreenBlockRules, type ScreenBridges, type ScreenCanvas, type ScreenCanvasDrag, type ScreenCanvasDragContext, type ScreenCanvasHeadProps, ScreenCanvasTargetProvider, type ScreenDevices, type ScreenDocumentOps, type ScreenDragItem, type ScreenInspector, type ScreenInspectorMode, type ScreenInspectorPanelProps, type ScreenLeftPanel, type ScreenLeftView, type ScreenLeftViewFrame, type ScreenLeftViewRules, type ScreenMenuRows, type ScreenNewNode, type ScreenNode, type ScreenNodeActions, type ScreenNodeLevel, type ScreenNodeMaker, type ScreenPartMode, type ScreenParts, ScreenPartsProvider, type ScreenPinnedBand, type ScreenPinnedNodes, type ScreenRailItem, type ScreenSelection, type ScreenSelector, type ScreenSlot, type ScreenSlotAction, type ScreenSlotMode, type ScreenStyleClipboard, type ScreenStyleDocument, type ScreenStylePastePlan, type ScreenTree, type ScreenTreeFolds, type ScreenTreeRows, isPinnedFirst, isPinnedLast, isSlotMode, sameInspectorMode, screenSlotsOf, useScreenAdd, useScreenBlockLook, useScreenBlockRules, useScreenBridges, useScreenCanvasDrag, useScreenCanvasFrame, useScreenCanvasHead, useScreenCanvasTarget, useScreenDevices, useScreenDocumentLabel, useScreenDocumentPass, useScreenInspectorPanel, useScreenLeftView, useScreenNodeKeys, useScreenNotify, useScreenOwnerName, useScreenParts, useScreenPickFollowsSelection, useScreenPinned, useScreenSaveSwitch, useScreenStyleClipboard, useStandaloneScreenBridges };