efficient-easel 21.0.0 → 21.1.0

package/dist/screen/lib/document/use-section-ops.d.ts

@@ -0,0 +1,110 @@
+import { N as NodeSelection } from '../../../plan-CZS902DV.js';
+import { Data } from '../../../blocks/index.js';
+import { TreeItem } from './content-tree.js';
+import '../../../types-41704JE4.js';
+import 'react';
+import '../../../types-Cq53lL8d.js';
+import '../../../data/index.js';
+import '../../../resolve-D68pb3Bx.js';
+
+type NodeSelector = {
+    index: number;
+    zone?: string;
+} | null;
+type ComponentData = TreeItem;
+type SectionOps = {
+    /** Insert a component into a zone at an index; returns the generated id. */
+    insertComponent: (zone: string, type: string, index: number) => string;
+    /** Insert into ROOT_ZONE (top-level section); returns the generated id. */
+    insertSection: (type: string, index: number) => string;
+    /** Atomically replace the node at (zone, index) — heal, reseed, hide toggle. */
+    replaceComponent: (zone: string, index: number, data: ComponentData) => void;
+    /** Seed a freshly-inserted slot child's props (insert THEN replace at a stable id). */
+    seedChild: (zone: string, index: number, childType: string, props: Record<string, unknown>) => void;
+    /**
+     * Insert a FULL node — type + props, including inline slot children — at
+     * (zone, index); returns its id. The same insert-then-replace pattern as
+     * seedChild, one level up: how a saved section template lands in a page.
+     * Callers pass a node whose ids are already fresh (cloneNodeWithFreshIds).
+     */
+    insertNode: (zone: string, index: number, node: TreeItem) => string;
+    /** Remove the node at (zone, index). A normal dispatch, so Undo restores it. */
+    removeComponent: (zone: string, index: number) => void;
+    /**
+     * Move the node at (zone, sourceIndex) to destinationIndex WITHIN THE SAME
+     * zone. `destinationIndex` is the node's final resting index in the array
+     * (Puck's `reorder` reducer splices it out then back in), so a caller moving a
+     * node DOWN must account for the one-slot shift itself.
+     */
+    reorderComponent: (zone: string, sourceIndex: number, destinationIndex: number) => void;
+    /** Duplicate the node at (zone, index). */
+    duplicateComponent: (zone: string, index: number) => void;
+    /** Set (or clear) the Puck selection by index-based address. */
+    select: (selector: NodeSelector) => void;
+    /** Replace the whole working document (used by Reset). */
+    setDocument: (data: Data) => void;
+    /**
+     * Write the next document, and what to select in it, as ONE undo step — the
+     * commit behind the block operations (`efficient-easel/node-ops`, blueprint
+     * step 2.4b: the menu's Delete, Duplicate, Move, Copy / Cut / Paste and Hide,
+     * and the rows' hover-delete). Each of those is planned whole and lands here
+     * once, instead of the two or three dispatches it used to be.
+     *
+     * `select` is BY ID, in `data` (`undefined` leaves the selection as it is),
+     * and goes in with the document through the store's `run` (0.105.1). Until
+     * then the chrome selected first, by position (`setUi { itemSelector }`),
+     * which the store reads in the document it still holds: a paste or a
+     * Duplicate selected the node after its copy, and a Move the node it passed.
+     * Behind the read-only gate like every other mutation here.
+     */
+    commitDocument: (data: Data, select?: NodeSelection) => void;
+};
+type SectionOpsOptions = {
+    /**
+     * SOMEBODY ELSE holds the open document: every MUTATION below becomes a no-op.
+     *
+     * This is the one place the editor's read-only state is enforced on the
+     * document, and it is here rather than on each button because this hook is
+     * already the single source of truth for every mutation — the tree rows, the
+     * canvas "+" seams, the inspector head buttons and the lifecycle effects all
+     * come through it. A gate on the buttons would be a gate on the ones somebody
+     * remembered.
+     *
+     * `select` and `setUi` are NOT mutations and stay live: a read-only viewer must
+     * still be able to click a section and read its settings.
+     *
+     * Deliberately keyed on "somebody else has it" and NOT on the wider save gate.
+     * The save gate is also false while the lock claim is still `checking`, and the
+     * pinned Header/Footer seed runs in the chrome's mount commit, inside that
+     * window, through these very ops. Its WRITE is what is held there — by
+     * `onChange`, released by the claim if it is granted — so the seed must be
+     * allowed to lay the node down (card 1096). Blocking it here would silently
+     * un-fix that card.
+     */
+    readOnly?: boolean;
+    /**
+     * Resolve each node an op puts in (`easel.resolveNode`, trigger `"insert"`).
+     * Default: the layer's rule (`ScreenBlockRules.resolveOnInsert`), else
+     * false — no op resolves anything, as before 0.103.0.
+     */
+    resolveOnInsert?: boolean;
+    /**
+     * NOT AN UNDO STEP: every write is folded into the history entry it happens
+     * in (the store's `recordHistory: false`), as the store folds a resolver's
+     * write (`resolveAll`), instead of being recorded as a step of its own.
+     *
+     * For the passes the screen runs over a document AS IT OPENS — the slot
+     * seeding, the duplicate-id heal, and the layer's own pass (the website's
+     * pinned Header and Footer). Recorded, each was the first entry of the
+     * history: Undo was offered the moment the page opened, and ONE press took
+     * the seeded slides and cards (or the Header) back out of the page, which
+     * autosave then wrote (1.0.1). Folded, the document opens as the history's
+     * first entry; a pass that runs after an edit (a section just inserted,
+     * seeded) lands in that edit's step, so one Undo takes both out together.
+     * Autosave still hears every write (the store's `onChange` fires on a fold).
+     */
+    foldIntoHistory?: boolean;
+};
+declare function useSectionOps(options?: SectionOpsOptions): SectionOps;
+
+export { type NodeSelector, type SectionOps, type SectionOpsOptions, useSectionOps };

package/dist/screen/lib/document/use-section-ops.js

@@ -0,0 +1 @@
+export{useSectionOps}from"../../../chunk-MLQKNED6.js";import"../../../chunk-OHZHYROJ.js";import"../../../chunk-PRHBWA5V.js";import"../../../chunk-FHCKFOCD.js";import"../../../chunk-MQA7OFRA.js";import"../../../chunk-TCAAOYQY.js";import"../../../chunk-TUXLORVR.js";import"../../../chunk-TBY3DFKS.js";import"../../../chunk-PFFH7ASD.js";import"../../../chunk-BPXEFVSQ.js";import"../../../chunk-ZEH6QLBH.js";import"../../../chunk-FM6JO4WF.js";import"../../../chunk-KFV7N2DJ.js";import"../../../chunk-WHS6Y55E.js";import"../../../chunk-K56YDHYQ.js";import"../../../chunk-IWCKVZHS.js";import"../../../chunk-FIVU2COQ.js";import"../../../chunk-BSHIQIZC.js";import"../../../chunk-MZ5GSSZ3.js";import"../../../chunk-KRL3IUV3.js";import"../../../chunk-Y2T3JX7K.js";import"../../../chunk-KFWNGPW3.js";import"../../../chunk-S3DUFDQ6.js";import"../../../chunk-JACEEVVF.js";import"../../../chunk-MFIRYGHW.js";import"../../../chunk-3S5N4HLJ.js";import"../../../chunk-P2VEMZH5.js";import"../../../chunk-4FD7TAOE.js";import"../../../chunk-LF3FUSCQ.js";import"../../../chunk-K7BTCBWD.js";import"../../../chunk-L55YIXDC.js";

package/dist/screen/lib/document-addressing.d.ts

@@ -1,4 +1,4 @@
-export { A as AnyDocumentAddressing, a as DocumentAddressing, N as NO_DOCUMENT_ADDRESSING } from '../../ScreenDocumentContext-CFJeqqKk.js';
+export { A as AnyDocumentAddressing, a as DocumentAddressing, N as NO_DOCUMENT_ADDRESSING } from '../../ScreenDocumentContext-1RgtGKWR.js';
 import './document-contract.js';
 import './session.js';
 import 'react';
@@ -18,5 +18,5 @@ import './links/link-filters.js';
 import 'efficient-shell/ui';
 import './document-hooks.js';
 import './section-template-types.js';
-import './puck/content-tree.js';
+import './document/content-tree.js';
 import './shared-section-types.js';

package/dist/screen/lib/document-switch.d.ts

@@ -9,7 +9,7 @@ import { EditAccess } from '../../edit-lock/index.js';
  * read off the autosave's state, and a set of per-document facts (the pending
  * edit, the version token, a refused save, the lock) that are true of the
  * document being left and of no other. They were written beside the website's
- * pinned-chrome seed, which defers on that status (lib/puck/pinned-seed-gate —
+ * pinned-chrome seed, which defers on that status (lib/document/pinned-seed-gate —
  * the account of why the two must not drift is there, and that module still
  * hands these on), and are here because the document provider reads them and
  * holds no website.

package/dist/screen/lib/host.d.ts

@@ -1,5 +1,5 @@
 import 'react';
-export { D as DETACHED_EASEL_HOST, E as EaselBlockType, b as EaselFieldDescription, c as EaselHost, d as EaselHostAddress, e as EaselHostContext, f as EaselHostPanels, g as EaselHostProvider, h as EaselMessageType, i as EaselSelection, j as EaselToHostMessage, H as HostPickedMedia, k as HostToEaselMessage, I as InboundHostMessage, P as PageEditOp, l as PickedMediaSource, S as SectionScreenTarget, m as SendToHost, n as createEaselHost, u as useEaselHost, o as useHostEscape } from '../../ScreenDocumentContext-CFJeqqKk.js';
+export { D as DETACHED_EASEL_HOST, E as EaselBlockType, b as EaselFieldDescription, c as EaselHost, d as EaselHostAddress, e as EaselHostContext, f as EaselHostPanels, g as EaselHostProvider, h as EaselMessageType, i as EaselSelection, j as EaselToHostMessage, H as HostPickedMedia, k as HostToEaselMessage, I as InboundHostMessage, P as PageEditOp, l as PickedMediaSource, S as SectionScreenTarget, m as SendToHost, n as createEaselHost, u as useEaselHost, o as useHostEscape } from '../../ScreenDocumentContext-1RgtGKWR.js';
 import '../../blocks/index.js';
 import '../../types-Cq53lL8d.js';
 import '../../data/index.js';
@@ -18,5 +18,5 @@ import './links/link-filters.js';
 import 'efficient-shell/ui';
 import './document-hooks.js';
 import './section-template-types.js';
-import './puck/content-tree.js';
+import './document/content-tree.js';
 import './shared-section-types.js';

package/dist/screen/lib/key-scope.d.ts

@@ -1,5 +1,5 @@
 import { RefObject } from 'react';
-import { C as CanvasTarget } from '../../watch-BTYOJpQU.js';
+import { C as CanvasTarget } from '../../watch-D8xZow3y.js';
 
 /**
  * Where the editor listens for its page-wide shortcuts — undo / redo, copy and

package/dist/screen/lib/key-scope.js

@@ -1 +1 @@
-export{editorRootFocus,isSaveShortcut,useEaselKeyTarget,useEaselSaveKey,useEaselUndoKeys}from"../../chunk-HGCGIRVA.js";import"../../chunk-MQA7OFRA.js";import"../../chunk-7L3NKHEC.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-K7BTCBWD.js";import"../../chunk-L55YIXDC.js";import"../../chunk-QIDRJH3S.js";import"../../chunk-LF3FUSCQ.js";
+export{editorRootFocus,isSaveShortcut,useEaselKeyTarget,useEaselSaveKey,useEaselUndoKeys}from"../../chunk-DNQ7AF6K.js";import"../../chunk-MQA7OFRA.js";import"../../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";

package/dist/screen/lib/media-panel.d.ts

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { ComponentType, ReactNode } from 'react';
-import { H as HostPickedMedia, c as EaselHost } from '../../ScreenDocumentContext-CFJeqqKk.js';
+import { H as HostPickedMedia, c as EaselHost } from '../../ScreenDocumentContext-1RgtGKWR.js';
 import '../../blocks/index.js';
 import '../../types-Cq53lL8d.js';
 import '../../data/index.js';
@@ -19,7 +19,7 @@ import './links/link-filters.js';
 import 'efficient-shell/ui';
 import './document-hooks.js';
 import './section-template-types.js';
-import './puck/content-tree.js';
+import './document/content-tree.js';
 import './shared-section-types.js';
 
 /**

package/dist/screen/lib/media-picker.d.ts

@@ -1,4 +1,4 @@
-import { H as HostPickedMedia, c as EaselHost } from '../../ScreenDocumentContext-CFJeqqKk.js';
+import { H as HostPickedMedia, c as EaselHost } from '../../ScreenDocumentContext-1RgtGKWR.js';
 import 'react';
 import '../../blocks/index.js';
 import '../../types-Cq53lL8d.js';
@@ -18,7 +18,7 @@ import './links/link-filters.js';
 import 'efficient-shell/ui';
 import './document-hooks.js';
 import './section-template-types.js';
-import './puck/content-tree.js';
+import './document/content-tree.js';
 import './shared-section-types.js';
 
 /**

package/dist/screen/lib/page-lock.d.ts

@@ -14,7 +14,7 @@ import 'efficient-shell/ui';
 import './document-contract.js';
 import './document-hooks.js';
 import './section-template-types.js';
-import './puck/content-tree.js';
+import './document/content-tree.js';
 import './shared-section-types.js';
 
 /**

package/dist/screen/lib/puck/add-target-types.d.ts

@@ -1,55 +1,3 @@
-import { BlockChoice } from './block-choice.js';
-import { SlotSectionSpec } from './slot-section-spec.js';
-
-/** Which registry answered — the discriminator three of the four decisions read. */
-type AddTargetSource = "section" | "footer" | "container";
-/**
- * What a parent can take, and everything the four decisions below need to act on
- * it.
- *
- * ⚠️ THE LOOKUP DECIDES FOUR THINGS, NOT ONE. Wiring only the choice list ships
- * a menu with wrong row names, wrong handlers, and unreachable on an empty
- * container — which is why this returns a record rather than a list:
- *
- *   1  the CHOICE LIST — {@link AddTarget.choices}, what the Add menu offers, or
- *      `null` where the parent adds ONE child type from a button instead.
- *   2  the ROW NAME    — `rowNamerFor` (components/SlotChildRows) reads
- *      {@link AddTarget.source} to pick the FOOTER's block-label rule over
- *      lib/puck/slot-child-name.ts. It must ask "is this a FOOTER block", NOT
- *      "does this parent use a menu": a Box adds from a menu too and
- *      keeps the slot-child rule, or its Headings, Texts and Buttons all fall
- *      through to a rule that reads a heading, a bound menu and first-words.
- *   3  WHICH HANDLERS  — SectionScreenShell's adapter reads `source` to choose
- *      which pair of host handlers a row presses. Keyed the other way round it
- *      answered null for a Box, whose rows then pressed and did nothing.
- *   4  REACHABILITY    — `Boolean(canAddTo(type))` feeds `nestState`, and a row
- *      folds open only if it has children OR an add affordance. An EMPTY
- *      container with no caret cannot be opened to reach its own menu — and
- *      empty is exactly the state a merchant is in when adding the first block.
- */
-interface AddTarget {
-    /** Which of the three registries answered. */
-    source: AddTargetSource;
-    /**
-     * The slot this parent keeps its children on.
-     *
-     * RETURNED rather than defaulted, so a caller can never reach it by falling
-     * through another mechanism's constant — the rule container-blocks states for
-     * its own lookup, kept here because this is now the one that is asked. A Flex
-     * listed on the Footer's `blocks` would draw its rows off `undefined`.
-     */
-    slot: string;
-    /** The registry's own choice list, or `null` for a single-type "Add …" button. */
-    choices: BlockChoice[] | null;
-    /**
-     * The section's own spec — its `addLabel`, `childType`, `seeds`, `addBlocked`,
-     * `notice` and `slider`. Non-null exactly when `source === "section"`.
-     *
-     * Carried so a caller that needs a section's own arithmetic (the Hero slide's
-     * anchor cap, the seed-on-load effect) reaches it through this one seam rather
-     * than importing the registry beside it and gaining a second opinion.
-     */
-    spec: SlotSectionSpec | null;
-}
-
-export type { AddTarget, AddTargetSource };
+export { AddTarget, AddTargetSource } from '../document/add-target-types.js';
+import '../document/block-choice.js';
+import '../document/slot-section-spec.js';

package/dist/screen/lib/puck/add-target-types.js

@@ -0,0 +1 @@
+import"../../../chunk-YIUE4US7.js";

package/dist/screen/lib/puck/block-choice.d.ts

@@ -1,64 +1 @@
-/**
- * One row of an "Add block" menu.
- *
- * `group` is OPTIONAL and is the menu's own heading, not a property of the
- * block: the same `ImageBlock` is grouped in a Box's menu and ungrouped in a
- * Slide box's, because grouping is a fact about the LIST a merchant is reading,
- * not about the component. A list whose choices carry no group renders flat, so
- * every menu that shipped before this stays exactly as it was.
- *
- * It is set at BUILD time by whichever module assembles the list, from the
- * source each choice came from — never hand-written per row. See
- * `lib/puck/container-blocks.ts`, which is the only assembler that sets one.
- */
-type BlockChoice = {
-    type: string;
-    label: string;
-    group?: string;
-    /**
-     * RETIRED: Add does not offer it, and a node of it already in a slot still
-     * belongs there (card [MERGE] One Text Block And Click Through Parts). The
-     * website's Heading and Eyebrow blocks: the Text block took their job, so
-     * nobody starts a new one, and every stored one still draws, edits, moves
-     * and pastes. Read through {@link offeredChoices} wherever a list is shown
-     * to ADD from; the whole list is still the slot's answer to "does this slot
-     * take it?", so a move or a paste reads it unfiltered.
-     */
-    retired?: boolean;
-};
-/** The choices Add offers: every one that is not {@link BlockChoice.retired}, in order. */
-declare function offeredChoices<C extends BlockChoice>(choices: readonly C[]): C[];
-/**
- * One run of consecutive choices sharing a `group` — what a menu draws under one
- * heading.
- *
- * ⚠️ ONE FUNCTION, BOTH SURFACES, and that is the whole reason it is a function.
- * A Box's menu is drawn twice — the dropdown in `components/AddBlockRow`
- * (reached from the Layers tree and from the box's own settings panel) and the
- * chip row at the top of the Add panel (`components/AddSectionPanel`). They draw
- * ONE list, so "where does a heading start" must be ONE answer; two `map`s each
- * comparing with the previous item is how the two surfaces begin dividing the
- * same list differently. That is the exact defect `lib/puck/add-target.ts`'s
- * docblock is an essay about, one tier down.
- *
- * ⚠️ AND THE MENU'S CLASS NAME IS DELIBERATELY NOT WRITTEN IN THIS FILE.
- * `test-footer-block-lists` §8 counts the files mentioning it to prove the menu
- * has exactly ONE home, and it reads prose the same way it reads code — naming
- * the class in a comment here makes this module look like a second menu. The
- * markup lives in `components/AddBlockRow`; this is only the arithmetic.
- *
- * It preserves ORDER and never sorts: the list arrives in the order its assembler
- * chose (`lib/puck/container-blocks.ts` says why that order is what it is), and a
- * renderer is not the place to have a second opinion about it.
- *
- * A list whose choices carry NO group comes back as a single run with
- * `group: undefined` — so a caller written for runs draws an ungrouped list
- * exactly the way it drew it before groups existed, with no branch of its own.
- */
-type BlockChoiceRun = {
-    group?: string;
-    items: BlockChoice[];
-};
-declare function blockRuns(choices: BlockChoice[]): BlockChoiceRun[];
-
-export { type BlockChoice, type BlockChoiceRun, blockRuns, offeredChoices };
+export { BlockChoice, BlockChoiceRun, blockRuns, offeredChoices } from '../document/block-choice.js';

package/dist/screen/lib/puck/block-choice.js

@@ -1 +1 @@
-export{blockRuns,offeredChoices}from"../../../chunk-M2Z775ZC.js";
+export{blockRuns,offeredChoices}from"../../../chunk-RUQOIQWI.js";

package/dist/screen/lib/puck/block-types-in.d.ts

@@ -1,39 +1 @@
-/**
- * Every block type a saved layout uses — the top-level sections and whatever
- * sits in their slots, to any depth.
- *
- * WHAT IT IS FOR. A host chooses which blocks its editor offers
- * (`WebsiteEditor`'s `blocks`), and that choice hides them in the palette, the
- * slot menus and the drop targets. It is not a boundary: a saved page is a JSON
- * document, and whoever can call the host's save endpoint can send one holding
- * any type. So the host's SERVER reads the layout it was handed with this, and
- * refuses a type it does not allow.
- *
- * READ BY SHAPE, WITH NO REGISTRY. A node is `{ type: string, props: {…} }`,
- * and a slot is an array of nodes kept on a prop of its parent — directly, or
- * inside an object or a list item. This walks every value under `props` and
- * takes each array item of that shape as a node. It asks no block registry which
- * props are slots, because the caller is a server that must not have to load
- * one: this module imports nothing.
- *
- * That makes it wider than the editor's own walk in one direction only: a prop
- * that merely LOOKS like a node (an object with a string `type` and an object
- * `props`, inside an array) is counted. It does not ask for the `id` the engine
- * gives every node, because the renderer draws a node without one and a request
- * written by hand can leave it out. Wider is the safe side for an allow-list —
- * it can refuse a page it might have accepted, never accept one it should have
- * refused.
- *
- * `zones` — the engine's older place for slot children, which this editor has
- * never written — is walked too, so a document from elsewhere hides nothing
- * there.
- */
-/**
- * The block types in `layout`, each once, sorted. `layout` is the page document
- * a `WebsiteBackend` stores (`PageLayout`: `content`, `root`, `zones`); a single
- * node — a section template's — is read the same way. Anything else answers
- * an empty list: it holds no block.
- */
-declare function blockTypesIn(layout: unknown): string[];
-
-export { blockTypesIn };
+export { blockTypesIn } from '../document/block-types-in.js';

package/dist/screen/lib/puck/block-types-in.js

@@ -1 +1 @@
-export{blockTypesIn}from"../../../chunk-5ZBY24K7.js";
+export{blockTypesIn}from"../../../chunk-CPL43ZLJ.js";

package/dist/screen/lib/puck/content-tree.d.ts

@@ -1,222 +1 @@
-type TreeItem = {
-    type: string;
-    props: {
-        id: string;
-        [key: string]: unknown;
-    };
-};
-type SlotConfigView = {
-    components?: Record<string, unknown>;
-};
-/**
- * Which of a component type's props are SLOTS — the prop names that hold child
- * Blocks, read off the config's field map.
- *
- * Puck 0.20 stores slot children INLINE on the parent's props
- * (`props.<slotName> = [{type,props}, …]`), NOT in `data.zones` — so a walker
- * that wants a section's children has to know which prop names to look under.
- * That set is per-component and lives in exactly one place, `config.components`:
- * `Grid`/`Flex` call theirs `content`, but `Hero` calls it `slides`,
- * `Collections` `cards`, `GalleryB` `items`, `ProductGrid` `products` and
- * `Footer`/`FooterGroup` `blocks`.
- *
- * This is the ONE reader of that set. Hard-coding `"content"` instead is how the
- * heading/SEO audit came to be blind to every heading nested in a Hero slide
- * (card 66067): the walker recursed on a prop name only two of the eight slots
- * happen to use, so a page with two H1s reported as fine. A type the config does
- * not know has no slots — and cannot render either, so there is nothing to walk.
- */
-declare function slotFieldsOf(config: SlotConfigView, type: string): string[];
-/**
- * What a component type's config ALLOWS of the two actions that make another
- * node or take one away (0.103.0): its `permissions.duplicate` and
- * `permissions.delete`, each true unless the config says false — the reading
- * Puck gave a config that carried none. The campaign designer's Product keeps
- * its Price line this way (`{ delete: false, duplicate: false }`).
- *
- * The screen's tree rows, its menu and the inspector head it hands this to
- * (`ScreenInspectorPanelProps.nodeActions`) all ask HERE, so the three cannot
- * come to disagree about one block. Only the config's own, never the
- * easel-wide permissions the edit lock sets: a document somebody else holds is
- * refused at the writes, as it always was, and draws the rows it drew.
- *
- * A type the config does not know allows both, as one with no `permissions`.
- */
-declare function blockNodeActions(config: SlotConfigView, type: string): {
-    duplicate: boolean;
-    delete: boolean;
-};
-/**
- * A slot child, addressed the way the Layers tree selects it: the node, the
- * compound zone key "<parentId>:<slotName>" Puck's ops take, and its index in
- * that slot.
- */
-type SlotChild = {
-    child: TreeItem;
-    zone: string;
-    index: number;
-};
-/**
- * Every slot child of `item`, across EVERY slot field its type declares — so a
- * type with two slots reports both, and nesting is general: the result's `child`
- * is itself an item this function accepts.
- *
- * Puck 0.20 stores slot children INLINE on the parent's props, so this reads the
- * arrays rather than `data.zones` (which stays empty for slots).
- */
-declare function childSlotsOf(config: SlotConfigView, item: TreeItem): SlotChild[];
-/**
- * The children of ONE slot of `item`, addressed as {@link childSlotsOf}
- * addresses them (0.105.0): what the Layers tree draws under a slot it draws
- * as a row of its own (`ScreenBlockRules.slotsOf`). A slot the node holds
- * nothing in, or no array in, has none.
- */
-declare function slotChildrenIn(item: TreeItem, slot: string): SlotChild[];
-/**
- * WHERE a node sits in the document — the node itself, the zone key its own
- * array is addressed by, and its index in that array. Exactly the three
- * arguments a Puck `replace` / `remove` / `reorder` op takes.
- */
-type NodeLocation = {
-    item: TreeItem;
-    zone: string;
-    index: number;
-};
-/**
- * Find a node by id and say WHERE IT IS, anywhere in the document — the root
- * list or any slot at any depth.
- *
- * ── WHY A PANEL NEEDS THIS ──────────────────────────────────────────────────
- * `useEasel((s) => s)` hands a field the SELECTED node and, in `ui.itemSelector`, the
- * zone and index of that node. A control that has to rewrite the node's PARENT
- * — "Apply to all cards" writes the whole Collections node once, so one press is
- * one undo step — gets only half of what it needs: the selector's zone is the
- * compound `"<parentId>:cards"`, which names the parent but says nothing about
- * where the PARENT itself lives. Without that, the write has nowhere to go.
- *
- * ⚠️ IT IS NOT `enclosingSectionProps`, AND THE DIFFERENCE IS NOT COSMETIC.
- * That one answers "which TOP-LEVEL section is this inside", returns props, and
- * deliberately returns `null` for the immediate parent when the parent is not a
- * root section. This one answers "where is THIS node", returns an address, and
- * is happy to name a node nested inside a Box inside a Box. Its own docblock
- * asks for a third question to be a third function rather than a third shape
- * returned by the same walker; this is that function.
- *
- * ⚠️ AND IT IS NOT `childSlotsOf` WITH A FILTER. That lists one node's children;
- * this searches a whole document. It is BUILT on `childSlotsOf` so the set of
- * slot prop names stays read in exactly one place — hard-coding `"content"`
- * instead is how the heading audit went blind to every heading nested in a Hero
- * slide (card 66067), and the reason is written out on `slotFieldsOf`.
- *
- * ⚠️ THE CHROME ALREADY ANSWERS THIS, AND THAT IS NOT A DUPLICATE OF THIS.
- * `ScreenChrome` memoises a Map of EVERY node's address (plus each
- * zone's whole sibling list) and hands the lookup to the context menu as
- * `locate`. That map is built once per document for a surface that needs all of
- * it; this finds ONE node and is reachable from a Puck field, which the map is
- * not — it lives in a component's closure and rides no context. What must not
- * be two things is the set of SLOT PROP NAMES, and it is not: both walk through
- * `childSlotsOf`, so an address here and an address there cannot disagree.
- * Puck's own `getSelectorForId` is a third reader of the same fact, and the one
- * a live store already offers — it is a hook-bound function, so a guard cannot
- * call it, which is the whole reason this one is written pure.
- *
- * PURE, and takes the config as an argument, so a guard can assert against it
- * without a Puck store, a React tree or a hook.
- *
- * `null` when no node carries the id — the honest answer for a stale selection,
- * and every caller treats it as "there is nothing to write".
- */
-declare function locateNode(config: SlotConfigView, content: ReadonlyArray<TreeItem>, id: string): NodeLocation | null;
-/**
- * How many levels of slot children the Layers tree draws below a top-level row.
- *
- * The tree is a ~288px panel that already scrolls and each level costs 10px of
- * indent (`.sf-subtree`'s `padding-left`, storefront-editor.css — it was 25px
- * until card 66199 took the drag grip out of the flow and moved the caret to the
- * row's right end), so the depth is capped rather than unbounded: `Grid.content`
- * is an open slot that accepts a Grid, so a document CAN nest without limit and a
- * tree that followed it would run out of width.
- *
- * ⚠️ 3 SINCE CARD 66273, and the level it buys is the one a merchant was stuck
- * on. A hero group's blocks are the THIRD level — Hero → slide → group → blocks
- * — and at 2 a group row was a LEAF: no `.sf-subtree` was rendered under it, so
- * the "Add block" row that lives inside that subtree had nowhere to go, and a
- * merchant who made a group in the tree could not put anything into it. The
- * number was 2 because the Footer's chain (Footer → blocks → Group → blocks) was
- * the only one that existed when the cap was named; the hero's is one level
- * deeper.
- *
- * The Footer is unaffected, measured rather than hoped: `FooterGroup.blocks`
- * allows FooterText / FooterEmailSignup / FooterMenu / FooterDivider and none of
- * those owns a slot, so no footer row grows a third level. What DOES gain one is
- * a container nested inside a container (a Box in a Box) —
- * blocks a merchant can already build and could not see.
- */
-declare const TREE_MAX_DEPTH = 6;
-/**
- * Does the Layers tree draw a subtree under a node of `type` sitting at `depth`?
- * True only when the type owns at least one slot AND the level is inside the cap.
- * `depth` is 1 for a section's own children (the first `.sf-subtree`).
- *
- * The ONE place the cap is decided — both tree renderers and the "collapse all"
- * gather read it here, so a row that folds and a row that draws children can
- * never disagree about which rows those are.
- */
-declare function nestsInTree(config: SlotConfigView, type: string, depth: number): boolean;
-declare const newNodeId: (type: string) => string;
-declare const HEADER_TYPE = "Header";
-declare const FOOTER_TYPE = "Footer";
-declare const ROOT_ZONE = "root:default-zone";
-/**
- * Indices of the DUPLICATE pinned chrome sections in a top-level content array —
- * every Header/Footer node PAST the first of its type, in ascending order. Empty
- * when the array already holds at most one of each (the healthy case), so a caller
- * can skip the rewrite. Keeping the FIRST of each type matches exactly what the
- * Sections tree shows (footerIndex/findIndex), so healing never surprises the
- * author by dropping the copy they were looking at. Accepts a loose node shape so
- * both the editor's `TreeItem[]` and the published render's untyped content pass.
- */
-declare function pinnedDuplicateIndices(content: ReadonlyArray<{
-    type?: string;
-}>): number[];
-/**
- * Ids of the DUPLICATE pinned chrome sections — the id-anchored counterpart of
- * pinnedDuplicateIndices, derived FROM it so the two can never disagree about
- * which copy is the keeper (the first of each type).
- *
- * A LIVE store must be edited by identity, never by position: an index computed
- * from a render snapshot addresses whatever has since shifted into that slot,
- * which is how the old editor heal deleted real sections. Ids survive that skew
- * — the worst a stale read can do is name a node that is no longer there. A
- * duplicate carrying no id is skipped (it cannot be named in a remove); the
- * published render's index-based dedupe still drops it.
- */
-declare function pinnedDuplicateIds(content: ReadonlyArray<{
-    type?: string;
-    props?: {
-        id?: unknown;
-    };
-}>): string[];
-/**
- * Which pinned chrome types a document is MISSING, and a load-time seed must
- * therefore create. A type counts as missing only when it is absent from BOTH:
- *
- *   - `live` — the editor's Puck store, read at the moment of the write; and
- *   - `persisted` — the document exactly as it was LOADED from the backend.
- *
- * Requiring both is what makes seeding idempotent, and neither check can be
- * dropped. Trusting `live` alone was the duplicate-Header bug: a remount re-armed
- * the seed's per-mount guard while a snapshot that lagged the store reported "no
- * Header", so a second one was appended next to the first. Trusting `persisted`
- * alone would re-seed a node this session has already inserted but not yet saved.
- *
- * Returned in no particular order — the CALLER owns the insert order, because
- * only it knows that the Footer is pinned last and the Header first.
- */
-declare function missingPinnedTypes(live: ReadonlyArray<{
-    type?: string;
-}>, persisted: ReadonlyArray<{
-    type?: string;
-}>): string[];
-
-export { FOOTER_TYPE, HEADER_TYPE, type NodeLocation, ROOT_ZONE, type SlotChild, type SlotConfigView, TREE_MAX_DEPTH, type TreeItem, blockNodeActions, childSlotsOf, locateNode, missingPinnedTypes, nestsInTree, newNodeId, pinnedDuplicateIds, pinnedDuplicateIndices, slotChildrenIn, slotFieldsOf };
+export { FOOTER_TYPE, HEADER_TYPE, NodeLocation, ROOT_ZONE, SlotChild, SlotConfigView, TREE_MAX_DEPTH, TreeItem, blockNodeActions, childSlotsOf, locateNode, missingPinnedTypes, nestsInTree, newNodeId, pinnedDuplicateIds, pinnedDuplicateIndices, slotChildrenIn, slotFieldsOf } from '../document/content-tree.js';

package/dist/screen/lib/puck/content-tree.js

@@ -1 +1 @@
-export{FOOTER_TYPE,HEADER_TYPE,ROOT_ZONE,TREE_MAX_DEPTH,blockNodeActions,childSlotsOf,locateNode,missingPinnedTypes,nestsInTree,newNodeId,pinnedDuplicateIds,pinnedDuplicateIndices,slotChildrenIn,slotFieldsOf}from"../../../chunk-PLVEGYK6.js";
+import"../../../chunk-PRHBWA5V.js";export{FOOTER_TYPE,HEADER_TYPE,ROOT_ZONE,TREE_MAX_DEPTH,blockNodeActions,childSlotsOf,locateNode,missingPinnedTypes,nestsInTree,newNodeId,pinnedDuplicateIds,pinnedDuplicateIndices,slotChildrenIn,slotFieldsOf}from"../../../chunk-TCAAOYQY.js";