@juo/blocks 1.12.0-alpha.3 → 1.12.1

package/dist/{juo-workflow-DY4rd256.js → juo-workflow-CkyZRq60.js}

@@ -1,9 +1,829 @@
 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 { e as createContext, d, f as createBlockInstanceFromObject, g as createBlockInstance, h as getDefinedBlocks, j as serializeBlocks, o as onRegisterBlock, E, k as w, r as registerBlock, l as defineBlock, s as subscribeContext } from "./block-B6s9jL7l.js";
-import { reportBlockError } from "./observability.js";
-import { c as createEditorBridge, v as createSelectBlockMessage } from "./bridge-r7Yk8fjY.js";
+import { reportBlockError, reportBlockWarning } from "./observability.js";
+import { a as createEditorBridge, e as createSelectBlockMessage } from "./bridge-w5KQ-czl.js";
+const createContext = (key) => key;
+class ContextRequestEvent extends Event {
+  constructor(context, callback, subscribe) {
+    super("context-request", { bubbles: true, composed: true });
+    this.context = context;
+    this.callback = callback;
+    this.subscribe = subscribe;
+  }
+}
+class ContextProvideEvent extends Event {
+  constructor(context, value, subscribe) {
+    super("context-provide", { bubbles: true, composed: true });
+    this.context = context;
+    this.value = value;
+    this.subscribe = subscribe;
+  }
+}
+function provideContext(target, context, init) {
+  console.log("context:provide", context, target);
+  const ev = new ContextProvideEvent(context, init);
+  target.dispatchEvent(ev);
+}
+function injectContext(target, context) {
+  let value = void 0;
+  console.log("context:inject", context, target);
+  const ev = new ContextRequestEvent(context, (received) => {
+    value = received;
+  });
+  target.dispatchEvent(ev);
+  if (value === void 0) {
+    throw new Error(`Context '${context}' not defined`);
+  }
+  return value;
+}
+function subscribeContext(target, context, callback) {
+  let unsubscribeFunction = null;
+  console.log("context:subscribe", context, target);
+  const protocolCallback = (value, unsubscribe) => {
+    if (unsubscribe) {
+      unsubscribeFunction = unsubscribe;
+    }
+    callback(value);
+  };
+  const ev = new ContextRequestEvent(context, protocolCallback, true);
+  target.dispatchEvent(ev);
+  return () => {
+    if (unsubscribeFunction) {
+      unsubscribeFunction();
+    }
+  };
+}
+class ContextRoot extends HTMLElement {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "store", /* @__PURE__ */ new Map());
+    __publicField(this, "callbacks", /* @__PURE__ */ new Map());
+  }
+  connectedCallback() {
+    this.addEventListener("context-provide", (ev) => {
+      ev.stopPropagation();
+      console.log("context-root:provide", ev.context, ev.value);
+      this.store.set(ev.context, ev.value);
+      const registeredCallbacks = this.callbacks.get(ev.context) ?? [];
+      console.log("callbacks", registeredCallbacks);
+      registeredCallbacks.forEach((cb) => {
+        const unsubscribe = () => {
+          const callbacks = this.callbacks.get(ev.context);
+          if (callbacks) {
+            const cbIndex = callbacks.indexOf(cb);
+            if (cbIndex > -1) {
+              callbacks.splice(cbIndex, 1);
+            }
+          }
+          console.log("context-root:unsubscribed", ev.context);
+        };
+        cb(ev.value, unsubscribe);
+      });
+    });
+    this.addEventListener("context-request", (ev) => {
+      ev.stopPropagation();
+      console.log("context-root:request", ev.context, ev);
+      const storedValue = this.store.get(ev.context);
+      if (ev.subscribe) {
+        let callbacks = this.callbacks.get(ev.context);
+        if (!callbacks) {
+          callbacks = [];
+          this.callbacks.set(ev.context, callbacks);
+        }
+        const unsubscribe = () => {
+          const currentCallbacks = this.callbacks.get(ev.context);
+          if (currentCallbacks) {
+            const index = currentCallbacks.indexOf(ev.callback);
+            if (index > -1) {
+              currentCallbacks.splice(index, 1);
+            }
+          }
+          console.log("context-root:unsubscribed", ev.context);
+        };
+        callbacks.push(ev.callback);
+        if (storedValue !== void 0) {
+          ev.callback(storedValue, unsubscribe);
+        }
+      } else {
+        if (storedValue !== void 0) {
+          ev.callback(storedValue);
+        } else {
+          console.warn("Context not present in store: " + String(ev.context));
+        }
+      }
+    });
+    console.log("context-root:ready");
+  }
+}
+var i = Symbol.for("preact-signals");
+function t() {
+  if (!(s > 1)) {
+    var i2, t2 = false;
+    while (void 0 !== h) {
+      var r = h;
+      h = void 0;
+      f++;
+      while (void 0 !== r) {
+        var o2 = r.o;
+        r.o = void 0;
+        r.f &= -3;
+        if (!(8 & r.f) && c(r)) try {
+          r.c();
+        } catch (r2) {
+          if (!t2) {
+            i2 = r2;
+            t2 = true;
+          }
+        }
+        r = o2;
+      }
+    }
+    f = 0;
+    s--;
+    if (t2) throw i2;
+  } else s--;
+}
+var o = void 0;
+function n(i2) {
+  var t2 = o;
+  o = void 0;
+  try {
+    return i2();
+  } finally {
+    o = t2;
+  }
+}
+var h = void 0, s = 0, f = 0, v = 0;
+function e(i2) {
+  if (void 0 !== o) {
+    var t2 = i2.n;
+    if (void 0 === t2 || t2.t !== o) {
+      t2 = { i: 0, S: i2, p: o.s, n: void 0, t: o, e: void 0, x: void 0, r: t2 };
+      if (void 0 !== o.s) o.s.n = t2;
+      o.s = t2;
+      i2.n = t2;
+      if (32 & o.f) i2.S(t2);
+      return t2;
+    } else if (-1 === t2.i) {
+      t2.i = 0;
+      if (void 0 !== t2.n) {
+        t2.n.p = t2.p;
+        if (void 0 !== t2.p) t2.p.n = t2.n;
+        t2.p = o.s;
+        t2.n = void 0;
+        o.s.n = t2;
+        o.s = t2;
+      }
+      return t2;
+    }
+  }
+}
+function u(i2, t2) {
+  this.v = i2;
+  this.i = 0;
+  this.n = void 0;
+  this.t = void 0;
+  this.W = null == t2 ? void 0 : t2.watched;
+  this.Z = null == t2 ? void 0 : t2.unwatched;
+}
+u.prototype.brand = i;
+u.prototype.h = function() {
+  return true;
+};
+u.prototype.S = function(i2) {
+  var t2 = this, r = this.t;
+  if (r !== i2 && void 0 === i2.e) {
+    i2.x = r;
+    this.t = i2;
+    if (void 0 !== r) r.e = i2;
+    else n(function() {
+      var i3;
+      null == (i3 = t2.W) || i3.call(t2);
+    });
+  }
+};
+u.prototype.U = function(i2) {
+  var t2 = this;
+  if (void 0 !== this.t) {
+    var r = i2.e, o2 = i2.x;
+    if (void 0 !== r) {
+      r.x = o2;
+      i2.e = void 0;
+    }
+    if (void 0 !== o2) {
+      o2.e = r;
+      i2.x = void 0;
+    }
+    if (i2 === this.t) {
+      this.t = o2;
+      if (void 0 === o2) n(function() {
+        var i3;
+        null == (i3 = t2.Z) || i3.call(t2);
+      });
+    }
+  }
+};
+u.prototype.subscribe = function(i2) {
+  var t2 = this;
+  return E(function() {
+    var r = t2.value, n2 = o;
+    o = void 0;
+    try {
+      i2(r);
+    } finally {
+      o = n2;
+    }
+  });
+};
+u.prototype.valueOf = function() {
+  return this.value;
+};
+u.prototype.toString = function() {
+  return this.value + "";
+};
+u.prototype.toJSON = function() {
+  return this.value;
+};
+u.prototype.peek = function() {
+  var i2 = o;
+  o = void 0;
+  try {
+    return this.value;
+  } finally {
+    o = i2;
+  }
+};
+Object.defineProperty(u.prototype, "value", { get: function() {
+  var i2 = e(this);
+  if (void 0 !== i2) i2.i = this.i;
+  return this.v;
+}, set: function(i2) {
+  if (i2 !== this.v) {
+    if (f > 100) throw new Error("Cycle detected");
+    this.v = i2;
+    this.i++;
+    v++;
+    s++;
+    try {
+      for (var r = this.t; void 0 !== r; r = r.x) r.t.N();
+    } finally {
+      t();
+    }
+  }
+} });
+function d(i2, t2) {
+  return new u(i2, t2);
+}
+function c(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) if (t2.S.i !== t2.i || !t2.S.h() || t2.S.i !== t2.i) return true;
+  return false;
+}
+function a(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) {
+    var r = t2.S.n;
+    if (void 0 !== r) t2.r = r;
+    t2.S.n = t2;
+    t2.i = -1;
+    if (void 0 === t2.n) {
+      i2.s = t2;
+      break;
+    }
+  }
+}
+function l(i2) {
+  var t2 = i2.s, r = void 0;
+  while (void 0 !== t2) {
+    var o2 = t2.p;
+    if (-1 === t2.i) {
+      t2.S.U(t2);
+      if (void 0 !== o2) o2.n = t2.n;
+      if (void 0 !== t2.n) t2.n.p = o2;
+    } else r = t2;
+    t2.S.n = t2.r;
+    if (void 0 !== t2.r) t2.r = void 0;
+    t2 = o2;
+  }
+  i2.s = r;
+}
+function y(i2, t2) {
+  u.call(this, void 0);
+  this.x = i2;
+  this.s = void 0;
+  this.g = v - 1;
+  this.f = 4;
+  this.W = null == t2 ? void 0 : t2.watched;
+  this.Z = null == t2 ? void 0 : t2.unwatched;
+}
+y.prototype = new u();
+y.prototype.h = function() {
+  this.f &= -3;
+  if (1 & this.f) return false;
+  if (32 == (36 & this.f)) return true;
+  this.f &= -5;
+  if (this.g === v) return true;
+  this.g = v;
+  this.f |= 1;
+  if (this.i > 0 && !c(this)) {
+    this.f &= -2;
+    return true;
+  }
+  var i2 = o;
+  try {
+    a(this);
+    o = this;
+    var t2 = this.x();
+    if (16 & this.f || this.v !== t2 || 0 === this.i) {
+      this.v = t2;
+      this.f &= -17;
+      this.i++;
+    }
+  } catch (i3) {
+    this.v = i3;
+    this.f |= 16;
+    this.i++;
+  }
+  o = i2;
+  l(this);
+  this.f &= -2;
+  return true;
+};
+y.prototype.S = function(i2) {
+  if (void 0 === this.t) {
+    this.f |= 36;
+    for (var t2 = this.s; void 0 !== t2; t2 = t2.n) t2.S.S(t2);
+  }
+  u.prototype.S.call(this, i2);
+};
+y.prototype.U = function(i2) {
+  if (void 0 !== this.t) {
+    u.prototype.U.call(this, i2);
+    if (void 0 === this.t) {
+      this.f &= -33;
+      for (var t2 = this.s; void 0 !== t2; t2 = t2.n) t2.S.U(t2);
+    }
+  }
+};
+y.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var i2 = this.t; void 0 !== i2; i2 = i2.x) i2.t.N();
+  }
+};
+Object.defineProperty(y.prototype, "value", { get: function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  var i2 = e(this);
+  this.h();
+  if (void 0 !== i2) i2.i = this.i;
+  if (16 & this.f) throw this.v;
+  return this.v;
+} });
+function w(i2, t2) {
+  return new y(i2, t2);
+}
+function _(i2) {
+  var r = i2.u;
+  i2.u = void 0;
+  if ("function" == typeof r) {
+    s++;
+    var n2 = o;
+    o = void 0;
+    try {
+      r();
+    } catch (t2) {
+      i2.f &= -2;
+      i2.f |= 8;
+      b(i2);
+      throw t2;
+    } finally {
+      o = n2;
+      t();
+    }
+  }
+}
+function b(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) t2.S.U(t2);
+  i2.x = void 0;
+  i2.s = void 0;
+  _(i2);
+}
+function g(i2) {
+  if (o !== this) throw new Error("Out-of-order effect");
+  l(this);
+  o = i2;
+  this.f &= -2;
+  if (8 & this.f) b(this);
+  t();
+}
+function p(i2) {
+  this.x = i2;
+  this.u = void 0;
+  this.s = void 0;
+  this.o = void 0;
+  this.f = 32;
+}
+p.prototype.c = function() {
+  var i2 = this.S();
+  try {
+    if (8 & this.f) return;
+    if (void 0 === this.x) return;
+    var t2 = this.x();
+    if ("function" == typeof t2) this.u = t2;
+  } finally {
+    i2();
+  }
+};
+p.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1;
+  this.f &= -9;
+  _(this);
+  a(this);
+  s++;
+  var i2 = o;
+  o = this;
+  return g.bind(this, i2);
+};
+p.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 2;
+    this.o = h;
+    h = this;
+  }
+};
+p.prototype.d = function() {
+  this.f |= 8;
+  if (!(1 & this.f)) b(this);
+};
+p.prototype.dispose = function() {
+  this.d();
+};
+function E(i2) {
+  var t2 = new p(i2);
+  try {
+    t2.c();
+  } catch (i3) {
+    t2.d();
+    throw i3;
+  }
+  var r = t2.d.bind(t2);
+  r[Symbol.dispose] = r;
+  return r;
+}
+function isEditorPreview() {
+  if (typeof window === "undefined") return false;
+  return new URLSearchParams(window.location.search).get("editor") === "true";
+}
+function hasRenderedContent(scope) {
+  var _a;
+  for (const child of scope.children) {
+    if (!(child instanceof HTMLElement)) {
+      continue;
+    }
+    const display = (_a = child.ownerDocument.defaultView) == null ? void 0 : _a.getComputedStyle(child).display;
+    if (display === "contents") {
+      if (hasRenderedContent(child)) {
+        return true;
+      }
+      continue;
+    }
+    if (child.checkVisibility()) {
+      return true;
+    }
+  }
+  return false;
+}
+function attachEmptyTracking(host, scope) {
+  let observer = null;
+  let disposed = false;
+  queueMicrotask(() => {
+    if (disposed) return;
+    const observed = scope ?? host.shadowRoot ?? host;
+    const sync = () => host.toggleAttribute("data-empty", !hasRenderedContent(observed));
+    observer = new MutationObserver(sync);
+    observer.observe(observed, { childList: true, subtree: true });
+    sync();
+  });
+  return () => {
+    disposed = true;
+    observer == null ? void 0 : observer.disconnect();
+    observer = null;
+  };
+}
+function serializeBlocks(blocks) {
+  return blocks.map((block) => serializeBlock(block));
+}
+function serializeBlock(block) {
+  return {
+    id: block.id,
+    type: block.type,
+    props: JSON.parse(JSON.stringify(block.props)),
+    slots: Object.fromEntries(
+      Object.entries(block.slots ?? {}).map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.map(
+          (v2) => typeof v2 === "string" ? v2 : serializeBlock(v2)
+        ) : typeof value === "string" ? value : serializeBlock(value)
+      ])
+    )
+  };
+}
+function createSelectedBlock() {
+  const selected = d(null);
+  function setSelection(block) {
+    selected.value = null;
+    selected.value = block;
+  }
+  function clearSelection(block) {
+    var _a;
+    if (block == null || ((_a = selected.value) == null ? void 0 : _a.id) === block.id) {
+      selected.value = null;
+    }
+  }
+  return { selected, setSelection, clearSelection };
+}
+const SelectedBlockContext = createContext("selectedBlock");
+const blockDefinitions = (() => {
+  if (typeof window !== "undefined") {
+    window._juoBlocks = window._juoBlocks || /* @__PURE__ */ new Map();
+    return window._juoBlocks;
+  }
+  return /* @__PURE__ */ new Map();
+})();
+class BlockWrapperEvent extends Event {
+  constructor(block, callback) {
+    super("juo:block-wrapper-render", {
+      bubbles: true,
+      composed: true,
+      cancelable: true
+    });
+    this.block = block;
+    this.callback = callback;
+  }
+}
+function withWrapper(fn) {
+  let wrapper = null;
+  return (block) => {
+    var _a;
+    let rendered;
+    try {
+      rendered = fn(block);
+    } catch (error) {
+      reportBlockError(error, {
+        site: "block.withWrapper",
+        block: { id: block.id, type: block.type, definition: block.definition },
+        keys: {
+          props: Object.keys(block.props ?? {}),
+          slots: Object.keys(block.slots ?? {})
+        }
+      });
+      rendered = createStubDefinition(block.type).render(block);
+    }
+    if (wrapper === null) {
+      if (isEditorPreview()) {
+        wrapper = document.createElement("juo-editor-block-wrapper");
+        wrapper.setAttribute("data-block-id", block.id);
+        (_a = wrapper.setBlock) == null ? void 0 : _a.call(wrapper, block);
+        wrapper.appendChild(rendered);
+      } else {
+        const evt = new BlockWrapperEvent(block, (evtWrapper) => {
+          wrapper = evtWrapper;
+        });
+        document.dispatchEvent(evt);
+      }
+    }
+    if (!wrapper) {
+      return rendered;
+    }
+    wrapper.replaceChildren(rendered);
+    return wrapper;
+  };
+}
+const registerBlockListeners = [];
+function registerBlock(block) {
+  blockDefinitions.set(block.name, block);
+  stubDefinitionCache.delete(block.name);
+  registerBlockListeners.forEach((cb) => cb(block.name, block));
+}
+function onRegisterBlock(cb) {
+  registerBlockListeners.push(cb);
+  return () => {
+    const idx = registerBlockListeners.indexOf(cb);
+    if (idx >= 0) registerBlockListeners.splice(idx, 1);
+  };
+}
+function defineBlock(name, opts) {
+  const definition = {
+    name,
+    displayName: opts.displayName,
+    group: opts.group,
+    schema: opts.schema,
+    initialValue: opts.initialValue,
+    render: opts.renderer,
+    presets: opts.presets,
+    locales: opts.locales
+  };
+  return definition;
+}
+function defineBlockRuntime(name, opts) {
+  const definition = {
+    name,
+    displayName: opts.displayName,
+    group: opts.group,
+    schema: {},
+    initialValue() {
+      throw new Error("Initial value cannot be called in runtime mode");
+    },
+    render: opts.renderer
+  };
+  return definition;
+}
+function getDefinedBlocks() {
+  return [...blockDefinitions.values()];
+}
+function createCeRenderer(name) {
+  function renderSlots(slots, block) {
+    if (!slots) {
+      return slots;
+    }
+    return Object.entries(slots).flatMap(([key, value]) => {
+      const values = Array.isArray(value) ? value : [value];
+      return values.flatMap((value2) => {
+        if (typeof value2 === "string") {
+          const el = document.createElement("span");
+          if (key !== "default") {
+            el.slot = key;
+          }
+          el.innerText = value2;
+          return [el];
+        }
+        try {
+          const el = value2.definition.render({
+            ...value2,
+            props: {
+              ...value2.props,
+              parentProps: block.props
+            }
+          });
+          if (key !== "default") {
+            el.slot = key;
+          }
+          return [el];
+        } catch (error) {
+          reportBlockError(error, {
+            site: "block.createCeRenderer.renderSlots",
+            block: { id: value2.id, type: value2.type, definition: value2.definition },
+            extra: {
+              parentBlockId: block.id,
+              parentBlockType: block.type,
+              slotKey: key
+            }
+          });
+          return [];
+        }
+      });
+    });
+  }
+  return (block) => {
+    const el = document.createElement(name);
+    el.setAttribute("data-block-id", block.id);
+    el.setAttribute("data-block-type", block.type);
+    Object.entries(block.props).forEach(([key, value]) => {
+      el[key] = value;
+    });
+    el.replaceChildren(...renderSlots(block.slots, block));
+    attachEmptyTracking(el);
+    return el;
+  };
+}
+const stubDefinitionCache = /* @__PURE__ */ new Map();
+function createStubDefinition(name) {
+  const cached = stubDefinitionCache.get(name);
+  if (cached) return cached;
+  const stub = {
+    name,
+    group: "internal",
+    schema: {},
+    initialValue: { props: {}, slots: {} },
+    __stub: true,
+    render() {
+      const el = document.createElement("div");
+      el.dataset.stubBlock = name;
+      if (isEditorPreview()) {
+        el.textContent = `Block definition not found: ${name}`;
+      } else {
+        el.style.display = "none";
+      }
+      return el;
+    }
+  };
+  stubDefinitionCache.set(name, stub);
+  reportBlockWarning(`Block definition '${name}' not found`, {
+    site: "block.createStubDefinition",
+    block: { id: "(none)", type: name }
+  });
+  console.warn(
+    `[juo/blocks] Block definition '${name}' not found. This block may have been removed or renamed. Rendering a hidden stub.`
+  );
+  return stub;
+}
+function isStubDefinition(definition) {
+  return definition.__stub === true;
+}
+function backfillInstanceDefaults(block) {
+  if (Object.keys(block.props ?? {}).length > 0) return false;
+  if (Object.keys(block.slots ?? {}).length > 0) return false;
+  if (isStubDefinition(block.definition)) return false;
+  let defaults;
+  try {
+    const iv = block.definition.initialValue;
+    defaults = (typeof iv === "function" ? iv() : iv) ?? {};
+  } catch (error) {
+    reportBlockError(error, {
+      site: "block.backfillInstanceDefaults",
+      block: { id: block.id, type: block.type, definition: block.definition }
+    });
+    return false;
+  }
+  const propsDefault = defaults.props ?? {};
+  const slotsDefault = defaults.slots ?? {};
+  const hasProps = Object.keys(propsDefault).length > 0;
+  const hasSlots = Object.keys(slotsDefault).length > 0;
+  if (!hasProps && !hasSlots) return false;
+  if (hasProps) Object.assign(block.props, propsDefault);
+  if (hasSlots) Object.assign(block.slots, slotsDefault);
+  return true;
+}
+function getDefinitionByName(name) {
+  const definition = blockDefinitions.get(name);
+  if (definition != null) {
+    return definition;
+  }
+  return createStubDefinition(name);
+}
+function createBlockInstance(name, opts) {
+  const initialValue = (() => {
+    const value = getDefinitionByName(name).initialValue ?? {};
+    if (typeof value === "function") {
+      return value();
+    }
+    return value;
+  })();
+  if ((opts == null ? void 0 : opts.props) == null && initialValue == null) {
+    const error = new Error(
+      `Block '${name}' cannot be created without value in runtime mode`
+    );
+    reportBlockError(error, {
+      site: "block.createBlockInstance",
+      block: { id: "(none)", type: name }
+    });
+    throw error;
+  }
+  const slots = {
+    ...initialValue.slots,
+    ...(opts == null ? void 0 : opts.slots) ?? {}
+  };
+  const props = {
+    ...initialValue.props ?? {},
+    ...(opts == null ? void 0 : opts.props) ?? {}
+  };
+  return {
+    // TODO: This should be unique
+    id: (opts == null ? void 0 : opts.id) ?? Math.round(1e3 * Math.random()).toString(10),
+    type: name,
+    props,
+    slots,
+    get definition() {
+      return getDefinitionByName(name);
+    }
+  };
+}
+function createBlockInstanceFromObject(input) {
+  const { id, type, props, slots } = input;
+  return createBlockInstance(type, {
+    props,
+    slots: Object.fromEntries(
+      Object.entries(slots).map(([key, value]) => [
+        key,
+        (Array.isArray(value) ? value : [value]).map(
+          (child) => createBlockInstanceFromObject(child)
+        )
+      ])
+    ),
+    id
+  });
+}
+function createBlockInstanceFromJSON(input) {
+  try {
+    return createBlockInstanceFromObject(JSON.parse(input));
+  } catch (error) {
+    reportBlockError(error, {
+      site: "block.createBlockInstanceFromJSON",
+      extra: { inputLength: input.length }
+    });
+    throw error;
+  }
+}
 const DEFAULT_GLOBAL_STYLES = {
   volume: "comfort",
   style: "ghost",
@@ -86,20 +906,6 @@ function createThemeState(deps) {
   function setGlobalStyles(styles) {
     globalStyles.value = styles;
   }
-  function setInstanceTranslationOverride(blockId, key, value) {
-    const current = catalogs.value;
-    if (current == null) return;
-    catalogs.value = {
-      ...current,
-      blocks: {
-        ...current.blocks,
-        overrides: {
-          ...current.blocks.overrides,
-          [blockId]: { ...current.blocks.overrides[blockId], [key]: value }
-        }
-      }
-    };
-  }
   async function collectBlockDefaults(loc) {
     const nextDefaults = {};
     const nextModes = {};
@@ -141,12 +947,12 @@ function createThemeState(deps) {
     };
     locale.value = nextLocale;
   }
-  async function resolve(surface, path, params) {
-    var _a2, _b, _c, _d, _e, _f, _g, _h;
+  async function resolve(surface, path) {
+    var _a2, _b, _c, _d;
     surfaces[surface].blocks.value = [];
     const stored = await deps.resolve(surface, path);
     if (stored != null) {
-      const instances = stored.blocks.flatMap((block) => {
+      surfaces[surface].blocks.value = stored.blocks.flatMap((block) => {
         try {
           return [createBlockInstanceFromObject(block)];
         } catch (error) {
@@ -161,56 +967,19 @@ function createThemeState(deps) {
           return [];
         }
       });
-      if (surface === "overlay") {
-        for (const instance of instances) {
-          if (typeof instance.type !== "string" || !instance.type.startsWith("overlay:")) {
-            continue;
-          }
-          try {
-            const canonical = createBlockInstance(instance.type);
-            instance.props = {
-              ...instance.props ?? {},
-              layout: (_a2 = canonical.props) == null ? void 0 : _a2.layout,
-              canAbort: (_b = canonical.props) == null ? void 0 : _b.canAbort
-            };
-          } catch (error) {
-            reportBlockError(error, {
-              site: "theme-state.resolve.overlay-layout",
-              extra: { surface, path, blockType: instance.type }
-            });
-          }
-        }
-      }
-      if (params != null) {
-        for (const instance of instances) {
-          const content = (_c = instance.slots) == null ? void 0 : _c.content;
-          const child = Array.isArray(content) ? content[0] : void 0;
-          if (child != null) {
-            child.props = { ...child.props ?? {}, ...params };
-          }
-        }
-      }
-      surfaces[surface].blocks.value = instances;
       return stored;
     }
-    const blockToUse = surface === "page" ? (_e = (_d = deps.routerService) == null ? void 0 : _d.getPages().find((p) => p.path === path)) == null ? void 0 : _e.block : (_f = getDefinedBlocks().find((b) => b.name === path)) == null ? void 0 : _f.name;
+    const blockToUse = surface === "page" ? (_b = (_a2 = deps.routerService) == null ? void 0 : _a2.getPages().find((p2) => p2.path === path)) == null ? void 0 : _b.block : (_c = getDefinedBlocks().find((b2) => b2.name === path)) == null ? void 0 : _c.name;
     if (blockToUse != null) {
       const instance = createBlockInstance(blockToUse);
-      if (params != null) {
-        const content = (_g = instance.slots) == null ? void 0 : _g.content;
-        const child = Array.isArray(content) ? content[0] : void 0;
-        if (child != null) {
-          child.props = { ...child.props ?? {}, ...params };
-        }
-      }
       surfaces[surface].blocks.value = [instance];
       const serialized = serializeBlocks([instance]);
-      (_h = deps.upsertState) == null ? void 0 : _h.call(deps, surface, path, serialized);
+      (_d = deps.upsertState) == null ? void 0 : _d.call(deps, surface, path, serialized);
       return { blocks: serialized };
     }
     return { blocks: [] };
   }
-  onRegisterBlock(async (_, block) => {
+  onRegisterBlock(async (_2, block) => {
     if (block.locales == null || catalogs.value == null) return;
     const localeAtLoadStart = locale.value;
     let file = null;
@@ -246,7 +1015,6 @@ function createThemeState(deps) {
     locales: { locale, catalogs, setLocale },
     globalStyles,
     setGlobalStyles,
-    setInstanceTranslationOverride,
     resolve
   };
 }
@@ -303,7 +1071,7 @@ function createTranslationService(locales, options = {}) {
 function getDefaultBlockForAction(actionType, actionConfig, blockId) {
   const blockName = `action:${actionType}`;
   const definedBlocks = getDefinedBlocks();
-  const exists = definedBlocks.some((b) => b.name === blockName);
+  const exists = definedBlocks.some((b2) => b2.name === blockName);
   if (!exists) {
     throw new Error(
       `No default block registered for action type "${actionType}". Expected a block named "${blockName}" to be registered in blocks-extensions.`
@@ -313,7 +1081,7 @@ function getDefaultBlockForAction(actionType, actionConfig, blockId) {
 }
 function hasDefaultBlockForAction(actionType) {
   const blockName = `action:${actionType}`;
-  return getDefinedBlocks().some((b) => b.name === blockName);
+  return getDefinedBlocks().some((b2) => b2.name === blockName);
 }
 const WorkflowServiceContext = createContext("services/workflow");
 function createWorkflowApiAdapter(sdk) {
@@ -447,7 +1215,7 @@ function createWorkflowService(deps) {
         outcome: null
       });
       if (editor.isEditorMode) {
-        const displayStepId = isInitialResponse && previewStepId && ((_e = data.interactiveSteps) == null ? void 0 : _e.some((s) => s.stepId === previewStepId)) ? previewStepId : currentStepId;
+        const displayStepId = isInitialResponse && previewStepId && ((_e = data.interactiveSteps) == null ? void 0 : _e.some((s2) => s2.stepId === previewStepId)) ? previewStepId : currentStepId;
         const overlayBlocks = deps.themeState.overlay.blocks.value;
         const rootBlock = overlayBlocks[0];
         const stepSlot = displayStepId ? (_f = rootBlock == null ? void 0 : rootBlock.slots) == null ? void 0 : _f[displayStepId] : null;
@@ -542,7 +1310,7 @@ function createWorkflowService(deps) {
     const presets = {};
     const baseLabelFor = (step) => {
       var _a;
-      return ((_a = getDefinedBlocks().find((b) => b.name === `action:${step.actionType}`)) == null ? void 0 : _a.displayName) ?? step.stepId;
+      return ((_a = getDefinedBlocks().find((b2) => b2.name === `action:${step.actionType}`)) == null ? void 0 : _a.displayName) ?? step.stepId;
     };
     const totalCounts = /* @__PURE__ */ new Map();
     for (const step of allSteps) {
@@ -854,15 +1622,46 @@ if (typeof customElements !== "undefined" && !customElements.get("juo-workflow")
   customElements.define("juo-workflow", JuoWorkflowElement);
 }
 export {
+  isEditorPreview as A,
+  BlockWrapperEvent as B,
+  ContextProvideEvent as C,
   DEFAULT_GLOBAL_STYLES as D,
-  TranslationContext as T,
+  E,
+  isStubDefinition as F,
+  onRegisterBlock as G,
+  provideContext as H,
+  serializeBlocks as I,
+  subscribeContext as J,
+  n as K,
+  withWrapper as L,
+  ContextRoot as M,
+  SelectedBlockContext as S,
+  ThemeStateContext as T,
   WorkflowServiceContext as W,
-  ThemeStateContext as a,
-  createTranslationService as b,
-  createThemeState as c,
-  createWorkflowApiAdapter as d,
-  createWorkflowService as e,
-  getDefaultBlockForAction as g,
-  hasDefaultBlockForAction as h,
-  indexOverrides as i
+  ContextRequestEvent as a,
+  TranslationContext as b,
+  createContext as c,
+  d,
+  attachEmptyTracking as e,
+  backfillInstanceDefaults as f,
+  createBlockInstance as g,
+  createBlockInstanceFromJSON as h,
+  createBlockInstanceFromObject as i,
+  createCeRenderer as j,
+  createSelectedBlock as k,
+  createThemeState as l,
+  createTranslationService as m,
+  createWorkflowApiAdapter as n,
+  createWorkflowService as o,
+  defineBlock as p,
+  defineBlockRuntime as q,
+  registerBlock as r,
+  getDefaultBlockForAction as s,
+  getDefinedBlocks as t,
+  u,
+  hasDefaultBlockForAction as v,
+  w,
+  hasRenderedContent as x,
+  indexOverrides as y,
+  injectContext as z
 };