efficient-easel 20.2.1 → 21.1.0

package/dist/screen/lib/document/preview-events.d.ts

@@ -0,0 +1,25 @@
+/**
+ * lib/document/preview-events.ts — events the editor's screen sends INTO the preview.
+ *
+ * Moved from components/HeroSection (which re-exports them) so the screen's
+ * preview bridge (lib/document/preview-dom) can send them without importing a
+ * section, and moves into efficient-easel with the screen (doc/adr/0004). A
+ * section listens for its own; the name is the contract between the two.
+ */
+/**
+ * Event the editor chrome dispatches INTO the preview iframe to jump a Hero's
+ * slider to a slide by index. The chrome (section tree + "Add slide") lives
+ * outside this iframe and can't reach the slider's React state, and Puck's
+ * selection overlay is portaled to the iframe `<body>` (not inside `.hero-track`),
+ * so selection alone can't be observed from here — this is the explicit bridge.
+ * See {@link ScreenChrome} `selectChild` / `addChild`.
+ */
+declare const HERO_SLIDER_GOTO_EVENT = "hero-slider:goto";
+interface HeroSliderGotoDetail {
+    /** Target Hero's stable Puck id (`data-easel-block`); omit to hit all Heroes. */
+    id?: string;
+    /** Zero-based slide index to show. */
+    index: number;
+}
+
+export { HERO_SLIDER_GOTO_EVENT, type HeroSliderGotoDetail };

package/dist/screen/lib/document/preview-events.js

@@ -0,0 +1 @@
+export{HERO_SLIDER_GOTO_EVENT}from"../../../chunk-AJ2SUSET.js";

package/dist/screen/lib/document/preview-selection-context.d.ts

@@ -0,0 +1,72 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * Shared machinery for the editor preview's "selection bridges" — the click-to-
+ * select plumbing every piece of site CHROME needs because it is NOT a Puck node
+ * and so can't route through Puck's own selection. The header, the chat bubble,
+ * and a Hero's ticker / background / text overlay each expose the SAME two-way
+ * bridge, and all built it by hand until this file:
+ *
+ *  - `select(…)` / `setSelectHandler(fn)` — a ref-backed handler the chrome
+ *    registers (it opens the matching inspector panel), invoked from inside the
+ *    portaled preview iframe when the element is clicked. It lives behind a ref so
+ *    the chrome can re-register without re-rendering the preview; `select` itself
+ *    stays stable. See {@link useSelectHandler}.
+ *  - a mirrored SELECTION the preview reads to draw its own "selected" outline.
+ *
+ * Two entry points reuse the bridge:
+ *  - {@link useSelectHandler} — just the ref-backed `select` / `setSelectHandler`
+ *    pair, for the header + chat bridges. They keep a plain boolean `selected` and
+ *    layer their own live-config state around it, so they compose this hook rather
+ *    than the whole context factory.
+ *  - {@link createPreviewSelectionContext} — a whole context + provider + hook for
+ *    an ID-SCOPED bridge (a Hero's ticker / background / text), where the mirrored
+ *    selection is "which sibling id is selected" (`selected<Thing>Id`), scoped by
+ *    id so sibling heroes never cross-select. The three such contexts differ ONLY
+ *    in that field's name, so they are each one call to this factory.
+ */
+/**
+ * The ref-backed `select` / `setSelectHandler` pair shared by every selection
+ * bridge. `Args` is the click payload the chrome's handler receives — `[]` for a
+ * lone toggle (header / chat) or `[id: string]` for an id-scoped bridge (ticker /
+ * hero media / hero text). `select` is stable across renders; registering a new
+ * handler never re-renders the portaled preview.
+ */
+declare function useSelectHandler<Args extends unknown[]>(): {
+    select: (...args: Args) => void;
+    setSelectHandler: (fn: (...args: Args) => void) => void;
+};
+/**
+ * The context value of an id-scoped selection bridge, keyed by the id field's
+ * name `Key` (e.g. `"selectedHeroId"`): the mirrored id + its `set…` setter, plus
+ * the shared `select(id)` / `setSelectHandler` pair. Keeping the field name in the
+ * type is what lets one factory reproduce each context's exact public API.
+ */
+type PreviewIdSelection<Key extends string> = {
+    [P in Key]: string | null;
+} & {
+    [P in Key as `set${Capitalize<P>}`]: (id: string | null) => void;
+} & {
+    select: (id: string) => void;
+    setSelectHandler: (fn: (id: string) => void) => void;
+};
+/**
+ * Build a complete id-scoped selection-bridge context — the shared body of
+ * PreviewTickerContext / PreviewHeroMediaContext / PreviewHeroTextContext, which
+ * differ only in the id field's NAME. Pass that field name and the returned
+ * `Provider` + `useSelection` expose exactly `{ [idKey], set<IdKey>, select,
+ * setSelectHandler }`, so each context's existing consumers read unchanged.
+ *
+ * @example
+ * export const { Provider: PreviewTickerProvider, useSelection: usePreviewTicker } =
+ *   createPreviewSelectionContext("selectedHeroId");
+ */
+declare function createPreviewSelectionContext<Key extends string>(idKey: Key): {
+    Provider: ({ children }: {
+        children: ReactNode;
+    }) => react.JSX.Element;
+    useSelection: () => PreviewIdSelection<Key>;
+};
+
+export { type PreviewIdSelection, createPreviewSelectionContext, useSelectHandler };

package/dist/screen/lib/document/preview-selection-context.js

@@ -0,0 +1 @@
+export{createPreviewSelectionContext,useSelectHandler}from"../../../chunk-TIAWIOGD.js";import"../../../chunk-MGVI67QV.js";

package/dist/screen/lib/document/section-doc.d.ts

@@ -0,0 +1,24 @@
+import { Data } from '../../../blocks/index.js';
+import { TreeItem } from './content-tree.js';
+import 'react';
+import '../../../types-Cq53lL8d.js';
+import '../../../data/index.js';
+import '../../../types-41704JE4.js';
+import '../../../resolve-D68pb3Bx.js';
+import '../../../plan-CZS902DV.js';
+
+declare function nodeToDoc(node: TreeItem): Data;
+declare function docToNode(data: Data): TreeItem | null;
+/**
+ * Deep-copy a stored section node with FRESH ids — the node's own and every
+ * inline slot child's, recursively — so inserting the same template twice never
+ * lands two nodes with colliding ids (Puck keys selection/replace on id, and
+ * React keys render on it).
+ *
+ * `strip` (0.106.0) sees each copied node once its children are copied, and
+ * answers it as the copy should hold it — the layer's `blockRules.stripCopy`,
+ * which takes out what only an original may hold. It keeps the fresh id.
+ */
+declare function cloneNodeWithFreshIds(node: TreeItem, strip?: (node: TreeItem) => TreeItem): TreeItem;
+
+export { cloneNodeWithFreshIds, docToNode, nodeToDoc };

package/dist/screen/lib/document/section-doc.js

@@ -0,0 +1 @@
+export{cloneNodeWithFreshIds,docToNode,nodeToDoc}from"../../../chunk-BDSLF5BR.js";import"../../../chunk-TCAAOYQY.js";

package/dist/screen/lib/document/slot-child-name.d.ts

@@ -0,0 +1,225 @@
+/**
+ * What a slot child is CALLED — the ONE rule, and the only place it is written
+ * (card 66194).
+ *
+ * A slot-backed section (Hero Slideshow, Collections, Product Grid, Customer
+ * Photo Grid, Gallery) keeps its children on its own props, and three surfaces
+ * have to put a word on each of them: the page editor's Sections tree
+ * (`ScreenChrome`), the standalone section editor's tree
+ * (`SectionScreenShell`) — which also feeds the list drawn inside the section's
+ * own settings panel through `SlotChildActionsContext` — and `CollectionCard`'s
+ * own render, which puts the SAME word on the published card.
+ *
+ * Before this card the rule was written out three times. Card 66186 wrote the
+ * second copy, card 66190 had to edit both to add the Collection Card step and
+ * discovered the third while doing it. Three copies of a five-rung precedence is
+ * a rule that looks right until the day two of them disagree — and a merchant
+ * would meet that as a tree row and a card that name the same thing differently.
+ *
+ * ── THE PRECEDENCE, most specific first ──────────────────────────────────────
+ *   1. `props.name`       an explicit identifier the author typed (Hero Slide's
+ *                         "Slide name", Gallery Item's "Heading").
+ *   2. `props.altName`    a card-local override of the name below it
+ *                         (Collection Card's "Alt name").
+ *   3. `props.collection` the LINKED category's snapshot name — the source the
+ *                         override above overrides.
+ *   3b. `props.source`    the LINKED post's snapshot headline (Post card). The
+ *                         SAME rung as `collection` and deliberately beside it:
+ *                         both are "the thing this block is linked to, named by
+ *                         its own snapshot", and both are overridable by the two
+ *                         rungs above. A Post card is the first slot child that
+ *                         links to a post — Featured cover and Long read link to
+ *                         one too, but they are top-level sections and never
+ *                         reach this rule — so without it four cards in a Box
+ *                         all read "Post card" and a merchant cannot tell which
+ *                         one they are dragging.
+ *   4. `props.code`       a catalog slug (Product Ref stores only this), resolved
+ *                         through `wheelName` when a caller supplies one.
+ *   5. the caller's own fallback — see {@link slotChildRowName}.
+ *
+ * `name` and `altName` may be hidable values (`{text,hidden}`) rather than bare
+ * strings, so both read through `hidableText`: an object reaching a tree row
+ * crashes it ("Objects are not valid as a React child").
+ *
+ * Rungs 1–3 are authored copy and may carry the shop's editorial marks. A TREE
+ * ROW unwraps them ({@link slotChildRowName}); the published card does not, and
+ * must not — that rung's own comment carries the reasoning (card 66202). How a
+ * mark is unwrapped is the grammar's, so the row is handed the function that
+ * does it, as it is handed the catalog: this module goes into efficient-easel
+ * with the screen (doc/adr/0004), and the grammar is the layer's.
+ *
+ * ── WHY THE CATALOG RESOLVER IS AN ARGUMENT ──────────────────────────────────
+ * The two trees genuinely differ at rung 4, and always have: the page editor has
+ * the product catalog loaded and shows a Product Ref as "Turbine II", while the
+ * standalone shell has no catalog and shows the raw slug `turbine-ii`. That
+ * asymmetry shipped with card 66186 and is real behaviour, NOT a defect this
+ * module quietly repairs. Taking the resolver as a parameter makes it an
+ * explicit argument instead of an accident: the shell passes none, so it shows
+ * the slug, and a reader sees that on the call line rather than discovering it.
+ * (Same reasoning as `content-tree.ts`, which takes the config as an argument
+ * rather than importing it.)
+ *
+ * `scripts/test-slot-child-name.tsx` pins the behaviour — the precedence, the
+ * resolver contract, and that every existing row name is unchanged.
+ * `scripts/test-slot-child-lists.tsx` §5 pins that this stays the ONE home.
+ */
+/**
+ * A Puck content node as this rule reads it. Deliberately looser than
+ * `TreeItem` (no required `id`): `CollectionCard.render` names itself from the
+ * props it was handed, and never has a node in hand.
+ */
+type SlotChild = {
+    type: string;
+    props: Record<string, unknown>;
+};
+/**
+ * The name a slot child carries in its OWN data — rungs 1–4 above — or `""` when
+ * it carries none.
+ *
+ * `wheelName` resolves a `props.code` catalog slug to a wheel's design name; a
+ * caller with no catalog omits it and the slug stands.
+ *
+ * Callers that need a word for an unnamed child add their own last rung; they do
+ * not agree on what it should be, which is exactly why it is not in here. The
+ * two trees fall back to the component's label ({@link slotChildRowName}), while
+ * `CollectionCard.render` falls back to an editor-only placeholder — an unlinked
+ * card must not publish the words "Collection Card".
+ */
+declare function slotChildName(child: SlotChild, wheelName?: (code: string) => string | undefined): string;
+/**
+ * The full five-rung rule as a TREE ROW reads it: {@link slotChildName} with its
+ * markup unwrapped, else the component's friendly label. `compLabel` is the
+ * host's own config-backed lookup (`config.components[type].label ?? type`) —
+ * passed in, because this module has no config and importing one would make the
+ * editor's naming rule a dependency of the config that describes it.
+ *
+ * `plainText` unwraps the markup: the plain words of authored copy in the
+ * layer's grammar, which the screen holds as `ScreenBlockLook.plainText`
+ * (lib/screen-parts). The website's is lib/markup `stripMarkup`. Passed in for
+ * the reason `compLabel` is: the grammar is the layer's, and an email's is not
+ * a website's.
+ *
+ * ── WHY THE STRIP IS HERE AND NOT ONE RUNG DOWN (card 66202) ─────────────────
+ * A slot child's name is AUTHORED COPY. Rungs 1–3 are boxes a merchant types
+ * into, so they may carry any mark in the shop's grammar, and a tree row printed
+ * them verbatim: `Precision== Forged==` in a list that is plain text end to end.
+ * It reads as broken, and it is expensive — `.sf-subtree` costs 25px a nesting
+ * level, so a depth-2 row has roughly 172px of a 288px panel to spell a name in
+ * and truncates. Four delimiters come out of that budget before a word does.
+ *
+ * `slotChildName` deliberately does NOT strip, and that asymmetry is the whole
+ * point of putting this on the row rung instead. Its third caller is
+ * `CollectionCard.render`, which puts the word on a customer's LIVE page, where
+ * `<CollectionCard/>` routes `name` through `renderHeadline` — so `==phrase==`
+ * there is the merchant's accent colour, not noise. Stripping one rung lower
+ * would have flattened it on every published card that uses one. A tree row is
+ * the surface that cannot draw a mark; it is the surface that drops it.
+ *
+ * Through the grammar's own stripper (the website's `stripMarkup`), never by
+ * deleting delimiter characters: that unwraps a PAIR and leaves a lone
+ * delimiter exactly where the renderer leaves it, so a half-typed name — which
+ * is what mid-edit data actually looks like — keeps its whole line. It also
+ * means a mark the grammar grows is handled here with no edit, because this
+ * file names no delimiter of its own.
+ *
+ * The fallback still fires only for a genuinely nameless child: the grammar
+ * needs at least one character between a pair, so a name that is non-empty
+ * cannot strip to nothing and be renamed into its component's label.
+ */
+declare function slotChildRowName<N extends SlotChild>(child: N, compLabel: (type: string) => string, plainText: (copy: string) => string, wheelName?: (code: string) => string | undefined, rowName?: RowNameRule<N>): string;
+/**
+ * THE LAYER'S LAST WORD (0.103.0) — `ScreenBlockLook.rowName`
+ * (lib/screen-parts), the rung a layer may stand above the whole precedence:
+ * handed the node, the level it is named at and what the rule here answered,
+ * it answers the row's name. The campaign designer names its rows by its own
+ * labels, and needs none of the website's rungs.
+ *
+ * An argument and not a rung written here, for the reason the grammar and the
+ * catalog are: this module has no layer. Absent, the rule here is the name, as
+ * it was before the member existed.
+ */
+type RowNameRule<N extends SlotChild = SlotChild> = (node: N, level: "section" | "block", fallback: string) => string;
+/**
+ * WHICH PROP A RENAME WRITES — the write side of the rule above, and here for
+ * the reason the read side is: naming a slot child has ONE home (card 66194).
+ * A rename that picked its own prop would be a sixth opinion about what a child
+ * is called, and the day it disagreed a merchant would rename a row and watch
+ * the row not change.
+ *
+ * Returns the prop key, or `null` when this component has no name to write —
+ * and a `null` is what takes `Rename` out of the menu, rather than a menu item
+ * that does nothing.
+ *
+ * ── ONLY A DECLARED IDENTIFIER, AND THIS IS THE WHOLE TRAP ───────────────────
+ * `GalleryItem.name` is keyed `name`, it IS what its Layers row says, and it is
+ * an ordinary `Heading` a merchant writes — copy, printed on the page. A rename
+ * keyed on the prop NAME would quietly rewrite that heading from a menu item
+ * called "Rename". So the field must DECLARE itself an identifier
+ * (`withIdentifier`, see `lib/document/controls`), which is the same declaration the
+ * settings panel reads to keep these rows out of the copy list.
+ *
+ * `fields` is taken as an argument rather than imported, exactly like the
+ * `wheelName` resolver above: this module has no config, and importing one would
+ * make the editor's naming rule a dependency of the config that describes it.
+ *
+ * The order matches {@link slotChildName}'s precedence, so the prop a rename
+ * writes is the prop the row then reads. `altName` before `name` cannot happen
+ * in today's config — no component declares both — and the order is written out
+ * anyway so the answer does not depend on that staying true.
+ */
+declare function slotChildRenameProp(fields: Record<string, unknown> | undefined): "name" | "altName" | null;
+/**
+ * WHICH PROP A SECTION'S RENAME WRITES (0.105.0) — the write side of
+ * {@link rootRowName} below, as {@link slotChildRenameProp} is the write side of
+ * a slot child's name, and here for the same reason: one home for what a node
+ * is called.
+ *
+ * Owner ruling R11 (Victor Mau, 2026-10-09): Rename works on top-level sections
+ * in both editors. A section's row reads rung 1 and nothing below it — its own
+ * `name`, else its type's label — so `name` is what a rename writes, and the row
+ * then reads it back. Until the ruling a root node had no Rename at all: its row
+ * was taken to say only its type, which stopped being true the day the row
+ * started reading the `name` the presets seed ("Brand Text", a split's
+ * "<Section> section"), and that name had no way to be changed.
+ *
+ * ── `name` IS WRITTEN UNLESS IT IS COPY — the slot child's trap, at the root ──
+ * A section whose fields do not declare `name` carries it only as the editor's
+ * label for it: the presets write it, the Layers row reads it, and no page draws
+ * it. One that declares it an identifier (`withIdentifier`) is the same. But a
+ * field keyed `name` that is ordinary copy — `GalleryItem.name` is a Heading
+ * printed on the page — is not a name, and a menu item called "Rename" must not
+ * rewrite it: null, and the section gets no Rename. No section of the website's
+ * registry declares `name` at all today, so every one of them is renamed.
+ */
+declare function sectionRenameProp(fields: Record<string, unknown> | undefined): "name" | null;
+/**
+ * What a ROOT-level node is called in the trees — rung 1 of the same precedence
+ * above, and nothing below it.
+ *
+ * A root node is not a slot child: it has no linked collection, no card-local
+ * override and no catalog slug, so four of the five rungs have nothing to say
+ * about it. What it CAN carry is rung 1 — an explicit name the author (or the
+ * seeding) wrote — and before this function nothing at the root read it.
+ *
+ * ⚠️ THE DEFECT THAT PUT THIS HERE. `addSection` seeds a split pair as a Box
+ * carrying `name: "<Section> section"`, and the comment beside that line says
+ * the rename seam reads `name`. At the root both trees named a node by its TYPE
+ * alone, and a Box's type name at section level is the literal "Blank section" —
+ * so every pair a merchant added arrived in Layers as "Blank section", with the
+ * stored name read by nobody. A value written and never read is the same defect
+ * as a control that reaches nothing.
+ *
+ * It lives HERE, beside the rule it is a rung of, rather than in the chrome that
+ * calls it: two files deciding what a node is called is exactly what card 66194
+ * collapsed into this module, and a root rule written in the component would be
+ * the fourth copy.
+ *
+ * `fallback` is the caller's type-level label (`sectionLabel(type)`), which is
+ * what every published page reads today and what an unnamed node keeps reading.
+ *
+ * `rowName` is the layer's last word ({@link RowNameRule}), asked at the
+ * SECTION level with what this rung answered.
+ */
+declare function rootRowName<N extends SlotChild>(node: N, fallback: string, rowName?: RowNameRule<N>): string;
+
+export { type RowNameRule, type SlotChild, rootRowName, sectionRenameProp, slotChildName, slotChildRenameProp, slotChildRowName };

package/dist/screen/lib/document/slot-child-name.js

@@ -0,0 +1 @@
+export{rootRowName,sectionRenameProp,slotChildName,slotChildRenameProp,slotChildRowName}from"../../../chunk-SSRYU3YG.js";import"../../../chunk-ANPOR6EY.js";import"../../../chunk-6UAEFOJ4.js";

package/dist/screen/lib/document/slot-heal.d.ts

@@ -0,0 +1,5 @@
+import { TreeItem } from './content-tree.js';
+
+declare function dedupeSlotChildren(item: TreeItem, slots: string[]): TreeItem["props"] | null;
+
+export { dedupeSlotChildren };

package/dist/screen/lib/document/slot-heal.js

@@ -0,0 +1 @@
+export{dedupeSlotChildren}from"../../../chunk-7OCEPOEJ.js";

package/dist/screen/lib/document/slot-section-spec.d.ts

@@ -0,0 +1,96 @@
+/**
+ * A component type's own `defaultProps`, looked up in the Puck config.
+ *
+ * Handed IN rather than imported: `lib/document/config` imports the seed
+ * registry's neighbours, and a seed registry that reached back into the config
+ * would close the loop. Both callers of `seeds()` already hold the config
+ * (`components/ScreenChrome`, `components/StandaloneSectionEditor`),
+ * so the lookup travels the short way.
+ *
+ * ⚠️ IT IS OPTIONAL, AND THE FIVE SPECS THAT PREDATE IT IGNORE IT. They
+ * seed ONE flat child whose every field is content, so a missing default changes
+ * nothing they draw. Image & Text Columns seeds a Box holding blocks, and a Box
+ * without its `direction` / `justify` / `align` / `wrap` is a different shape on
+ * the page — see `boxColumnSeed` in lib/document/slot-specs.
+ */
+type NodeDefaults = (type: string) => Record<string, unknown>;
+interface SlotSectionSpec {
+    /** The primary slot field on the section (e.g. Hero's `slides`). */
+    slot: string;
+    /** The child component type the slot holds. */
+    childType: string;
+    /** The "Add …" affordance label. */
+    addLabel: string;
+    /**
+     * The children ARE the section, and no surface offers to add one.
+     *
+     * ⚠️ NOT THE SAME THING AS `addBlocked`, AND THE DIFFERENCE IS WHY IT EXISTS.
+     * `addBlocked` is a reason adding is impossible RIGHT NOW — a hero anchor
+     * already holds four — so the row stays, greyed, with the sentence on it, and
+     * the merchant can act on it (re-place a group and Add comes back). A fixed
+     * set has no such state: the row would be permanently dead furniture, and
+     * `NodeContextMenu`'s own rule says it plainest — a row must never be a button
+     * that does nothing.
+     *
+     * Both surfaces that draw an Add row read this. `addBlocked` is still declared
+     * beside it, because the DROP path asks that one and never this.
+     */
+    fixed?: boolean;
+    /** Children render as a HORIZONTAL slider (selection must advance it). */
+    slider?: boolean;
+    /**
+     * Prop bags for the default children a fresh section is seeded with.
+     *
+     * `defaultsFor` is {@link NodeDefaults} — present when the caller holds the
+     * config, absent otherwise, and every spec that seeds a plain content child
+     * simply declines it.
+     */
+    seeds: (defaultsFor?: NodeDefaults) => Record<string, unknown>[];
+    /**
+     * Convert a section's LEGACY props (an older inline-array field) into slot
+     * children at load-time — the chrome-only migration for pages saved before the
+     * field became a slot. Returns [] when there's nothing to migrate, in which
+     * case the seeder falls back to `seeds()`.
+     */
+    legacy?: (props: Record<string, unknown>) => Record<string, unknown>[];
+    /**
+     * Why this section cannot take another child right now — a sentence the
+     * merchant reads — or `null` when it can (card 66189).
+     *
+     * Optional, and only the Hero slide answers it today: a group is placed on one
+     * of nine anchors, an anchor stacks at most four, and a fifth would be drawn
+     * ON TOP of the fourth. The rule lives on the SPEC rather than inside
+     * `SlotChildRows` because the list is shared by five sections and this is one
+     * section's arithmetic — the list asks, the spec answers.
+     */
+    addBlocked?: (children: readonly unknown[], incoming?: unknown) => string | null;
+    /**
+     * Why this section must NOT be seeded at all, read off its OWN stored props.
+     *
+     * The seeder's existing guard is "the slot already has children" — right for a
+     * section whose only shape is the slot, and blind to a section that still
+     * carries an OLDER one. Image & Text Columns is the first of those: its
+     * columns used to be a `steps` ARRAY, the owner ruled on 2026-09-05 that
+     * nothing is migrated, and a stored page therefore has a full `steps` and an
+     * empty `boxes`. Without this the seeder would drop three fresh Boxes into a
+     * published page that already draws three columns, and the merchant would find
+     * six.
+     *
+     * Deliberately a question about the PARENT'S props, not about the slot — the
+     * slot is what the existing guard already reads, and answering "is there an
+     * older shape here" from the same place is what makes this a second question
+     * rather than a second opinion on the first.
+     */
+    skipSeed?: (props: Record<string, unknown>) => boolean;
+    /**
+     * What the list says about the children it ALREADY holds, or `null`.
+     *
+     * The counterpart to `addBlocked`, and deliberately a second question rather
+     * than a second answer from the first: `addBlocked` is about a group that has
+     * not arrived yet, this is about the ones that are already here and cannot all
+     * be drawn. A section that cannot get into that state simply declares neither.
+     */
+    notice?: (children: readonly unknown[]) => string | null;
+}
+
+export type { NodeDefaults, SlotSectionSpec };

package/dist/screen/lib/document/slot-section-spec.js

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

package/dist/screen/lib/document/style-clipboard.d.ts

@@ -0,0 +1,144 @@
+import { StyleRow } from '../../../style-clipboard/index.js';
+import { S as StyleClipboardWords } from '../../../words-CnnHb9jo.js';
+import { ScreenStyleDocument, ScreenNode, ScreenStylePastePlan, ScreenStyleClipboard } from '../screen-parts.js';
+import { panelFieldsOf } from './panel-fields.js';
+import '../../../types-BbOBWXMP.js';
+import 'react';
+import '../../../blocks/index.js';
+import '../../../types-Cq53lL8d.js';
+import '../../../data/index.js';
+import '../../../types-41704JE4.js';
+import '../../../resolve-D68pb3Bx.js';
+import '../../../plan-CZS902DV.js';
+import '../../../watch-D8xZow3y.js';
+import '../../../types-B3iSHX-w.js';
+import '../../../types-Cy7rdmXt.js';
+import '../../../wordFit-7XpmhcaW.js';
+import '../../../edit-lock/index.js';
+import '../../../panelWidths-DgQXiPXU.js';
+import '../../../CanvasDragLayer-CFUcBbgc.js';
+import '../../../session-DSQFmIvx.js';
+import '../../../words-SD4neL0n.js';
+import '../../../types-DBy3L69b.js';
+import 'efficient-shell/ui';
+import '../../../words-Cl9xMUYY.js';
+import '../../components/AddSidePanel.js';
+import '../section-template-types.js';
+import './content-tree.js';
+import '../shared-section-types.js';
+import './block-choice.js';
+import '../../../ScreenDocumentContext-1RgtGKWR.js';
+import '../document-contract.js';
+import '../document-switch.js';
+import '../../../engine-CvXpFE86.js';
+import '../admin-bridge.js';
+import '../session.js';
+import '../backend-error.js';
+import '../host-chrome.js';
+import '../links/link-filters.js';
+import '../document-hooks.js';
+import './add-target-types.js';
+import './slot-section-spec.js';
+
+/**
+ * lib/document/style-clipboard.ts — COPY STYLE / PASTE STYLE in the website editor
+ * (card [ADD] Copy Style And Paste Style, owner 2026-09-19).
+ *
+ * The clipboard, the matching rule, the menu rows, the words and the shortcut
+ * test are `efficient-easel/style-clipboard`'s — written once for both editors;
+ * the campaign designer draws the same two rows from the same module. This file
+ * answers only the two questions that are the website editor's own:
+ *
+ *   1. WHICH ROWS of a node are its look — {@link nodeStyleRows};
+ *   2. WHAT KIND each row is — {@link shopFieldKind}.
+ *
+ * ── WHICH ROWS ──────────────────────────────────────────────────────────────
+ * Owner's rule 3 was "the Style and Layout tabs, never Content". Since 4.0.0
+ * the panel has two tabs, Design and Animation (owner, final 2026-10-10), and
+ * what was the Content tab sits at the top of Design — so the rule is read off
+ * the Design GROUPS instead of the tabs: the rows under Size, Design, Layout or
+ * Position are a look and are copied. Never the Content group (its
+ * `_dContent` marker, and every row of Design before the first group heading),
+ * never Anchor, never Animation.
+ *
+ * The panel after `assignSectionGroups` is a flat list in which each bucket
+ * header (`BUCKET_KEY`) opens its run — the same reading the tab strip hides
+ * rows by — and inside Design each group heading (`DESIGN_GROUP_KEY`) opens
+ * its own; a row belongs to the headers above it. A group heading counts only
+ * inside Design.
+ *
+ * Left out even in those groups (the list GG approved on 2026-09-19):
+ *   · every picture (`__media`) — Media folded into Style on 2026-09-14, and a
+ *     picture is Content;
+ *   · words and links (`__text`, `__link`);
+ *   · headings, bucket headers and notes — `__fold`, and every `_`-key (the
+ *     panel's own furniture, as in the campaign designer) — which store nothing;
+ *   · the Anchor rows — a deep-link id must be unique on the page;
+ *   · slots (Boxes, children) — structure, not a look;
+ *   · a picture's focal point (`focal`, `imageFocal`) — a point ON ONE picture,
+ *     meaningless on another, like the campaign logo's colour map.
+ * A text part's own look (`partStyles`) is no row at all, so it is never read.
+ *
+ * ── THE PHONE VALUE ─────────────────────────────────────────────────────────
+ * Stored as its own row (`<key>Phone`, ./phone-override), on the same tab, so it
+ * travels like any row. It is not COUNTED: the merchant sees one row per
+ * device, and the number is the rows they see.
+ */
+
+type Props = Record<string, unknown>;
+type NodeLike = {
+    type: string;
+    props: Props;
+};
+type ConfigLike = Parameters<typeof panelFieldsOf>[0];
+/** The clipboard's scope: one site (GG, 2026-09-19) — across its pages. */
+declare function siteStyleScope(siteId: string | null | undefined): string;
+/**
+ * The kind of one website-editor row.
+ *
+ *   · a tag (a shared builder's `section:<key>`, ../controls `sharedStyleKinds`)
+ *     wins, on the gate or on the control it wraps;
+ *   · a CHOICE row (it declares `options`) is `choice:` plus its sorted values;
+ *   · anything else is the shell's reading, which answers `null` for an
+ *     untagged custom control: it pastes only onto the same section type.
+ */
+declare function shopFieldKind(field: unknown): string | null;
+/** A node's look, as rows the shell's clipboard can hold and match. */
+declare function nodeStyleRows(config: ConfigLike, node: NodeLike): StyleRow[];
+/** Copy one node's look into the site's clipboard. */
+declare function copyNodeStyle(config: ConfigLike, scope: string, node: NodeLike, label: string): void;
+/**
+ * What a paste onto this node would do: the new props, and the words the
+ * merchant reads. Null when nothing is held for this site. The caller writes
+ * `props` through its one replace op only when `changed`, and always shows
+ * `message` — "nothing matched" is an answer, not a silence.
+ */
+declare function planNodePaste(config: ConfigLike, scope: string, node: NodeLike, label: string, words?: StyleClipboardWords): {
+    props: Props;
+    changed: boolean;
+    pasted: number;
+    message: string;
+} | null;
+/** A style clipboard with every member answered: the screen's reading of a
+ *  layer's {@link ScreenStyleClipboard}. */
+interface ResolvedStyleClipboard {
+    scope: (doc: ScreenStyleDocument) => string;
+    rows: (config: unknown, node: ScreenNode) => StyleRow[];
+    copy: (scope: string, node: ScreenNode, label: string, config: unknown) => void;
+    plan: (scope: string, node: ScreenNode, label: string, config: unknown) => ScreenStylePastePlan | null;
+}
+/**
+ * COPY STYLE / PASTE STYLE AS THE SCREEN RUNS THEM (0.105.0): a layer's
+ * clipboard (lib/screen-parts `styleClipboard`) with every member it left out
+ * answered the website's way. A layer's `copy` and `plan`, where it hands none,
+ * read the rows it handed (`rows`), so a layer with its own look and nothing
+ * else still copies and pastes. With no layer's: exactly the website's —
+ * `siteStyleScope(siteId)`, `nodeStyleRows`, `copyNodeStyle`, `planNodePaste`.
+ */
+declare function styleClipboardOf(part: ScreenStyleClipboard | null | undefined, 
+/** What the screen's own `plan` says after a paste, in the host's language
+ *  (`EaselStrings.styleClipboard`, 3.1.0). A layer's own `plan` says its own
+ *  words. Left out: English. */
+words?: StyleClipboardWords): ResolvedStyleClipboard;
+
+export { type ResolvedStyleClipboard, copyNodeStyle, nodeStyleRows, planNodePaste, shopFieldKind, siteStyleScope, styleClipboardOf };

package/dist/screen/lib/document/style-clipboard.js

@@ -0,0 +1 @@
+export{copyNodeStyle,nodeStyleRows,planNodePaste,shopFieldKind,siteStyleScope,styleClipboardOf}from"../../../chunk-SWBADIQT.js";import"../../../chunk-5XL2RXFU.js";import"../../../chunk-KWLHKKZO.js";import"../../../chunk-INRERJU4.js";import"../../../chunk-3QB2ZQXK.js";import"../../../chunk-EB6NI2VK.js";import"../../../chunk-V7U33NF2.js";import"../../../chunk-6WY6ZXJG.js";import"../../../chunk-ANPOR6EY.js";import"../../../chunk-BPXEFVSQ.js";import"../../../chunk-MFIRYGHW.js";import"../../../chunk-BSPCSC45.js";