efficient-easel 0.0.0 → 0.96.0

package/dist/types-pGBXevBU.d.ts

@@ -0,0 +1,131 @@
+import { CSSProperties, ReactNode } from 'react';
+
+/** One row of the menu.
+ *
+ *  Carried over unchanged from `efficient-admin-portal`'s `RowContextMenuItem`
+ *  (card 66039), because the campaign designer's registry is typed against it and
+ *  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 {
+    label: string;
+    onClick: () => void;
+    danger?: boolean;
+    header?: boolean;
+    /** A SUBMENU: this item opens a flyout of these instead of acting itself.
+     *  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[];
+    /** 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;
+    /**
+     * A glyph for the row, drawn before the label.
+     *
+     * ⚠️ A TYPE SLOT, NOT A LOOKUP. The box renders what it is handed and does
+     * not know what a glyph means — it must never import the icon set, or the
+     * leaf stops being a leaf (`tests/menu-leaf-safety.test.ts` (a) fails if it
+     * tries). Hosts pass an element from `efficient-easel/icons`, whose four
+     * menu glyphs — copy, paste, move-up, move-down — shipped in 0.30.0 for
+     * exactly this row.
+     *
+     * OMIT IT AND NOTHING IS DRAWN — not an empty span. That is what keeps the
+     * admin portal's three shipped surfaces byte-identical, and it is pinned by
+     * `tests/menu-layer.test.tsx` (g).
+     */
+    icon?: ReactNode;
+    /**
+     * The keyboard shortcut, drawn right-aligned after the label (the `.k`
+     * column of the approved drawing).
+     *
+     * Display text, not a binding — the box neither registers nor honours it;
+     * the host owns the key handling. `aria-hidden`, like the tick and the
+     * chevron: "Duplicate ⌘D" read aloud is worse than "Duplicate".
+     *
+     * OMIT IT AND NOTHING IS DRAWN. Same guard as `icon`.
+     */
+    shortcut?: string;
+}
+/**
+ * What the box is dressed in.
+ *
+ * ⚠️ A SKIN IS TOTAL. Pass one and it replaces {@link ES_MENU_SKIN} outright —
+ * nothing from the default is merged in underneath. That is not tidiness, it is
+ * the only arrangement that keeps the admin portal's three shipped render sites
+ * looking the way they do:
+ *
+ *   · their look is Tailwind classes, and Tailwind v4 scans the project root and
+ *     NOT `node_modules` (`efficient-admin-portal/src/index.css:13-22` says so in
+ *     its own words, and adds `@source` lines for efficient-shell because of it);
+ *   · so those class strings have to keep living in that project's own `src/`,
+ *     where its build still sees them — they cannot move into this package;
+ *   · and a merge would append a class of ours to a caller's string, which is
+ *     the one thing that stops the rendered markup being byte-identical.
+ *
+ * A slot left empty is left empty. The default fills all of them.
+ */
+interface EditorContextMenuSkin {
+    /** The box. */
+    menu?: string;
+    /** The FLYOUT box. Falls back to {@link menu} when a skin gives only one —
+     *  they are the same surface in the default look, but not everywhere: the
+     *  admin portal's box carries `overflow-y-auto` (it takes a `maxHeight`) and
+     *  its flyout does not. Collapsing the two would quietly change the markup of
+     *  a surface already in front of users. */
+    menuSub?: string;
+    /** A plain row. */
+    item?: string;
+    /** A row that destroys something. */
+    itemDanger?: string;
+    /** The `'—'` separator. */
+    divider?: string;
+    /** A `header: true` caption. */
+    header?: string;
+    /** The label span of a row that has something beside it — a chevron, a tick.
+     *  A row that is only a label renders bare text and takes no class at all,
+     *  which is what the two grid callers have always drawn. */
+    label?: string;
+    /** The label span inside a FLYOUT. Falls back to {@link label} when a skin
+     *  gives only one — the admin portal wants them different, because a state
+     *  name in a flyout can be long enough to need truncating and a row in the box
+     *  never is. */
+    labelSub?: string;
+    /** The glyph column, when a row carries an `icon`. */
+    icon?: string;
+    /** The right-aligned shortcut column, when a row carries a `shortcut`. */
+    shortcut?: string;
+    /** The `›` on a row that opens a flyout. */
+    chevron?: string;
+    /** The tick column of a flyout whose entries are states. */
+    tick?: string;
+    /** Merged into the box's own inline style, under the placement this component
+     *  computes — so a caller can hand it a surface (the admin passes
+     *  `glassStyle()` from efficient-shell) without being able to move it. */
+    surface?: CSSProperties;
+    /** Merged into each row's inline style. */
+    itemStyle?: CSSProperties;
+}
+interface EditorContextMenuProps {
+    /** 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[];
+    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;
+    /**
+     * Where to portal to. Defaults to `document.body`.
+     *
+     * 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.
+     */
+    portalTo?: HTMLElement | null;
+}
+
+export type { EditorContextMenuItem as E, EditorContextMenuProps as a, EditorContextMenuSkin as b };

package/dist/useNodeOps-6IAej9jy.d.ts

@@ -0,0 +1,68 @@
+import { N as Node, S as SlotAddress, D as Data, a as DataConfig, P as Place } from './types-DziKCwsN.js';
+import { N as NodeSelection, A as AfterRemove, S as StepBounds } from './plan-DtNw2VuI.js';
+
+/**
+ * The node clipboard — what Copy and Cut hold, and Paste reads.
+ *
+ * In memory, one per editor (the host makes it once, at module scope, the way
+ * the storefront's NodeContextMenu kept a module-level `clipboard`), with
+ * subscribers so a menu that is open when something is copied can offer Paste
+ * straight away. Not the system clipboard, and not storage: a block is a JSON
+ * tree with ids that only mean something inside this document.
+ *
+ * Framework-free; ./useNodeOps reads it through useSyncExternalStore.
+ */
+
+interface ClipboardEntry {
+    /** The block as it was copied — pasted through `copyNode`, so every paste gets fresh ids. */
+    node: Node;
+    /** What the menu calls it: "Paste ‹label›". */
+    label: string;
+    /** Where it was copied from. A host that only pastes into the same kind of
+     *  list (the storefront: same zone) compares against this. */
+    from: SlotAddress;
+}
+interface NodeClipboard {
+    get(): ClipboardEntry | null;
+    set(entry: ClipboardEntry | null): void;
+    subscribe(listener: () => void): () => void;
+}
+declare function createNodeClipboard(): NodeClipboard;
+
+interface NodeOpsHost {
+    data: Data;
+    config: DataConfig;
+    /** Write the next document and selection — ONCE. `select: undefined` keeps the selection. */
+    commit(data: Data, options: {
+        select: NodeSelection | undefined;
+    }): void;
+    readOnly?: boolean;
+    /** Applied to every copied node (duplicate, paste): e.g. release a baked image's id. */
+    strip?: (node: Node) => Node;
+    /** What a delete selects: nothing (default) or a neighbour. */
+    afterRemove?: AfterRemove;
+    /** The range a node may step within its list; default the whole list. */
+    stepBounds?: StepBounds;
+    /** Is a slot (a column) a level of its own for "up one level"? */
+    slotIsLevel?: (parent: Node, slot: string) => boolean;
+    clipboard?: NodeClipboard;
+}
+declare function useNodeOps(host: NodeOpsHost): {
+    /** What Copy / Cut last put on the clipboard. */
+    held: ClipboardEntry | null;
+    remove: (id: string) => boolean;
+    duplicate: (id: string) => boolean;
+    move: (id: string, to: Place) => boolean;
+    step: (id: string, dir: -1 | 1) => boolean;
+    canStep: (id: string, dir: -1 | 1) => boolean;
+    setProps: (id: string, patch: Record<string, unknown>) => boolean;
+    copy: (id: string, label: string) => boolean;
+    /** Copy, then delete — the delete is the one commit. */
+    cut: (id: string, label: string) => boolean;
+    paste: (at: Place) => boolean;
+    /** Where "up one level" goes from `selection`, or null when there is nothing above. */
+    parentOf: (selection: NodeSelection) => NodeSelection;
+};
+type NodeOps = ReturnType<typeof useNodeOps>;
+
+export { type ClipboardEntry as C, type NodeClipboard as N, type NodeOps as a, type NodeOpsHost as b, createNodeClipboard as c, useNodeOps as u };

package/dist/watch-DmasQA61.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Finding the canvas frame and its document — ONCE, with no polling.
+ *
+ * Both editors draw the canvas inside an iframe (today Puck's
+ * `<iframe id="preview-frame">`; later the engine's own CanvasFrame). The frame
+ * gives no "ready" callback, its document arrives ASYNCHRONOUSLY (a srcdoc
+ * frame starts on an empty about:blank document and swaps to the real one on
+ * `load`), and the frame element itself can be replaced by a re-render. The
+ * apps answered that with eight separate setInterval / setTimeout loops, each
+ * with its own interval and its own idea of when to give up (blueprint §2 row
+ * 6). This is the one watcher they all read:
+ *
+ *   - a MutationObserver on the editor's root notices the frame being added,
+ *     removed or replaced;
+ *   - the frame's own `load` event says its document was (re)placed;
+ *   - `onChange` is called with the current `{ frame, document, window }` —
+ *     or `null` — only when one of those actually changed.
+ *
+ * Pure DOM, no React (the hook in ./index wraps it). Nothing runs at import.
+ */
+interface CanvasTarget {
+    frame: HTMLIFrameElement;
+    document: Document;
+    window: Window;
+}
+interface WatchOptions {
+    /** How the frame is found under `root`. Puck's canvas is the default. */
+    selector?: string;
+    /**
+     * Publish the frame only once its document holds an element matching this.
+     * A loaded frame can still be EMPTY — Puck portals the blocks in after
+     * `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.
+     */
+    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`)
+ * because both apps' canvas CSS and checks read it.
+ */
+declare const BLOCK_SELECTOR = "[data-puck-component]";
+/** The canvas frame: Puck 0.20's, and the engine's own `CanvasFrame` since 0.89.0. */
+declare const CANVAS_SELECTOR = "iframe#preview-frame";
+/**
+ * Is this frame's CURRENT document the real one, not the placeholder it starts
+ * with? A `srcdoc` frame is real once its document says `about:srcdoc`; a `src`
+ * frame once it has left the initial about:blank; either must have finished
+ * parsing (`readyState` past `loading`) so its `<body>` exists.
+ */
+declare function isFrameReady(frame: HTMLIFrameElement): boolean;
+/**
+ * Watch `root` for the canvas frame. Calls `onChange` once straight away with
+ * the current state, then again whenever the frame or its document changes.
+ * Returns a function that stops watching.
+ */
+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 };

package/dist/wordFit-9B9nqyf3.d.ts

@@ -0,0 +1,35 @@
+/**
+ * WHERE A STRIP'S WORDS STOP FITTING — the one thing the shell cannot know
+ * about a strip whose words belong to the host, measured by whoever owns the
+ * words.
+ *
+ * Two strips use it, and they use ONE rule (`panel.css`, "word fit"):
+ *
+ *   `SettingsSegmented`   the host passes its measured `fit`;
+ *   the top-bar rail      `TopBarRail` measures the words in the browser and
+ *                         hands `EditorRail` 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
+ * them. That split is the point — a card that re-pads a button moves every
+ * threshold with it, instead of leaving each consumer holding a number that
+ * went stale silently.
+ *
+ * AN OVER-ESTIMATE IS SAFE and an under-estimate is not: too large drops the
+ * words a little early, too small draws a button past the strip's edge.
+ */
+interface WordFit {
+    /** The sum of every label's width, px. Decides where ALL the words go. */
+    labelsPx: number;
+    /**
+     * The WIDEST single label, px. Decides where the chosen one goes too.
+     *
+     * The widest and not the current one: the person may be on any option, and
+     * a strip that fits while "Bold" is chosen and overflows on "Semibold" is a
+     * strip that overflows. It also keeps the strip in one state while the
+     * person clicks along it — the state follows the width, not the click.
+     */
+    widestLabelPx: number;
+}
+
+export type { WordFit as W };

package/dist/words-B2YLaKEr.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copy style and Paste style's own words (`efficient-easel/strings`, 0.95.0):
+ * the two menu rows and what a merchant reads after a paste. A component's
+ * name (`source`, `target`) is the host's.
+ *
+ * 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`.
+ */
+type StyleClipboardWords = {
+    /** The Copy style row. */
+    copy: string;
+    /** The Paste style row. `source` is what the held style was copied from. */
+    paste: (v: {
+        source: string;
+    }) => string;
+    /** After a paste where no setting matched. */
+    nothing: (v: {
+        source: string;
+        target: string;
+    }) => string;
+    /** After a paste. `count` is the settings a merchant sees in the panel, one or more. */
+    pasted: (v: {
+        count: number;
+        source: string;
+    }) => string;
+};
+
+export type { StyleClipboardWords as S };

package/dist/words-B87GIFWH.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The pickers' own words (`efficient-easel/strings`, 0.95.0). The row's name
+ * (`label`) and a theme colour's name are the host's.
+ *
+ * A plain module with no import, in the pickers' own folder: they may reach
+ * nothing else (`tests/pick-leaf-safety.test.ts`), so they do NOT read the
+ * strings provider. `ColourPicker` and `ImageBox` take their group as `words`,
+ * and a host passes `useEditorStrings().pick.colour` / `.pick.image`.
+ */
+type PickWords = {
+    colour: {
+        /** What the row says while the setting has no colour. */
+        notSet: string;
+        /** The swatch's accessible name. `shown` is the hex, the caption or `notSet`. */
+        swatch: (v: {
+            label: string;
+            shown: string;
+        }) => string;
+        /** The accessible name of the box the swatch opens. */
+        dialog: (v: {
+            label: string;
+        }) => string;
+        /** The group of theme colours at the top of that box. */
+        theme: string;
+        /** A theme colour's tooltip. */
+        themeSwatchTitle: (v: {
+            name: string;
+            hex: string;
+        }) => string;
+        /** A theme colour's accessible name. */
+        themeSwatch: (v: {
+            name: string;
+            hex: string;
+        }) => string;
+        /** The square's accessible name. */
+        square: string;
+        /** The square's value, read out. Both are percentages: "40%". */
+        squareValue: (v: {
+            saturation: string;
+            brightness: string;
+        }) => string;
+        /** The strip's accessible name. */
+        hue: string;
+        /** The hex box's accessible name. */
+        hex: (v: {
+            label: string;
+        }) => string;
+    };
+    image: {
+        /** While the library is open. */
+        choosing: string;
+        /** The library threw. */
+        failed: string;
+        /** The empty box, for a picture. */
+        chooseImage: string;
+        /** The empty box, for a video. */
+        chooseVideo: string;
+        /** The empty box's accessible name. `placeholder` is the host's own words for the empty box, when it gave any. */
+        empty: (v: {
+            label: string;
+            kind: 'image' | 'video';
+            placeholder?: string;
+        }) => string;
+        /** The line under the empty box's words. */
+        hint: string;
+        /** The picture's (or the video's) accessible name, once its file has a name. */
+        named: (v: {
+            label: string;
+            name: string;
+        }) => string;
+        /** The Replace button. */
+        replace: string;
+        /** The Replace button's accessible name. */
+        replaceNamed: (v: {
+            label: string;
+        }) => string;
+        /** The Remove button. */
+        remove: string;
+        /** The Remove button's accessible name. */
+        removeNamed: (v: {
+            label: string;
+        }) => string;
+    };
+};
+
+export type { PickWords as P };

package/dist/words-BK-npta-.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The Layers tree's own words (`efficient-easel/strings`, 0.95.0): the drag
+ * hint and the caret's. A row's name, its marks and its actions are the
+ * host's.
+ *
+ * The tree is hook-free, so it does not read the strings provider: `TreeRow`
+ * takes these as its `words` prop and a host passes
+ * `useEditorStrings().tree`.
+ */
+type TreeWords = {
+    /** What a draggable row says after 0.7 s on it. */
+    dragHint: string;
+    /** The caret's tooltip while the row is open. */
+    collapse: string;
+    /** The caret's tooltip while the row is folded. */
+    expand: string;
+    /** The caret's accessible name while open. `label` is the host's word for what folds: "section". */
+    collapseNamed: (v: {
+        label: string;
+    }) => string;
+    /** The caret's accessible name while folded. */
+    expandNamed: (v: {
+        label: string;
+    }) => string;
+};
+
+export type { TreeWords as T };

package/dist/words-CD3WADyb.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The settings rows' own words (`efficient-easel/strings`, 0.95.0): the number
+ * box's two buttons, the dropdown's empty state and everything a list field
+ * says. A row's label, its options and its hint are the block's.
+ *
+ * A plain module with no import. `noun` is one item's word, lower case — the
+ * field's own (`noun: 'slide'`) or `list.item`.
+ */
+type FieldsWords = {
+    /** `FieldNumber`: the − button. */
+    less: string;
+    /** `FieldNumber`: the + button. */
+    more: string;
+    /** `FieldSelect`: what the box says while nothing is chosen. */
+    choose: string;
+    /** `ListField` — an array field drawn as rows. */
+    list: {
+        /** One item's word when the field names none. */
+        item: string;
+        /** An item's name when it has none of its own: "Slide 2". `n` counts from 1. */
+        itemName: (v: {
+            noun: string;
+            n: number;
+        }) => string;
+        /** Where the open item sits: "2 of 5". */
+        position: (v: {
+            n: number;
+            total: number;
+        }) => string;
+        /** The open item's copy button. */
+        duplicate: string;
+        /** A row's copy action. */
+        duplicateItem: (v: {
+            noun: string;
+        }) => string;
+        /** A row's delete action, and the open item's delete button. */
+        deleteItem: (v: {
+            noun: string;
+        }) => string;
+        /** The button under the list. */
+        add: (v: {
+            noun: string;
+        }) => string;
+        /** The "+" between two rows. */
+        addHere: (v: {
+            noun: string;
+        }) => string;
+    };
+};
+
+export type { FieldsWords as F };

package/dist/words-CsRWXkY4.d.ts

@@ -0,0 +1,129 @@
+import { S as SaveTone } from './types-CuNiSnX6.js';
+
+/** Time and timers, passed in so a test can run minutes in a millisecond. */
+type AutosaveClock = {
+    now: () => number;
+    setTimeout: (fn: () => void, ms: number) => unknown;
+    clearTimeout: (handle: unknown) => void;
+};
+/** What an editor needs to draw about its saving. Replaced, never mutated. */
+type AutosaveSnapshot = Readonly<{
+    /** An edit is not on the server yet (held, waiting, being written or failed). */
+    pending: boolean;
+    /** …and has not been for `unsavedAfterMs`: the one time to say so. */
+    unsaved: boolean;
+    /** The last save failed; the next try is on the backoff (or "Retry now"). */
+    failed: boolean;
+    /** Failed saves in a row. Back to 0 once one lands. */
+    attempt: number;
+    /** A save has landed since this editor opened (the pill's green dot). */
+    saved: boolean;
+    /** The operator paused autosave: edits are held, not written. */
+    paused: boolean;
+    /** A save was refused (`stop()`): nothing more is written. */
+    stopped: boolean;
+}>;
+type AutosaveOptions<T> = {
+    /** Write one document. A rejection is a failed save and starts the backoff.
+     *  Optional so a host can create the autosave first and install the save
+     *  later (`setSave`) — a React host's save closes over props that change. */
+    save?: (value: T) => Promise<void>;
+    /** Told about each failed save, with its 0-based number in the current run —
+     *  a host warns on 0 only, not once per retry. Not called for a save that
+     *  `stop()` was called during: that one is the host's own to report. */
+    onFailure?: (error: unknown, attempt: number) => void;
+    debounceMs?: number;
+    maxWaitMs?: number;
+    unsavedAfterMs?: number;
+    retryDelays?: readonly number[];
+    clock?: AutosaveClock;
+};
+type Autosave<T> = {
+    /** Swap in the current save. The autosave is built ONCE (it holds the edit). */
+    setSave: (save: (value: T) => Promise<void>) => void;
+    /** The newest edit. Replaces any earlier unsaved one: only the latest is worth writing. */
+    push: (value: T) => void;
+    /** Write everything now, skipping the wait — even while paused, because the
+     *  operator (or the host on their behalf) asked. Resolves `true` when nothing
+     *  is left unsaved, `false` when a save failed or the autosave is stopped. */
+    flush: () => Promise<boolean>;
+    /** "Retry now": the backoff starts again from its first step, and the save goes now. */
+    retryNow: () => Promise<boolean>;
+    /** Hold edits instead of writing them on a timer. */
+    pause: () => void;
+    /** Stop holding, and write what was held at once. */
+    resume: () => Promise<boolean>;
+    /** A save was refused: write nothing more, keep the edit. Not undone by `resume`. */
+    stop: () => void;
+    /** Start over for ANOTHER document, in the same editor: the pending edit is
+     *  dropped (the host has already saved or discarded it), and a failure, a
+     *  refusal and the saved dot go with it — they were about the old document.
+     *  A save still in flight finishes, but its answer no longer touches anything.
+     *  A pause stays: it is the operator's, not the document's. */
+    reset: () => void;
+    /** An edit is not on the server yet — what the close-tab warning reads. */
+    hasPending: () => boolean;
+    getSnapshot: () => AutosaveSnapshot;
+    /** Called when the snapshot changes. Returns the unsubscribe. */
+    subscribe: (listener: () => void) => () => void;
+    /** Schedule nothing more. Keeps the edit; `flush()` first if it should go. */
+    dispose: () => void;
+};
+declare function createAutosave<T>(options?: AutosaveOptions<T>): Autosave<T>;
+
+/**
+ * What the save pill says, for both editors — ONE copy.
+ *
+ * There were three: the campaign designer's `saveStatusLabel`
+ * (efficient-admin-portal `src/components/email/autosaveStatus.ts`), the
+ * website editor's `autosaveStatusLabel` (efficient-shop
+ * `lib/editor/autosave-status.ts`, which said of the first "a MIRRORED copy …
+ * whether that pair should collapse into `efficient-easel` is called out
+ * rather than decided here") and the website chrome's own words for its
+ * autosave switch. This decides it.
+ *
+ * The rule they all kept, and keep here (card 66103): **the pill speaks only
+ * when it has something to say.** A save that lands is silence — the dot goes
+ * green, no word. An edit younger than five seconds is silence too: with a
+ * one-second save it is about to land, and saying "unsaved" at every keystroke
+ * would blink the bar once a second. What is left is worth a word each:
+ *
+ *   - the work has been off the server for five seconds — "Unsaved changes";
+ *   - a save failed and is being retried — "Save failed" (with "Retry now");
+ *   - the operator paused autosave — "Auto-save off", and whether that is
+ *     holding anything;
+ *   - a save was refused — "Auto-save stopped", which must never read as a
+ *     switch somebody flicked themselves.
+ *
+ * The tones are `efficient-easel/chrome`'s `SaveState` tones, so the result
+ * goes straight onto the pill: `<SaveState {...saveIndicator(state)} />`.
+ */
+
+type SaveIndicator = {
+    tone: SaveTone;
+    label: string;
+};
+/**
+ * The pill's five things to say (`efficient-easel/strings`, 0.95.0). Kept in
+ * autosave's own folder, with no import: autosave may reach nothing else
+ * (`tests/autosave-leaf-safety.test.ts`).
+ */
+type SaveWords = {
+    /** A save was refused: nothing will be written. */
+    stopped: string;
+    /** The operator paused autosave, and an edit is waiting. */
+    pausedUnsaved: string;
+    /** The operator paused autosave. */
+    paused: string;
+    /** A save failed and is being retried. */
+    failed: string;
+    /** The work has been off the server for five seconds. */
+    unsaved: string;
+};
+/**
+ * `words` is the host's language (`useEditorStrings().save`); left out, the
+ * pill speaks English as it always has.
+ */
+declare function saveIndicator(state: AutosaveSnapshot, words?: SaveWords): SaveIndicator;
+
+export { type Autosave as A, type SaveWords as S, type AutosaveSnapshot as a, type SaveIndicator as b, type AutosaveOptions as c, type AutosaveClock as d, createAutosave as e, saveIndicator as s };

package/dist/words-D9ChvbNC.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Drag-and-drop's own words (`efficient-easel/strings`, 0.95.0): the Add
+ * panel's shell and the canvas layer's handle and "+" buttons. A tile's
+ * caption, a group's heading and a block's name are the host's.
+ *
+ * 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`.
+ */
+type DragWords = {
+    add: {
+        /** The "×" beside "Adding to Column 2". */
+        stop: string;
+        /** The line under the title. */
+        hint: string;
+        /** The search field's name. */
+        search: string;
+        /** The search field's placeholder. `label` is the field's name. */
+        searchPlaceholder: (v: {
+            label: string;
+        }) => string;
+        /** The "×" in the search field. */
+        clearSearch: string;
+        /** Nothing matched. `query` is what was typed, trimmed. */
+        nothing: (v: {
+            query: string;
+        }) => string;
+        /** The line under it. */
+        tryAnother: string;
+        /** A tile's accessible name and tooltip. `label` is its caption. */
+        tile: (v: {
+            label: string;
+        }) => string;
+    };
+    canvas: {
+        /** The button in a gap between two sections. */
+        addSection: string;
+        /** The button in an empty slot. */
+        addBlock: string;
+        /** How either button is drawn. `label` is one of the two above, or the host's. */
+        addButton: (v: {
+            label: string;
+        }) => string;
+        /** The handle's tooltip. `label` is the block's name. */
+        handle: (v: {
+            label: string;
+        }) => string;
+    };
+};
+
+export type { DragWords as D };