efficient-easel 22.0.0 → 23.0.0

package/dist/data/index.d.ts

@@ -1,29 +1,37 @@
-import { D as Data, a as DataConfig, N as Node, S as SlotAddress, F as Found, P as Place, b as SlotEntry, W as WalkInfo } from '../types-DlQIM1YO.js';
-export { B as BlockShape, c as FieldShape, d as FieldsShape, e as NodeProps, R as RootData } from '../types-DlQIM1YO.js';
-export { R as ResolvableItem, a as ResolveCache, b as ResolveOptions, c as ResolveTrigger, d as changedProps, e as createResolveCache, f as deepEqual, r as resolveNodeData } from '../resolve-AJ6WF4EL.js';
+import { N as Node, D as Data, a as DataConfig, S as SlotAddress, F as Found, P as Place, b as SlotEntry, W as WalkInfo } from '../types-Dq180WRV.js';
+export { B as BlockShape, c as FieldShape, d as FieldsShape, e as NodeProps, R as RootData } from '../types-Dq180WRV.js';
+export { R as ResolvableItem, a as ResolveCache, b as ResolveOptions, c as ResolveTrigger, d as changedProps, e as createResolveCache, f as deepEqual, r as resolveNodeData } from '../resolve-Bz4mszpL.js';
 
 /**
  * Finding a node's slots, and reading or writing a value at a prop path.
  *
- * A slot is found the way the old editor finds one: by the FIELDS, not by the value. A
+ * A slot is found the way the old library finds one: by the FIELDS, not by the value. A
  * prop is a slot when its field says `type: 'slot'`; a slot can also sit inside
  * an `object` field or inside each item of an `array` field, and its name is
- * then the prop path the old editor gives it — `items[0].content`, `box.content`.
+ * then the prop path the old library gives it — `items[0].content`, `box.content`.
  *
- * One deliberate difference from the old editor: the old editor also walks an object whose field is
+ * One deliberate difference from the old library: the old library also walks an object whose field is
  * NOT an `object` field using the PARENT's field map, so a key there that
  * happens to share a slot's name is treated as a slot. No document relies on
- * that (a non-array value there crashes the old editor's own walk), and a rule that
+ * that (a non-array value there crashes the old library's own walk), and a rule that
  * depends on a coincidence of names is not one to copy.
  *
  * Order is DECLARATION order — the order the fields are written in the config,
- * which is the order a person reads the block in (`col1` before `col2`). The old editor
+ * which is the order a person reads the block in (`col1` before `col2`). The old library
  * visits slots in reverse, as a side effect of how it fills empty ones; nothing
  * in either app depends on that.
  */
 
 /** One step of a prop path: a key, or an index into an array. */
 type Segment = string | number;
+/** One document node: a string `type` and a `props` object. */
+declare const isNode: (value: unknown) => value is Node;
+/**
+ * A slot's array, read by its SHAPE: non-empty, every item a node. A list field
+ * (stats rows, ticker items) fails and is left alone. The one answer for the
+ * easel and its hosts, so no walk keeps a private copy that drifts.
+ */
+declare const isNodeList: (value: unknown) => value is Node[];
 declare function getIn(value: unknown, segments: readonly Segment[]): unknown;
 
 /** One translated value, and the fingerprint of the base value it was made from. */
@@ -195,7 +203,7 @@ declare function copyTranslation(overlay: TranslationOverlay | null | undefined,
 /**
  * efficient-easel/data — the document, as pure functions.
  *
- * The bottom layer of the engine that replaces the old editor (the blueprint "From
+ * The bottom layer of the engine that replaces the old library (the blueprint "From
  * The Ground Up For Efficient Editor", 2026-09-29, step 1.1). Every function
  * takes a document and returns a new one; nothing here holds state, knows
  * about React, or touches a browser global, so a server component, a Node
@@ -213,17 +221,17 @@ declare function copyTranslation(overlay: TranslationOverlay | null | undefined,
  * round-trip spec pins each one:
  *
  *   1. An empty slot is written as `[]`, and `zones` is written as `{}`.
- *   2. Default props follow the old editor: a new block is created WITH its
+ *   2. Default props follow the old library: a new block is created WITH its
  *      `defaultProps`; the root's `defaultProps` are filled in on open; an
  *      existing block is never back-filled.
  *   3. A root prop that no field declares (a site's `theme`, `fonts`, `scales`)
  *      is kept exactly as it is. Nothing here drops a key it doesn't know.
  *   4. The two older formats are READ — root props written directly on `root`,
- *      and children parked in `zones` — and converted on open, the way the old editor's
+ *      and children parked in `zones` — and converted on open, the way the old library's
  *      `migrate()` converts them. They are never written back.
  *
  * KEY ORDER. The backend stores these documents in Postgres `jsonb`, which does
- * not keep key order, so "the same document as the old editor" means the same keys and
+ * not keep key order, so "the same document as the old library" means the same keys and
  * values. What this layer does promise is stronger for its own round trip: a
  * document that is already in shape comes back as THE SAME OBJECT (so
  * `normalizeData(doc) === doc`), and every edit copies only the nodes on the
@@ -239,7 +247,7 @@ declare function copyTranslation(overlay: TranslationOverlay | null | undefined,
  */
 
 /**
- * What `normalizeData` accepts: any saved document, as loosely as the old editor's own
+ * What `normalizeData` accepts: any saved document, as loosely as the old library's own
  * `Data` type describes one (`root.props` optional). Converting the older
  * shapes is its job, so it must take them without a cast. Every OTHER function
  * here takes the normalised `Data` it returns.
@@ -259,9 +267,9 @@ declare const ROOT_ID = "root";
 declare const ROOT_SLOT = "default-zone";
 /** The top-level list, as an address. */
 declare const ROOT_LIST: SlotAddress;
-/** `{ parentId, slot }` → the old editor's zone key `"<parentId>:<slot>"`. */
+/** `{ parentId, slot }` → the old library's zone key `"<parentId>:<slot>"`. */
 declare const zoneKey: ({ parentId, slot }: SlotAddress) => string;
-/** The old editor's zone key → `{ parentId, slot }`. Ids and prop paths hold no colon. */
+/** The old library's zone key → `{ parentId, slot }`. Ids and prop paths hold no colon. */
 declare function parseZoneKey(key: string): SlotAddress;
 type DataErrorCode = 'not-found' | 'no-slot' | 'bad-index' | 'duplicate-id' | 'cycle' | 'id-change' | 'unknown-type';
 declare class DataError extends Error {
@@ -294,7 +302,7 @@ declare function find(data: Data, config: DataConfig, id: string): Found | null;
 /** The list at an address, or `null` when no such slot exists. */
 declare function getList(data: Data, config: DataConfig, address: SlotAddress): Node[] | null;
 /**
- * What the easel does to a document when it opens it — the same result the old editor
+ * What the easel does to a document when it opens it — the same result the old library
  * reaches on load, with the older formats converted (rule 4):
  *
  *   - `root` holding its props directly becomes `{ props: { …those keys } }`;
@@ -309,7 +317,7 @@ declare function getList(data: Data, config: DataConfig, address: SlotAddress):
  */
 declare function normalizeData(data: DataInput | Data, config: DataConfig): Data;
 /**
- * A new block, the way the Add panel makes one — the old editor's `insert` recipe:
+ * A new block, the way the Add panel makes one — the old library's `insert` recipe:
  * `{ ...defaultProps, id }`, plus any `props` the caller starts it with. The
  * defaults are copied, so two blocks never share an array or object, and every
  * child a default slot seeds gets its own id.
@@ -328,7 +336,7 @@ declare function insert(data: Data, config: DataConfig, place: Place, node: Node
 declare function remove(data: Data, config: DataConfig, id: string): Data;
 /**
  * Move a node to `to`. Within one list, `to.index` is the node's index AFTER
- * the move (the old editor's rule), so `0 … length-1`; into another list it is the index
+ * the move (the old library's rule), so `0 … length-1`; into another list it is the index
  * to insert at, `0 … length`. A move into the node's own subtree is refused.
  */
 declare function move(data: Data, config: DataConfig, id: string, to: Place): Data;
@@ -336,7 +344,7 @@ declare function move(data: Data, config: DataConfig, id: string, to: Place): Da
  * Copy a node, and everything under it, to the place just after it. Every
  * copied node gets a fresh id. `strip` sees each copied node (with its new id)
  * and returns what to keep — the hook for "a copy must not claim the
- * original's baked image" (`bakedId`), which the old editor's own duplicate copied
+ * original's baked image" (`bakedId`), which the old library's own duplicate copied
  * verbatim.
  */
 declare function duplicate(data: Data, config: DataConfig, id: string, options?: {
@@ -354,7 +362,7 @@ declare function copyNode(node: Node, config: DataConfig, options?: {
     strip?: (node: Node) => Node;
 }): Node;
 /**
- * Merge `patch` into a node's props — the old editor's `replace`, for the common case of
+ * Merge `patch` into a node's props — the old library's `replace`, for the common case of
  * changing some props. A key keeps its place; a new key goes on the end;
  * `undefined` clears a key (JSON drops it on save). New children in a patched
  * slot are brought into shape. Changing `id` is refused. A patch that changes
@@ -362,7 +370,7 @@ declare function copyNode(node: Node, config: DataConfig, options?: {
  */
 declare function setProps(data: Data, config: DataConfig, id: string, patch: Record<string, unknown>): Data;
 /**
- * Replace a node wholesale — the old editor's `replace` action: the node keeps its place
+ * Replace a node wholesale — the old library's `replace` action: the node keeps its place
  * and its id, and every prop is the new node's (a key it does not carry is
  * gone, which `setProps` cannot do). Children in its slots that arrive without
  * an id get one, and an id another node already holds is refused, as `insert`
@@ -372,4 +380,4 @@ declare function replaceNode(data: Data, config: DataConfig, id: string, node: N
 /** Merge `patch` into the root's props, the same way `setProps` does. */
 declare function setRoot(data: Data, config: DataConfig, patch: Record<string, unknown>): Data;
 
-export { Data, DataConfig, DataError, type DataErrorCode, type DataInput, Found, Node, Place, ROOT_ID, ROOT_LIST, ROOT_SLOT, type Segment, SlotAddress, SlotEntry, type TranslatableItem, type TranslatablePath, type TranslatedValue, type TranslationEntries, type TranslationOverlay, type TranslationRef, type TranslationStatus, WalkInfo, applyTranslation, copyNode, copyTranslation, createNode, duplicate, extractTranslation, find, getIn, getList, insert, mapIds, move, newId, normalizeData, parseZoneKey, pruneTranslation, rebaseTranslation, remove, replaceNode, setProps, setRoot, slotsOf, translatablePaths, translationFingerprint, translationStatus, walk, zoneKey };
+export { Data, DataConfig, DataError, type DataErrorCode, type DataInput, Found, Node, Place, ROOT_ID, ROOT_LIST, ROOT_SLOT, type Segment, SlotAddress, SlotEntry, type TranslatableItem, type TranslatablePath, type TranslatedValue, type TranslationEntries, type TranslationOverlay, type TranslationRef, type TranslationStatus, WalkInfo, applyTranslation, copyNode, copyTranslation, createNode, duplicate, extractTranslation, find, getIn, getList, insert, isNode, isNodeList, mapIds, move, newId, normalizeData, parseZoneKey, pruneTranslation, rebaseTranslation, remove, replaceNode, setProps, setRoot, slotsOf, translatablePaths, translationFingerprint, translationStatus, walk, zoneKey };

package/dist/data/index.js

@@ -1 +1 @@
-export{DataError,ROOT_ID,ROOT_LIST,ROOT_SLOT,applyTranslation,changedProps,copyNode,copyTranslation,createNode,createResolveCache,deepEqual,duplicate,extractTranslation,find,getList,insert,mapIds,move,newId,normalizeData,parseZoneKey,pruneTranslation,rebaseTranslation,remove,replaceNode,resolveNodeData,setProps,setRoot,slotsOf,translatablePaths,translationFingerprint,translationStatus,walk,zoneKey}from"../chunk-K7BTCBWD.js";export{getIn}from"../chunk-L55YIXDC.js";
+export{DataError,ROOT_ID,ROOT_LIST,ROOT_SLOT,applyTranslation,changedProps,copyNode,copyTranslation,createNode,createResolveCache,deepEqual,duplicate,extractTranslation,find,getList,insert,mapIds,move,newId,normalizeData,parseZoneKey,pruneTranslation,rebaseTranslation,remove,replaceNode,resolveNodeData,setProps,setRoot,slotsOf,translatablePaths,translationFingerprint,translationStatus,walk,zoneKey}from"../chunk-TGZCD6IP.js";export{getIn,isNode,isNodeList}from"../chunk-KXM6YRG2.js";

package/dist/drag/drag.css

@@ -33,7 +33,8 @@
   display: inline-flex;
   pointer-events: none;
 }
-.es-canvas-handle {
+.es-canvas-handle,
+.es-canvas-tag {
   position: relative;
   display: inline-flex;
   align-items: center;
@@ -51,6 +52,14 @@
   pointer-events: none;
   transition: opacity 0.12s;
 }
+/* The selected part's name tag (`tag`, Lewis 2026-10-26): the handle's look
+   (above), placed where it is drawn, never taking the pointer. After the
+   shared rule, so its place and opacity win. */
+.es-canvas-tag {
+  position: absolute;
+  cursor: default;
+  opacity: 1;
+}
 .es-canvas-handle.is-shown {
   opacity: 1;
   pointer-events: auto;

package/dist/drag/index.d.ts

@@ -1,11 +1,11 @@
 import * as react from 'react';
 import { HTMLAttributes, CSSProperties, ReactNode } from 'react';
-import { P as Place } from '../types-DlQIM1YO.js';
-import { D as DragSession } from '../session-CrWwDt7Z.js';
-export { a as DragHeld, c as createDragSession } from '../session-CrWwDt7Z.js';
-export { B as Box, a as CanvasDragLayer, b as CanvasDragLayerProps, C as CanvasDragModel, c as CanvasDropTarget, d as CanvasSeam, e as CanvasSource, f as CanvasZone, E as EMPTY_MEASURE, H as HANDLE_GRACE_MS, M as MeasuredCanvas, g as MeasuredNode, h as canvasTarget, i as contains, j as gapInZone, k as gapLine, l as insertSeams, m as measureCanvas, p as pickSource, s as seamsBetween, n as sourcesAt } from '../CanvasDragLayer-B6Yn9S8T.js';
+import { P as Place } from '../types-Dq180WRV.js';
+import { D as DragSession } from '../session-EsjORLQ0.js';
+export { a as DragHeld, c as createDragSession } from '../session-EsjORLQ0.js';
+export { B as Box, a as CanvasDragLayer, b as CanvasDragLayerProps, C as CanvasDragModel, c as CanvasDropTarget, d as CanvasSeam, e as CanvasSource, f as CanvasZone, E as EMPTY_MEASURE, H as HANDLE_GRACE_MS, M as MeasuredCanvas, g as MeasuredNode, h as canvasTarget, i as contains, j as gapInZone, k as gapLine, l as insertSeams, m as measureCanvas, p as pickSource, s as seamsBetween, n as sourcesAt } from '../CanvasDragLayer-NZpaX6aq.js';
 import { D as DragWords } from '../words-SD4neL0n.js';
-import '../watch-D0bNZRtU.js';
+import '../watch-Unf6SfUf.js';
 
 /**
  * Where a drop lands — the engine's one hit rule, as pure functions (blueprint

package/dist/drag/index.js

@@ -1 +1 @@
-export{AddPanel,CanvasDragLayer,CanvasInsert,EMPTY_MEASURE,HANDLE_GRACE_MS,canvasTarget,contains,gapInZone,gapLine,insertSeams,measureCanvas,pickSource,seamsBetween,sourcesAt}from"../chunk-CUZQ2HMA.js";import"../chunk-TQ5Y6S2X.js";export{AUTO_SCROLL_EDGE,AUTO_SCROLL_MAX_SPEED,autoScrollDelta,autoScrollSpeed,createDragSession,dropEffectFor,dropOnRow,frameScrollBox,gapToMoveIndex,isNoOpDrop,scrollBoxOf,scrollParent,startAutoScroll,stepGap,useTreeDrag}from"../chunk-3S5N4HLJ.js";import"../chunk-P2VEMZH5.js";import"../chunk-GHBK7BKL.js";import"../chunk-LF3FUSCQ.js";import"../chunk-K7BTCBWD.js";import"../chunk-L55YIXDC.js";
+export{AddPanel,CanvasDragLayer,CanvasInsert,EMPTY_MEASURE,HANDLE_GRACE_MS,canvasTarget,contains,gapInZone,gapLine,insertSeams,measureCanvas,pickSource,seamsBetween,sourcesAt}from"../chunk-LN43DP2A.js";import"../chunk-TQ5Y6S2X.js";export{AUTO_SCROLL_EDGE,AUTO_SCROLL_MAX_SPEED,autoScrollDelta,autoScrollSpeed,createDragSession,dropEffectFor,dropOnRow,frameScrollBox,gapToMoveIndex,isNoOpDrop,scrollBoxOf,scrollParent,startAutoScroll,stepGap,useTreeDrag}from"../chunk-6NJHYXJM.js";import"../chunk-P2VEMZH5.js";import"../chunk-YU3WHLGI.js";import"../chunk-LF3FUSCQ.js";import"../chunk-TGZCD6IP.js";import"../chunk-KXM6YRG2.js";

package/dist/draw/index.d.ts

@@ -8,4 +8,4 @@ export { AUTO_RULES, AutoRule, FOLLOW_RULES, VIEW_DESKTOP_MIN, VIEW_TABLET_MIN,
 export { HERO_SLIDER_GOTO_EVENT, HeroSliderGotoDetail } from '../screen/lib/document/preview-events.js';
 export { R as REPEAT_ATTRIBUTE, a as REPEAT_INDEX_ATTRIBUTE } from '../repeat-D65bJS8d.js';
 export { TEXT_STYLE_CASES, TEXT_STYLE_CASE_CSS, TextStyleCase, TextStyleCaseCss, isTextStyleCase, textStyleCaseCss, textStyleCaseOfCss } from '../text-styles/model.js';
-import '../words-gIDCeRv3.js';
+import '../words-B5Gb7KFq.js';

package/dist/easel/easel.css

@@ -1,7 +1,7 @@
 /*
  * efficient-easel/easel — the canvas's own marks (blueprint 5.1): the
  * lists' empty and selected states, and the outlines over the selected and
- * hovered block. The old editor's stylesheet drew these until now; the rules follow it.
+ * hovered block. The old library's stylesheet drew these until now; the rules follow it.
  *
  * The canvas is an iframe of its own, so this sheet must reach it: import it
  * once in the host, and `CanvasFrame` copies the host's stylesheets into the
@@ -51,7 +51,7 @@
   z-index: 0;
 }
 /* A frame that FILLS its parent (`height="fill"`): the page is at least as tall
-   as the frame, as the old editor's `#frame-root` was, so a short page's background and
+   as the frame, as the old library's `#frame-root` was, so a short page's background and
    its top list reach the bottom of the canvas. `height: 1px` gives the root a
    height of its own for a list's `height: 100%` to resolve against. Not on an
    `auto` frame, whose height comes FROM the page: there `100vh` is the frame
@@ -126,10 +126,17 @@
    is measured from the words' bounding box, so words on three lines get one
    rectangle, not a line round each. Its colour is the one outline colour
    above: without its fallback the outline is not drawn in the canvas. */
-.es-canvas-outline.is-typing {
+.es-canvas-outline.is-typing,
+.es-canvas-outline.is-selected.is-words {
   outline: 2px solid var(--es-canvas-outline-colour);
-  outline-offset: 4px;
-}
+  outline-offset: var(--es-words-clear);
+}
+/* The 4px is WORDS_CLEAR in canvas/dom, the one home: the canvas sets
+   `--es-words-clear` from it on both boxes; no literal here. Selected words
+   wear that same box from the click on (Lewis 2026-10-26, option B): a
+   double-click puts the caret in it and moves nothing. The drag layer keeps
+   the handle, the name and the hint on its corners, measured from the same
+   constant. */
 /* THE POINTER (Lewis 2026-10-20, mockup v4 decision c): on the canvas it is
    the arrow — over words, and over the links and buttons the page drew, which
    the canvas never follows — and the I-beam only inside the words being

package/dist/easel/index.d.ts

@@ -1,18 +1,18 @@
 import { DataInput } from '../data/index.js';
-import { N as NodeSelection, P as PassThrough } from '../plan-CRUh2kVK.js';
-export { I as ItemSelector } from '../plan-CRUh2kVK.js';
-import { E as EaselConfig, a as EaselView, b as EaselAction, P as Permissions, c as EaselCore, d as EaselUi } from '../types-DFxBChE3.js';
-export { A as AppState, e as EaselHistory, H as HistoryEntry, S as SetDataPatch } from '../types-DFxBChE3.js';
-import { S as SlotAddress, D as Data, P as Place, N as Node } from '../types-DlQIM1YO.js';
-import { c as ResolveTrigger, a as ResolveCache, R as ResolvableItem } from '../resolve-AJ6WF4EL.js';
+import { N as NodeSelection, P as PassThrough } from '../plan-D0DgSLnY.js';
+export { I as ItemSelector } from '../plan-D0DgSLnY.js';
+import { E as EaselConfig, a as EaselView, b as EaselAction, P as Permissions, c as EaselCore, d as EaselUi } from '../types-BljCVdzR.js';
+export { A as AppState, e as EaselHistory, H as HistoryEntry, S as SetDataPatch } from '../types-BljCVdzR.js';
+import { S as SlotAddress, D as Data, a as DataConfig, P as Place, N as Node } from '../types-Dq180WRV.js';
+import { c as ResolveTrigger, a as ResolveCache, R as ResolvableItem } from '../resolve-Bz4mszpL.js';
 import * as react from 'react';
 import { ReactNode, CSSProperties, ComponentType, ReactElement } from 'react';
 import { TextToolbarProps } from 'efficient-shell/ui';
-import { C as CopyBoxLastTool, a as CopyThemeColor, b as CanvasTypingEnd } from '../canvas-typing-Be4FO4q7.js';
+import { C as CopyBoxLastTool, a as CopyThemeColor, b as CanvasTypingEnd } from '../canvas-typing-DOBx8dD3.js';
 import { InlineRule } from 'efficient-shell/markup';
-import { b as NodeOpsHost, C as ClipboardEntry } from '../useNodeOps-C_nisDHh.js';
-import { I as InspectorFields } from '../types-BFd8FqQw.js';
-import '../words-BpTjCfqO.js';
+import { b as NodeOpsHost, C as ClipboardEntry } from '../useNodeOps-igxrnEhq.js';
+import { I as InspectorFields } from '../types-BIytwvvH.js';
+import '../words-Cf5VT2Ic.js';
 import '../buckets-_MGDYJlb.js';
 
 interface EaselOptions<C extends EaselConfig = EaselConfig> {
@@ -31,11 +31,11 @@ interface EaselOptions<C extends EaselConfig = EaselConfig> {
      * loaded as if it were an edit.
      */
     onChange?: (data: Data) => void;
-    /** Easel-wide permissions, under each block's own (the old editor's `permissions`). */
+    /** Easel-wide permissions, under each block's own (the old library's `permissions`). */
     permissions?: Partial<Permissions>;
     /**
      * Changes recorded closer together than this collapse into ONE undo step —
-     * The old editor's 250 ms history debounce, so a word typed into a field is undone as
+     * The old library's 250 ms history debounce, so a word typed into a field is undone as
      * a word and not as letters. A `batch` is never collapsed into its
      * neighbours. 0 records every change on its own.
      */
@@ -55,7 +55,7 @@ interface Easel<C extends EaselConfig = EaselConfig> {
     getState: () => EaselView<C>;
     subscribe: (listener: () => void) => () => void;
     /**
-     * One the old editor action. Outside a `batch`, one undo step when it records.
+     * One action. Outside a `batch`, one undo step when it records.
      * Permissions are not checked here (see `setPermissions`).
      */
     dispatch: (action: EaselAction) => void;
@@ -87,8 +87,8 @@ interface Easel<C extends EaselConfig = EaselConfig> {
         select?: NodeSelection | undefined;
     }) => void;
     /**
-     * Put a different document in WITHOUT remounting anything — the old editor needed a
-     * new `key` on `the old editor root` for that, which threw away every subscriber's state.
+     * Put a different document in WITHOUT remounting anything — the old library needed a
+     * new `key` on the old library's root component for that, which threw away every subscriber's state.
      * The history starts again at this document unless `keepHistory`.
      */
     load: (data: DataInput | Data, options?: {
@@ -111,11 +111,11 @@ interface Easel<C extends EaselConfig = EaselConfig> {
      */
     setPermissions: (permissions: Partial<Permissions>) => void;
     /**
-     * Run every block's `resolveData` over the document, as `the old editor root` did when it
+     * Run every block's `resolveData` over the document, as the old library's root component did when it
      * mounted (trigger `'load'`), and write what changed as ONE change folded
      * into the step it happens in — a resolver bringing a stale document up to
-     * date is not an undo step (the old editor made it one, which undid back to the stale
-     * document). `onChange` hears it, as the old editor's did. `EaselProvider` runs this
+     * date is not an undo step (the old library made it one, which undid back to the stale
+     * document). `onChange` hears it, as the old library's did. `EaselProvider` runs this
      * on mount; a node changed by hand while it ran is left as the hand left it.
      */
     resolveAll: (options?: {
@@ -127,10 +127,10 @@ interface Easel<C extends EaselConfig = EaselConfig> {
      * write what changed folded into the step it happens in — `resolveAll`, for
      * one node. Resolves to whether anything was written.
      *
-     * It is what the old editor's own insert ran: a block dropped from its component list
+     * It is what the old library's own insert ran: a block dropped from its component list
      * was resolved with trigger `'insert'` (`insertComponent`), which is how a
      * block seeds its children or stamps a default the moment it arrives. The
-     * `insert` ACTION never did — the old editor's reducer was pure, and so is this one —
+     * `insert` ACTION never did — the old library's reducer was pure, and so is this one —
      * and the engine has no drop of its own: the Add list's click and the drag's
      * drop are the host's. So a host that puts a new block in, by `dispatch` or
      * by `run`, follows it with this (second host, 2026-10-07):
@@ -138,7 +138,7 @@ interface Easel<C extends EaselConfig = EaselConfig> {
      *     easel.dispatch({ type: 'insert', componentType, destinationZone, destinationIndex, id });
      *     void easel.resolveNode(id, { trigger: 'insert' });
      *
-     * ONE undo step with the insert (the old editor made the resolver's write a second
+     * ONE undo step with the insert (the old library made the resolver's write a second
      * one, and a single undo left a block that had never been resolved). A node
      * changed by hand, or taken out, while its resolver ran is left as it is.
      * `trigger` is `'replace'` when not given, as `resolveNodeData`'s is.
@@ -148,10 +148,10 @@ interface Easel<C extends EaselConfig = EaselConfig> {
         metadata?: Record<string, unknown>;
     }) => Promise<boolean>;
     /** This easel's memory of the last change each node was resolved for —
-     *  The old editor kept one per editor, shared by every write that resolves. */
+     *  The old library kept one per editor, shared by every write that resolves. */
     readonly resolveCache: ResolveCache;
     /**
-     * Swap the config in place — `the old editor root` took a new `config` prop live. The
+     * Swap the config in place — the old library's root component took a new `config` prop live. The
      * website editor rebuilds a few blocks' fields when the site's gap moves; the
      * document, the selection and the history are untouched.
      */
@@ -176,12 +176,12 @@ interface Easel<C extends EaselConfig = EaselConfig> {
  * Puck 0.20's UI at mount (`defaultAppState.ui`), less the selection, which
  * the store holds by id. A host's chrome reads these — the website editor
  * opens its side panels from `leftSideBarVisible` / `rightSideBarVisible` — so
- * a host moving off `the old editor root` finds them where they were.
+ * a host moving off the old library's root component finds them where they were.
  */
 declare const DEFAULT_UI: Record<string, unknown>;
 /**
  * THE EASEL STORE (blueprint step 5.1): the document, the selection by id and
- * the host's UI keys, with the old editor's actions, the old editor's history and a `batch` the old editor
+ * the host's UI keys, with the old library's actions, the old library's history and a `batch` the old library
  * never had. Framework-free — `useEasel` (./react) is the React binding.
  */
 declare function createEasel<C extends EaselConfig>(options: EaselOptions<C>): Easel<C>;
@@ -189,24 +189,24 @@ declare function createEasel<C extends EaselConfig>(options: EaselOptions<C>): E
 /**
  * Puck 0.20's reducer, on `efficient-easel/data` — blueprint step 5.1.
  *
- * Each action means what it meant to the old editor, so the apps' `dispatch` calls move
+ * Each action means what it meant to the old library, so the apps' `dispatch` calls move
  * over unchanged (`reorder`'s and `move`'s indexes, `replaceRoot` MERGING
  * props, `duplicate` selecting the copy, `insert` leaving the selection where
  * it was). Two things differ, on purpose:
  *
- *   - THE SELECTION IS BY ID. The old editor held `itemSelector` — a place — so a node
+ *   - THE SELECTION IS BY ID. The old library held `itemSelector` — a place — so a node
  *     inserted or removed above the selected one silently moved the selection
  *     onto its neighbour, and both editors carried patches for exactly that.
  *     Here `itemSelector` is derived from the id on every read, and a
  *     selection whose node is gone becomes nothing rather than whatever now
  *     sits in its place.
- *   - A SLOT CAN BE SELECTED (a column): `ui.selectedSlot`, which the old editor had no
+ *   - A SLOT CAN BE SELECTED (a column): `ui.selectedSlot`, which the old library had no
  *     way to say.
  */
-/** Whether the old editor records an action in history when the action does not say:
+/** Whether the old library records an action in history when the action does not say:
  *  everything but the state-setters. */
 declare function recordsByDefault(action: EaselAction): boolean;
-/** The UI as the old editor shows it: the host's keys, with the selection translated. */
+/** The UI as the old library shows it: the host's keys, with the selection translated. */
 declare function uiView(core: EaselCore, config: EaselConfig): EaselUi;
 /** A selection that still points at something; otherwise nothing. */
 declare function validSelection(data: Data, config: EaselConfig, selection: NodeSelection): NodeSelection;
@@ -223,13 +223,13 @@ interface EaselProviderProps {
      * `edit` permission is off (`bindUndoKeys`).
      */
     hotkeys?: boolean;
-    /** Run every block's `resolveData` once the easel mounts, as `the old editor root` did
+    /** Run every block's `resolveData` once the easel mounts, as the old library's root component did
      *  (`easel.resolveAll`). On by default. */
     resolveOnMount?: boolean;
     children?: ReactNode;
 }
-/** Puts one easel in reach of everything under it — `the old editor root`'s provider
- *  half — and, as `the old editor root` did, binds undo / redo to the page's keyboard
+/** Puts one easel in reach of everything under it — the old library's root component, its provider
+ *  half — and, as the old library's root component did, binds undo / redo to the page's keyboard
  *  (`hotkeys={false}` for a host that binds its own) and runs every block's
  *  `resolveData` once on mount (`resolveOnMount={false}` to skip). */
 declare function EaselProvider({ easel, hotkeys, resolveOnMount, children }: EaselProviderProps): react.JSX.Element;
@@ -252,7 +252,7 @@ declare function useEasel<T, C extends EaselConfig = EaselConfig>(selector: (vie
  */
 declare function createUseEasel<C extends EaselConfig = EaselConfig>(): <T>(selector: (view: EaselView<C>) => T) => T;
 
-/** What a slot component accepts — the old editor's. */
+/** What a slot component accepts — the old library's. */
 interface CanvasSlotProps {
     className?: string;
     style?: CSSProperties;
@@ -282,7 +282,7 @@ interface CanvasFrameProps {
     /** Called with the frame's document once it is ready, and null when it goes. */
     onDocument?: (doc: Document | null) => void;
     /**
-     * `'auto'` (the default, the old editor's): the frame is as tall as its content, and
+     * `'auto'` (the default, the old library's): the frame is as tall as its content, and
      * the host's pane scrolls it — so the canvas reads like the page it is.
      * `'fill'`: the frame fills its parent and scrolls itself.
      */
@@ -309,7 +309,7 @@ interface CanvasFrameProps {
  * arriving late, a dev reload).
  *
  * ⚠️ THAT FIRST DOCUMENT HAS NO DOCTYPE, SO IT RENDERS IN QUIRKS MODE, and it
- * is rewritten with one before anything is drawn. The old editor's frame was a
+ * is rewritten with one before anything is drawn. The old library's frame was a
  * `<!DOCTYPE html>` srcdoc, so every block was written against standards mode;
  * in quirks mode a `height: 100%` resolves through auto-height ancestors (an
  * empty slot grew to the frame's full height), tables stop inheriting the
@@ -359,7 +359,27 @@ declare const CanvasSharedContext: react.Context<((id: string) => boolean) | und
 interface CanvasPart {
     id: string;
     element: Element;
+    /**
+     * The part is its block's ONLY part — a Text block's words (Lewis
+     * 2026-10-26: one box per text). The host counts its own parts; the engine
+     * cannot. A whole part of a block with no lists shares the block's box (and
+     * the handle's label on it); any other part gets a box of its own. Absent:
+     * the engine reads a block with no lists as one rung with its part.
+     */
+    whole?: boolean;
+    /** The part's name as Layers shows it ("Scrolling bar"): the canvas's
+     *  label on its box while it is selected (Lewis 2026-10-26). */
+    label?: string;
 }
+/**
+ * Whether a part of block `ownerId` gets a box of its own (Lewis 2026-10-26:
+ * one box per text): yes, unless the block has no lists and the part is its
+ * only one (`CanvasPart.whole`, a Text block's words) — then the block and its
+ * words are one rung and share the block's box and its handle. With no
+ * `whole` from the host, a block with no lists is read as that one rung. One
+ * rule for the canvas's boxes and the screen's label.
+ */
+declare function partHasOwnBox(data: Data, config: DataConfig, ownerId: string, part: CanvasPart): boolean;
 /**
  * THE HOST'S PARTS ON THE CLICK CHAIN (W0, click-through plan 2026-10-12; card
  * [MERGE] One Text Block And Click Through Parts). A host that lets a merchant
@@ -379,9 +399,19 @@ interface CanvasParts {
     selected(): string | null;
     /** Select `partId` (its block is already the selection), or let it go. */
     select(partId: string | null): void;
+    /**
+     * The selected part as it is drawn in `doc` (the canvas's document, the
+     * frame's when it has one), or null (Lewis 2026-10-26: one box per text).
+     * Handed: the canvas draws its selected outline round that part, a regular
+     * rectangle like a selected block's, and the block's own selected box
+     * stands down — unless the part is `whole` in a block with no lists, which
+     * keeps the block box. Absent: the block box, as before, and the host
+     * draws whatever it draws.
+     */
+    selectedPart?(doc: Document): CanvasPart | null;
 }
 declare const CanvasPartsContext: react.Context<CanvasParts | undefined>;
-/** What a host may wrap an outline in — the old editor's `componentOverlay`: render
+/** What a host may wrap an outline in — the old library's `componentOverlay`: render
  *  `children` to draw it, or nothing to hide it (a text part open on the
  *  block, say). */
 type CanvasOverlay = ComponentType<{
@@ -467,7 +497,7 @@ interface EaselCanvasProps {
     metadata?: Record<string, unknown>;
     /** Copy the host's stylesheets into the frame (default true). */
     mirrorStyles?: boolean;
-    /** The frame's height: as tall as its content (default, the old editor's), or filling its parent. */
+    /** The frame's height: as tall as its content (default, the old library's), or filling its parent. */
     height?: 'auto' | 'fill';
     /**
      * The frame's accessible name — an iframe with none is announced as "frame".
@@ -490,14 +520,14 @@ interface EaselCanvasProps {
     onDocument?: (doc: Document | null) => void;
     /**
      * Wraps everything drawn in the frame, and is handed the frame's document —
-     * The old editor's `overrides.iframe`: where a host syncs its theme onto the frame's
+     * The old library's `overrides.iframe`: where a host syncs its theme onto the frame's
      * `<html>` or adds frame-only CSS.
      */
     frameWrapper?: ComponentType<{
         document?: Document;
         children: ReactNode;
     }>;
-    /** Wraps each outline — the old editor's `componentOverlay`; see `CanvasOverlay`. */
+    /** Wraps each outline — the old library's `componentOverlay`; see `CanvasOverlay`. */
     overlay?: CanvasOverlay;
     /** Drawn inside the frame, after the document — a host's canvas-only layer. */
     children?: ReactNode;
@@ -515,7 +545,7 @@ interface EaselCanvasProps {
     passThrough?: PassThrough;
 }
 /**
- * `the old editor's preview`, ours: the document for editing, its outlines, and the
+ * `the old library's preview`, ours: the document for editing, its outlines, and the
  * clicks that select. Must sit under an `EaselProvider`.
  */
 declare function EaselCanvas({ frame, className, style, metadata, mirrorStyles, onDocument, height, title, nonce, hotkeys, frameWrapper: FrameWrapper, overlay, children, typing, passThrough: passThroughProp, }: EaselCanvasProps): ReactElement;
@@ -524,8 +554,8 @@ declare function EaselCanvas({ frame, className, style, metadata, mirrorStyles,
  * THE PARTS, ON THE STORE (blueprint step 5.2).
  *
  * Every part built in steps 2.1–4.9 takes a HOST — what to read, how to write
- * — so it never knew the old editor. Until now each app wrote that host twice, once per
- * editor, against the old editor's store: `EmailFields` and `SiteFields` for the settings
+ * — so it never knew the old library. Until now each app wrote that host twice, once per
+ * editor, against the old library's store: `EmailFields` and `SiteFields` for the settings
  * panel, the node-ops host for the menus. These are the hosts, written ONCE,
  * against the engine's store; the parts' own APIs do not change.
  */
@@ -551,13 +581,13 @@ interface SelectedFields {
     id: string;
     /** The node the fields are for — the selected one, or the root as `{ type: 'root', props }`. */
     node: ResolvableItem;
-    /** Its fields, resolved as the old editor resolved them (`resolveFields` with the old editor's params, parent included). */
+    /** Its fields, resolved as the old library resolved them (`resolveFields` with the old library's params, parent included). */
     fields: InspectorFields;
     /** What the fields show. */
     values: Record<string, unknown>;
     /** The block's (or the root's) `edit` permission is off. */
     readOnly: boolean;
-    /** Write one field: `resolveData` as the old editor ran it, then ONE replace — one undo step. */
+    /** Write one field: `resolveData` as the old library ran it, then ONE replace — one undo step. */
     onChange: (name: string, value: unknown) => void;
     /**
      * Write SEVERAL fields at once: one merged props object, `resolveData` once,
@@ -570,11 +600,11 @@ interface SelectedFields {
 }
 /**
  * The settings panel's host: the selected node's fields and the write that
- * changes one — what `EmailFields` and `SiteFields` each did against the old editor,
+ * changes one — what `EmailFields` and `SiteFields` each did against the old library,
  * here once:
- *   - fields resolve through `useResolvedFields` (the old editor's
+ *   - fields resolve through `useResolvedFields` (the old library's
  *     `useRegisterFieldsSlice`: `changed`, `lastFields`, `appState`, `parent`);
- *   - a change runs the block's `resolveData` (`resolveNodeData`, the old editor's
+ *   - a change runs the block's `resolveData` (`resolveNodeData`, the old library's
  *     `resolveComponentData`, with this easel's own memory of the last
  *     change) and then writes ONE `replace` of the node, or ONE `replaceRoot`.
  *
@@ -583,16 +613,23 @@ interface SelectedFields {
  * selected when the change began.
  */
 declare function useSelectedFields(): SelectedFields;
+/**
+ * The ROOT's fields and write, whatever is selected: `useSelectedFields` with
+ * nothing selected, for a panel that edits the page beside a selection — the
+ * website's Styles ▸ Basics, the This page group, open while a section is (Lewis, 2026-10-26).
+ * The same resolve and the same one `replaceRoot`; the selection is untouched.
+ */
+declare function useRootFields(): SelectedFields;
 
 /**
- * UNDO AND REDO ON THE KEYBOARD — the old editor's own six bindings, which both editors
+ * UNDO AND REDO ON THE KEYBOARD — the old library's own six bindings, which both editors
  * relied on without writing any: ⌘Z / Ctrl+Z undo; ⇧⌘Z, ⌘Y, Ctrl+Shift+Z and
  * Ctrl+Y redo.
  *
- * Exact combinations, read off the physical key (`code`, as the old editor read it), so
+ * Exact combinations, read off the physical key (`code`, as the old library read it), so
  * a layout that moves Z still undoes and ⌥⌘Z does nothing.
  *
- * ⚠️ THE OLD EDITOR FIRED THESE IN A TEXT FIELD TOO, and so does this: ⌘Z while typing
+ * ⚠️ THE OLD LIBRARY FIRED THESE IN A TEXT FIELD TOO, and so does this: ⌘Z while typing
  * in a setting undoes the easel's last step — which, since a field writes as
  * it is typed, is the typing — and the browser's own text undo is prevented,
  * so there are never two undo histories answering one key.
@@ -617,10 +654,10 @@ declare function useSelectedFields(): SelectedFields;
  * editable region (efficient-easel/canvas `isTypingTarget`) — is not taken:
  * it is that field's own undo. The assembled screen binds its keys so, to its
  * own root and to the canvas frame, inside another app's page (lib/key-scope);
- * left out, a press in a field undoes the easel's step, as the old editor's did.
+ * left out, a press in a field undoes the easel's step, as the old library's did.
  */
 declare function bindUndoKeys(doc: Document, easel: Pick<Easel, 'undo' | 'redo'> & Partial<Pick<Easel, 'getState'>>, options?: {
     leaveTyping?: boolean;
 }): () => void;
 
-export { CanvasFrame, type CanvasFrameProps, type CanvasOverlay, type CanvasPart, type CanvasParts, CanvasPartsContext, CanvasPassThroughContext, CanvasSharedContext, type CanvasSlotProps, type CanvasTyping, type CanvasTypingState, type CanvasTypingTarget, DEFAULT_UI, type Easel, EaselAction, EaselCanvas, type EaselCanvasProps, EaselConfig, EaselCore, type EaselOptions, EaselProvider, type EaselProviderProps, EaselUi, EaselView, EditDocument, NodeSelection, Permissions, type SelectedFields, bindUndoKeys, createEasel, createUseEasel, recordsByDefault, reduce, uiView, useEasel, useEaselApi, useEaselNodeOps, useSelectedFields, validSelection };
+export { CanvasFrame, type CanvasFrameProps, type CanvasOverlay, type CanvasPart, type CanvasParts, CanvasPartsContext, CanvasPassThroughContext, CanvasSharedContext, type CanvasSlotProps, type CanvasTyping, type CanvasTypingState, type CanvasTypingTarget, DEFAULT_UI, type Easel, EaselAction, EaselCanvas, type EaselCanvasProps, EaselConfig, EaselCore, type EaselOptions, EaselProvider, type EaselProviderProps, EaselUi, EaselView, EditDocument, NodeSelection, Permissions, type SelectedFields, bindUndoKeys, createEasel, createUseEasel, partHasOwnBox, recordsByDefault, reduce, uiView, useEasel, useEaselApi, useEaselNodeOps, useRootFields, useSelectedFields, validSelection };

package/dist/easel/index.js

@@ -1 +1 @@
-export{CanvasFrame,CanvasPartsContext,CanvasPassThroughContext,CanvasSharedContext,DEFAULT_UI,EaselCanvas,EaselProvider,EditDocument,bindUndoKeys,createEasel,createUseEasel,recordsByDefault,reduce,uiView,useEasel,useEaselApi,useEaselNodeOps,useSelectedFields,validSelection}from"../chunk-WJSEWAWK.js";import"../chunk-TBY3DFKS.js";import"../chunk-IWCKVZHS.js";import"../chunk-BSHIQIZC.js";import"../chunk-MZ5GSSZ3.js";import"../chunk-KRL3IUV3.js";import"../chunk-MFIRYGHW.js";import"../chunk-GHBK7BKL.js";import"../chunk-LF3FUSCQ.js";import"../chunk-K7BTCBWD.js";import"../chunk-L55YIXDC.js";
+export{CanvasFrame,CanvasPartsContext,CanvasPassThroughContext,CanvasSharedContext,DEFAULT_UI,EaselCanvas,EaselProvider,EditDocument,bindUndoKeys,createEasel,createUseEasel,partHasOwnBox,recordsByDefault,reduce,uiView,useEasel,useEaselApi,useEaselNodeOps,useRootFields,useSelectedFields,validSelection}from"../chunk-KXTXYINN.js";import"../chunk-TBY3DFKS.js";import"../chunk-AGWKB77Q.js";import"../chunk-RPMSET77.js";import"../chunk-HZSZT3BE.js";import"../chunk-KRL3IUV3.js";import"../chunk-MFIRYGHW.js";import"../chunk-YU3WHLGI.js";import"../chunk-LF3FUSCQ.js";import"../chunk-TGZCD6IP.js";import"../chunk-KXM6YRG2.js";