efficient-easel 0.101.1 → 0.103.0

package/dist/host-DJ8Gzsx7.d.ts

@@ -0,0 +1,552 @@
+import * as react from 'react';
+import { RefObject, ReactNode } from 'react';
+import { Data } from './blocks/index.js';
+import { EaselDocumentAdapter, EaselCapabilities } from './screen/lib/document-contract.js';
+import { SessionBackend, SessionBlocks } from './screen/lib/session.js';
+import { SaveStatus } from './screen/lib/document-switch.js';
+import { BridgedCapabilities } from './screen/lib/admin-bridge.js';
+import { EditAccess, SaveConflict } from './edit-lock/index.js';
+import { A as AutosaveSnapshot } from './engine-DBxp_v6B.js';
+
+/**
+ * lib/document-addressing.ts — HOW A DOCUMENT IS ADDRESSED: what the
+ * layer that knows its documents hands the provider that loads and saves them
+ * (doc/adr/0003, seam W5).
+ *
+ * The provider (components/ScreenDocumentContext) is the document's
+ * load-and-save: which one is open, its autosave, its edit lock, the switch
+ * from one to the next. Any editor has that. What it is told, and does not
+ * know: which document stands for "home", whether an editor may be LOADED on a
+ * target at all, what a switch of document does to the layer's own
+ * bookkeeping, what stores the document a target names, and what a stored
+ * layout needs before the canvas reads it. A website's answers are its Home
+ * page, its template entry and the page that keeps its footer, its two record
+ * types and its renamed props (lib/website-document-addressing).
+ *
+ * A PROP of the provider, and not one more of the screen's parts
+ * (lib/screen-parts): those reach the screen through the store's provider,
+ * and the document's provider stands above that one. And a module of its own
+ * for what it would otherwise load: lib/screen-parts carries the engine's
+ * canvas and inspector for its defaults, and the provider is imported by
+ * fields and panels that mount no screen.
+ *
+ * ONE object for the life of a mount, like the session. The provider lists
+ * these rules among the dependencies of what it memoises, the adapter first:
+ * rules built anew on a render would build a new adapter on it, and a new
+ * adapter opens the document again.
+ *
+ * FOR ONE KIND OF TARGET (0.103.0). A layer's rules answer for the targets it
+ * names: a website's for its pages and templates (`ScreenTarget`, the default,
+ * so the website's rules are typed as they always were), a host's own for its
+ * documents (`DocumentAddressing<DocumentTarget>`). The rules are asked about
+ * a target and never hand one of their own kind back, except where the editor
+ * goes instead of where it was loaded (`entryBounce`), which may be any.
+ */
+
+interface DocumentAddressing<T extends AnyScreenTarget = ScreenTarget> {
+    /**
+     * The slug of the HOME document: the one a target stands for when it names
+     * no document within its record, and the one an editor falls back to when
+     * the document it was pointed at has gone. Null when there is none: such a
+     * target then names the empty slug, and a document that has gone is
+     * reported and not replaced.
+     */
+    homeSlug: string | null;
+    /**
+     * May an editor LOADED on `target` be sent somewhere else before it opens
+     * anything? Asked of the target a mount starts on, as it first renders:
+     * while the answer is yes the provider shows its "Loading…" and not the
+     * document, until `entryBounce` has said where the editor goes — or that it
+     * stays after all.
+     */
+    entryMayBounce: (target: T) => boolean;
+    /**
+     * Where an editor loaded on `target` goes INSTEAD: the target the host's
+     * address is then loaded on, or null and it stays. Asked once per mount, of
+     * the target it started on, with the query of the host's address. A switch
+     * made in place loads nothing, so it is never asked.
+     */
+    entryBounce: (target: T, search: string) => AnyScreenTarget | null;
+    /**
+     * A switch of document, in place, is going ahead and `next` is where it
+     * goes: whatever the layer keeps of its own that depends on where the
+     * editor is, it brings up to date here. Called once per switch, after what
+     * belonged to the document being left has been cleared and before the
+     * provider moves to the new one.
+     */
+    onSwitch: (next: T) => void;
+    /**
+     * Is the host told that the editor moved to `next`? The host remembers the
+     * last target it was told, and reopens the editor there on a reload — so a
+     * target the editor must not be reopened on is one the host is not told.
+     */
+    tellsHost: (next: T) => boolean;
+    /**
+     * What stores the document `target` names: its adapter, over the backend in
+     * force and the sets of blocks the host offers (both the session's, and the
+     * provider's to read). The provider asks again when the target moves to
+     * another record — not on every switch of document within one.
+     *
+     * The backend comes as the session holds it (lib/session
+     * `SessionBackend`): the layer that handed the session its backend knows its
+     * own type, and the provider names none.
+     */
+    adapterFor: (target: T, backend: SessionBackend, blocks: SessionBlocks | null) => EaselDocumentAdapter;
+    /**
+     * Carry the stored answer of every prop the layer has RENAMED to its new
+     * key, in a layout as it was stored and before the canvas reads it. The
+     * canvas reads a node's props by the keys its fields declare, so an answer
+     * left under an old key would be shown as the default and then saved as it.
+     * Answers with the same object when it carried nothing.
+     */
+    migrateRenamedProps: <D>(data: D) => D;
+    /**
+     * The sentence the editor shows for a document that is NOT THERE (the
+     * adapter resolved `target` to null, and there was no Home to fall back to):
+     * the layer's words for its own kind of document — "Couldn't open this
+     * campaign." Asked once, when it is found missing. Absent, the screen says
+     * its own (`EaselStrings.screen`: `missingPage`, `missingTemplatePage`,
+     * `missingDocument`), the website's sentences among them.
+     */
+    describeMissing?: (target: T) => string;
+    /**
+     * The document `target` names did not open, and the editor shows why
+     * instead of it. `err` is what the load was refused with, or `null` when the
+     * backend said there is no such document (and there was no Home to fall back
+     * to). Called once per failed load, after the sentence is chosen — for a
+     * layer that has bookkeeping of its own to let go of (the campaign designer's
+     * window forgets the campaign it would reopen). Absent, nobody is told.
+     */
+    onLoadFailed?: (target: T, err: unknown) => void;
+}
+/**
+ * The rules a provider may be handed: a website's, for its pages and
+ * templates, or a host's own, for its documents. Whichever it is handed it
+ * asks of every target it opens, so a layer hands the rules of the kind of
+ * target it mounts the editor on.
+ */
+type AnyDocumentAddressing = DocumentAddressing<ScreenTarget> | DocumentAddressing<DocumentTarget>;
+/**
+ * With no layer: there is no home, so nothing is fallen back to; an editor
+ * stays on whatever target it is loaded on; a switch of document has nothing
+ * of a layer's to bring up to date, and the host is told of every one; the
+ * document is the one nothing stores; and a stored layout is read as it was
+ * stored, there being no layer to have renamed a prop. It answers for every
+ * kind of target, so it stands in for the rules of either. It describes no
+ * missing document of its own (the screen says its words) and tells nobody of
+ * one that would not open.
+ */
+declare const NO_DOCUMENT_ADDRESSING: DocumentAddressing<AnyScreenTarget>;
+
+type ScreenTarget = {
+    kind: "page";
+    slug: string;
+    siteId?: string;
+    originSlug?: string;
+} | {
+    kind: "template";
+    id: string;
+    pageSlug?: string;
+};
+/**
+ * A DOCUMENT OF A HOST'S OWN — not a website's page or template: what the
+ * campaign designer opens (0.103.0). `record` is the record that stores it (a
+ * campaign's id), and `slug` the document within that record (one of its
+ * variants), the empty slug when it names none.
+ *
+ * The provider asks no more of it than that. One record is one adapter (it
+ * re-keys on `record`, as a page target re-keys on its site); two of these are
+ * the same document when record and slug match; and a document that has gone
+ * is reported, never replaced by a Home, which is a website's.
+ *
+ * Beside `ScreenTarget` and not in it: that union is the website's two kinds,
+ * as its hosts name and build them (and as the storefront publishes them), and
+ * its host messages carry one. A host's own document reaches the host through
+ * its address (`EaselHostAddress.show`), and never as `navigated`.
+ */
+type DocumentTarget = {
+    kind: "document";
+    record: string;
+    slug?: string;
+};
+/** Every target the document's provider opens: a website's page or template
+ *  (`ScreenTarget`), or a document of a host's own (`DocumentTarget`). */
+type AnyScreenTarget = ScreenTarget | DocumentTarget;
+
+type ScreenDocumentValue = {
+    /** The document the editor is currently pointed at (runtime, retargetable). */
+    target: AnyScreenTarget;
+    /** Record-type plumbing (load/save/list/create/delete) for the pointed-at
+     *  document. Chrome and panels consult `capabilities`, never the record type. */
+    adapter: EaselDocumentAdapter;
+    /** What this document type supports — the ONLY sanctioned mode switch. */
+    capabilities: EaselCapabilities;
+    /** Id of the website template being edited (template mode only). */
+    templateId: string | null;
+    /** Slug of the page being edited — the template page's slug in template mode,
+     *  and a host's own document's `slug` (or the empty slug) for one of those. */
+    currentSlug: string;
+    /** Kind of the loaded page (`dynamic` drives the product-binding controls), or
+     *  null while loading / in template mode where the record carries no kind. */
+    currentKind: string | null;
+    /** Id of the website this page belongs to (page mode only; null in template
+     *  mode or when the editor was opened without a site). The list/save paths and
+     *  the page switcher scope to this so they act on one site's pages, not the
+     *  whole tenant's. */
+    siteId: string | null;
+    /** Whether the editor's backend may be called yet. Under the EFFICIENT backend
+     *  that is "the console's token has arrived"; an embedder's own backend
+     *  authorises its calls itself and is ready from the first render. THE gate
+     *  for anything that goes through the backend — never `token`, which an
+     *  embedder's backend does not have. */
+    ready: boolean;
+    /** The bridged admin JWT once it arrives (null while waiting, and always null
+     *  under an embedder's own backend). Only for the callers that still pass it
+     *  to the EFFICIENT client themselves. */
+    token: string | null;
+    /** Latest token for imperative reads (custom fields, pickers, panels). */
+    tokenRef: RefObject<string | null>;
+    /** Bridge editor events to the embedding admin portal. */
+    notifyParent: SendToHost;
+    /** Operator capabilities the ADMIN CONSOLE granted over the origin-gated
+     *  bridge. Distinct from `capabilities` above: those describe the DOCUMENT
+     *  (can it publish, has it site settings), these describe the PERSON, and the
+     *  editor is never allowed to infer them for itself. */
+    bridgeCapabilities: BridgedCapabilities;
+    /** Run an authed op; on 401 ask the parent for a fresh token and retry once. */
+    runAuthed: (op: (token: string) => Promise<unknown>) => Promise<boolean>;
+    /** Backend id of the loaded document — the identity of what the editor is
+     *  editing right now. Null while loading and between retargets, so it also
+     *  keys any once-per-document work (e.g. the pinned-chrome seed). */
+    docId: string | null;
+    /** The document exactly as it was LOADED from the backend: Puck's initial
+     *  state, and the persisted snapshot a load-time seed must measure itself
+     *  against. Null while loading. Edits live in Puck's own store, so this does
+     *  NOT track them — it stays the last-loaded layout for the whole session. */
+    data: Data | null;
+    /** The freshest layout the merchant is actually viewing — the latest edit made
+     *  since load (tracked on every onChange, even after the autosave settles), else
+     *  the last-loaded `data`. Lets a feature snapshot the live view (e.g. the
+     *  read-only origin backdrop in footer focus) without reaching into Puck's store.
+     *  Lean accessor (ISP) — never exposes the ref. */
+    getLiveData: () => Data | null;
+    /** FOOTER FOCUS: the slug of the page the footer was opened from, or null. Rides
+     *  the nav target, so it's atomic with the retarget (never stale). */
+    footerOriginSlug: string | null;
+    error: string | null;
+    /** True while the template-entry bounce is redirecting to the Home page. */
+    redirecting: boolean;
+    /** The pinned-seed gate's four words for where the autosave stands. */
+    saveStatus: SaveStatus;
+    /** The autosave's state (efficient-easel/autosave) — what the toolbar pill
+     *  draws, through `saveIndicator`. */
+    saveState: AutosaveSnapshot;
+    /** Whether autosave is running. The toolbar pill is a switch: clicking it
+     *  flips this. OFF = edits are HELD (kept in memory, still flushable by Publish
+     *  / navigation / re-enabling) but never written on a timer. Session-scoped —
+     *  survives in-place page switches. */
+    autoSaveEnabled: boolean;
+    /** Auto-save stopped because a save was REFUSED, not because the operator
+     *  paused it — so a stopped auto-save can never read as a switch somebody
+     *  flicked themselves. */
+    autoSaveStoppedByConflict: boolean;
+    /** True when an edit hasn't been persisted yet — including one held while the
+     *  claim is in flight. Drives the guard that prompts before an in-place
+     *  navigation would abandon held-but-unsaved edits. */
+    hasUnsavedEdits: boolean;
+    /** Flip autosave on/off. Turning it back ON writes any held edits at once, so
+     *  "on" always means caught up. */
+    toggleAutoSave: () => void;
+    /** "Retry now": a failed save goes again at once instead of waiting out its
+     *  backoff. */
+    retrySave: () => void;
+    /** Autosave — hand every Puck onChange to this. */
+    onChange: (next: Data) => void;
+    /** Persist the pending edit immediately; resolves to whether nothing is left
+     *  unsaved. */
+    flushSave: () => Promise<boolean>;
+    /** Persist + publish the current document (Save for templates). */
+    onPublish: (next: Data) => Promise<void>;
+    /** Whether this editor may write the open page, and why not when it may not.
+     *  `editing` is the only writable state; the gate is on the save path itself,
+     *  so hiding or showing chrome from this can't be the thing that protects the
+     *  document. Always `editing` in template mode (no lock there). */
+    access: EditAccess;
+    /** SOMEBODY ELSE holds this page, so this editor is read-only: it may look and
+     *  select, but not move, add, duplicate or delete anything — until they take
+     *  control themselves. The ONE answer the chrome asks; no panel re-derives it,
+     *  so none of them can drift.
+     *
+     *  NOT what protects the document — `persistLayout` refuses the write, and it
+     *  refuses it in more cases than this (while the claim is still `checking`, and
+     *  after a refused save). This is the narrower question the CHROME asks, and it
+     *  is narrower on purpose: during `checking` nobody is named yet, and the
+     *  pinned Header/Footer seed runs in the chrome's mount commit and must still
+     *  land. Its write is held by `onChange` and released by the claim if it is
+     *  granted, or never released if it is not — card 1096.
+     *
+     *  …or the document itself is FROZEN (`readOnlyReason`): nobody holds it, and
+     *  nobody may write it, ever. */
+    readOnly: boolean;
+    /** Why the open document may never be written, as the backend said it
+     *  (`EaselDocument.readOnlyReason`: a campaign that has been sent), or null
+     *  for every document that may. Such a document is read-only for good: its
+     *  saves are refused, its lock is never claimed, and the save pill's place
+     *  says this instead. Optional for a context built by hand, where it is
+     *  absent and means null. */
+    readOnlyReason?: string | null;
+    /** Take the page: from the "someone else is editing" choice, or back after
+     *  somebody took it from you. */
+    takeOverEditing: () => void;
+    /** Choose to look without touching (keeps the holder for the ribbon). */
+    viewReadOnly: () => void;
+    /** A save the backend REFUSED because the stored page moved on. Non-null means
+     *  autosave has stopped and the operator's work is still only on their screen.
+     *  Told in a bar under the top bar (efficient-easel/chrome `EditNotice`),
+     *  never a dialog, so there is nothing to dismiss: the operator reads and
+     *  copies from the screen it is warning them about. */
+    saveConflict: SaveConflict | null;
+    /** Abandon this editor's version and reload what is stored. The ONLY path that
+     *  throws the operator's work away, and only they can ask for it. */
+    reloadFromServer: () => void;
+    /** Retarget the editor in place (guards unsaved changes before it swaps). */
+    navigate: (target: AnyScreenTarget) => void;
+    /** A retarget held behind the unsaved-changes prompt (null = no prompt). */
+    pendingNav: AnyScreenTarget | null;
+    cancelPendingNav: () => void;
+    discardAndNavigate: () => void;
+    saveAndNavigate: () => Promise<void>;
+};
+declare const ScreenDocumentContext: react.Context<ScreenDocumentValue | null>;
+declare function useScreenDocument(): ScreenDocumentValue;
+declare function ScreenDocumentProvider({ target, addressing: handed, onHostMessage, children, }: {
+    target: AnyScreenTarget;
+    /** How this editor's documents are ADDRESSED — the layer's rules, handed in
+     *  by whoever mounts the provider (the website's entry hands the website's:
+     *  lib/website-document-addressing). Without them there is one document that
+     *  nothing stores. ONE object for the life of the mount, like the session. */
+    addressing?: AnyDocumentAddressing;
+    /** The layer's own host messages, asked before the ones every editor answers
+     *  (lib/host-inbound): the website's are lib/website-host-inbound.
+     *  Returns true when it handled one. */
+    onHostMessage?: (raw: unknown) => boolean;
+    children: ReactNode;
+}): react.JSX.Element;
+
+/**
+ * The editor's HOST — whatever embeds the storefront editor, and the one way the
+ * editor talks to it.
+ *
+ * The editor asks its host for the things it cannot do itself (open the media
+ * picker, the form builder, a product's window; say that a save failed) and
+ * hears back from it (the admin token, a category that was edited elsewhere, a
+ * retarget to another page). It used to be the shop's own `/edit/*` route,
+ * framed by the admin portal in a cross-origin iframe, and every one of those
+ * calls was a `postMessage` to `window.parent`. The admin portal now mounts the
+ * editor in its own window (the `efficient-web-builder` package) and builds its host
+ * with {@link createEaselHost}: the same `storefront-editor:*` messages, as
+ * function calls — no origin, no serialisation, no handshake race. Surfaces
+ * still read inbound messages defensively; the protocol kept its shape.
+ *
+ * A surface with no provider above it (a dev harness, a guard rendering one
+ * panel) gets {@link DETACHED_EASEL_HOST}: nobody listening, nothing sent — a
+ * request that needs an answer settles empty instead of waiting forever.
+ */
+/** A picked media item, as the host's media picker returns it. */
+interface HostPickedMedia {
+    id: string;
+    url: string;
+    kind: "image" | "video";
+}
+/** The SECTION editor's target (the standalone one-section surface). */
+type SectionScreenTarget = {
+    kind: "section";
+    id: string;
+    type?: string;
+    name?: string;
+};
+/** Every message the editor sends its host, by name. */
+type EaselToHostMessage = 
+/** The editor is listening; send (or re-send) `auth`. Repeats until a token lands. */
+{
+    type: "storefront-editor:ready";
+}
+/** A call was refused 401; refresh the token and send `auth` again. */
+ | {
+    type: "storefront-editor:auth-expired";
+}
+/** The document changed in the editor (every edit). */
+ | {
+    type: "storefront-editor:dirty";
+}
+/** An explicit Save landed (autosaves stay quiet). */
+ | {
+    type: "storefront-editor:saved";
+}
+/** The page was published. */
+ | {
+    type: "storefront-editor:published";
+}
+/** A save failed (first failure of a retry run only). */
+ | {
+    type: "storefront-editor:save-failed";
+}
+/** The editor moved in place to another page (page targets only). */
+ | {
+    type: "storefront-editor:navigated";
+    target: ScreenTarget;
+}
+/** Open the media picker; answer `media-picked` / `media-pick-cancelled` with the same id. */
+ | {
+    type: "storefront-editor:open-media-picker";
+    requestId: string;
+    accept: string;
+    title: string;
+    file?: File;
+}
+/** A form. `mode: "create"` asks for a new one and carries a `requestId`:
+ *  answer `form-saved` / `form-closed` with the same id. `mode: "edit"` opens
+ *  the form builder on `formId` and carries none: nothing waits on it. */
+ | {
+    type: "storefront-editor:open-form";
+    requestId?: string;
+    mode: "create" | "edit";
+    formId?: string;
+} | {
+    type: "storefront-editor:open-category";
+    categoryId: string;
+    name?: string;
+} | {
+    type: "storefront-editor:open-product";
+    slug: string;
+    name?: string;
+} | {
+    type: "storefront-editor:open-post";
+    slug: string;
+    title?: string;
+} | {
+    type: "storefront-editor:open-menus";
+    menuId?: string | null;
+} | {
+    type: "storefront-editor:open-page";
+    slug: string;
+} | {
+    type: "storefront-editor:new-page";
+}
+/** Ask the host to save this website as a platform template (it decides). */
+ | {
+    type: "storefront-editor:save-as-template";
+    siteId: string;
+    slug: string;
+};
+/** Every message a host sends the editor, by name. */
+type HostToEaselMessage = {
+    type: "storefront-editor:auth";
+    token: string;
+    siteId?: string;
+    brandId?: string;
+    theme?: string;
+    can?: {
+        canCreatePlatformTemplate?: boolean;
+    };
+} | {
+    type: "storefront-editor:navigate";
+    target: ScreenTarget | SectionScreenTarget;
+} | {
+    type: "storefront-editor:category-updated";
+    categoryId?: string;
+} | {
+    type: "storefront-editor:menus-updated";
+} | {
+    type: "storefront-editor:form-saved";
+    requestId?: string;
+    form?: {
+        id: string;
+        slug: string;
+    };
+} | {
+    type: "storefront-editor:form-closed";
+    requestId?: string;
+} | {
+    type: "storefront-editor:media-picked";
+    requestId: string;
+    media: HostPickedMedia;
+} | {
+    type: "storefront-editor:media-pick-cancelled";
+    requestId: string;
+};
+type EaselMessageType = EaselToHostMessage["type"];
+type PayloadOf<T extends EaselMessageType> = Omit<Extract<EaselToHostMessage, {
+    type: T;
+}>, "type">;
+/** Send one message to the host — `send("storefront-editor:open-page", { slug })`.
+ *  The payload is required exactly when the message carries one. */
+type SendToHost = <T extends EaselMessageType>(type: T, ...payload: Record<string, never> extends PayloadOf<T> ? [PayloadOf<T>?] : [PayloadOf<T>]) => void;
+/** What reaches a surface's listener: a named message whose fields the surface
+ *  reads defensively (over the iframe transport it is untrusted data). */
+type InboundHostMessage = {
+    type: string;
+} & Record<string, unknown>;
+/**
+ * The editor's address. An iframe editor IS a document with a URL — a refresh
+ * must reopen the page being edited, so the address follows it. An editor
+ * mounted inside another app has no address of its own; that app keeps its own
+ * notion of "where" (it hears `navigated`) and implements these as retargets.
+ */
+interface EaselHostAddress {
+    /** The query the editor was opened with (`?editTemplate=1`, `?site=` …). */
+    search(): string;
+    /** Keep the address in step with the open document (no load). A host's own
+     *  document (`DocumentTarget`, 0.103.0) is told here and only here: the
+     *  `navigated` message carries a website's targets. */
+    show(target: ScreenTarget | SectionScreenTarget | DocumentTarget): void;
+    /** Leave for another document by LOADING it (an entry bounce, a deleted page). */
+    load(target: ScreenTarget | DocumentTarget): void;
+    /** Reload the editor from scratch (abandon this tab's copy of the document). */
+    reload(): void;
+}
+interface EaselHost {
+    /** Whether anything is listening. False on a bare `/edit` page no admin embeds. */
+    readonly connected: boolean;
+    /**
+     * Whether the editor IS the page — the shop's `/edit` routes, where nothing
+     * else shares the document, so page-wide shortcuts (undo, copy style) listen
+     * on `document` and the editor may stamp `<html>`. False for an embedder that
+     * mounts the editor inside its own page: there a key belongs to the editor
+     * only while focus is inside it, and the page's `<html>` is not the editor's.
+     */
+    readonly ownsDocument: boolean;
+    send: SendToHost;
+    /** Listen to the host. Returns the unsubscribe. */
+    subscribe(listener: (message: InboundHostMessage) => void): () => void;
+    readonly address: EaselHostAddress;
+}
+/** The host of a surface nobody embeds: nothing sent, nothing heard, an address
+ *  that stays put. */
+declare const DETACHED_EASEL_HOST: EaselHost;
+declare const EaselHostContext: react.Context<EaselHost>;
+declare function EaselHostProvider({ host, children }: {
+    host: EaselHost;
+    children: ReactNode;
+}): react.JSX.Element;
+/** The host of the editor this component renders in. */
+declare function useEaselHost(): EaselHost;
+/**
+ * A host for an embedder that mounts the editor in its own page — the admin
+ * portal's native editor window. `onMessage` receives everything the editor
+ * sends (typed); the returned `deliver` hands a message to the editor, exactly
+ * as a trusted postMessage would have arrived.
+ *
+ * One per mounted editor: a host carries one editor's conversation, so two
+ * editors open at once (a page and a section) each get their own and a retarget
+ * meant for one never reaches the other.
+ */
+declare function createEaselHost(options: {
+    onMessage: (message: EaselToHostMessage) => void;
+    address: EaselHostAddress;
+}): {
+    host: EaselHost;
+    deliver: (message: HostToEaselMessage) => void;
+};
+
+export { type AnyDocumentAddressing as A, DETACHED_EASEL_HOST as D, type EaselHost as E, type HostPickedMedia as H, type InboundHostMessage as I, NO_DOCUMENT_ADDRESSING as N, type SectionScreenTarget as S, type DocumentAddressing as a, type EaselHostAddress as b, EaselHostContext as c, EaselHostProvider as d, type EaselMessageType as e, type EaselToHostMessage as f, type HostToEaselMessage as g, type SendToHost as h, createEaselHost as i, type AnyScreenTarget as j, type DocumentTarget as k, ScreenDocumentContext as l, ScreenDocumentProvider as m, type ScreenDocumentValue as n, type ScreenTarget as o, useScreenDocument as p, useEaselHost as u };

package/dist/menu/index.js

@@ -1 +1 @@
-export{ES_MENU_SKIN,EaselContextMenu}from"../chunk-KTVH2ZRL.js";var e=/\b(transform|translate|rotate|scale|perspective|filter|backdrop-filter|contain)\b/;function t(t){const n=e=>t.getPropertyValue(e).trim(),r=(e,t)=>{const r=n(e);return""!==r&&!t.includes(r)};return!!r("transform",["none"])||(!!(r("translate",["none"])||r("rotate",["none"])||r("scale",["none"]))||(!!r("perspective",["none"])||(!!r("filter",["none"])||(!(!r("backdrop-filter",["none"])&&!r("-webkit-backdrop-filter",["none"]))||(!!/\b(layout|paint|strict|content)\b/.test(n("contain"))||(!!r("container-type",["normal"])||(!!r("content-visibility",["visible"])||e.test(n("will-change")))))))))}function n(e){const n=e?.ownerDocument,r=n?.defaultView;if(!(e&&n&&r&&e.isConnected))return null;for(let o=e;o&&o!==n.body&&o!==n.documentElement;o=o.parentElement)if(t(r.getComputedStyle(o)))return null;return e}export{n as menuPortalTarget};
+export{menuPortalTarget}from"../chunk-RW4XBUUW.js";export{ES_MENU_SKIN,EaselContextMenu}from"../chunk-KTVH2ZRL.js";

package/dist/node-ops/index.js

@@ -1 +1 @@
-import{DEFAULT_NODE_MENU_WORDS as e}from"../chunk-WK3AFPXY.js";export{canStep,fromItemSelector,parentStep,planDuplicate,planMove,planPaste,planRemove,planSetProps,planStep,toItemSelector,useNodeOps}from"../chunk-D2BCHTQR.js";import{TrashIcon as n,EyeIcon as t,EyeOffIcon as o,RenameIcon as p,PasteIcon as l,CopyIcon as c,MoveDownIcon as s,MoveUpIcon as a,DuplicateIcon as i,AddIcon as r,LayersIcon as u}from"../chunk-L5KW4HG5.js";import"../chunk-KRXQM65X.js";import"../chunk-NKB3KVAB.js";import{jsx as h}from"react/jsx-runtime";function d(){let e=null;const n=/* @__PURE__ */new Set;return{get:()=>e,set(t){e=t;for(const e of[...n])e()},subscribe:e=>(n.add(e),()=>n.delete(e))}}var m={layer:{icon:/* @__PURE__ */h(u,{})},addInside:{icon:/* @__PURE__ */h(r,{})},duplicate:{icon:/* @__PURE__ */h(i,{})},moveUp:{icon:/* @__PURE__ */h(a,{})},moveDown:{icon:/* @__PURE__ */h(s,{})},copy:{icon:/* @__PURE__ */h(c,{}),shortcut:"⌘C"},cut:{icon:/* @__PURE__ */h(c,{}),shortcut:"⌘X"},paste:{icon:/* @__PURE__ */h(l,{}),shortcut:"⌘V"},rename:{icon:/* @__PURE__ */h(p,{})},hide:{icon:/* @__PURE__ */h(o,{})},show:{icon:/* @__PURE__ */h(t,{})},upLevel:{},delete:{icon:/* @__PURE__ */h(n,{}),danger:!0}};function v(n){const{actions:t,rows:o={},extras:p={},words:l=e}=n,c=e=>({...m[e],label:l[e],...o[e]}),s=(e,n,t)=>{const o=c(e),p={label:t??o.label??e,onClick:n};return o.icon&&(p.icon=o.icon),o.shortcut&&(p.shortcut=o.shortcut),o.danger&&(p.danger=!0),p},a=()=>{const e=c("layer"),t={label:e.label??l.layer,onClick:()=>{},children:n.layer.items};return e.icon&&(t.icon=e.icon),t},i=[],r=[],u=[],h=[],d=!!n.layer&&n.layer.items.length>1;if(d&&"pick"===(n.layer.group??"pick")&&i.push(a()),t.addInside&&r.push(s("addInside",t.addInside)),t.duplicate&&r.push(s("duplicate",t.duplicate)),t.moveUp&&r.push(s("moveUp",t.moveUp)),t.moveDown&&r.push(s("moveDown",t.moveDown)),t.copy&&r.push(s("copy",t.copy)),t.cut&&r.push(s("cut",t.cut)),t.paste){const e=c("paste").label??l.paste;r.push(s("paste",t.paste.run,l.pasteNamed({paste:e,label:t.paste.label})))}t.rename&&u.push(s("rename",t.rename)),t.hide&&u.push(t.hide.hidden?s("show",t.hide.run):s("hide",t.hide.run)),d&&"change"===n.layer.group&&u.push(a()),t.upLevel&&u.push(s("upLevel",t.upLevel)),t.delete&&h.push(s("delete",t.delete)),i.push(...p.pick??[]),r.push(...p.make??[]),u.push(...p.change??[]),h.push(...p.remove??[]);const v=[i,r,n.style??[],u,h].filter(e=>e.length>0),g=i.length+r.length+u.length+h.length===0,k=[{label:n.title,header:!0,onClick:()=>{}}];return g&&n.pinnedLine&&k.push({label:n.pinnedLine,header:!0,onClick:()=>{}}),v.forEach((e,t)=>{(t>0||g&&n.pinnedLine)&&k.push({label:"—",onClick:()=>{}}),k.push(...e)}),k}export{d as createNodeClipboard,v as nodeMenuItems};
+export{createNodeClipboard,nodeMenuItems}from"../chunk-2LK54I4E.js";import"../chunk-WK3AFPXY.js";export{canStep,fromItemSelector,parentStep,planDuplicate,planMove,planPaste,planRemove,planSetProps,planStep,toItemSelector,useNodeOps}from"../chunk-D2BCHTQR.js";import"../chunk-L5KW4HG5.js";import"../chunk-KRXQM65X.js";import"../chunk-NKB3KVAB.js";

package/dist/panelWidths-D9hTLR25.d.ts

@@ -0,0 +1,66 @@
+import { CSSProperties } from 'react';
+
+/**
+ * The side-panel widths every editor opens on and drags between (px).
+ *
+ * Lifted from `efficient-storefront/components/panel-widths.ts`, where the website
+ * editor measured them:
+ *
+ *   RIGHT is 320, not 308 (card 8810). At 308 the settings tab strip was left
+ *   269px once the inspector's 14px sides and its 11px scrollbar were off it —
+ *   one pixel under the 270 the strip's widest tier needs, so the tab words
+ *   turned into glyphs at the width every merchant opens on.
+ *
+ *   MIN_PANEL_W is load-bearing on the top bar: six 34px rail buttons are 204px,
+ *   and at 220 the rail column spreads them with nothing to spare.
+ *
+ * The campaign designer opened at 288 / 288 with a 520 ceiling until the
+ * 2026-09-17 redesign. One set of numbers now, here.
+ */
+declare const DEFAULT_PANEL_W: {
+    readonly left: 288;
+    readonly right: 320;
+};
+declare const MIN_PANEL_W = 220;
+declare const MAX_PANEL_W = 560;
+/** Which side panel a width belongs to. */
+type PanelSide = 'left' | 'right';
+type PanelWidths = {
+    left: number;
+    right: number;
+};
+/** Clamp a width into the panel band and round to a whole pixel. */
+declare function clampPanelWidth(width: number): number;
+/**
+ * The inline style that carries the widths, as `--es-left-w` / `--es-right-w`.
+ *
+ * ⚠️ PUT IT ON THE EDITOR ROOT, the nearest ancestor of EVERYTHING that reads
+ * it. The website editor learned this on 2026-09-04: the vars sat on the panel
+ * row, the top bar is that row's SIBLING, and the rail column read a width with
+ * no declaration in scope — which is not an error, it silently falls back to
+ * `auto` and the column shrinks to its buttons. (Since 2026-10-06 chrome.css
+ * falls back to `DEFAULT_PANEL_W` instead: the column keeps its width and
+ * simply stops following the grip.)
+ *
+ * ⚠️ A SERVER RENDERS THIS AS A `style=""` ATTRIBUTE, and a
+ * Content-Security-Policy without `'unsafe-inline'` for styles refuses those.
+ * A client render is not affected: React writes a `style` prop through the
+ * CSSOM. A server-rendered editor under such a policy uses
+ * {@link setPanelWidthVars} instead.
+ */
+declare function panelWidthVars(widths: PanelWidths): CSSProperties;
+/**
+ * The same two variables, written onto the editor root through the CSSOM
+ * (second host, 2026-10-06) — so the server's HTML carries no `style` attribute for a strict
+ * Content-Security-Policy to refuse:
+ *
+ *     <div className="es-editor" ref={(el) => { if (el) setPanelWidthVars(el, widths); }}>
+ *
+ * A ref runs on the client only, before the browser paints, and again on each
+ * render — so it follows the widths as a grip is dragged. Until it runs (the
+ * server's HTML, before hydration) chrome.css draws the panels at
+ * `DEFAULT_PANEL_W`. Touches nothing but the element it is handed.
+ */
+declare function setPanelWidthVars(el: HTMLElement, widths: PanelWidths): void;
+
+export { DEFAULT_PANEL_W as D, MAX_PANEL_W as M, type PanelSide as P, MIN_PANEL_W as a, type PanelWidths as b, clampPanelWidth as c, panelWidthVars as p, setPanelWidthVars as s };

package/dist/screen/components/AddBlockRow.d.ts

@@ -0,0 +1,14 @@
+import * as react from 'react';
+import { BlockChoice } from '../lib/puck/block-choice.js';
+
+declare function AddBlockRow({ choices, onPick, open, onToggle, }: {
+    /** The block types this slot accepts, from `canAddTo(parentType)?.choices`. */
+    choices: BlockChoice[];
+    /** Insert the chosen type. The caller knows the zone and the index. */
+    onPick: (type: string) => void;
+    /** Host-owned open state — omitted where the caller draws only one row. */
+    open?: boolean;
+    onToggle?: () => void;
+}): react.JSX.Element;
+
+export { AddBlockRow as default };

package/dist/screen/components/AddBlockRow.js

@@ -0,0 +1 @@
+export{AddBlockRow as default}from"../../chunk-66ICOE3I.js";import"../../chunk-HQ4VVRIC.js";import"../../chunk-NBJ2YY6Y.js";import"../../chunk-P67FP7PG.js";import"../../chunk-AELNNAFM.js";import"../../chunk-BXZ6WLHC.js";import"../../chunk-EOJNJCMJ.js";import"../../chunk-ZFDCDJNZ.js";import"../../chunk-ZNS7727Y.js";import"../../chunk-3EDSDPIP.js";import"../../chunk-QTLAVDJE.js";import"../../chunk-YRLPFZW3.js";import"../../chunk-KTVH2ZRL.js";import"../../chunk-D2BCHTQR.js";import"../../chunk-EWVJSRRY.js";import"../../chunk-P6O363EE.js";import"../../chunk-FPOKPNO4.js";import"../../chunk-MFIRYGHW.js";import"../../chunk-BZ5ASXOL.js";import"../../chunk-67GNT6PF.js";import"../../chunk-ZNCEOSXO.js";import"../../chunk-L5KW4HG5.js";import"../../chunk-KRXQM65X.js";import"../../chunk-NKB3KVAB.js";