efficient-easel 0.99.1 → 0.100.0

package/dist/{types-pGBXevBU.d.ts → types-Djdq6Xkd.d.ts}

@@ -7,7 +7,7 @@ import { CSSProperties, ReactNode } from 'react';
  *  what the menus OFFER is not this card's to move. A `label` of `'—'` renders a
  *  separator; `header: true` renders a caption, and the FIRST such caption names
  *  the menu for assistive tech. */
-interface EditorContextMenuItem {
+interface EaselContextMenuItem {
     label: string;
     onClick: () => void;
     danger?: boolean;
@@ -16,7 +16,7 @@ interface EditorContextMenuItem {
      *  One level only — a child carrying its own `children` is drawn as a plain
      *  item, which is all any caller has needed and keeps the flyout from becoming
      *  a tree nobody can navigate with a mouse. */
-    children?: EditorContextMenuItem[];
+    children?: EaselContextMenuItem[];
     /** Draw a tick beside this item — for a submenu whose entries are STATES
      *  rather than actions, so it can say which one you are already on. */
     checked?: boolean;
@@ -65,7 +65,7 @@ interface EditorContextMenuItem {
  *
  * A slot left empty is left empty. The default fills all of them.
  */
-interface EditorContextMenuSkin {
+interface EaselContextMenuSkin {
     /** The box. */
     menu?: string;
     /** The FLYOUT box. Falls back to {@link menu} when a skin gives only one —
@@ -106,26 +106,33 @@ interface EditorContextMenuSkin {
     /** Merged into each row's inline style. */
     itemStyle?: CSSProperties;
 }
-interface EditorContextMenuProps {
+interface EaselContextMenuProps {
     /** Where the pointer was. The box is placed from here and then kept on
      *  screen — see the note on the component. */
     x: number;
     y: number;
-    items: EditorContextMenuItem[];
+    items: EaselContextMenuItem[];
     onClose: () => void;
     /** Cap the box's height; it scrolls past that. */
     maxHeight?: number;
     /** Defaults to {@link ES_MENU_SKIN}, the storefront editor's approved look. */
-    skin?: EditorContextMenuSkin;
+    skin?: EaselContextMenuSkin;
     /**
-     * Where to portal to. Defaults to `document.body`.
+     * Where to portal to. Defaults to `document.body` (`null` means the default).
      *
      * A host that OVERRIDES `--es-*` on its own editor root should pass that root
      * instead: the default skin re-declares the token defaults on the box (see the
      * component's note), which is right for a box hanging off `<body>` and wrong
      * for one that should inherit a re-themed editor's values.
+     *
+     * So should a host that wants the box INSIDE ITS LANDMARKS (on the body it
+     * is page content outside every landmark: axe-core's `region`) — through
+     * `menuPortalTarget(root)`, never the bare root: the box is `position:
+     * fixed`, and a transformed, filtered or contained ancestor places and clips
+     * it. `menuPortalTarget` answers the root only when none does. The decision
+     * is recorded in `./portal`.
      */
     portalTo?: HTMLElement | null;
 }
 
-export type { EditorContextMenuItem as E, EditorContextMenuProps as a, EditorContextMenuSkin as b };
+export type { EaselContextMenuItem as E, EaselContextMenuProps as a, EaselContextMenuSkin as b };

package/dist/{types-Dy6oR6Z2.d.ts → types-E3HrTPg2.d.ts}

@@ -3,12 +3,12 @@ import { I as ItemSelector, N as NodeSelection } from './plan-DChbUXdS.js';
 import { D as Data, S as SlotAddress, a as DataConfig, N as Node } from './types-41704JE4.js';
 
 /**
- * The editor's UI state, in Puck's shape so the apps' `appState.ui` reads move
+ * The easel's UI state, in Puck's shape so the apps' `appState.ui` reads move
  * over unchanged. `itemSelector` and `selectedSlot` are DERIVED from the
  * selection the store holds by id; every other key is the host's own and is
  * kept as written.
  */
-type EditorUi = Record<string, unknown> & {
+type EaselUi = Record<string, unknown> & {
     itemSelector: ItemSelector | null;
     /** The selected slot (a column), when a slot rather than a node is selected. */
     selectedSlot: SlotAddress | null;
@@ -22,7 +22,7 @@ type EditorUi = Record<string, unknown> & {
 /** Puck's public `appState`. */
 interface AppState {
     data: Data;
-    ui: EditorUi;
+    ui: EaselUi;
 }
 type Recordable = {
     recordHistory?: boolean;
@@ -34,13 +34,19 @@ type SetDataPatch = Partial<Data> | DataInput;
 /**
  * The actions the apps dispatch today — Puck 0.20's, with Puck's meaning. Zone
  * keys are `"<parentId>:<slot>"`; `root:default-zone` is the page's own list.
+ *
+ * `insert` puts the block in with its `defaultProps` and runs NO resolver, as
+ * Puck's reducer did not. What ran a new block's `resolveData` in Puck was its
+ * own drop from the component list; here that is `easel.resolveNode(id, {
+ * trigger: 'insert' })`, called by the host after the insert (pass the action
+ * an `id` so there is one to name).
  */
-type EditorAction = ({
+type EaselAction = ({
     type: 'setData';
     data: SetDataPatch | ((prev: Data) => SetDataPatch);
 } & Recordable) | ({
     type: 'setUi';
-    ui: Partial<EditorUi> | ((prev: EditorUi) => Partial<EditorUi>);
+    ui: Partial<EaselUi> | ((prev: EaselUi) => Partial<EaselUi>);
 } & Recordable) | ({
     type: 'set';
     state: Partial<AppState> | ((prev: AppState) => Partial<AppState>);
@@ -81,7 +87,7 @@ type EditorAction = ({
     index: number;
     zone: string;
 } & Recordable);
-/** What a block, the root or the whole editor allows. Puck's five. */
+/** What a block, the root or the whole easel allows. Puck's five. */
 interface Permissions {
     drag: boolean;
     duplicate: boolean;
@@ -93,7 +99,7 @@ interface Permissions {
 /** The config the store needs: the data layer's shape, plus each block's own
  *  `permissions` (Puck's per-component permissions). Rendering keys are the
  *  renderer's business and pass through untouched. */
-interface EditorConfig extends DataConfig {
+interface EaselConfig extends DataConfig {
     root?: DataConfig['root'] & {
         permissions?: Partial<Permissions>;
     };
@@ -102,7 +108,7 @@ interface EditorConfig extends DataConfig {
     }) | undefined>;
 }
 /** The state the store holds. The selection is BY ID. */
-interface EditorCore {
+interface EaselCore {
     data: Data;
     selection: NodeSelection;
     /** The host's own UI keys — everything but `itemSelector` / `selectedSlot`. */
@@ -115,7 +121,7 @@ interface HistoryEntry {
 }
 /** Puck's PUBLIC `history` (what `usePuck` hands out): `hasPast` and
  *  `hasFuture` are booleans there, read at the state they came with. */
-interface EditorHistory {
+interface EaselHistory {
     back: () => void;
     forward: () => void;
     hasPast: boolean;
@@ -126,18 +132,18 @@ interface EditorHistory {
     setHistoryIndex: (index: number) => void;
 }
 /**
- * What `useEditor` reads — Puck's `usePuck` state, so the apps' selectors move
+ * What `useEasel` reads — Puck's `usePuck` state, so the apps' selectors move
  * over by renaming the hook: `appState`, `selectedItem`, `dispatch`, `config`,
  * `history`, `getPermissions`, `getItemById`, `getSelectorForId`. Plus the
  * selection by id (`selection`), which Puck never had.
  */
-interface EditorView<C extends EditorConfig = EditorConfig> {
+interface EaselView<C extends EaselConfig = EaselConfig> {
     appState: AppState;
     selection: NodeSelection;
     selectedItem: Node | null;
     config: C;
-    dispatch: (action: EditorAction) => void;
-    history: EditorHistory;
+    dispatch: (action: EaselAction) => void;
+    history: EaselHistory;
     getPermissions: (params?: {
         item?: Node | null;
         type?: string;
@@ -150,4 +156,4 @@ interface EditorView<C extends EditorConfig = EditorConfig> {
     getSelectorForId: (id: string) => Required<ItemSelector> | undefined;
 }
 
-export type { AppState as A, EditorConfig as E, HistoryEntry as H, Permissions as P, SetDataPatch as S, EditorView as a, EditorAction as b, EditorCore as c, EditorUi as d, EditorHistory as e };
+export type { AppState as A, EaselConfig as E, HistoryEntry as H, Permissions as P, SetDataPatch as S, EaselView as a, EaselAction as b, EaselCore as c, EaselUi as d, EaselHistory as e };

package/dist/{types-C7HFvdtk.d.ts → types-VqL6t5HH.d.ts}

@@ -38,6 +38,9 @@ interface FieldNumberProps extends ControlBase {
     /** Two small stacked arrows at the cell's end. */
     steppers?: boolean;
     placeholder?: string;
+    /** The cell's tooltip — the text box's cells say their name and step here
+     *  (E5b), since the cell draws no name. */
+    title?: string;
 }
 /**
  * A slider row (Site styles, Email styles): the name left and the typed value
@@ -50,20 +53,94 @@ interface FieldSliderProps extends Omit<FieldNumberProps, 'icon' | 'steppers' |
     label: string;
     sliderMin: number;
     sliderMax: number;
+    /**
+     * The word for "no number of its own: each section draws its own" (plan
+     * step E6). Given, the slider gains one spot left of `sliderMin` that means
+     * it, and the value reads the word while there is no number.
+     */
+    auto?: string;
 }
 interface FieldOption<V = unknown> {
     label: string;
     value: V;
     disabled?: boolean;
     icon?: ReactNode;
+    /**
+     * The heading this option sits under in the open list — what `<optgroup>`
+     * did. Each RUN of options with the same group gets one heading, in the
+     * order the options come; an option with none sits under no heading. A
+     * heading is not an option: it cannot be chosen and the keys never land on it.
+     */
+    group?: string;
+    /**
+     * A small picture at the head of the row (a product's cover). One option
+     * with a `thumb` key gives EVERY row the picture column, so a mixed list
+     * keeps its columns; `null` draws the empty well. No option with the key, no
+     * column.
+     */
+    thumb?: string | null;
+    /**
+     * One quiet fact at the end of the row (a price, a count). It is not part
+     * of the option's name: a screen reader does not hear it, and the closed
+     * control never shows it.
+     */
+    meta?: string;
 }
-interface FieldSelectProps<V = unknown> extends ControlBase {
-    value: V | undefined;
+/**
+ * `ariaLabelledBy` / `ariaLabel` name the button AND its open list. Left out,
+ * the button is named by its `<label for>` (or by what it shows) and the list
+ * by the button, so the list is never without a name.
+ */
+interface FieldSelectBase<V> extends ControlBase {
     options: readonly FieldOption<V>[];
-    onChange: (value: V) => void;
-    /** Shown when the value names no option. */
+    /** Shown when the value names no option (when nothing is on, for `multiple`). */
     placeholder?: string;
+    /**
+     * A search box at the top of the open list. Typing narrows the options by
+     * label and the keys walk what is left; a letter goes into the box, so
+     * there is no letter jump. A long list (every product in a catalogue).
+     */
+    searchable?: boolean;
+    /**
+     * The search box's hint and name, in the host's own words ("Search your
+     * catalog…"). Left out, the catalogue's `fields.search`.
+     */
+    searchPlaceholder?: string;
+    /** Each group heading says how many of its options are showing. Derived, never passed. */
+    groupCount?: boolean;
+    /**
+     * The list opens IN FLOW, pushing the rows below it down, instead of
+     * floating. For a list inside a panel that scrolls, where a floating list is
+     * clipped by the panel's edge.
+     */
+    inline?: boolean;
+    /** Draws an option's row in place of its label (each style in its own face). It is still an option. */
+    renderOption?: (option: FieldOption<V>, state: {
+        active: boolean;
+        chosen: boolean;
+    }) => ReactNode;
+}
+/** One of a set. */
+interface FieldSelectOneProps<V = unknown> extends FieldSelectBase<V> {
+    multiple?: false;
+    value: V | undefined;
+    onChange: (value: V) => void;
+    /** Draws the closed control's value in place of the chosen label. */
+    renderValue?: (chosen: FieldOption<V> | undefined) => ReactNode;
 }
+/**
+ * Several of a set (`multiple`). The value is a list, saved in the order the
+ * OPTIONS come, never in the order they were ticked: two lists that look the
+ * same hold the same data. An empty list is an answer, not a missing one.
+ */
+interface FieldSelectManyProps<V = unknown> extends FieldSelectBase<V> {
+    multiple: true;
+    value: readonly V[] | undefined;
+    onChange: (value: V[]) => void;
+    /** Draws the closed control's value in place of the labels of what is on. */
+    renderValue?: (on: FieldOption<V>[]) => ReactNode;
+}
+type FieldSelectProps<V = unknown> = FieldSelectOneProps<V> | FieldSelectManyProps<V>;
 interface FieldMeta {
     label?: string;
     /** The tab this field opens; inherited by the fields after it (see above). */
@@ -148,4 +225,4 @@ type FieldRenderer = (props: {
     readOnly?: boolean;
 }) => ReactNode;
 
-export type { ArrayFieldDef as A, CustomFieldDef as C, FieldRenderer as F, InspectorFields as I, NumberFieldDef as N, ObjectFieldDef as O, RadioFieldDef as R, SelectFieldDef as S, TextFieldDef as T, InspectorFieldDef as a, FieldTextProps as b, FieldNumberProps as c, FieldSliderProps as d, FieldSelectProps as e, FieldOption as f, CustomFieldRenderProps as g, SlotFieldDef as h, TextareaFieldDef as i };
+export type { ArrayFieldDef as A, CustomFieldDef as C, FieldRenderer as F, InspectorFields as I, NumberFieldDef as N, ObjectFieldDef as O, RadioFieldDef as R, SelectFieldDef as S, TextFieldDef as T, InspectorFieldDef as a, FieldTextProps as b, FieldNumberProps as c, FieldSliderProps as d, FieldSelectManyProps as e, FieldSelectOneProps as f, FieldOption as g, CustomFieldRenderProps as h, FieldSelectProps as i, SlotFieldDef as j, TextareaFieldDef as k };

package/dist/{watch-DmasQA61.d.ts → watch-BTYOJpQU.d.ts}

@@ -32,15 +32,32 @@ interface WatchOptions {
      * `load` — and a measurement taken then measures nothing. For the editor's
      * canvas pass `BLOCK_SELECTOR`. Watched with a MutationObserver on the frame's
      * document, never polled.
+     *
+     * ⚠️ "Ready" then means "holds a block", so a page with NO blocks is never
+     * ready: the frame is not published, and nothing that needs the canvas (the
+     * drag layer, a canvas stylesheet, a context menu) works on an empty page —
+     * the one page a first block has to be dropped on. An editor whose page can
+     * be empty names something the canvas ALWAYS draws instead — a list,
+     * `LIST_SELECTOR`: the page's own is there with nothing in it — or leaves
+     * this out.
      */
     readySelector?: string;
 }
 /**
  * Every block the canvas draws carries this attribute. The markup is the one
- * Puck 0.20 drew, kept by the engine's own canvas (`efficient-easel/editor`)
+ * Puck 0.20 drew, kept by the engine's own canvas (`efficient-easel/easel`)
  * because both apps' canvas CSS and checks read it.
  */
 declare const BLOCK_SELECTOR = "[data-puck-component]";
+/**
+ * Every LIST the canvas draws carries this attribute — the page's own
+ * (`root:default-zone`) and each slot's — whether or not there is a block in
+ * it. So it is the `readySelector` for an editor whose page may be EMPTY: the
+ * canvas of a page with no blocks holds no `BLOCK_SELECTOR` and would never be
+ * published, on the one page a first block has to be dropped on (second host,
+ * 2026-10-07: it had typed the attribute out by hand to get this).
+ */
+declare const LIST_SELECTOR = "[data-puck-dropzone]";
 /** The canvas frame: Puck 0.20's, and the engine's own `CanvasFrame` since 0.89.0. */
 declare const CANVAS_SELECTOR = "iframe#preview-frame";
 /**
@@ -57,4 +74,4 @@ declare function isFrameReady(frame: HTMLIFrameElement): boolean;
  */
 declare function watchCanvasFrame(root: Node, onChange: (target: CanvasTarget | null) => void, { selector, readySelector }?: WatchOptions): () => void;
 
-export { BLOCK_SELECTOR as B, type CanvasTarget as C, type WatchOptions as W, CANVAS_SELECTOR as a, isFrameReady as i, watchCanvasFrame as w };
+export { BLOCK_SELECTOR as B, type CanvasTarget as C, LIST_SELECTOR as L, type WatchOptions as W, CANVAS_SELECTOR as a, isFrameReady as i, watchCanvasFrame as w };

package/dist/{wordFit-9B9nqyf3.d.ts → wordFit-D4S36PvB.d.ts}

@@ -7,7 +7,7 @@
  *
  *   `SettingsSegmented`   the host passes its measured `fit`;
  *   the top-bar rail      `TopBarRail` measures the words in the browser and
- *                         hands `EditorRail` the result.
+ *                         hands `EaselRail` the result.
  *
  * Both numbers are the width of TEXT ONLY, in the strip's own type, and neither
  * includes any padding, glyph or gap: those are the strip's, and the sheet adds

package/dist/{words-DagJdwIA.d.ts → words-AHHfiaRY.d.ts}

@@ -1,7 +1,8 @@
 /**
  * The editor frame's own words (`efficient-easel/strings`, 0.95.0), in two
- * groups: what `EditNotice` says (`NoticeWords`) and the few words the rest of
- * the chrome carries when the host gives none (`ChromeWords`).
+ * groups: what `EditNotice` says (`NoticeWords`) and the words the rest of the
+ * chrome carries when the host gives none (`ChromeWords`), the media panel's
+ * head among them.
  *
  * A plain module with no import. Anything with a value in it is a function, so
  * a host puts the name, the noun and the time where its language wants them.
@@ -73,6 +74,34 @@ type ChromeWords = {
     }) => string;
     /** `PanelResizeHandle`: the tooltip. */
     resize: string;
+    /** `MediaPanelHead`, browsing: the panel's name. */
+    mediaLibrary: string;
+    /** `MediaPanelHead`, choosing: the panel's name. `kind` is a `mediaKinds` word. */
+    mediaChoose: (v: {
+        kind: string;
+    }) => string;
+    /** `MediaPanelHead`, choosing: the line under the name. `field` is the host's label for the field. */
+    mediaFor: (v: {
+        field: string;
+    }) => string;
+    /** What a field can hold, as the head says it, by `MediaPickKind`. */
+    mediaKinds: {
+        image: string;
+        video: string;
+        svg: string;
+    };
+    /** `MediaPanelHead`: the word that leaves choosing. */
+    mediaCancel: string;
+    /** `MediaPanelHead`: Cancel's tooltip. `kind` is a `mediaKinds` word. */
+    mediaKeep: (v: {
+        kind: string;
+    }) => string;
+    /** The Hide panel button at the end of a side panel's head: the tooltip. */
+    hidePanel: string;
+    /** The same button: its accessible name. */
+    hidePanelLabel: (v: {
+        side: 'left' | 'right';
+    }) => string;
 };
 
 export type { ChromeWords as C, NoticeWords as N };

package/dist/{words-D9ChvbNC.d.ts → words-BDignMl_.d.ts}

@@ -6,7 +6,7 @@
  * A plain module with no import, in drag's own folder: drag may reach only its
  * lane (`tests/drag-leaf-safety.test.ts`), so `AddPanel` and `CanvasDragLayer`
  * do NOT read the strings provider. They take their group as `words`, and a
- * host passes `useEditorStrings().drag.add` / `.drag.canvas`.
+ * host passes `useEaselStrings().drag.add` / `.drag.canvas`.
  */
 type DragWords = {
     add: {

package/dist/{words-Cqmyey0s.d.ts → words-BMzV04b1.d.ts}

@@ -1,4 +1,4 @@
-import { S as SaveTone } from './types-CnRzp9oc.js';
+import { S as SaveTone } from './types-DGcCsxs8.js';
 
 /** Time and timers, passed in so a test can run minutes in a millisecond. */
 type AutosaveClock = {
@@ -121,7 +121,7 @@ type SaveWords = {
     unsaved: string;
 };
 /**
- * `words` is the host's language (`useEditorStrings().save`); left out, the
+ * `words` is the host's language (`useEaselStrings().save`); left out, the
  * pill speaks English as it always has.
  */
 declare function saveIndicator(state: AutosaveSnapshot, words?: SaveWords): SaveIndicator;

package/dist/words-CJjUKcV5.d.ts

@@ -0,0 +1,37 @@
+import { S as SettingsBucket } from './buckets-CuLM47h9.js';
+
+/**
+ * The settings panel's own words (`efficient-easel/strings`, 0.95.0): what
+ * the tab strip is called, what each tab SAYS, and the Default / Reset part.
+ *
+ * A bucket's key (`'Content'`, `'Style'`, …) is an identifier — fields name
+ * their tab with it and `SETTINGS_BUCKETS` orders them — so it never changes
+ * with the language. `buckets` is the word drawn for each key.
+ *
+ * The panel is hook-free, so nothing here is read from the strings provider:
+ * `SettingsTabs` takes its name as `ariaLabel` and each tab's word as the
+ * item's `label`, and `Inspector` (which has hooks) passes both.
+ * `SettingsDefaultReset` takes `words`, and a host passes the four from
+ * `useWords('panel', …)`.
+ */
+
+type PanelWords = {
+    /** The tab strip's accessible name. */
+    settings: string;
+    /** The word each tab shows, by its key. */
+    buckets: Record<SettingsBucket, string>;
+    /** `SettingsDefaultReset`, resting: the value follows its default. */
+    followsDefault: string;
+    /** `SettingsDefaultReset`, changed: the button that clears the value. */
+    reset: string;
+    /** The Reset button's accessible name — which setting it resets. */
+    resetName: (p: {
+        label: string;
+    }) => string;
+    /** The Reset button's tooltip, when the host says what the default is. */
+    backToDefault: (p: {
+        detail: string;
+    }) => string;
+};
+
+export type { PanelWords as P };

package/dist/words-CRYvAiHX.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The text-styles list's own words (`efficient-easel/strings`, plan step E6).
+ * A style's NAME is the host's data ("Heading 1" is stored); `styleName` is
+ * only how a NEW one is named. The fonts' and theme colours' names are the
+ * host's too.
+ *
+ * A plain module with no import. The English is the design's own (both pages,
+ * final 2026-10-06): "Body", never "Paragraph" (N10.1); US spelling, "Color".
+ */
+type TextStylesWords = {
+    /** The two group headings, in the order they are drawn. */
+    groups: {
+        heading: string;
+        body: string;
+    };
+    /** The button under each group. */
+    add: {
+        heading: string;
+        body: string;
+    };
+    /** Beside the button: how many there are of the most allowed. */
+    count: (v: {
+        n: number;
+        max: number;
+    }) => string;
+    /** The button's tooltip once the group is full. */
+    full: (v: {
+        kind: 'heading' | 'body';
+        max: number;
+    }) => string;
+    /** A new style's name. `n` counts from 1 within its kind. */
+    styleName: (v: {
+        kind: 'heading' | 'body';
+        n: number;
+    }) => string;
+    /** Delete's tooltip: the same word as the Layers delete and the node menu. */
+    remove: string;
+    /** Delete's accessible name. `name` is the style's: "Heading 4". */
+    removeNamed: (v: {
+        name: string;
+    }) => string;
+    /** The line an open style's preview is drawn in, unless the host gives its own. */
+    sample: string;
+    /** The preview's accessible name. */
+    preview: string;
+    /** A row's grey line. Each part is already words: "16 px", "Auto", "Regular". */
+    summary: (v: {
+        font: string;
+        size: string;
+        weight: string;
+    }) => string;
+    /** A size in the grey line. */
+    px: (v: {
+        n: number;
+    }) => string;
+    /** No number of its own: each section draws its own. */
+    auto: string;
+    /** A weight's name, by the hundred it is nearest. */
+    weights: {
+        thin: string;
+        extraLight: string;
+        light: string;
+        regular: string;
+        medium: string;
+        semibold: string;
+        bold: string;
+        extraBold: string;
+        black: string;
+    };
+    /** Each setting's name in an open style. */
+    settings: {
+        font: string;
+        color: string;
+        size: string;
+        weight: string;
+        /** The B · I row (Site styles). */
+        emphasis: string;
+        lineSpacing: string;
+        letterSpacing: string;
+        paragraphSpacing: string;
+        letterCase: string;
+        largestSize: string;
+    };
+    bold: string;
+    italic: string;
+    /** The Italic button's tooltip when the font has no italic. */
+    italicMissing: string;
+    /** Letter case's buttons. */
+    case: {
+        auto: string;
+        autoTitle: string;
+        none: string;
+        upper: string;
+        lower: string;
+    };
+    colour: {
+        /** The rainbow swatch at the end of the theme's colours. */
+        any: string;
+        /** What the Color row reads while the style has no colour of its own. */
+        follows: string;
+    };
+};
+declare const DEFAULT_TEXT_STYLES_WORDS: TextStylesWords;
+
+export { DEFAULT_TEXT_STYLES_WORDS as D, type TextStylesWords as T };

package/dist/{words-B2YLaKEr.d.ts → words-CnnHb9jo.d.ts}

@@ -6,7 +6,7 @@
  * A plain module with no import. The style clipboard imports React's JSX
  * runtime and nothing else (`tests/style-clipboard-leaf-safety.test.ts`), so it
  * reads no provider: `styleMenuItems` and `pasteMessage` take these as an
- * argument, and a host passes `useEditorStrings().styleClipboard`.
+ * argument, and a host passes `useEaselStrings().styleClipboard`.
  */
 type StyleClipboardWords = {
     /** The Copy style row. */

package/dist/{words-CD3WADyb.d.ts → words-CzoyDNHm.d.ts}

@@ -13,6 +13,10 @@ type FieldsWords = {
     more: string;
     /** `FieldSelect`: what the box says while nothing is chosen. */
     choose: string;
+    /** `FieldSelect` with `searchable`: the search box's hint and name. Optional: a host's older catalogue falls back to the English. */
+    search?: string;
+    /** `FieldSelect` with `searchable`: what the list says when nothing matches. */
+    noMatches?: string;
     /** `ListField` — an array field drawn as rows. */
     list: {
         /** One item's word when the field names none. */