@juo/blocks 1.7.1 → 1.8.1

package/dist/editor.js

@@ -2,8 +2,8 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { onRegisterBlock, getDefinedBlocks } from "@juo/blocks";
-import { a as createEditorBridge, f as createRemoveBlockMessage, g as createRegisterBlocksMessage, h as createRegisterRoutesMessage } from "./bridge-DAUIcGuq.js";
-import { i, b, j, k, l, m, n, c, o, p, q, r, s, e, t, u, v, w, d, x, y, z, A } from "./bridge-DAUIcGuq.js";
+import { a as createEditorBridge, f as createOpenAddBlockMenuMessage, g as createRemoveBlockMessage, h as createRegisterBlocksMessage, i as createRegisterRoutesMessage } from "./bridge-BOcO9toS.js";
+import { j, k, b, l, m, n, o, p, c, q, r, s, t, u, e, v, w, x, y, d, z, A, B, C } from "./bridge-BOcO9toS.js";
 import { h as createBlockInstanceFromObject } from "./block-C8lPBCF8.js";
 import { i as indexOverrides } from "./theme-state-LZS5T-Xb.js";
 function createEditorHandler(options) {
@@ -128,17 +128,17 @@ function createEditorHandler(options) {
       if (location.type === "before" || location.type === "after") {
         let findAndInsertBlock = function(blocks, targetId, newBlock2, position) {
           var _a2;
-          for (let i2 = 0; i2 < blocks.length; i2++) {
-            if (blocks[i2].id === targetId) {
+          for (let i = 0; i < blocks.length; i++) {
+            if (blocks[i].id === targetId) {
               if (position === "before") {
-                blocks.splice(i2, 0, newBlock2);
+                blocks.splice(i, 0, newBlock2);
               } else {
-                blocks.splice(i2 + 1, 0, newBlock2);
+                blocks.splice(i + 1, 0, newBlock2);
               }
               return true;
             }
-            for (const slotKey of Object.keys(blocks[i2].slots || {})) {
-              const slotBlocks = blocks[i2].slots[slotKey];
+            for (const slotKey of Object.keys(blocks[i].slots || {})) {
+              const slotBlocks = blocks[i].slots[slotKey];
               const slotArray = Array.isArray(slotBlocks) ? slotBlocks : [slotBlocks];
               for (let j2 = 0; j2 < slotArray.length; j2++) {
                 if (typeof slotArray[j2] !== "string" && ((_a2 = slotArray[j2]) == null ? void 0 : _a2.id) === targetId) {
@@ -147,7 +147,7 @@ function createEditorHandler(options) {
                   } else {
                     slotArray.splice(j2 + 1, 0, newBlock2);
                   }
-                  blocks[i2].slots[slotKey] = slotArray;
+                  blocks[i].slots[slotKey] = slotArray;
                   return true;
                 }
               }
@@ -201,21 +201,21 @@ function createEditorHandler(options) {
     } else if (message.type === "REMOVE_BLOCK") {
       let findAndRemoveBlock = function(blocks, blockId, slot, parentId) {
         var _a2;
-        for (let i2 = 0; i2 < blocks.length; i2++) {
-          if (blocks[i2].id === parentId && ((_a2 = blocks[i2].slots) == null ? void 0 : _a2[slot])) {
-            const slotBlocks = blocks[i2].slots[slot];
+        for (let i = 0; i < blocks.length; i++) {
+          if (blocks[i].id === parentId && ((_a2 = blocks[i].slots) == null ? void 0 : _a2[slot])) {
+            const slotBlocks = blocks[i].slots[slot];
             const slotArray = Array.isArray(slotBlocks) ? slotBlocks : [slotBlocks];
             const index = slotArray.findIndex(
               (b2) => typeof b2 !== "string" && (b2 == null ? void 0 : b2.id) === blockId
             );
             if (index !== -1) {
               slotArray.splice(index, 1);
-              blocks[i2].slots[slot] = slotArray;
+              blocks[i].slots[slot] = slotArray;
               return true;
             }
           }
-          for (const slotKey of Object.keys(blocks[i2].slots || {})) {
-            const slotBlocks = blocks[i2].slots[slotKey];
+          for (const slotKey of Object.keys(blocks[i].slots || {})) {
+            const slotBlocks = blocks[i].slots[slotKey];
             const slotArray = Array.isArray(slotBlocks) ? slotBlocks : [slotBlocks];
             for (const child of slotArray) {
               if (typeof child !== "string" && (child == null ? void 0 : child.id)) {
@@ -309,14 +309,6 @@ const styles = `
     box-sizing: border-box;
   }
 
-  :host(:hover:not(.active)) .block-wrapper {
-    outline: 1px dashed #060606;
-    /* 4px gap between the block content and the dashed outline so the
-     * outline reads as a hover affordance rather than a touching border.
-     * Outline doesn't participate in layout, so this stays layout-neutral. */
-    outline-offset: 4px;
-  }
-
   /*
    * Stacking model for the active state (no negative z-index, no isolation):
    *   - .block-wrapper__chrome   z-index: 100 → visual frame above neighbours
@@ -518,6 +510,262 @@ const styles = `
     background: #e9e9e9;
     flex-shrink: 0;
   }
+
+  /*
+   * Add-block UI — full-width rail (absolute, inset of .block-wrapper) so
+   * spill line widths use 50% of the block without container-type / cqw
+   * (which breaks flex layout in workflow overlays). Each chrome edge is an
+   * .add-edge row; the button and ::before/::after spills live on that edge.
+   *
+   * Chrome extends 44px above and 12px below the block content:
+   *   .add-edge--top    → top: -44px
+   *   .add-edge--bottom → bottom: -12px
+   */
+  .block-wrapper__add-rail {
+    position: absolute;
+    left: 0;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    pointer-events: none;
+    z-index: 103;
+  }
+
+  .block-wrapper__add-edge {
+    position: absolute;
+    left: 0;
+    right: 0;
+    height: 0;
+    pointer-events: none;
+  }
+
+  .block-wrapper__add-edge--top {
+    top: -44px;
+  }
+
+  .block-wrapper__add-edge--bottom {
+    bottom: -12px;
+  }
+
+  .block-wrapper__add-btn {
+    position: absolute;
+    left: 50%;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    /* Above ::before/::after spills on the same .add-edge */
+    z-index: 1;
+    pointer-events: none;
+    appearance: none;
+    border: none;
+    background: none;
+    padding: 0;
+    margin: 0;
+    cursor: pointer;
+    /* Larger hit target than the 14×14 icon (lines are pointer-events: none). */
+    min-width: 28px;
+    min-height: 28px;
+    overflow: visible;
+    line-height: 1;
+    font-family: inherit;
+    opacity: 0;
+    transition: opacity 180ms ease;
+  }
+
+  .block-wrapper__add-btn--top {
+    top: 0;
+    transform: translate(-50%, -50%);
+  }
+
+  .block-wrapper__add-btn--bottom {
+    bottom: 0;
+    top: auto;
+    transform: translate(-50%, 50%);
+  }
+
+  /* B — active chrome hovered: fade buttons in (opacity only). */
+  :host(.active:hover) .block-wrapper__add-btn {
+    opacity: 1;
+    pointer-events: auto;
+  }
+
+  /*
+   * Entering the chrome from outside often lands on the button at once — skip
+   * the fade so only the + → pill morph runs (avoids end-of-animation snap).
+   */
+  :host(.active:hover)
+    .block-wrapper__add-edge:has(.block-wrapper__add-btn:hover)
+    .block-wrapper__add-btn,
+  :host(.active)
+    .block-wrapper__add-edge:has(.block-wrapper__add-btn--menu-open)
+    .block-wrapper__add-btn {
+    transition: opacity 0s;
+  }
+
+  .block-wrapper__add-btn-inner {
+    position: relative;
+    z-index: 1;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    height: 14px;
+    overflow: visible;
+  }
+
+  /*
+   * Single surface morphs 14×14 circle → 60×14 pill (plus scales away, text
+   * fades in). No overlapping icon + label layers.
+   */
+  .block-wrapper__add-btn-surface {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    box-sizing: border-box;
+    width: 14px;
+    height: 14px;
+    padding: 0;
+    background: #121212;
+    border: 0.5px solid #121212;
+    border-radius: 50%;
+    overflow: visible;
+    isolation: isolate;
+    transition:
+      width 200ms cubic-bezier(0.34, 1.12, 0.64, 1),
+      border-radius 200ms cubic-bezier(0.34, 1.12, 0.64, 1),
+      padding 200ms cubic-bezier(0.34, 1.12, 0.64, 1);
+  }
+
+  .block-wrapper__add-btn-plus {
+    display: inline-flex;
+    flex-shrink: 0;
+    align-items: center;
+    justify-content: center;
+    width: 14px;
+    height: 14px;
+    transition:
+      opacity 160ms ease,
+      transform 200ms cubic-bezier(0.34, 1.12, 0.64, 1),
+      width 200ms cubic-bezier(0.34, 1.12, 0.64, 1);
+  }
+
+  .block-wrapper__add-btn-plus svg {
+    display: block;
+    filter: drop-shadow(0 0 7px rgba(0, 0, 0, 0.1));
+  }
+
+  .block-wrapper__add-btn-text {
+    max-width: 0;
+    opacity: 0;
+    overflow: hidden;
+    color: #ffffff;
+    font-size: 9px;
+    font-weight: 600;
+    letter-spacing: -0.036px;
+    line-height: 1;
+    white-space: nowrap;
+    transition:
+      max-width 200ms cubic-bezier(0.34, 1.12, 0.64, 1) 35ms,
+      opacity 140ms ease 70ms;
+  }
+
+  /*
+   * 0.5px spill on the chrome border — ::before/::after meet at 50% (no gap
+   * for the pill) so the line stays continuous when the button fades out.
+   * The button paints above (z-index). Vertical: fixed translateY (never
+   * transitioned). Horizontal: width 0 → full (not scale — Safari thickens /
+   * shifts 0.5px lines when scale is composited with translateY on transform).
+   */
+  .block-wrapper__add-edge::before,
+  .block-wrapper__add-edge::after {
+    content: "";
+    position: absolute;
+    top: 50%;
+    width: 0;
+    min-width: 0;
+    height: 0.5px;
+    pointer-events: none;
+    z-index: 0;
+    overflow: hidden;
+    transition-property: width;
+    transition-duration: 260ms;
+    transition-timing-function: cubic-bezier(0.22, 1, 0.36, 1);
+    transition-delay: 50ms;
+  }
+
+  .block-wrapper__add-edge::before {
+    right: 50%;
+    background: linear-gradient(to left, #121212 0%, #b5b5b5 100%);
+  }
+
+  .block-wrapper__add-edge::after {
+    left: 50%;
+    background: linear-gradient(to right, #121212 0%, #b5b5b5 100%);
+  }
+
+  .block-wrapper__add-edge--top::before,
+  .block-wrapper__add-edge--top::after {
+    transform: translateY(calc(-50% + 0.25px));
+  }
+
+  .block-wrapper__add-edge--bottom::before,
+  .block-wrapper__add-edge--bottom::after {
+    transform: translateY(calc(-50% - 0.25px));
+  }
+
+  /* C — hover / menu-open: morph + spill extend */
+  :host(.active:hover) .block-wrapper__add-btn:hover .block-wrapper__add-btn-surface,
+  :host(.active) .block-wrapper__add-btn--menu-open .block-wrapper__add-btn-surface {
+    width: 60px;
+    border-radius: 32px;
+    padding: 0 6px;
+  }
+
+  :host(.active:hover) .block-wrapper__add-btn:hover .block-wrapper__add-btn-plus,
+  :host(.active) .block-wrapper__add-btn--menu-open .block-wrapper__add-btn-plus {
+    width: 0;
+    opacity: 0;
+    transform: scale(0.35);
+  }
+
+  :host(.active:hover) .block-wrapper__add-btn:hover .block-wrapper__add-btn-text,
+  :host(.active) .block-wrapper__add-btn--menu-open .block-wrapper__add-btn-text {
+    max-width: 52px;
+    opacity: 1;
+  }
+
+  :host(.active:hover) .block-wrapper__add-edge:has(.block-wrapper__add-btn:hover)::before,
+  :host(.active:hover) .block-wrapper__add-edge:has(.block-wrapper__add-btn:hover)::after,
+  :host(.active) .block-wrapper__add-edge:has(.block-wrapper__add-btn--menu-open)::before,
+  :host(.active) .block-wrapper__add-edge:has(.block-wrapper__add-btn--menu-open)::after {
+    width: calc(50% - 24px);
+    min-width: 40px;
+  }
+
+  /*
+   * --menu-open keeps the button in pill state while the editor's AddMenu
+   * is open against this button — so the user has a visual anchor of
+   * where the menu was triggered from. Note: we explicitly do NOT require
+   * :host(:hover) here because the user's pointer is over the menu (which
+   * lives outside the iframe) once the menu opens, so :host(:hover) has
+   * dropped.
+   */
+  :host(.active) .block-wrapper__add-btn--menu-open {
+    opacity: 1;
+    pointer-events: auto;
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .block-wrapper__add-btn,
+    .block-wrapper__add-btn-inner,
+    .block-wrapper__add-btn-surface,
+    .block-wrapper__add-edge::before,
+    .block-wrapper__add-edge::after,
+    .block-wrapper__add-btn-plus,
+    .block-wrapper__add-btn-text {
+      transition: none;
+    }
+  }
 </style>
 `;
 const blockIconSvg = `
@@ -531,6 +779,12 @@ const moreIconSvg = `
 <path d="M1.5 0C2.32843 2.0934e-07 3 0.671573 3 1.5C3 2.32843 2.32843 3 1.5 3C0.671573 3 3.62117e-08 2.32843 0 1.5C6.04266e-08 0.671573 0.671573 3.62117e-08 1.5 0ZM6.5 0C7.32843 2.0934e-07 8 0.671573 8 1.5C8 2.32843 7.32843 3 6.5 3C5.67157 3 5 2.32843 5 1.5C5 0.671573 5.67157 3.62117e-08 6.5 0ZM11.5 0C12.3284 2.0934e-07 13 0.671573 13 1.5C13 2.32843 12.3284 3 11.5 3C10.6716 3 10 2.32843 10 1.5C10 0.671573 10.6716 3.62117e-08 11.5 0Z" fill="currentColor"/>
 </svg>
 `;
+const addBlockIconSvg = `
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <circle cx="7" cy="7" r="7" fill="#121212"/>
+  <path d="M7 4.77V9.23M4.77 7H9.23" stroke="white" stroke-width="1.14" stroke-linecap="round"/>
+</svg>
+`;
 const trashIconSvg = `
 <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
 <path d="M2 4H12" stroke="currentColor" stroke-width="1.2" stroke-linecap="round"/>
@@ -550,7 +804,25 @@ class BlockWrapper extends HTMLElement {
     __publicField(this, "menuElement", null);
     __publicField(this, "isMenuOpen", false);
     __publicField(this, "closeMenuOnOutsideClick", null);
-    __publicField(this, "emptyObserver", null);
+    __publicField(this, "addButtons", []);
+    __publicField(this, "addRail", null);
+    __publicField(this, "hoverOutlineTarget", null);
+    __publicField(this, "handleHoverEnter", () => {
+      if (this.classList.contains("active")) return;
+      const slotted = this.firstElementChild;
+      if (!slotted || slotted.hasAttribute("data-empty")) return;
+      const target = BlockWrapper.resolveOutlineTarget(slotted);
+      if (!target) return;
+      this.hoverOutlineTarget = target;
+      target.style.outline = "1px solid #060606";
+      target.style.outlineOffset = "0";
+    });
+    __publicField(this, "handleHoverLeave", () => {
+      if (!this.hoverOutlineTarget) return;
+      this.hoverOutlineTarget.style.outline = "";
+      this.hoverOutlineTarget.style.outlineOffset = "";
+      this.hoverOutlineTarget = null;
+    });
     this.attachShadow({ mode: "open" });
     this.setupStyles();
     this.setupTemplate();
@@ -617,16 +889,91 @@ class BlockWrapper extends HTMLElement {
     const slot = document.createElement("slot");
     slotHost.appendChild(slot);
     wrapper.appendChild(slotHost);
+    const addRail = document.createElement("div");
+    addRail.className = "block-wrapper__add-rail";
+    this.addRail = addRail;
+    const topEdge = document.createElement("div");
+    topEdge.className = "block-wrapper__add-edge block-wrapper__add-edge--top";
+    const topAddBtn = this.createAddButton("before");
+    topAddBtn.classList.add("block-wrapper__add-btn--top");
+    topEdge.appendChild(topAddBtn);
+    addRail.appendChild(topEdge);
+    const bottomEdge = document.createElement("div");
+    bottomEdge.className = "block-wrapper__add-edge block-wrapper__add-edge--bottom";
+    const bottomAddBtn = this.createAddButton("after");
+    bottomAddBtn.classList.add("block-wrapper__add-btn--bottom");
+    bottomEdge.appendChild(bottomAddBtn);
+    addRail.appendChild(bottomEdge);
+    wrapper.appendChild(addRail);
+    this.addButtons = [topAddBtn, bottomAddBtn];
     this.shadowRoot.appendChild(wrapper);
     this.nameElement = nameSpan;
     this.menuElement = menuEl;
     this.editorBridge.onMessage((message) => {
-      var _a;
+      var _a, _b;
       if (message.type === "SELECT_BLOCK") {
         this.updateActiveState(message.payload.blockId === ((_a = this.block) == null ? void 0 : _a.id));
+      } else if (message.type === "ADD_BLOCK_MENU_CLOSED" && message.payload.targetBlockId === ((_b = this.block) == null ? void 0 : _b.id)) {
+        this.clearAddButtonMenuState(message.payload.position);
       }
     });
   }
+  createAddButton(position) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "block-wrapper__add-btn";
+    btn.setAttribute("aria-label", "Add block");
+    btn.dataset.position = position;
+    const inner = document.createElement("span");
+    inner.className = "block-wrapper__add-btn-inner";
+    const surface = document.createElement("span");
+    surface.className = "block-wrapper__add-btn-surface";
+    const plus = document.createElement("span");
+    plus.className = "block-wrapper__add-btn-plus";
+    plus.setAttribute("aria-hidden", "true");
+    plus.innerHTML = addBlockIconSvg;
+    const text = document.createElement("span");
+    text.className = "block-wrapper__add-btn-text";
+    text.textContent = "Add block";
+    surface.appendChild(plus);
+    surface.appendChild(text);
+    inner.appendChild(surface);
+    btn.appendChild(inner);
+    btn.addEventListener("click", (e2) => {
+      e2.stopPropagation();
+      e2.preventDefault();
+      this.handleAddBlock(position, btn);
+    });
+    return btn;
+  }
+  handleAddBlock(position, button) {
+    if (!this.block) return;
+    const rect = button.getBoundingClientRect();
+    const anchor = {
+      x: rect.right,
+      // Top edge of the button — menu opens to the right with align=start.
+      y: rect.top
+    };
+    for (const btn of this.addButtons) {
+      btn.classList.toggle(
+        "block-wrapper__add-btn--menu-open",
+        btn === button
+      );
+    }
+    this.editorBridge.sendMessage(
+      createOpenAddBlockMenuMessage({
+        targetBlockId: this.block.id,
+        position,
+        anchor
+      })
+    );
+  }
+  clearAddButtonMenuState(position) {
+    for (const btn of this.addButtons) {
+      if (position != null && btn.dataset.position !== position) continue;
+      btn.classList.remove("block-wrapper__add-btn--menu-open");
+    }
+  }
   connectedCallback() {
     const isInOverlay = this.closest('juo-extension-root[surface="overlay"]') !== null;
     if (isInOverlay) {
@@ -638,6 +985,9 @@ class BlockWrapper extends HTMLElement {
         ".block-wrapper__menu-item--danger"
       );
       if (deleteBtn) deleteBtn.style.display = "none";
+      if (this.addRail) {
+        this.addRail.style.display = "none";
+      }
     }
     const isWorkflowPreview = (() => {
       try {
@@ -650,50 +1000,40 @@ class BlockWrapper extends HTMLElement {
     if (isWorkflowPreview && !isInOverlay) {
       this.style.pointerEvents = "none";
     }
-    this.observeSlotEmptyState();
+    this.addEventListener("mouseenter", this.handleHoverEnter);
+    this.addEventListener("mouseleave", this.handleHoverLeave);
   }
   /**
-   * Mirror `data-empty` from the slotted block wrapper onto this editor
-   * wrapper so page-level divider CSS (and live-data preview) treat empty
-   * blocks the same as in view mode.
+   * Resolve the slotted block's first painted descendant — the
+   * card-like surface we paint the hover outline on. We can't use
+   * ::slotted() (CE blocks' own :host rules win the cascade) and we
+   * can't put outline on .block-wrapper directly (it has no radius and
+   * adopting one is more code than this), so we apply outline as an
+   * inline style on the visible element. Skips:
+   *   - <style> nodes (Vue's defineCustomElement injects styles into
+   *     the CE shadow root next to the rendered tree).
+   *   - display:contents wrappers (Vue's <ContextProvider> sits between
+   *     the slotted div and the actual UiCard for createVueRenderer).
+   * Crosses one shadow-root boundary for createVueCeRenderer blocks
+   * whose slotted element is itself a CE host.
    */
-  observeSlotEmptyState() {
-    var _a;
-    (_a = this.emptyObserver) == null ? void 0 : _a.disconnect();
-    const sync = () => {
-      const slotted = this.firstElementChild;
-      const empty = slotted == null || slotted.hasAttribute("data-empty");
-      this.toggleAttribute("data-empty", empty);
-    };
-    const bindObservers = () => {
-      this.emptyObserver.observe(this, { childList: true });
-      const slotted = this.firstElementChild;
-      if (slotted) {
-        this.emptyObserver.observe(slotted, {
-          attributes: true,
-          attributeFilter: ["data-empty"]
-        });
+  static resolveOutlineTarget(slotted) {
+    const root = slotted.shadowRoot ?? slotted;
+    let el = root.firstElementChild;
+    while (el) {
+      if (el.tagName === "STYLE") {
+        el = el.nextElementSibling;
+        continue;
       }
-    };
-    sync();
-    this.emptyObserver = new MutationObserver((records) => {
-      const slottedChildChanged = records.some(
-        (record) => record.type === "childList" && record.target === this
-      );
-      if (slottedChildChanged) {
-        this.emptyObserver.disconnect();
-        sync();
-        bindObservers();
-        return;
+      if (getComputedStyle(el).display === "contents") {
+        el = el.firstElementChild;
+        continue;
       }
-      sync();
-    });
-    bindObservers();
+      return el;
+    }
+    return slotted.shadowRoot ? null : slotted;
   }
   disconnectedCallback() {
-    var _a;
-    (_a = this.emptyObserver) == null ? void 0 : _a.disconnect();
-    this.emptyObserver = null;
     this.closeMenu();
   }
   toggleMenu() {
@@ -733,6 +1073,7 @@ class BlockWrapper extends HTMLElement {
   updateActiveState(isActive) {
     if (isActive) {
       this.classList.add("active");
+      this.handleHoverLeave();
     } else {
       this.classList.remove("active");
       this.closeMenu();
@@ -863,33 +1204,35 @@ async function setupEditorMode(deps) {
 }
 export {
   BlockWrapper,
-  i as createAddBlockMessage,
+  j as createAddBlockMenuClosedMessage,
+  k as createAddBlockMessage,
   createEditorBridge,
   createEditorHandler,
   b as createFocusInlineTextMessage,
-  j as createMoveBlockMessage,
-  k as createProvideGlobalStylesMessage,
-  l as createProvideInitialGlobalStylesMessage,
-  m as createProvideThemeStateMessage,
-  n as createProvideTranslationOverridesMessage,
+  l as createMoveBlockMessage,
+  createOpenAddBlockMenuMessage,
+  m as createProvideGlobalStylesMessage,
+  n as createProvideInitialGlobalStylesMessage,
+  o as createProvideThemeStateMessage,
+  p as createProvideTranslationOverridesMessage,
   c as createRegisterBlockTranslationKeysMessage,
   createRegisterBlocksMessage,
   createRegisterRoutesMessage,
   createRemoveBlockMessage,
-  o as createReportContentHeightMessage,
-  p as createRequestGlobalStylesMessage,
-  q as createRequestThemeStateMessage,
-  r as createRequestTranslationOverridesMessage,
-  s as createScrollSyncMessage,
+  q as createReportContentHeightMessage,
+  r as createRequestGlobalStylesMessage,
+  s as createRequestThemeStateMessage,
+  t as createRequestTranslationOverridesMessage,
+  u as createScrollSyncMessage,
   e as createSelectBlockMessage,
-  t as createSetBlockPresetMessage,
-  u as createSetGlobalStylesMessage,
-  v as createSetLocaleMessage,
-  w as createUpdateBlockPropsMessage,
+  v as createSetBlockPresetMessage,
+  w as createSetGlobalStylesMessage,
+  x as createSetLocaleMessage,
+  y as createUpdateBlockPropsMessage,
   d as createUpdateBlockTranslationMessage,
-  x as createUpsertThemeStateMessage,
-  y as getEditorBridge,
-  z as isEditorMessage,
-  A as isIframeMessage,
+  z as createUpsertThemeStateMessage,
+  A as getEditorBridge,
+  B as isEditorMessage,
+  C as isIframeMessage,
   setupEditorMode
 };

package/dist/{juo-workflow-Dqr1lB1k.js → juo-workflow-B3OHYsp-.js}

@@ -2,7 +2,7 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { c as createContext, d, E, m as getDefinedBlocks, f as createBlockInstance, w, r as registerBlock, k as defineBlock, v as subscribeContext } from "./block-C8lPBCF8.js";
-import { a as createEditorBridge, e as createSelectBlockMessage } from "./bridge-DAUIcGuq.js";
+import { a as createEditorBridge, e as createSelectBlockMessage } from "./bridge-BOcO9toS.js";
 const TranslationContext = createContext("translation");
 function toStringRecord(input) {
   if (input == null) return {};

package/dist/preact.js

@@ -6,7 +6,7 @@ import { useState, useRef, useEffect, useContext as useContext$1, useMemo } from
 import { g as getSignalValue, s as setSignalValue, w as wrapContext, c as createSlotChildren } from "./block-VhmfGB3N.js";
 import { t } from "./block-VhmfGB3N.js";
 import { createContext, h, render } from "preact";
-import { a as createEditorBridge } from "./bridge-DAUIcGuq.js";
+import { a as createEditorBridge } from "./bridge-BOcO9toS.js";
 function toState(signal) {
   const [value, setValue] = useState(() => getSignalValue(signal));
   const disposeRef = useRef(null);

package/dist/react.js

@@ -6,7 +6,7 @@ import React, { useSyncExternalStore, createContext, useState, useContext as use
 import { g as getSignalValue, s as setSignalValue, w as wrapContext, c as createSlotChildren } from "./block-VhmfGB3N.js";
 import { t } from "./block-VhmfGB3N.js";
 import { createRoot } from "react-dom/client";
-import { a as createEditorBridge } from "./bridge-DAUIcGuq.js";
+import { a as createEditorBridge } from "./bridge-BOcO9toS.js";
 function toState(signal) {
   const subscribe = (callback) => {
     const dispose = effect(() => {