efficient-easel 21.1.0 → 22.0.0

package/dist/data/index.d.ts

@@ -1,23 +1,23 @@
-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-41704JE4.js';
-export { B as BlockShape, c as FieldShape, d as FieldsShape, e as NodeProps, R as RootData } from '../types-41704JE4.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-D68pb3Bx.js';
+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';
 
 /**
  * Finding a node's slots, and reading or writing a value at a prop path.
  *
- * A slot is found the way Puck finds one: by the FIELDS, not by the value. A
+ * A slot is found the way the old editor 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 Puck gives it — `items[0].content`, `box.content`.
+ * then the prop path the old editor gives it — `items[0].content`, `box.content`.
  *
- * One deliberate difference from Puck: Puck also walks an object whose field is
+ * One deliberate difference from the old editor: the old editor 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 Puck's own walk), and a rule that
+ * that (a non-array value there crashes the old editor'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`). Puck
+ * which is the order a person reads the block in (`col1` before `col2`). The old editor
  * visits slots in reverse, as a side effect of how it fills empty ones; nothing
  * in either app depends on that.
  */
@@ -195,7 +195,7 @@ declare function copyTranslation(overlay: TranslationOverlay | null | undefined,
 /**
  * efficient-easel/data — the document, as pure functions.
  *
- * The bottom layer of the engine that replaces Puck (the blueprint "Puck From
+ * The bottom layer of the engine that replaces the old editor (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 +213,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 Puck: a new block is created WITH its
+ *   2. Default props follow the old editor: 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 Puck's
+ *      and children parked in `zones` — and converted on open, the way the old editor'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 Puck" means the same keys and
+ * not keep key order, so "the same document as the old editor" 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 +239,7 @@ declare function copyTranslation(overlay: TranslationOverlay | null | undefined,
  */
 
 /**
- * What `normalizeData` accepts: any saved document, as loosely as Puck's own
+ * What `normalizeData` accepts: any saved document, as loosely as the old editor'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 +259,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 }` → Puck's zone key `"<parentId>:<slot>"`. */
+/** `{ parentId, slot }` → the old editor's zone key `"<parentId>:<slot>"`. */
 declare const zoneKey: ({ parentId, slot }: SlotAddress) => string;
-/** Puck's zone key → `{ parentId, slot }`. Ids and prop paths hold no colon. */
+/** The old editor'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 +294,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 Puck
+ * What the easel does to a document when it opens it — the same result the old editor
  * reaches on load, with the older formats converted (rule 4):
  *
  *   - `root` holding its props directly becomes `{ props: { …those keys } }`;
@@ -309,7 +309,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 — Puck's `insert` recipe:
+ * A new block, the way the Add panel makes one — the old editor'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 +328,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 (Puck's rule), so `0 … length-1`; into another list it is the index
+ * the move (the old editor'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 +336,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 Puck's own duplicate copied
+ * original's baked image" (`bakedId`), which the old editor's own duplicate copied
  * verbatim.
  */
 declare function duplicate(data: Data, config: DataConfig, id: string, options?: {
@@ -354,7 +354,7 @@ declare function copyNode(node: Node, config: DataConfig, options?: {
     strip?: (node: Node) => Node;
 }): Node;
 /**
- * Merge `patch` into a node's props — Puck's `replace`, for the common case of
+ * Merge `patch` into a node's props — the old editor'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 +362,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 — Puck's `replace` action: the node keeps its place
+ * Replace a node wholesale — the old editor'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`

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-41704JE4.js';
-import { D as DragSession } from '../session-DSQFmIvx.js';
-export { a as DragHeld, c as createDragSession } from '../session-DSQFmIvx.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-CFUcBbgc.js';
+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 { D as DragWords } from '../words-SD4neL0n.js';
-import '../watch-D8xZow3y.js';
+import '../watch-D0bNZRtU.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-WJJ7H42G.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-4FD7TAOE.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-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";

package/dist/draw/index.d.ts

@@ -6,6 +6,6 @@ export { RowNameRule, rootRowName, sectionRenameProp, slotChildName, slotChildRe
 export { FOOTER_TYPE, HEADER_TYPE, NodeLocation, ROOT_ZONE, SlotConfigView, TREE_MAX_DEPTH, TreeItem, blockNodeActions, childSlotsOf, locateNode, missingPinnedTypes, nestsInTree, newNodeId, pinnedDuplicateIds, pinnedDuplicateIndices, slotChildrenIn, slotFieldsOf } from '../screen/lib/document/content-tree.js';
 export { AUTO_RULES, AutoRule, FOLLOW_RULES, VIEW_DESKTOP_MIN, VIEW_TABLET_MIN, VIEW_TIERS, VIEW_TIER_LABEL, ViewTier, ViewValueKind, ViewValues, isAuto, phoneKey, resolveViewValue, tabletKey, viewTierForWidth } from '../screen/lib/content/view-tiers.js';
 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-BNgSq2Nw.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';

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. Puck's `puck.css` drew these until now; the rules follow it.
+ * hovered block. The old editor'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
@@ -44,16 +44,14 @@
   box-shadow: var(--elevation-panel);
 }
 
-/* The frame's root (CanvasFrame). Puck's `[data-puck-entry]` rule: a stacking
-   context of its own, so a block's z-index stays inside the page.
-   `data-puck-entry` is the old name, drawn beside the new one until easel 22. */
-[data-easel-entry],
-[data-puck-entry] {
+/* The frame's root (CanvasFrame): a stacking context of its own, so a block's
+   z-index stays inside the page. */
+[data-easel-entry] {
   position: relative;
   z-index: 0;
 }
 /* A frame that FILLS its parent (`height="fill"`): the page is at least as tall
-   as the frame, as Puck's `#frame-root` was, so a short page's background and
+   as the frame, as the old editor'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

package/dist/easel/index.d.ts

@@ -1,19 +1,19 @@
 import { DataInput } from '../data/index.js';
-import { N as NodeSelection, P as PassThrough } from '../plan-CZS902DV.js';
-export { I as ItemSelector } from '../plan-CZS902DV.js';
-import { E as EaselConfig, a as EaselView, b as EaselAction, P as Permissions, c as EaselCore, d as EaselUi } from '../types-Cq53lL8d.js';
-export { A as AppState, e as EaselHistory, H as HistoryEntry, S as SetDataPatch } from '../types-Cq53lL8d.js';
-import { S as SlotAddress, D as Data, P as Place, N as Node } from '../types-41704JE4.js';
-import { c as ResolveTrigger, a as ResolveCache, R as ResolvableItem } from '../resolve-D68pb3Bx.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 * 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 { InlineRule } from 'efficient-shell/markup';
-import { b as NodeOpsHost, C as ClipboardEntry } from '../useNodeOps-fIDWzftn.js';
-import { I as InspectorFields } from '../types-B8NwXKlE.js';
+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 '../buckets-Sw94ll9I.js';
+import '../buckets-_MGDYJlb.js';
 
 interface EaselOptions<C extends EaselConfig = EaselConfig> {
     config: C;
@@ -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 (Puck's `permissions`). */
+    /** Easel-wide permissions, under each block's own (the old editor's `permissions`). */
     permissions?: Partial<Permissions>;
     /**
      * Changes recorded closer together than this collapse into ONE undo step —
-     * Puck's 250 ms history debounce, so a word typed into a field is undone as
+     * The old editor'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 Puck action. Outside a `batch`, one undo step when it records.
+     * One the old editor 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 — Puck needed a
-     * new `key` on `<Puck>` for that, which threw away every subscriber's state.
+     * 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.
      * 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 `<Puck>` did when it
+     * Run every block's `resolveData` over the document, as `the old editor root` 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 (Puck made it one, which undid back to the stale
-     * document). `onChange` hears it, as Puck's did. `EaselProvider` runs this
+     * 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
      * 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 Puck's own insert ran: a block dropped from its component list
+     * It is what the old editor'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 — Puck's reducer was pure, and so is this one —
+     * `insert` ACTION never did — the old editor'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 (Puck made the resolver's write a second
+     * ONE undo step with the insert (the old editor 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 —
-     *  Puck kept one per editor, shared by every write that resolves. */
+     *  The old editor kept one per editor, shared by every write that resolves. */
     readonly resolveCache: ResolveCache;
     /**
-     * Swap the config in place — `<Puck>` took a new `config` prop live. The
+     * Swap the config in place — `the old editor root` 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 `<Puck>` finds them where they were.
+ * a host moving off `the old editor root` 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 Puck's actions, Puck's history and a `batch` Puck
+ * the host's UI keys, with the old editor's actions, the old editor's history and a `batch` the old editor
  * 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 Puck, so the apps' `dispatch` calls move
+ * Each action means what it meant to the old editor, 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. Puck held `itemSelector` — a place — so a node
+ *   - THE SELECTION IS BY ID. The old editor 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 Puck had no
+ *   - A SLOT CAN BE SELECTED (a column): `ui.selectedSlot`, which the old editor had no
  *     way to say.
  */
-/** Whether Puck records an action in history when the action does not say:
+/** Whether the old editor 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 Puck shows it: the host's keys, with the selection translated. */
+/** The UI as the old editor 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,22 +223,22 @@ interface EaselProviderProps {
      * `edit` permission is off (`bindUndoKeys`).
      */
     hotkeys?: boolean;
-    /** Run every block's `resolveData` once the easel mounts, as `<Puck>` did
+    /** Run every block's `resolveData` once the easel mounts, as `the old editor root` did
      *  (`easel.resolveAll`). On by default. */
     resolveOnMount?: boolean;
     children?: ReactNode;
 }
-/** Puts one easel in reach of everything under it — `<Puck>`'s provider
- *  half — and, as `<Puck>` did, binds undo / redo to the page's keyboard
+/** 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
  *  (`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;
 /** The easel itself, for handlers that read the state at the moment they run
- *  (`useGetPuck`'s job) and for `dispatch` / `batch` / `select`. */
+ *  (`the old store getter`'s job) and for `dispatch` / `batch` / `select`. */
 declare function useEaselApi<C extends EaselConfig = EaselConfig>(): Easel<C>;
 /**
- * Read a slice of the easel and re-render when it changes — `usePuck` /
- * `createUsePuck()`'s selector form, over the same state shape, so the apps'
+ * Read a slice of the easel and re-render when it changes — the old store hook /
+ * `the old selector hook`'s selector form, over the same state shape, so the apps'
  * selectors move over by renaming the hook.
  *
  * A selector may return a fresh object; the snapshot is cached per state and
@@ -247,12 +247,12 @@ declare function useEaselApi<C extends EaselConfig = EaselConfig>(): Easel<C>;
  */
 declare function useEasel<T, C extends EaselConfig = EaselConfig>(selector: (view: EaselView<C>) => T): T;
 /**
- * A typed `useEasel` for one config — `createUsePuck<Config>()`'s shape, so
+ * A typed `useEasel` for one config — `the old selector hook`'s shape, so
  * a file that made its own typed hook keeps the one line that made it.
  */
 declare function createUseEasel<C extends EaselConfig = EaselConfig>(): <T>(selector: (view: EaselView<C>) => T) => T;
 
-/** What a slot component accepts — Puck's. */
+/** What a slot component accepts — the old editor'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, Puck's): the frame is as tall as its content, and
+     * `'auto'` (the default, the old editor'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. Puck's frame was a
+ * is rewritten with one before anything is drawn. The old editor'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
@@ -329,7 +329,7 @@ declare function CanvasFrame({ children, id, title, className, style, mirrorStyl
 /**
  * The whole document, for editing. Works in a `CanvasFrame` or on its own.
  *
- * `metadata` is the easel-wide metadata: the root's `puck.metadata`, and —
+ * `metadata` is the easel-wide metadata: the root's `editor.metadata`, and —
  * under each block's own — every block's (see the header).
  */
 declare function EditDocument({ metadata }: {
@@ -381,7 +381,7 @@ interface CanvasParts {
     select(partId: string | null): void;
 }
 declare const CanvasPartsContext: react.Context<CanvasParts | undefined>;
-/** What a host may wrap an outline in — Puck's `componentOverlay`: render
+/** What a host may wrap an outline in — the old editor's `componentOverlay`: render
  *  `children` to draw it, or nothing to hide it (a text part open on the
  *  block, say). */
 type CanvasOverlay = ComponentType<{
@@ -459,7 +459,7 @@ interface EaselCanvasProps {
     style?: CSSProperties;
     /**
      * The easel-wide metadata — what the published page passes `Render` as
-     * `metadata`. Every block reads it as `puck.metadata` (its own `metadata`
+     * `metadata`. Every block reads it as `editor.metadata` (its own `metadata`
      * laid over it) and the root as it is. Change it whenever the host's data
      * changes: the blocks redraw in place, nothing remounts, and it never enters
      * the document or the undo history.
@@ -467,7 +467,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, Puck's), or filling its parent. */
+    /** The frame's height: as tall as its content (default, the old editor's), or filling its parent. */
     height?: 'auto' | 'fill';
     /**
      * The frame's accessible name — an iframe with none is announced as "frame".
@@ -490,14 +490,14 @@ interface EaselCanvasProps {
     onDocument?: (doc: Document | null) => void;
     /**
      * Wraps everything drawn in the frame, and is handed the frame's document —
-     * Puck's `overrides.iframe`: where a host syncs its theme onto the frame's
+     * The old editor'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 — Puck's `componentOverlay`; see `CanvasOverlay`. */
+    /** Wraps each outline — the old editor's `componentOverlay`; see `CanvasOverlay`. */
     overlay?: CanvasOverlay;
     /** Drawn inside the frame, after the document — a host's canvas-only layer. */
     children?: ReactNode;
@@ -515,7 +515,7 @@ interface EaselCanvasProps {
     passThrough?: PassThrough;
 }
 /**
- * `<Puck.Preview>`, ours: the document for editing, its outlines, and the
+ * `the old editor'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 +524,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 Puck. Until now each app wrote that host twice, once per
- * editor, against Puck's store: `EmailFields` and `SiteFields` for the settings
+ * — 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
  * 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 +551,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 Puck resolved them (`resolveFields` with Puck's params, parent included). */
+    /** Its fields, resolved as the old editor resolved them (`resolveFields` with the old editor'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 Puck ran it, then ONE replace — one undo step. */
+    /** Write one field: `resolveData` as the old editor 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 +570,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 Puck,
+ * changes one — what `EmailFields` and `SiteFields` each did against the old editor,
  * here once:
- *   - fields resolve through `useResolvedFields` (Puck's
+ *   - fields resolve through `useResolvedFields` (the old editor's
  *     `useRegisterFieldsSlice`: `changed`, `lastFields`, `appState`, `parent`);
- *   - a change runs the block's `resolveData` (`resolveNodeData`, Puck's
+ *   - a change runs the block's `resolveData` (`resolveNodeData`, the old editor's
  *     `resolveComponentData`, with this easel's own memory of the last
  *     change) and then writes ONE `replace` of the node, or ONE `replaceRoot`.
  *
@@ -585,14 +585,14 @@ interface SelectedFields {
 declare function useSelectedFields(): SelectedFields;
 
 /**
- * UNDO AND REDO ON THE KEYBOARD — Puck's own six bindings, which both editors
+ * UNDO AND REDO ON THE KEYBOARD — the old editor'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 Puck read it), so
+ * Exact combinations, read off the physical key (`code`, as the old editor read it), so
  * a layout that moves Z still undoes and ⌥⌘Z does nothing.
  *
- * ⚠️ PUCK FIRED THESE IN A TEXT FIELD TOO, and so does this: ⌘Z while typing
+ * ⚠️ THE OLD EDITOR 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,7 +617,7 @@ 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 Puck's did.
+ * left out, a press in a field undoes the easel's step, as the old editor's did.
  */
 declare function bindUndoKeys(doc: Document, easel: Pick<Easel, 'undo' | 'redo'> & Partial<Pick<Easel, 'getState'>>, options?: {
     leaveTyping?: boolean;

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-TUXLORVR.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-4FD7TAOE.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,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";

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 Puck's `permissions` prop carries for the canvas. */
+/** The five capabilities the old editor's `permissions` prop carries for the canvas. */
 type DocumentPermissions = {
     edit: boolean;
     insert: boolean;
@@ -151,13 +151,13 @@ type DocumentPermissions = {
     drag: boolean;
 };
 /**
- * The canvas's Puck `permissions`, derived from the write gate.
+ * The canvas's the old editor `permissions`, derived from the write gate.
  *
  * BOTH branches name ALL FIVE keys — and that completeness is the whole point,
- * not tidiness. Puck does not replace this prop when it changes; it MERGES it
+ * not tidiness. The old editor 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`. Puck mounts
+ * and a field's editability is the live `getPermissions().edit`. The old editor 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 Puck's flaky cross-iframe canvas drag is always off.
+ * rails of their own, so the old editor'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 Puck
+ * and no spacing between groups. What it adds is what a row HOLDS where the old editor
  * 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