efficient-easel 21.0.0 → 21.1.0

package/dist/screen/lib/puck/device-fields.d.ts

@@ -1,128 +1,4 @@
-import { ReactElement } from 'react';
-import { PreviewDevice } from '../../components/PreviewDeviceContext.js';
+export { DEVICE_FIELD_MARKER, DEVICE_HIDDEN_ATTR, DEVICE_NOTE, DeviceFieldMeta, DeviceTier, deviceField, deviceMetaOf, deviceNote, shownTier, withoutDeviceGate } from '../document/device-fields.js';
+import 'react';
+import '../../components/PreviewDeviceContext.js';
 import '../content/view-tiers.js';
-
-/**
- * lib/puck/device-fields.tsx — show the setting for the device the merchant is
- * currently looking at, and only that one.
- *
- * THE PROBLEM. A section that can be sized differently on a phone stores TWO
- * props and the panel drew BOTH, side by side, told apart only by a "(desktop)"
- * / "(mobile)" suffix on the label. The canvas already knows which device is on
- * screen; the panel ignored it, so the merchant read labels to find the control
- * that matched what they were looking at.
- *
- * THE MECHANISM, and why this one. A Puck `resolveFields` cannot do it: in this
- * Puck version the fields slice re-resolves only when the selected node's DATA
- * changes (`useRegisterFieldsSlice` subscribes to `state.indexes.nodes[id]`), and
- * switching device changes no data — the panel would keep whatever field set the
- * last edit produced. So the decision is made where it can re-render freely: in
- * the FIELD ITSELF, off the React context the editor chrome already publishes
- * (`components/PreviewDeviceContext`, which the per-view Footer controls read
- * for the same reason). One context, no prop threaded anywhere, and every house
- * control is already a `type: "custom"` render, so wrapping one costs nothing.
- *
- * ⚠️ HIDDEN IS NOT DELETED. {@link deviceField} returns the SAME field object
- * with the same markers (`__media`, `__text`, …) and the same key; only its
- * paint is gated. Both props keep existing, keep their keys, keep their values
- * and keep their `defaultProps`. Switch to Phone, type a size, switch back — the
- * desktop size is exactly where it was, because nothing ever wrote to it.
- * `scripts/test-device-fields.tsx` pins that round trip.
- *
- * TABLET (owner ruling, card 66066). There are no tablet-specific stored values
- * today, and inventing them would mean a new stored prop on every section — a
- * different card. So tablet shows the DESKTOP values and the panel SAYS SO
- * ({@link DEVICE_NOTE}); it never presents desktop values as if they were
- * tablet's. {@link shownTier} is the single place that ruling is written down.
- *
- * WHY THE HIDDEN FIELD LEAVES NO GAP. Puck wraps every top-level field in its
- * own padded `_PuckFields-field_` box before it calls `render`, so a field that
- * renders nothing would still cost ~37px of empty panel. The gate instead paints
- * a zero-size marker and this package's `screen.css` collapses the
- * wrapper that contains one — the same "reach the wrapper Puck owns" trick the
- * fold reflow in `controls.tsx` already relies on, expressed as one CSS rule
- * instead of a second DOM pass (so it cannot race the fold's).
- */
-
-/** The two tiers a stored value can belong to. Tablet is not one — see
- *  {@link shownTier}. */
-type DeviceTier = "desktop" | "mobile";
-/**
- * Which tier's stored values the panel shows for a given preview device.
- *
- * The owner ruling in one expression: phone shows the phone values, everything
- * else — desktop AND tablet — shows the desktop values.
- */
-declare function shownTier(device: PreviewDevice): DeviceTier;
-/**
- * The quiet line the panel puts above a section's settings, so a merchant can
- * always tell WHICH device's value they are editing without reading the canvas.
- *
- * Desktop says nothing: it is the resting state, and a banner that is always
- * there is a banner nobody reads. Tablet says the ruling out loud rather than
- * letting the desktop values pass for tablet's own.
- */
-declare const DEVICE_NOTE: Readonly<Record<PreviewDevice, string | null>>;
-/** The attribute the stylesheet looks for to collapse a gated-off field's Puck
- *  wrapper. Declared here, matched once in this package's `screen.css`, which
- *  every host that mounts the screen loads (it sat in the website's sheet until
- *  0.103.0, so a second host's hidden rows kept their space). */
-declare const DEVICE_HIDDEN_ATTR = "data-sf-device-hidden";
-/** A house control's render, seen from outside: the builders in `controls.tsx`
- *  each type their own props, so the gate takes the widest shape that can be
- *  passed straight back through. */
-type FieldRender = (props: Record<string, unknown>) => ReactElement;
-/** Any house control — every one of them is a `type: "custom"` field whose
- *  `render` is a plain function of its props. */
-type AnyCustomField = {
-    type: "custom";
-    render: FieldRender;
-};
-/** Marker carried by every gated field, in the same style as
- *  {@link import("./controls").FOLD_FIELD_MARKER}: the tier and the field it
- *  wraps live ON the field object, never only inside the render closure. Without
- *  it a gated control is opaque to every static walk — and the fold guard in
- *  `scripts/test-section-groups.ts` genuinely needs to see the header underneath
- *  to check its label against what it draws. Puck ignores extra keys. */
-declare const DEVICE_FIELD_MARKER: "__device";
-/** The payload on {@link DEVICE_FIELD_MARKER}. */
-type DeviceFieldMeta = {
-    tier: DeviceTier;
-    inner: unknown;
-};
-/** Read a field's device payload, or null when it is not gated. The ONE place
- *  that knows the marker's shape. */
-declare function deviceMetaOf(field: unknown): DeviceFieldMeta | null;
-/** The field a gate wraps, or the field itself when it wraps nothing — what a
- *  static walk wants to look at. */
-declare function withoutDeviceGate(field: unknown): unknown;
-/**
- * Paint `field` only while the canvas is showing `tier`.
- *
- * Everything else about the field is preserved by identity-spread — its `type`,
- * its manifest markers, its data keys — so the media and neutralization walks,
- * the field-key census and every stored prop see exactly what they saw before.
- */
-declare function deviceField<F extends {
-    type: "custom";
-    render: (p: never) => ReactElement;
-}>(tier: DeviceTier, field: F): F;
-/**
- * The panel's device indicator — one quiet line, and only when there is
- * something to say (see {@link DEVICE_NOTE}).
- *
- * Declared as a FIELD rather than painted by the chrome so it sits inside the
- * settings panel it describes, above the first group, and so a section that has
- * no device-varying control never shows it. It edits nothing: like `group()` /
- * `section()` it is a header, with no prop behind it.
- *
- * …WHICH IS WHY IT SAYS SO ON THE FIELD (card 66201). A note is not a control, so
- * a heading with nothing but this under it is a heading over nothing — and it is
- * the whole reason the Hero's Content tab was empty: `_dDevice` is the section's
- * first field, so it opened the implicit leading Content run and gave the panel a
- * Content tab with only a banner in it, while the hero's actual copy is edited in
- * the Text sub-panel.
- */
-declare function deviceNote(): AnyCustomField;
-
-export { DEVICE_FIELD_MARKER, DEVICE_HIDDEN_ATTR, DEVICE_NOTE, type DeviceFieldMeta, type DeviceTier, deviceField, deviceMetaOf, deviceNote, shownTier, withoutDeviceGate };

package/dist/screen/lib/puck/device-fields.js

@@ -1 +1 @@
-export{DEVICE_FIELD_MARKER,DEVICE_HIDDEN_ATTR,DEVICE_NOTE,deviceField,deviceMetaOf,deviceNote,shownTier,withoutDeviceGate}from"../../../chunk-MSGZ56QL.js";import"../../../chunk-7F52SZOI.js";import"../../../chunk-EB6NI2VK.js";import"../../../chunk-MFIRYGHW.js";import"../../../chunk-BSPCSC45.js";
+export{DEVICE_FIELD_MARKER,DEVICE_HIDDEN_ATTR,DEVICE_NOTE,deviceField,deviceMetaOf,deviceNote,shownTier,withoutDeviceGate}from"../../../chunk-KWLHKKZO.js";import"../../../chunk-INRERJU4.js";import"../../../chunk-EB6NI2VK.js";import"../../../chunk-MFIRYGHW.js";import"../../../chunk-BSPCSC45.js";

package/dist/screen/lib/puck/field-buckets.d.ts

@@ -1,36 +1,2 @@
-import { S as SettingsBucket, D as DesignGroup } from '../../../buckets-Tj-nkBpg.js';
-
-/**
- * lib/puck/field-buckets.ts — the two settings buckets a section's fields are
- * sorted into (Design, Animation: owner 2026-10-08, final 2026-10-10), the
- * field key each bucket's header is emitted under, and the field key of each
- * Design group's heading.
- *
- * Moved out of lib/puck/field-groups (which re-exports both) so the editor's
- * screen can read a header's key — the style clipboard copies a look by the
- * groups it sits in — without importing the field builders that sort a
- * section's fields (doc/adr/0004). The reasoning behind the buckets themselves
- * stays in field-groups, beside the pass that applies them.
- */
-
-type Bucket = SettingsBucket;
-/**
- * The field key each bucket's header is emitted under. `_s*` because these are
- * level-1 headers (`section()`), matching the `_s*` convention the sections that
- * already carry level-1 headers use (`_sText`, `_sImage`, `_sSetup`, …).
- */
-declare const BUCKET_KEY: Record<Bucket, string>;
-/**
- * The field key of each Design group's heading, inside the Design bucket. The
- * HOST emits them, in `DESIGN_GROUPS` order, one for each group it has; a row
- * belongs to the heading above it. `_dContent` is a marker that draws no
- * heading (the Content part has none), and the rows before the first group
- * heading of Design are Content too. `_d*` for Design's own headings, apart
- * from the `_s*` bucket headers and the `_g*` group headers a section draws.
- * Only these six keys are group headings: `_dDevice` (the device note,
- * ./device-fields) shares the prefix and is not one, so never read a group off
- * the prefix.
- */
-declare const DESIGN_GROUP_KEY: Record<DesignGroup, string>;
-
-export { BUCKET_KEY, type Bucket, DESIGN_GROUP_KEY };
+export { BUCKET_KEY, Bucket, DESIGN_GROUP_KEY } from '../document/field-buckets.js';
+import '../../../buckets-Sw94ll9I.js';

package/dist/screen/lib/puck/field-buckets.js

@@ -1 +1 @@
-export{BUCKET_KEY,DESIGN_GROUP_KEY}from"../../../chunk-MQNBD6AB.js";
+export{BUCKET_KEY,DESIGN_GROUP_KEY}from"../../../chunk-3QB2ZQXK.js";

package/dist/screen/lib/puck/field-markers.d.ts

@@ -1,205 +1,2 @@
-import { TextControlKind } from './text-control-kinds.js';
-
-/**
- * field-markers — what a field DECLARES about itself, readable without the
- * inspector.
- *
- * A control factory in `lib/puck/controls` stamps a marker on the field object
- * it returns: this prop holds authored copy, this one a link, this row array
- * draws these scaffold rows while it is empty. Two kinds of code read those
- * stamps. The inspector does, and so does the RENDER side — the part walk that
- * makes a headline clickable (`lib/puck/text-parts`), the typing bridge
- * (`lib/puck/part-text`, `lib/puck/part-rows`) — and a section's own option
- * module may be typed by a control's vocabulary (`lib/sections/ticker-scroll`
- * names the pad cell each direction sits in).
- *
- * ⚠️ WHY THIS IS ITS OWN FILE. The markers were born in `controls.tsx` beside
- * the factories that stamp them, and `controls.tsx` is the inspector: React, the
- * editor shell, the link picker, the form picker, and through them the API
- * client and the cart. A render-side module that only wanted the string
- * `"__text"` imported all of it, which is what kept a general section from being
- * drawn anywhere the inspector cannot go (doc/adr/0002). The same split, for the
- * same reason, that `lib/puck/hidable` and `lib/puck/text-control-kinds` already
- * made.
- *
- * This file imports nothing but that kinds leaf. `controls.tsx` re-exports
- * every name, so an inspector-side import site is unchanged; a render-side
- * module imports from HERE. `scripts/test-general-sections-import-boundary.ts`
- * fails when one goes back to `controls`.
- */
-
-/** Marker carried by every AUTHORED-TEXT field object, mirroring
- *  {@link MEDIA_FIELD_MARKER} below. The neutralization manifest
- *  GENERATOR (`scripts/gen-neutralization-manifest.ts`) walks the built config
- *  looking for it, so the text factories are the single source of truth for
- *  "this prop holds customer-authored copy" — a new text field is covered the
- *  moment it is declared, with no list to maintain anywhere (Puck ignores extra
- *  keys).
- *
- *  Unlike the media marker this carries a PAYLOAD, because the neutralizer needs
- *  more than a boolean: the declared `placeholder` IS the neutral replacement
- *  copy (the greyed hint the designer already wrote for an empty field), and
- *  `control` says which value shape the prop stores — `text`/`textarea` persist
- *  `{ text, hidden }` once edited, the `plain*` variants stay bare strings, and
- *  `textList` stores `{ text }[]`. A neutralizer that assumed "string" would
- *  silently skip most EDITED copy. */
-declare const TEXT_FIELD_MARKER: "__text";
-/** Marker carried by every LINK-DESTINATION field. A destination is not authored
- *  prose — it is a tenant-specific target (an internal path, an absolute URL, a
- *  `mailto:`/`tel:`, or an in-page `#anchor`) — so it neutralizes by its own rule
- *  rather than to placeholder copy. Kept separate from {@link TEXT_FIELD_MARKER}
- *  so the two can never be conflated. */
-declare const LINK_FIELD_MARKER: "__link";
-/**
- * Marker carrying the rows a ROW-ARRAY field draws in the editor preview while
- * its stored value is still empty — the `phRows` scaffold, declared on the field
- * instead of only at the render call.
- *
- * WHY IT HAS TO BE ON THE FIELD. A scalar text control already declares its own
- * greyed hint (`placeholder` above), and everything that asks "what does this
- * prop put on screen?" — the neutralizer, the part walk — reads it there. A row
- * array had no equivalent: `config.tsx` passes the scaffold constant straight
- * into `phRows(value, SCAFFOLD, puck)` inside the render, where nothing outside
- * the component can see it. So a freshly-dropped section drew three grey rows of
- * scaffold copy that `lib/puck/text-parts` could not name, and clicking that copy
- * opened the whole section instead of the one control behind it (card 66072).
- *
- * It is the SAME constant the render passes — `withScaffold` (in
- * `lib/puck/controls`) takes it as an argument rather than copying it — so the
- * preview and the walk cannot drift. Puck ignores extra keys on a field, exactly
- * as it does for the two markers above.
- */
-declare const SCAFFOLD_FIELD_MARKER: "__scaffold";
-/**
- * How the SECTION consuming a `textList` draws each row — and therefore whether
- * the list may offer a formatting bar at all.
- *
- * This is the `COPY_FIELD_TOOLS` rule (`lib/markup.ts`) applied one level up. Upstream, the
- * button set is derived from the grammar so a tool whose output the parser cannot
- * read back can never appear. Here the same question is asked of the CONSUMER: a
- * `"markup"` list is one whose rows go through `renderGold`, so every mark the
- * grammar writes is drawn; a `"verbatim"` list is printed as-is (an Integrations
- * chip, a ContactRouting meta line, a Mockup kanban card), where `**bold**` would
- * reach the shopper as four literal asterisks. A mark stored where nothing renders
- * it is a bug, not a feature — so a verbatim list gets no bar.
- *
- * DELIBERATELY REQUIRED, with no default. The two facts — what a field offers and
- * what its section renders — sit in different files, and a default would let them
- * agree by luck: whichever way it pointed, the next `textList` would inherit an
- * answer nobody checked. Stating it at the call site puts the question in front of
- * whoever adds the field, next to the render that answers it.
- */
-type TextListRendering = 
-/** Rows render through `renderGold` — the shared grammar parses them back. */
-"markup"
-/** Rows are printed exactly as stored; a delimiter would reach the shopper. */
- | "verbatim";
-/** The payload on {@link TEXT_FIELD_MARKER}: what a text field says about the
- *  copy it holds. The `with…` wrappers that set its optional facts, and the
- *  readers that pair with them, are in `lib/puck/controls`. */
-type TextFieldMeta = {
-    control: TextControlKind;
-    /** The control's inspector label — a classification signal when a field
-     *  declares no placeholder (labels read "Heading …", "Body …", "Alt text"). */
-    label: string;
-    /** The declared greyed hint. PRIMARY source of the neutral replacement copy. */
-    placeholder?: string;
-    /** The one-line caption UNDER the box, where the field carries one. Recorded
-     *  here for the same reason the two above are: it is merchant-facing copy, so
-     *  the walks that ask "what words does this panel show?" — the neutralizer,
-     *  `test-accent-syntax-taught`, `test-panel-plain-words` — must be able to see
-     *  it without rendering. It is NOT a neutralization source: a hint explains
-     *  the control and belongs to the product, not to the tenant's content. */
-    hint?: string;
-    /**
-     * DECLARED: these words never reach a shopper (card 66280). Set only by
-     * `withOffPage`, and only on a prop whose copy no render puts on the
-     * storefront — a join key, a tab reference, a tree label. The section screen's
-     * entry row then says so instead of previewing the value.
-     *
-     * ABSENT MEANS ON THE PAGE, and that default is the point. It cannot be
-     * derived: the walk that builds the entry rows reads fields, and only a
-     * component's RENDER knows whether a prop reaches a shopper. The costs of
-     * being wrong are not symmetric either — a field wrongly marked hides a
-     * merchant's own words behind a note, while a field wrongly left unmarked
-     * merely previews its stored value, which is true. So the default takes the
-     * harmless side and the exception is typed.
-     */
-    offPage?: true;
-    /**
-     * DECLARED: this row NAMES the thing rather than saying anything to a shopper
-     * — a slide's own name, a box's name in the Layers tree, a card's display
-     * override. The Text entry list draws these in a folded group of their own, so
-     * a panel opens on the words a merchant is writing and not on the labels the
-     * editor needs (owner 2026-09-04, pointing at a Hero Slide's `Slide name` and
-     * `Category tag`: "every panel carries this, I think it is wrong").
-     *
-     * ⚠️ IT IS NOT {@link offPage}, AND THE TWO ARE INDEPENDENT. `offPage` answers
-     * "do the words reach a shopper"; this answers "is the row a name or is it
-     * copy". Three of the four fields that carry this ARE on the page — a slide
-     * name is printed in the reel rail — so deriving one from the other would have
-     * folded away a merchant's published copy. `Box name` is the only one that is
-     * both, and it is the coincidence that makes the pair look derivable.
-     *
-     * FOLDED, NOT DROPPED, and that is the whole design. The entry list is the
-     * ONLY way back into a part with no clickable words on the canvas
-     * (`components/SectionTextEntries.tsx`), and an EMPTY field never has any: an
-     * unset `Alt name` draws the category's name, not its own, so a row that
-     * vanished once hidden would stand the merchant up with no way to set one.
-     * A fold keeps every row reachable in one press and still answers the owner.
-     */
-    identifier?: true;
-    /** For `textList`, the key each row stores its copy under. */
-    itemKey?: string;
-    /** For `textList`, whether its rows go through `renderGold` — the same answer
-     *  {@link TextListRendering} makes the call site state, recorded here so a
-     *  ROW opened on its own (card 66090) offers the formatting bar exactly when
-     *  the whole list does. Without it the row control would have to guess, and a
-     *  bar on a `verbatim` list writes markers the shopper reads as asterisks. */
-    rendering?: TextListRendering;
-};
-/** Which of an edge pad's four live squares an answer sits in — the cell a
- *  direction option names beside its value (`lib/sections/ticker-scroll`), and
- *  the one the pad in `lib/puck/controls` lights. */
-type EdgeCell = "top" | "right" | "bottom" | "left";
-/** Marker carried by every media field object. The manifest GENERATOR walks the
- *  built config looking for it, so the factory below is the single source of
- *  truth for "this prop holds media" — a new media field is covered the moment
- *  it is declared, with no list to maintain anywhere (Puck ignores extra keys). */
-declare const MEDIA_FIELD_MARKER: "__media";
-/** Marker carried by every heading {@link group} / {@link section} builds — and
- *  by every bucket header {@link bucketHeader} builds, whose "heading" a
- *  merchant reads as a TAB. Same style as {@link TEXT_FIELD_MARKER} / {@link LINK_FIELD_MARKER}:
- *  the label and the level ON the field object, not only inside the render
- *  closure. Without it a header's label is unreadable at runtime — the closure
- *  is all there is — and the four-bucket pass (`lib/puck/field-groups.ts`) would
- *  have to re-derive it by parsing `config.tsx`, i.e. a second source of truth
- *  for something the field already knows. Puck ignores extra keys, and the
- *  neutralization walk classifies by its own markers / `type` / prop name, so a
- *  header stays exactly as invisible to it as it was (see
- *  `scripts/gen-neutralization-manifest.ts`). */
-declare const FOLD_FIELD_MARKER: "__fold";
-type FoldFieldMeta = {
-    label: string;
-    level: 1 | 2;
-};
-/** Read a field's fold-header payload, or null when it is not a header. The ONE
- *  place that knows the marker's shape. */
-declare function foldMetaOf(field: unknown): FoldFieldMeta | null;
-/**
- * Does this field DECLARE itself a name rather than copy? The read that pairs
- * with {@link withIdentifier}'s write, so the one fact has one reader — the same
- * shape as {@link textFieldOffPage}, and false for anything that is not a text
- * field at all rather than throwing.
- */
-declare function textFieldIdentifier(field: unknown): boolean;
-/**
- * The keys `anchorFields()` (lib/puck/controls) declares: the anchor's group
- * header and its name row. The style clipboard leaves them out of a copied
- * look — an anchor is the section's address, not its style — and reads them
- * here rather than calling the builder, so it needs nothing of the inspector's
- * field builders. scripts/test-anchor-field-keys.ts holds the two equal.
- */
-declare const ANCHOR_FIELD_KEYS: readonly ["_gAnchor", "anchor"];
-
-export { ANCHOR_FIELD_KEYS, type EdgeCell, FOLD_FIELD_MARKER, type FoldFieldMeta, LINK_FIELD_MARKER, MEDIA_FIELD_MARKER, SCAFFOLD_FIELD_MARKER, TEXT_FIELD_MARKER, type TextFieldMeta, type TextListRendering, foldMetaOf, textFieldIdentifier };
+export { ANCHOR_FIELD_KEYS, EdgeCell, FOLD_FIELD_MARKER, FoldFieldMeta, LINK_FIELD_MARKER, MEDIA_FIELD_MARKER, SCAFFOLD_FIELD_MARKER, TEXT_FIELD_MARKER, TextFieldMeta, TextListRendering, foldMetaOf, textFieldIdentifier } from '../document/field-markers.js';
+import '../document/text-control-kinds.js';

package/dist/screen/lib/puck/field-markers.js

@@ -1 +1 @@
-export{ANCHOR_FIELD_KEYS,FOLD_FIELD_MARKER,LINK_FIELD_MARKER,MEDIA_FIELD_MARKER,SCAFFOLD_FIELD_MARKER,TEXT_FIELD_MARKER,foldMetaOf,textFieldIdentifier}from"../../../chunk-DUVRZ456.js";
+export{ANCHOR_FIELD_KEYS,FOLD_FIELD_MARKER,LINK_FIELD_MARKER,MEDIA_FIELD_MARKER,SCAFFOLD_FIELD_MARKER,TEXT_FIELD_MARKER,foldMetaOf,textFieldIdentifier}from"../../../chunk-ANPOR6EY.js";

package/dist/screen/lib/puck/hidable.d.ts

@@ -1,44 +1 @@
-/**
- * hidable — the ONE reader for the shape a hideable copy row stores.
- *
- * Every authored-text row in the editor is one of five controls
- * (`lib/puck/text-control-kinds`), and two of them — `text()` and `textarea()` —
- * carry the eye that takes an element off the page while keeping the words. Those
- * two persist `{ text, hidden }`; the other three persist a bare string, and so
- * does every page published before the eye existed. A prop's stored value is
- * therefore an OBJECT OR A STRING, and which one it is depends on whether a
- * merchant has touched that row — not on anything a reader can see in the code.
- *
- * ⚠️ WHY THIS IS ITS OWN FILE. `readHidable` was born in `lib/puck/controls.tsx`
- * beside the field that writes the shape, and `controls.tsx` is React: it imports
- * the editor shell, the markup toolbar and 30 components. So a PURE module that
- * needs to read a stored heading could not use the one reader without dragging
- * the whole editor in — and `lib/puck/heading-outline.ts` is exactly that module
- * (its own header promises no React and no config import, so the audit can be
- * walked in a test without mounting the editor). It called `String(...)` on the
- * prop instead, and printed the literal words `[object Object]` into the outline
- * a merchant reads. Splitting the ~6 lines out costs nothing and removes the
- * reason anyone would ever write a second unwrapper. `controls.tsx` re-exports
- * both names, so every existing import site is unchanged.
- *
- * There is exactly one definition. Do not add a second way to unwrap this value.
- */
-/** A hideable row's stored value: the object, a bare string (a `plainText()` row
- *  or legacy data), or nothing at all. */
-type HidableValue = {
-    text?: string;
-    hidden?: boolean;
-} | string | undefined;
-declare function readHidable(v: HidableValue): {
-    text: string;
-    hidden: boolean;
-};
-/**
- * Plain-text view of a hidable field value — a `{ text, hidden }` object (a
- * `text()`/`textarea()` row) OR a bare string (a `plainText()` row / legacy data).
- * Funnels through here at read sites that need a string (e.g. a section's
- * `imageLabel`, a link `href`) so a stored object can never reach a React child.
- */
-declare function hidableText(v: HidableValue): string;
-
-export { type HidableValue, hidableText, readHidable };
+export { HidableValue, hidableText, readHidable } from '../document/hidable.js';

package/dist/screen/lib/puck/hidable.js

@@ -1 +1 @@
-export{hidableText,readHidable}from"../../../chunk-6W7WLPZH.js";
+export{hidableText,readHidable}from"../../../chunk-6UAEFOJ4.js";

package/dist/screen/lib/puck/palette-sections.d.ts

@@ -1,103 +1,8 @@
-import { Config } from '../../../blocks/index.js';
+export { PaletteLook, PaletteSection, buildPaletteSections, categoryLabel, matchesQuery, paletteWithoutPinned, pinnedSection } from '../document/palette-sections.js';
+import '../../../blocks/index.js';
 import 'react';
 import '../../../types-Cq53lL8d.js';
 import '../../../data/index.js';
 import '../../../types-41704JE4.js';
 import '../../../resolve-D68pb3Bx.js';
 import '../../../plan-CZS902DV.js';
-
-/** One offerable section, with the category it is grouped under. */
-type PaletteSection = {
-    type: string;
-    cat: string;
-    name: string;
-    desc: string;
-    /**
-     * The heading of the category this section sits under, resolved once at build
-     * time — SEARCHED, and already SHOWN as the nav row this card sits beneath.
-     *
-     * ⚠️ IT IS HERE BECAUSE THE NAV AND THE SEARCH DISAGREED. Seven of the
-     * thirteen category names returned NOTHING when typed: "Blog & journal" reads
-     * 5 in the nav, and "blog" found 0, because not one of Issue Header, Featured
-     * Cover, Article Text, Recurring Columns or Latest Posts carries the word. Same
-     * for shop, about, promotions, navigation, legal and layout. A merchant reads
-     * the word off the screen, types it, and is told no section matches.
-     *
-     * Resolved HERE, not in `matchesQuery`, because the label needs the `config`
-     * (`categoryLabel`) and the matcher is given only a section — passing config
-     * into the matcher would make every caller carry it.
-     */
-    catLabel: string;
-    /**
-     * Another word this section is known by, searched but never shown.
-     *
-     * ⚠️ THIS EXISTS FOR ONE NODE AND ONE REASON. `Flex` is offered here as
-     * "Blank section" and is called "Box" everywhere it is nested — so a merchant
-     * who met it in a Layers row, or in last week's handoff, types "box" and must
-     * still find it. Without this they would find NOTHING: the card is pinned out
-     * of its group, so a search that misses it misses it completely.
-     */
-    alias?: string;
-};
-/**
- * What the layer says of its sections for the palette: the word for a type at
- * a level, a group's short heading where it has one, and the blurbs. The
- * screen's `blockLook` is one (lib/screen-parts); so is the website's own
- * (lib/puck/add-palette).
- */
-interface PaletteLook {
-    /** What a node of `type` is called at a level, given the label the config
-     *  holds for it. */
-    labelAtLevel: (type: string, level: "section" | "block", base: string) => string;
-    /** A group's short heading, by its key, where the layer has one; undefined,
-     *  and the config's own title is the heading. */
-    categoryLabel: (id: string) => string | undefined;
-    /** The one-line blurb for a section, by type. */
-    descriptions: Record<string, string>;
-}
-/**
- * Flatten `config.categories` into an ordered section list.
- *
- * Grouping and order ARE the category order in the config — which is the
- * catalog's order — so this adds no opinion of its own. A component listed in a
- * category but absent from `components` is skipped: a stale catalog row cannot
- * render and certainly cannot insert, so offering it would be a card that fails
- * on click.
- *
- * Child-only blocks (HeroSlide / CollectionCard / ProductRef) and the four
- * generic primitives (Heading / Text / ImageBlock / ButtonBlock) sit in NO
- * category on purpose, so they never appear here — they are added from their
- * parent's slot instead. See the note above `categories:` in lib/puck/config.tsx.
- *
- * A category the config marks `visible: false` is NOT offered (0.105.0, seam
- * E9): it is a registry's way of keeping blocks it has out of the picker — the
- * campaign designer's Product parts, its retired blocks, its Sections — and a
- * palette that listed them would offer things that may not be put on a page.
- * Puck's own palette read the flag the same way. No website category carries
- * it, so the website's palette is the list it was.
- */
-declare function buildPaletteSections(config: Config, look: PaletteLook): PaletteSection[];
-/** A category's display label — the layer's short one where there is one, else the config's title. */
-declare function categoryLabel(config: Config, id: string, shortLabel: (id: string) => string | undefined): string;
-/**
- * Does a section match a search query?
- *
- * The query is matched against the NAME, any ALIAS, the blurb, the component
- * TYPE and the CATEGORY HEADING — the type because a merchant who knows the
- * section by the word they saw in a handoff should still find it, the alias
- * because one node is called something else everywhere it is nested (see
- * `PaletteSection.alias`), and the category because it is PRINTED IN THE NAV
- * BESIDE THE RESULTS: seven of thirteen headings used to match nothing at all
- * (see `PaletteSection.catLabel`). A word a merchant can read off this screen
- * must find what it is labelling.
- *
- * `q` is expected already lower-cased and trimmed; an empty query matches
- * everything.
- */
-declare function matchesQuery(s: PaletteSection, q: string): boolean;
-/** The pinned section, or `null` if the layer pins none or the config does not offer it. */
-declare function pinnedSection(sections: PaletteSection[], pinned: string | null): PaletteSection | null;
-/** Every OTHER section — what the grouped grid below the pinned card draws. */
-declare function paletteWithoutPinned(sections: PaletteSection[], pinned: string | null): PaletteSection[];
-
-export { type PaletteLook, type PaletteSection, buildPaletteSections, categoryLabel, matchesQuery, paletteWithoutPinned, pinnedSection };

package/dist/screen/lib/puck/palette-sections.js

@@ -1 +1 @@
-export{buildPaletteSections,categoryLabel,matchesQuery,paletteWithoutPinned,pinnedSection}from"../../../chunk-PA3PNTVV.js";
+export{buildPaletteSections,categoryLabel,matchesQuery,paletteWithoutPinned,pinnedSection}from"../../../chunk-VKPOH6MK.js";

package/dist/screen/lib/puck/panel-fields.d.ts

@@ -1,47 +1 @@
-/**
- * THE ROWS A PANEL IS REALLY DRAWING — not the ones its component declares.
- *
- * `config.components[type].fields` is a DECLARATION. A component's
- * `resolveFields` then culls it for the state that node is in: the Booking Form
- * gives its head rows away to the boxes that own them, Spec Table drops its Rows
- * array on a linked product, Image & Text Columns takes its text-position row
- * away once it has Boxes.
- *
- * `Puck.Fields` honours all of that. Every list built beside it from the raw
- * declaration does not — and one of them is the copy list in
- * `components/SectionEditor`. So a merchant met the SAME heading twice: once in
- * the panel Puck drew, and once in a list drawn from rows the resolver had
- * already dropped (owner, 2026-09-10, on a Booking Form's Head box).
- *
- * ⚠️ PUCK DOES NOT EXPOSE ITS RESOLVED SET. The store slice that holds it is
- * internal — `useEasel((s) => s)` and `createUsePuck()` both hand back `PuckApi`, which
- * has no `fields` on it (checked against 0.20.2's own types, not remembered). So
- * the resolver is asked here, the same way Puck asks it.
- *
- * ⚠️ AND AN ASYNC RESOLVER IS ANSWERED WITH THE DECLARATION. A promise cannot be
- * read during a render, and a list that waited would flicker rows in and out.
- * Falling back is the same answer this code gave before, so an async resolver is
- * no worse off than it was — it simply is not helped either. Stated because a
- * silent half-fix is the thing worth naming.
- */
-type PanelFieldMap = Record<string, unknown>;
-interface PanelComponent {
-    fields?: PanelFieldMap;
-    resolveFields?: (data: unknown, params: Record<string, unknown>) => unknown;
-}
-/**
- * The field map to build a panel-side list from, for one node.
- *
- * `parent` is passed as null and `appState` as an empty object because the ONE
- * caller uses the result for authored-copy rows, which no resolver decides from
- * either. A caller that needs the width rows — which DO read `parent` — must ask
- * Puck rather than this.
- */
-declare function panelFieldsOf(config: {
-    components?: Record<string, PanelComponent>;
-}, node: {
-    type: string;
-    props: Record<string, unknown>;
-} | null | undefined): PanelFieldMap | null;
-
-export { type PanelFieldMap, panelFieldsOf };
+export { PanelFieldMap, panelFieldsOf } from '../document/panel-fields.js';

package/dist/screen/lib/puck/panel-fields.js

@@ -1 +1 @@
-export{panelFieldsOf}from"../../../chunk-LER7RKTO.js";import"../../../chunk-BPXEFVSQ.js";
+export{panelFieldsOf}from"../../../chunk-5XL2RXFU.js";import"../../../chunk-BPXEFVSQ.js";