efficient-easel 0.101.0 → 0.102.0

package/dist/host-B-byaQxg.d.ts

@@ -0,0 +1,480 @@
+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.
+ */
+
+interface DocumentAddressing {
+    /**
+     * 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: ScreenTarget) => 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: ScreenTarget, search: string) => ScreenTarget | 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: ScreenTarget) => 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: ScreenTarget) => 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: ScreenTarget, 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: <T>(data: T) => T;
+}
+/**
+ * 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.
+ */
+declare const NO_DOCUMENT_ADDRESSING: DocumentAddressing;
+
+type ScreenTarget = {
+    kind: "page";
+    slug: string;
+    siteId?: string;
+    originSlug?: string;
+} | {
+    kind: "template";
+    id: string;
+    pageSlug?: string;
+};
+
+type ScreenDocumentValue = {
+    /** The document the editor is currently pointed at (runtime, retargetable). */
+    target: ScreenTarget;
+    /** 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. */
+    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. */
+    readOnly: boolean;
+    /** 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: ScreenTarget) => void;
+    /** A retarget held behind the unsaved-changes prompt (null = no prompt). */
+    pendingNav: ScreenTarget | null;
+    cancelPendingNav: () => void;
+    discardAndNavigate: () => void;
+    saveAndNavigate: () => Promise<void>;
+};
+declare const ScreenDocumentContext: react.Context<ScreenDocumentValue | null>;
+declare function useScreenDocument(): ScreenDocumentValue;
+declare function ScreenDocumentProvider({ target, addressing, onHostMessage, children, }: {
+    target: ScreenTarget;
+    /** 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?: DocumentAddressing;
+    /** 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). */
+    show(target: ScreenTarget | SectionScreenTarget): void;
+    /** Leave for another document by LOADING it (an entry bounce, a deleted page). */
+    load(target: ScreenTarget): 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 { 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 ScreenTarget as j, ScreenDocumentContext as k, ScreenDocumentProvider as l, type ScreenDocumentValue as m, useScreenDocument as n, 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/panel/index.js

@@ -1,18 +1,18 @@
-export{SETTINGS_BUCKETS,SettingsField,SettingsGroup,SettingsTabs}from"../chunk-ZNS7727Y.js";import{DEFAULT_PANEL_WORDS as e}from"../chunk-QTLAVDJE.js";export{SettingsSegmented,SettingsSwitch}from"../chunk-P6O363EE.js";import"../chunk-BZ5ASXOL.js";import{RevertIcon as a}from"../chunk-L5KW4HG5.js";import{jsx as l,jsxs as s}from"react/jsx-runtime";function i({title:e,level:a=3,id:s,className:i}){/* @__PURE__ */
-return l(`h${a}`,{id:s,className:i?`es-group-head ${i}`:"es-group-head",children:e})}function n({title:e,level:a=4,id:s,className:i}){/* @__PURE__ */
-return l(`h${a}`,{id:s,className:i?`es-group-sub ${i}`:"es-group-sub",children:e})}function t({label:s,changed:i,onReset:n,detail:t,disabled:r,defaultAction:d,words:o,className:u}){const p={...e,...o},m=["es-default-reset"];if(i&&m.push("is-changed"),u&&m.push(u),!i&&d)return m.push("is-pressable"),/* @__PURE__ */l("button",{type:"button",className:m.join(" "),"aria-label":d.title,title:d.title,disabled:r,onClick:d.onPress,children:d.icon});if(!i)/* @__PURE__ */
-return l("span",{className:m.join(" "),"aria-hidden":"true"});const b=p.resetName({label:s});/* @__PURE__ */
-return l("button",{type:"button",className:m.join(" "),"aria-label":b,"aria-description":t||void 0,title:t?p.resetTitle({label:s,detail:t}):b,disabled:r,onClick:e=>{n(),function(e){const a=e.currentTarget.closest(".es-field"),l=a?.querySelector(c(".es-field-ctl"))??a?.querySelector(c(".es-field-head"));l?.focus()}(e)},children:/* @__PURE__ */l(a,{size:15})})}var r=['input:not([disabled]):not([type="hidden"])',"select:not([disabled])","textarea:not([disabled])","button:not([disabled]):not(.es-default-reset)",'[tabindex]:not([tabindex="-1"])'].join(", "),c=e=>r.split(", ").map(a=>`${e} ${a}`).join(", ");function d({name:e,preview:a,offPage:i,status:n,onOpen:t,id:r,className:c}){const d=null!=a;/* @__PURE__ */
-return s("button",{type:"button",id:r,className:c?`es-drill ${c}`:"es-drill",onClick:t,children:[
+export{SETTINGS_BUCKETS,SettingsField,SettingsGroup,SettingsTabs}from"../chunk-ZNS7727Y.js";import{DEFAULT_PANEL_WORDS as e}from"../chunk-QTLAVDJE.js";export{SettingsSegmented,SettingsSwitch}from"../chunk-P6O363EE.js";import"../chunk-BZ5ASXOL.js";import{RevertIcon as a}from"../chunk-L5KW4HG5.js";import{jsx as l,jsxs as s}from"react/jsx-runtime";function n({title:e,level:a=3,id:s,className:n}){/* @__PURE__ */
+return l(`h${a}`,{id:s,className:n?`es-group-head ${n}`:"es-group-head",children:e})}function i({title:e,level:a=4,id:s,className:n}){/* @__PURE__ */
+return l(`h${a}`,{id:s,className:n?`es-group-sub ${n}`:"es-group-sub",children:e})}function t({label:s,changed:n,onReset:i,detail:t,disabled:d,defaultAction:u,words:p,className:m}){const b={...e,...p},h=["es-default-reset"];if(n&&h.push("is-changed"),m&&h.push(m),!n&&u)return h.push("is-pressable"),/* @__PURE__ */l("button",{type:"button",className:h.join(" "),"aria-label":u.title,title:u.title,disabled:d,onClick:u.onPress,children:u.icon});if(!n)/* @__PURE__ */
+return l("span",{className:h.join(" "),"aria-hidden":"true"});const N=b.resetName({label:s});/* @__PURE__ */
+return l("button",{type:"button",className:h.join(" "),"aria-label":N,"aria-description":t||void 0,title:t?b.resetTitle({label:s,detail:t}):N,disabled:d,onClick:e=>{i(),function(e){const a=e.currentTarget,l=a.closest(".es-field");let s=l?.querySelector(o(".es-field-ctl"))??l?.querySelector(o(".es-field-head"))??null,n=l?null:a.parentElement;for(let e=0;!s&&n&&e<c;e+=1,n=n.parentElement)s=[...n.querySelectorAll(r)].find(e=>e!==a)??null;s?.focus()}(e)},children:/* @__PURE__ */l(a,{size:15})})}var r=['input:not([disabled]):not([type="hidden"])',"select:not([disabled])","textarea:not([disabled])","button:not([disabled]):not(.es-default-reset)",'[tabindex]:not([tabindex="-1"])'].join(", "),o=e=>r.split(", ").map(a=>`${e} ${a}`).join(", "),c=4;function d({name:e,preview:a,offPage:n,status:i,onOpen:t,id:r,className:o}){const c=null!=a;/* @__PURE__ */
+return s("button",{type:"button",id:r,className:o?`es-drill ${o}`:"es-drill",onClick:t,children:[
 /* @__PURE__ */s("span",{className:"es-drill-text",children:[
-/* @__PURE__ */l("span",{className:"es-drill-name",children:e}),d?/* @__PURE__ */l("span",{className:i?"es-drill-preview is-offpage":"es-drill-preview",children:a}):null]}),n?/* @__PURE__ */l("span",{className:"es-drill-status",children:n}):null,
-/* @__PURE__ */l("span",{className:"es-drill-chev","aria-hidden":"true"})]})}function o({label:e,value:a,points:s,onChange:i,id:n,className:t}){/* @__PURE__ */
-return l("div",{id:n,className:"es-placement"+(t?` ${t}`:""),role:"radiogroup","aria-label":e,children:s.map(e=>{const s=a===e.value,n=!0===e.disabled;/* @__PURE__ */
-return l("button",{type:"button",role:"radio","aria-checked":s,"aria-label":e.label,"aria-disabled":n||void 0,disabled:n,title:e.title??e.label,className:`es-placement-cell${s?" is-active":""}${n?" is-off":""}`,onClick:()=>i(e.value),children:e.icon?/* @__PURE__ */l("span",{className:"es-placement-icon","aria-hidden":"true",children:e.icon}):/* @__PURE__ */l("span",{className:"es-placement-dot"})},e.value)})})}function u({label:e,value:a,corners:i,onChange:n,id:t,className:r}){/* @__PURE__ */
+/* @__PURE__ */l("span",{className:"es-drill-name",children:e}),c?/* @__PURE__ */l("span",{className:n?"es-drill-preview is-offpage":"es-drill-preview",children:a}):null]}),i?/* @__PURE__ */l("span",{className:"es-drill-status",children:i}):null,
+/* @__PURE__ */l("span",{className:"es-drill-chev","aria-hidden":"true"})]})}function u({label:e,value:a,points:s,onChange:n,id:i,className:t}){/* @__PURE__ */
+return l("div",{id:i,className:"es-placement"+(t?` ${t}`:""),role:"radiogroup","aria-label":e,children:s.map(e=>{const s=a===e.value,i=!0===e.disabled;/* @__PURE__ */
+return l("button",{type:"button",role:"radio","aria-checked":s,"aria-label":e.label,"aria-disabled":i||void 0,disabled:i,title:e.title??e.label,className:`es-placement-cell${s?" is-active":""}${i?" is-off":""}`,onClick:()=>n(e.value),children:e.icon?/* @__PURE__ */l("span",{className:"es-placement-icon","aria-hidden":"true",children:e.icon}):/* @__PURE__ */l("span",{className:"es-placement-dot"})},e.value)})})}function p({label:e,value:a,corners:n,onChange:i,id:t,className:r}){/* @__PURE__ */
 return s("div",{id:t,className:"es-corners"+(r?` ${r}`:""),role:"group","aria-label":e,children:[
-/* @__PURE__ */l("span",{className:"es-corners-frame","aria-hidden":"true"}),i.map(e=>{const s=a.includes(e.value),i=!0===e.disabled;/* @__PURE__ */
-return l("button",{type:"button","aria-pressed":s,"aria-label":e.label,"aria-disabled":i||void 0,disabled:i,title:e.title??e.label,className:`es-corners-cell es-corners-${e.value}${s?" is-on":""}${i?" is-off":""}`,onClick:()=>n(s?a.filter(a=>a!==e.value):[...a,e.value]),children:/* @__PURE__ */l("span",{className:"es-corners-mark","aria-hidden":"true"})},e.value)})]})}function p({label:e,onPress:a,disabled:i,note:n,done:t,doneLabel:r,icon:c,id:d,className:o}){const u=void 0===r?e:r,p=t?u:e,m=null!=n,b=m&&d?`${d}-note`:void 0;/* @__PURE__ */
-return s("div",{className:o?`es-action-wrap ${o}`:"es-action-wrap",children:[
-/* @__PURE__ */s("button",{type:"button",id:d,className:t?"es-action is-done":"es-action",disabled:i,"aria-describedby":b,onClick:a,children:[c?/* @__PURE__ */l("span",{className:"es-action-icon","aria-hidden":"true",children:c}):null,
-/* @__PURE__ */l("span",{className:"es-action-label",children:p})]}),m?/* @__PURE__ */l("p",{id:b,className:"es-action-note",children:n}):null,
-/* @__PURE__ */l("span",{className:"es-action-live",role:"status","aria-live":"polite",children:t?u:null})]})}export{p as SettingsAction,u as SettingsCorners,t as SettingsDefaultReset,d as SettingsDrill,i as SettingsGroupHead,n as SettingsGroupSub,o as SettingsPlacement};
+/* @__PURE__ */l("span",{className:"es-corners-frame","aria-hidden":"true"}),n.map(e=>{const s=a.includes(e.value),n=!0===e.disabled;/* @__PURE__ */
+return l("button",{type:"button","aria-pressed":s,"aria-label":e.label,"aria-disabled":n||void 0,disabled:n,title:e.title??e.label,className:`es-corners-cell es-corners-${e.value}${s?" is-on":""}${n?" is-off":""}`,onClick:()=>i(s?a.filter(a=>a!==e.value):[...a,e.value]),children:/* @__PURE__ */l("span",{className:"es-corners-mark","aria-hidden":"true"})},e.value)})]})}function m({label:e,onPress:a,disabled:n,note:i,done:t,doneLabel:r,icon:o,id:c,className:d}){const u=void 0===r?e:r,p=t?u:e,m=null!=i,b=m&&c?`${c}-note`:void 0;/* @__PURE__ */
+return s("div",{className:d?`es-action-wrap ${d}`:"es-action-wrap",children:[
+/* @__PURE__ */s("button",{type:"button",id:c,className:t?"es-action is-done":"es-action",disabled:n,"aria-describedby":b,onClick:a,children:[o?/* @__PURE__ */l("span",{className:"es-action-icon","aria-hidden":"true",children:o}):null,
+/* @__PURE__ */l("span",{className:"es-action-label",children:p})]}),m?/* @__PURE__ */l("p",{id:b,className:"es-action-note",children:i}):null,
+/* @__PURE__ */l("span",{className:"es-action-live",role:"status","aria-live":"polite",children:t?u:null})]})}export{m as SettingsAction,p as SettingsCorners,t as SettingsDefaultReset,d as SettingsDrill,n as SettingsGroupHead,i as SettingsGroupSub,u as SettingsPlacement};

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-D7M6IRPJ.js";import"../../chunk-HQ4VVRIC.js";import"../../chunk-5464H65G.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";