efficient-easel 22.0.0 → 23.1.0

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-VBOSOH5M.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";

package/dist/edit-lock/index.d.ts

@@ -142,7 +142,7 @@ declare function accessForNewDocument(hasEditLock: boolean): EditAccess;
 declare const holderOf: (access: EditAccess) => LockHolder | null;
 /** Read the `edit-lock` body — from a 200 or from a 409's error payload. */
 declare function readLockHolder(data: unknown): LockHolder | null;
-/** The five capabilities the old editor's `permissions` prop carries for the canvas. */
+/** The five capabilities the old library's `permissions` prop carries for the canvas. */
 type DocumentPermissions = {
     edit: boolean;
     insert: boolean;
@@ -151,13 +151,13 @@ type DocumentPermissions = {
     drag: boolean;
 };
 /**
- * The canvas's the old editor `permissions`, derived from the write gate.
+ * The canvas's the old library `permissions`, derived from the write gate.
  *
  * BOTH branches name ALL FIVE keys — and that completeness is the whole point,
- * not tidiness. The old editor does not replace this prop when it changes; it MERGES it
+ * not tidiness. The old library does not replace this prop when it changes; it MERGES it
  * over the permissions it already holds (store/slices/permissions.ts,
  * `useRegisterPermissionsSlice`: `{ ...existingGlobalPermissions, ...prop }`),
- * and a field's editability is the live `getPermissions().edit`. The old editor mounts
+ * and a field's editability is the live `getPermissions().edit`. The old library mounts
  * while the lock claim is still `checking`, so `canEdit` is false and the store
  * latches every key false. A PARTIAL writable value (say `{ drag: false }`)
  * would then merge WITHOUT an `edit` key and leave `edit:false` stuck — every
@@ -166,7 +166,7 @@ type DocumentPermissions = {
  * resets them, so the panel comes back the instant `canEdit` flips true.
  *
  * `drag` stays false in EITHER state: both editors move blocks with native DnD
- * rails of their own, so the old editor's flaky cross-iframe canvas drag is always off.
+ * rails of their own, so the old library's flaky cross-iframe canvas drag is always off.
  *
  * Write safety is unchanged: the `checking` window is still non-editable here,
  * and the host's own write gate still drops any edit attempted before the claim

package/dist/fields/fields.css

@@ -4,7 +4,7 @@
  * The rows and the groups are `panel.css`'s (SettingsField, SettingsGroup),
  * and the tabs are the shell's `Tabs`. The panel's rhythm is defined in
  * `panel.css` ONCE (`--es-row-gap`, `--es-rhythm-*`), so this file adds no spacing between rows
- * and no spacing between groups. What it adds is what a row HOLDS where the old editor
+ * and no spacing between groups. What it adds is what a row HOLDS where the old library
  * used to put the browser's own: a text box, a number box, a dropdown.
  *
  * Every colour is a shell token (`shell.css`), so the dark editor is the same

package/dist/fields/index.d.ts

@@ -4,12 +4,12 @@ import { S as SettingsBucket } from '../buckets-_MGDYJlb.js';
 export { D as DesignGroup } from '../buckets-_MGDYJlb.js';
 import { ShowWhenContext } from 'efficient-shell/format';
 export { ShowWhenContext, ShowWhenRule, showWhenOf, withShowWhen } from 'efficient-shell/format';
-import { a as InspectorFieldDef, b as FieldRenderer, I as InspectorFields, c as FieldTextProps, d as FieldNumberProps, e as FieldSliderProps, f as FieldSelectManyProps, g as FieldSelectOneProps, F as FieldOption } from '../types-BFd8FqQw.js';
-export { A as ArrayFieldDef, C as CustomFieldDef, h as CustomFieldRenderProps, i as FieldSelectProps, N as NumberFieldDef, O as ObjectFieldDef, R as RadioFieldDef, S as SelectFieldDef, j as SlotFieldDef, T as TextFieldDef, k as TextareaFieldDef } from '../types-BFd8FqQw.js';
-import { R as ResolvableItem } from '../resolve-AJ6WF4EL.js';
+import { a as InspectorFieldDef, b as FieldRenderer, I as InspectorFields, c as FieldTextProps, d as FieldNumberProps, e as FieldSliderProps, f as FieldSelectManyProps, g as FieldSelectOneProps, F as FieldOption } from '../types-BIytwvvH.js';
+export { A as ArrayFieldDef, C as CustomFieldDef, h as CustomFieldRenderProps, i as FieldSelectProps, N as NumberFieldDef, O as ObjectFieldDef, R as RadioFieldDef, S as SelectFieldDef, j as SlotFieldDef, T as TextFieldDef, k as TextareaFieldDef } from '../types-BIytwvvH.js';
+import { R as ResolvableItem } from '../resolve-Bz4mszpL.js';
 export { F as FieldsWords } from '../words-CFkb8XtN.js';
 export { LinkFilter, LinkFilterField, LinkKindChoice, LinkOption, LinkOptionGroup, LinkPicker, LinkPickerProps, LinkRules, LinkTarget } from 'efficient-shell/ui';
-import '../types-DlQIM1YO.js';
+import '../types-Dq180WRV.js';
 
 /**
  * A SETTINGS ROW'S SHOW-WHEN, read by the panel (SSOT batch 1, Lewis
@@ -81,12 +81,12 @@ interface InspectorFieldProps {
 }
 /** A heading level a settings group may draw at. */
 type HeadingLevel = 2 | 3 | 4 | 5 | 6;
-/** The label a row shows: the field's own, else its key, as the old editor did. */
+/** The label a row shows: the field's own, else its key, as the old library did. */
 declare const labelOf: (field: InspectorFieldDef, name: string) => string;
 /**
- * ONE FIELD, drawn by its type — what the old editor's `AutoField` was (blueprint 4.1).
+ * ONE FIELD, drawn by its type — what the old library's `AutoField` was (blueprint 4.1).
  *
- *   custom    the field's own render, called with the old editor's props plus `context`;
+ *   custom    the field's own render, called with the old library's props plus `context`;
  *   text, textarea, number, select
  *             a SettingsField row (quiet label, control under it) holding the
  *             shell's own control, never the browser's;
@@ -162,6 +162,11 @@ interface FieldPlan {
  * `bucket` ends nothing: it is a key the host keeps and nothing more. One level only — a band in a band
  * cannot be said. A band whose rows are all hidden draws nothing
  * (`Inspector`).
+ *
+ * THE VIEW (Lewis, 2026-10-27). When `show.context.device` is `"mobile"` (the phone
+ * view), a row without a phone value is not planned either: it would write the
+ * desktop value under the phone's name (`fieldShownInView`). Its `bucket` and
+ * `fold` still count, as for a show-when row.
  */
 declare function planFields(fields: InspectorFields, show?: ShowWhenInput): FieldPlan;
 /**
@@ -221,7 +226,7 @@ interface InspectorProps {
     headingLevel?: HeadingLevel;
 }
 /**
- * THE SETTINGS PANEL'S BODY (blueprint step 4.1) — what `the old editor's fields panel` was in
+ * THE SETTINGS PANEL'S BODY (blueprint step 4.1) — what `the old library's fields panel` was in
  * both editors, without the hashed class names both had to hunt.
  *
  *   - THE TABS ARE THE FIELDS' OWN. Which tab a field opens is said on the field
@@ -238,7 +243,7 @@ interface InspectorProps {
  *     re-bakes its colours from a field on a tab you are not looking at; taking
  *     the row out of the tree would stop that.
  *   - EVERY ROW IS ONE `.es-insp-row` WITH ITS NAME ON IT (`data-field`), a
- *     public class an app may style, where the old editor's wrapper had a hashed one. A row
+ *     public class an app may style, where the old library's wrapper had a hashed one. A row
  *     that draws nothing takes no space (`:empty`).
  *   - THE SPACING IS THE PANEL'S (panel.css `--es-rhythm-*`): a row adds none of
  *     its own, so the rhythm is defined once for both editors.
@@ -259,6 +264,35 @@ interface InspectorProps {
  */
 declare function Inspector({ fields, values, onChange, readOnly, context, showWhenContext, tab, onTab, tabs, tabIcons, renderers, idPrefix, ariaLabel, lead, children, leadFold, closedFolds, onFold, headingLevel, }: InspectorProps): react.JSX.Element;
 
+/**
+ * IS THIS ROW DRAWN IN THIS VIEW? — the one gate (Lewis, 2026-10-27).
+ *
+ * In the phone view the panel draws only rows that have a phone value of their
+ * own: a `deviceField("mobile", …)`, which is a phone twin or a phone-only row,
+ * or a `deviceField("each", …)`, one row that writes the view's own value.
+ * Every other row writes the DESKTOP value, so drawing it under the phone view
+ * lets a merchant move the desktop while they look at the phone. The phone and
+ * the desktop are set apart and do not disturb each other.
+ *
+ * The answer comes from the one mark `deviceField` stamps (`deviceMetaOf`). It
+ * is not a list, and not a second filter beside the gate: a row is either
+ * gated to the phone or it is not a phone row.
+ *
+ * Never hidden by it, because they are not setting rows: a heading or tab mark
+ * (`marker`), a slot (it draws nothing; its name has a tab), and a field that
+ * draws no control anywhere (`noControlField(…, "always")`: the device note). Every other view (desktop, tablet, or no
+ * view named) draws every row, as before: tablet shows the desktop values.
+ *
+ * A host says which view it is in by `showWhenContext.device`; `"mobile"` is
+ * the phone. A host with no such fact (the campaign designer today) sees no
+ * change until it passes one.
+ *
+ * The `Inspector`'s `lead` (the host's own entry rows above the planned rows:
+ * the website's text boxes) is one more ungated row, so it is asked the same
+ * way: `fieldShownInView(LEAD_ROW, device)`. It is never a phone value.
+ */
+declare function fieldShownInView(field: unknown, device: unknown): boolean;
+
 /** What a block may declare about its fields. */
 interface FieldsBlock {
     fields?: object;
@@ -279,11 +313,11 @@ interface ResolvedFieldsInput {
     block: FieldsBlock | undefined;
     /** The node that holds it, or null at the top. */
     parent?: ResolvableItem | null;
-    /** What a resolver is told about the editor (the old editor's public `{ data, ui }`). */
+    /** What a resolver is told about the editor (the old library's public `{ data, ui }`). */
     appState?: unknown;
 }
 /**
- * A NODE'S FIELDS, RESOLVED AS THE OLD EDITOR RESOLVED THEM — `useRegisterFieldsSlice`
+ * A NODE'S FIELDS, RESOLVED AS THE OLD LIBRARY RESOLVED THEM — `useRegisterFieldsSlice`
  * in Puck 0.20, which both editors' `resolveFields` were written against.
  *
  *   - A new selection starts from the block's DECLARED fields (`lastFields` is
@@ -296,7 +330,7 @@ interface ResolvedFieldsInput {
  *   - `loading` turns on only when an answer takes longer than 50 ms.
  *
  * `appState` and `parent` are read when a resolution starts, never watched:
- * The old editor re-resolved on the node's change alone.
+ * The old library re-resolved on the node's change alone.
  */
 declare function useResolvedFields({ id, node, block, parent, appState }: ResolvedFieldsInput): {
     fields: InspectorFields;
@@ -350,9 +384,9 @@ interface ListFieldProps<T> {
     noun?: string;
     items: readonly T[];
     onChange: (next: T[]) => void;
-    /** A fresh item for "+" (the old editor's `defaultItemProps`, copied). */
+    /** A fresh item for "+" (the old library's `defaultItemProps`, copied). */
     newItem: () => T;
-    /** The words after an item's name in its row (the old editor's `getItemSummary`). */
+    /** The words after an item's name in its row (the old library's `getItemSummary`). */
     summary?: (item: T, index: number) => ReactNode;
     /** An item's own name; default "<Noun> <n>". */
     itemName?: (item: T, index: number) => string;
@@ -401,7 +435,7 @@ declare function moveTo<T>(items: readonly T[], from: number, to: number): T[];
 declare function removeAt<T>(items: readonly T[], index: number): T[];
 /**
  * A copy of an item: a deep copy of plain data, so editing the copy never
- * writes through to the original (a list item is JSON — the old editor stored it so).
+ * writes through to the original (a list item is JSON — the old library stored it so).
  */
 declare function copyItem<T>(item: T): T;
 declare function ListField<T>({ label, icon, noun: ownNoun, items, onChange, newItem, summary, itemName, thumb, min, max, readOnly, open, onOpen, renderItem, renderRow, canRemove: removable, lockedReason, fixed, removeOnRow, canDuplicate, above, head, }: ListFieldProps<T>): react.JSX.Element;
@@ -518,4 +552,4 @@ declare function optionFor<V>(options: readonly FieldOption<V>[], value: V | und
 declare function FieldSelect<V>(props: FieldSelectManyProps<V>): ReactNode;
 declare function FieldSelect<V>(props: FieldSelectOneProps<V>): ReactNode;
 
-export { FieldNumber, FieldNumberProps, FieldOption, type FieldPlan, FieldRenderer, FieldSelect, FieldSelectManyProps, FieldSelectOneProps, FieldSlider, FieldSliderProps, FieldText, FieldTextProps, type FieldsBlock, Inspector, InspectorField, InspectorFieldDef, type InspectorFieldProps, InspectorFields, type InspectorProps, ListField, type ListFieldProps, type PlannedFold, type PlannedRow, type ResolvedFieldsInput, SettingsBucket, type ShowWhenInput, bucketsOf, copyItem, fieldIsShown, insertAt, labelOf, moveTo, optionFor, planFields, removeAt, shownFields, useResolvedFields };
+export { FieldNumber, FieldNumberProps, FieldOption, type FieldPlan, FieldRenderer, FieldSelect, FieldSelectManyProps, FieldSelectOneProps, FieldSlider, FieldSliderProps, FieldText, FieldTextProps, type FieldsBlock, Inspector, InspectorField, InspectorFieldDef, type InspectorFieldProps, InspectorFields, type InspectorProps, ListField, type ListFieldProps, type PlannedFold, type PlannedRow, type ResolvedFieldsInput, SettingsBucket, type ShowWhenInput, bucketsOf, copyItem, fieldIsShown, fieldShownInView, insertAt, labelOf, moveTo, optionFor, planFields, removeAt, shownFields, useResolvedFields };

package/dist/fields/index.js

@@ -1 +1 @@
-export{FieldText,Inspector,InspectorField,LinkPicker,ListField,bucketsOf,copyItem,insertAt,labelOf,moveTo,planFields,removeAt}from"../chunk-YHFKWV7H.js";export{fieldIsShown,showWhenOf,shownFields,withShowWhen}from"../chunk-BPXEFVSQ.js";import"../chunk-WHS6Y55E.js";import"../chunk-K56YDHYQ.js";export{FieldSlider}from"../chunk-ZEH6QLBH.js";export{useResolvedFields}from"../chunk-IWCKVZHS.js";import"../chunk-FIVU2COQ.js";import"../chunk-FM6JO4WF.js";import"../chunk-KFV7N2DJ.js";export{FieldNumber}from"../chunk-Y2T3JX7K.js";export{FieldSelect,optionFor}from"../chunk-KFWNGPW3.js";import"../chunk-JACEEVVF.js";import"../chunk-S3DUFDQ6.js";import"../chunk-MFIRYGHW.js";import"../chunk-3S5N4HLJ.js";import"../chunk-P2VEMZH5.js";import"../chunk-K7BTCBWD.js";import"../chunk-L55YIXDC.js";
+export{FieldText,Inspector,InspectorField,LinkPicker,ListField,bucketsOf,copyItem,fieldShownInView,insertAt,labelOf,moveTo,planFields,removeAt}from"../chunk-6QSFJCJT.js";export{fieldIsShown,showWhenOf,shownFields,withShowWhen}from"../chunk-BPXEFVSQ.js";import"../chunk-YCSZAP7T.js";import"../chunk-WHS6Y55E.js";import"../chunk-K56YDHYQ.js";export{FieldSlider}from"../chunk-ZEH6QLBH.js";export{useResolvedFields}from"../chunk-AGWKB77Q.js";import"../chunk-FIVU2COQ.js";import"../chunk-FM6JO4WF.js";import"../chunk-KFV7N2DJ.js";export{FieldNumber}from"../chunk-Y2T3JX7K.js";export{FieldSelect,optionFor}from"../chunk-KFWNGPW3.js";import"../chunk-JACEEVVF.js";import"../chunk-S3DUFDQ6.js";import"../chunk-MFIRYGHW.js";import"../chunk-6NJHYXJM.js";import"../chunk-P2VEMZH5.js";import"../chunk-TGZCD6IP.js";import"../chunk-KXM6YRG2.js";

package/dist/node-ops/index.d.ts

@@ -1,9 +1,9 @@
-export { A as AfterRemove, I as ItemSelector, N as NodeSelection, P as PassThrough, a as Planned, S as StepBounds, c as canStep, b as clickPick, d as clickPickPart, f as fromItemSelector, n as nextInChain, e as nodeChain, p as parentStep, g as planDuplicate, h as planMove, i as planPaste, j as planRemove, k as planRestore, l as planSetProps, m as planStep, o as planSwap, t as toItemSelector } from '../plan-CRUh2kVK.js';
-export { C as ClipboardEntry, N as NodeClipboard, a as NodeOps, b as NodeOpsHost, c as createNodeClipboard, u as useNodeOps } from '../useNodeOps-C_nisDHh.js';
+export { A as AfterRemove, I as ItemSelector, N as NodeSelection, P as PassThrough, a as Planned, S as StepBounds, c as canStep, b as clickPick, d as clickPickPart, f as fromItemSelector, n as nextInChain, e as nodeChain, p as parentStep, g as planDuplicate, h as planMove, i as planPaste, j as planRemove, k as planRestore, l as planSetProps, m as planStep, o as planSwap, t as toItemSelector } from '../plan-D0DgSLnY.js';
+export { C as ClipboardEntry, N as NodeClipboard, a as NodeOps, b as NodeOpsHost, c as createNodeClipboard, u as useNodeOps } from '../useNodeOps-igxrnEhq.js';
 import { ReactNode } from 'react';
 import { E as EaselContextMenuItem } from '../types-BbOBWXMP.js';
 import { N as NodeMenuWords } from '../words-DMG4dYq2.js';
-import '../types-DlQIM1YO.js';
+import '../types-Dq180WRV.js';
 
 /**
  * nodeMenuItems — the right-click rows for a block, ONE list for both editors.

package/dist/node-ops/index.js

@@ -1 +1 @@
-export{createNodeClipboard,nodeMenuItems}from"../chunk-P5VYGWYO.js";import"../chunk-WK3AFPXY.js";export{canStep,clickPick,clickPickPart,fromItemSelector,nextInChain,nodeChain,parentStep,planDuplicate,planMove,planPaste,planRemove,planRestore,planSetProps,planStep,planSwap,toItemSelector,useNodeOps}from"../chunk-BSHIQIZC.js";import"../chunk-K7BTCBWD.js";import"../chunk-L55YIXDC.js";
+export{createNodeClipboard,nodeMenuItems}from"../chunk-P5VYGWYO.js";import"../chunk-WK3AFPXY.js";export{canStep,clickPick,clickPickPart,fromItemSelector,nextInChain,nodeChain,parentStep,planDuplicate,planMove,planPaste,planRemove,planRestore,planSetProps,planStep,planSwap,toItemSelector,useNodeOps}from"../chunk-RPMSET77.js";import"../chunk-TGZCD6IP.js";import"../chunk-KXM6YRG2.js";

package/dist/panel/index.d.ts

@@ -621,7 +621,7 @@ declare function SettingsSegmented<V = string>({ options, value, onChange, ariaL
 declare function SettingsGroup({ title, open, onToggle, count, level, id, children, className, }: SettingsGroupProps): react.JSX.Element;
 
 /**
- * A group heading with NO group under it — the band on its own, for the old editor's
+ * A group heading with NO group under it — the band on its own, for the old library's
  * flat inspector list, where a heading cannot wrap the rows that follow it. A
  * HEADING, not a control: no button, no sign, no count. THE SHELL'S
  * `AccordionHeading` (B2 plan C, Lewis 2026-10-26); this name stays because

package/dist/panel/panel.css

@@ -32,7 +32,7 @@
    token behind any of them: there was nowhere to change it once, and no floor
    under any of it.
 
-   ON `.es-editor`, because the panel HAS no root of its own. The old editor lays the
+   ON `.es-editor`, because the panel HAS no root of its own. The old library lays the
    inspector out as a flat sibling list, so the primitives render no wrapper —
    and `.es-editor` is the chrome root both editors already put on their own
    chrome and the root every colour in this sheet is already read from. A host
@@ -503,6 +503,11 @@
    because it is the only thing saying which name owns which control. Floored
    on `--es-row-gap`, not replaced, and not `calc()`. */
 .es-field { margin-top: max(var(--es-row-gap), var(--es-rhythm-between)); }
+/* An Inspector inside a group body (a host's group of rows under a heading, e.g.
+   the website's "This page" in Styles > Basics): `.es-insp` is a flex column, so
+   the body's 32px and the first row's 32px do not fold into one. The body
+   carries the band's gap; the first row adds none. */
+.es-group-body > .es-insp > .es-insp-rows > .es-insp-row:first-child > .es-field:first-child { margin-top: 0; }
 .es-field-head { margin-bottom: var(--es-rhythm-within); }
 
 /* A one-line row (a switch on the name line) has no control line, so no gap