@juo/blocks 1.13.0 → 1.15.0

package/dist/core.js

@@ -1,9 +1,12 @@
 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, w, r as registerBlock, E, u } from "./juo-workflow-BlG9CcAG.js";
-import { B, C, a, D, S, T, b, W, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t, v, x, y, z, A, F, G, H, I, J, K, L } from "./juo-workflow-BlG9CcAG.js";
+import { f as createContext, g as d, h as w, j as registerBlock, E, u, k as getDefinedBlocks, l as createBlockInstance, m as defineBlock, s as subscribeContext, G as GRID_V1_ENGINE_ID, n as clampRect, p as applyFillExpansion, q as compactItems, t as findFreeRect, D as DEFAULT_GRID } from "./css-runtime-ClH0MEYr.js";
+import { B, v, x, y, z, L, P, S, c, T, A, d as d2, b, F, H, I, J, K, N, O, Q, R, U, V, W, X, Y, Z, i, _, a, $, a0, o, a1, a2, a3, e, a4, r, a5, a6, a7, w as w2 } from "./css-runtime-ClH0MEYr.js";
 import { reportBlockWarning, reportBlockError } from "./observability.js";
+import { a as createEditorBridge, D as createSelectBlockMessage } from "./bridge-xiKEzCGR.js";
+import { p } from "./project-gridstack-CM783oKI.js";
+import { clearLayoutModeAdapter, getLayoutModeAdapter, registerLayoutModeAdapter } from "./layout-mode-adapter-BBd4JRQd.js";
 function createState() {
   const discountCode = d(null);
   const products = d([]);
@@ -132,7 +135,7 @@ async function loadBlockRegistry(options = {}) {
       if ("registerBlocks" in module && typeof module.registerBlocks === "function") {
         module.registerBlocks();
       } else {
-        Object.entries(module).forEach(([_, item]) => {
+        Object.entries(module).forEach(([_2, item]) => {
           if (typeof item === "object" && item != null) {
             registerBlock(item);
           }
@@ -176,7 +179,7 @@ const PARAMS = {
 function uuid() {
   return ("10000000-1000-4000-8000" + -1e11).replace(
     /[018]/g,
-    (c) => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
+    (c2) => (c2 ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c2 / 4).toString(16)
   );
 }
 var AuthenticationErrorReason = /* @__PURE__ */ ((AuthenticationErrorReason2) => {
@@ -1221,6 +1224,487 @@ const DISCOUNT_REJECTION_REASONS = [
   "INVALID_COMBINATION",
   "QUANTITY_REQUIREMENT_NOT_MET"
 ];
+function getDefaultBlockForAction(actionType, actionConfig, blockId) {
+  const blockName = `action:${actionType}`;
+  const definedBlocks = getDefinedBlocks();
+  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.`
+    );
+  }
+  return createBlockInstance(blockName, { props: actionConfig, id: blockId });
+}
+function hasDefaultBlockForAction(actionType) {
+  const blockName = `action:${actionType}`;
+  return getDefinedBlocks().some((b2) => b2.name === blockName);
+}
+const WorkflowServiceContext = createContext("services/workflow");
+const RUN_SCOPED_RESET = {
+  firstPollReason: null,
+  feedbackCollected: false
+};
+function createWorkflowApiAdapter(sdk) {
+  return {
+    async start(flowType, context, workflowId, dryRun) {
+      const { data } = await sdk.post("/customer/v1/workflows/start", {
+        flowType,
+        context,
+        ...workflowId ? { workflowId } : {},
+        ...dryRun ? { dryRun: true } : {}
+      });
+      return data;
+    },
+    async respond(runId, interactionId, responseType, responseData, expectedRunVersion, eventId) {
+      const { data } = await sdk.post(
+        "/customer/v1/workflows/{runId}/respond",
+        {
+          runId,
+          interactionId,
+          responseType,
+          responseData,
+          expectedRunVersion,
+          eventId
+        }
+      );
+      return data;
+    },
+    async getState(runId) {
+      const { data } = await sdk.get("/customer/v1/workflows/{runId}", {
+        runId
+      });
+      return data;
+    },
+    async cancel(runId) {
+      const { data } = await sdk.post("/customer/v1/workflows/{runId}/cancel", {
+        runId
+      });
+      return data;
+    }
+  };
+}
+function createWorkflowService(deps) {
+  const { api } = deps;
+  const editor = createEditorBridge();
+  const urlParams = typeof window !== "undefined" ? new URLSearchParams(window.location.search) : null;
+  const previewWorkflowTrigger = (urlParams == null ? void 0 : urlParams.get("trigger")) ?? null;
+  const previewStepId = (urlParams == null ? void 0 : urlParams.get("step-id")) ?? null;
+  const previewWorkflowId = (urlParams == null ? void 0 : urlParams.get("workflow-id")) ?? null;
+  const isEditorMode = editor.isEditorMode || previewWorkflowTrigger !== null;
+  const _state = d({
+    status: "idle",
+    flowType: null,
+    workflowId: null,
+    workflowVersion: null,
+    runId: null,
+    runVersion: null,
+    currentStepId: null,
+    currentInteraction: null,
+    error: null,
+    result: null,
+    flowParams: null,
+    invalidatedResources: [],
+    outcome: null,
+    completionData: null,
+    dryRun: null,
+    ...RUN_SCOPED_RESET
+  });
+  const _backendInteractionId = d(null);
+  const _registeredRootBlocks = /* @__PURE__ */ new Set();
+  const isActive = w(() => _state.value.status === "active");
+  const isLoading = w(() => _state.value.status === "loading");
+  const isCompleted = w(() => _state.value.status === "completed");
+  const hasError = w(() => _state.value.status === "error");
+  const currentInteraction = w(() => _state.value.currentInteraction);
+  const canRespond = w(() => {
+    const interaction = _state.value.currentInteraction;
+    const backendId = _backendInteractionId.value;
+    if (!interaction || !backendId) return false;
+    return interaction.interactionId === backendId;
+  });
+  const currentStepInfo = w(() => {
+    const interaction = _state.value.currentInteraction;
+    if (!interaction) return null;
+    const actionConfig = deps.shopCurrencyCode ? { ...interaction.actionConfig, currency: deps.shopCurrencyCode } : interaction.actionConfig;
+    return {
+      interactionId: interaction.interactionId,
+      stepId: interaction.stepId,
+      actionType: interaction.actionType,
+      actionConfig,
+      availableResponses: interaction.availableResponses
+    };
+  });
+  function updateState(updates) {
+    _state.value = { ..._state.value, ...updates };
+  }
+  function hashString(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+      hash ^= value.charCodeAt(index);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+  }
+  function shortenId(value, slugLength = 6) {
+    const compact = value.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const slug = (compact || "id").slice(0, slugLength);
+    return `${slug}-${hashString(value)}`;
+  }
+  function createStableStepBlockId(workflowId, stepId) {
+    return `wf-${shortenId(workflowId)}-${shortenId(stepId)}`;
+  }
+  function handleFlowResponse(data) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const mergedInvalidated = [
+      ..._state.value.invalidatedResources,
+      ...data.invalidatedResources ?? []
+    ];
+    if (data.status === "waiting_interaction") {
+      const currentStepId = ((_a = data.pendingInteraction) == null ? void 0 : _a.stepId) ?? (isEditorMode ? (_c = (_b = data.interactiveSteps) == null ? void 0 : _b[0]) == null ? void 0 : _c.stepId : null);
+      _backendInteractionId.value = ((_d = data.pendingInteraction) == null ? void 0 : _d.interactionId) ?? null;
+      const isInitialResponse = _state.value.runId == null;
+      updateState({
+        status: "active",
+        workflowId: data.workflowId,
+        workflowVersion: data.workflowVersion,
+        runId: data.runId,
+        runVersion: data.runVersion,
+        currentStepId,
+        currentInteraction: data.pendingInteraction,
+        invalidatedResources: mergedInvalidated,
+        outcome: null
+      });
+      if (editor.isEditorMode) {
+        const displayStepId = isInitialResponse && previewStepId && ((_e = data.interactiveSteps) == null ? void 0 : _e.some((s) => s.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;
+        const stepBlock = Array.isArray(stepSlot) ? stepSlot[0] : null;
+        const blockId = stepBlock && typeof stepBlock === "object" && "id" in stepBlock ? stepBlock.id : null;
+        if (blockId) {
+          editor.sendMessage(
+            createSelectBlockMessage({ blockId }, blockId)
+          );
+        }
+      }
+    } else if (data.status === "completed") {
+      _backendInteractionId.value = null;
+      updateState({
+        status: "completed",
+        currentStepId: null,
+        currentInteraction: null,
+        runVersion: data.runVersion,
+        result: data.result || null,
+        invalidatedResources: mergedInvalidated,
+        outcome: data.outcome || null,
+        completionData: data.completionData || null
+      });
+    } else if (data.status === "failed") {
+      _backendInteractionId.value = null;
+      handleError(new Error(((_g = data.error) == null ? void 0 : _g.message) || "Flow failed"));
+    } else if (data.status === "cancelled") {
+      _backendInteractionId.value = null;
+      updateState({
+        status: "idle",
+        flowType: null,
+        workflowId: null,
+        workflowVersion: null,
+        runId: null,
+        runVersion: null,
+        currentStepId: null,
+        currentInteraction: null,
+        error: null,
+        result: null,
+        invalidatedResources: [],
+        outcome: null,
+        completionData: null,
+        ...RUN_SCOPED_RESET
+      });
+    }
+  }
+  function handleError(error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    updateState({
+      status: "error",
+      error: message
+    });
+  }
+  function maybeApplyPreviewStep(flowType, data) {
+    var _a;
+    if (!previewWorkflowTrigger) return;
+    if (flowType !== previewWorkflowTrigger) return;
+    if (data.status !== "waiting_interaction") return;
+    const step = (_a = data.interactiveSteps) == null ? void 0 : _a.find(
+      (interactiveStep) => interactiveStep.stepId === previewStepId
+    );
+    if (!step) return;
+    updateState({
+      currentStepId: step.stepId,
+      currentInteraction: {
+        interactionId: `preview-${data.runId}-${step.stepId}`,
+        stepId: step.stepId,
+        actionType: step.actionType,
+        actionBehavior: "input",
+        actionConfig: step.actionConfig,
+        availableResponses: step.availableResponses,
+        presentedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  function initWorkflowRootBlock(data) {
+    if (_registeredRootBlocks.has(data.workflowId)) {
+      return;
+    }
+    const allSteps = data.interactiveSteps ?? (data.pendingInteraction ? [
+      {
+        stepId: data.pendingInteraction.stepId,
+        actionType: data.pendingInteraction.actionType,
+        actionConfig: data.pendingInteraction.actionConfig,
+        availableResponses: data.pendingInteraction.availableResponses
+      }
+    ] : []);
+    const slotProperties = {};
+    for (const step of allSteps) {
+      slotProperties[step.stepId] = {};
+    }
+    const presets = {};
+    const baseLabelFor = (step) => {
+      var _a;
+      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) {
+      const baseLabel = baseLabelFor(step);
+      totalCounts.set(baseLabel, (totalCounts.get(baseLabel) ?? 0) + 1);
+    }
+    const seenCounts = /* @__PURE__ */ new Map();
+    for (const step of allSteps) {
+      const baseLabel = baseLabelFor(step);
+      const occurrence = (seenCounts.get(baseLabel) ?? 0) + 1;
+      seenCounts.set(baseLabel, occurrence);
+      const isDuplicated = (totalCounts.get(baseLabel) ?? 0) > 1;
+      const label = isDuplicated ? `${baseLabel} (${occurrence})` : baseLabel;
+      presets[step.stepId] = {
+        label,
+        description: step.actionType,
+        state: step.stepId,
+        // @ts-expect-error Untyped
+        context: step
+      };
+    }
+    registerBlock(
+      defineBlock(`workflow:${data.workflowId}`, {
+        group: "workflow",
+        schema: {
+          type: "object",
+          properties: {
+            props: { type: "object" },
+            slots: {
+              type: "object",
+              properties: slotProperties
+            }
+          },
+          required: ["props", "slots"],
+          additionalProperties: true
+        },
+        initialValue: () => ({
+          props: {},
+          slots: Object.fromEntries(
+            allSteps.map((step) => [
+              step.stepId,
+              [
+                getDefaultBlockForAction(
+                  step.actionType,
+                  step.actionConfig,
+                  createStableStepBlockId(data.workflowId, step.stepId)
+                )
+              ]
+            ])
+          )
+        }),
+        presets,
+        renderer() {
+          return null;
+        }
+      })
+    );
+    _registeredRootBlocks.add(data.workflowId);
+  }
+  async function initWorkflowState(data) {
+    const { blocks } = await deps.themeState.resolve(
+      "overlay",
+      `workflow:${data.workflowId}`
+    );
+    if (blocks.length === 0) return;
+    editor.onBlockPresetChange(blocks[0].id, (preset) => {
+      if (!preset) {
+        return;
+      }
+      updateState({
+        // @ts-expect-error Untyped
+        currentStepId: preset.state,
+        // @ts-expect-error Untyped
+        currentInteraction: { ...preset == null ? void 0 : preset.context }
+      });
+    });
+  }
+  const service = {
+    // State signals (readonly)
+    state: _state,
+    /** True when the portal is running inside the Blocks Editor (editorMode dep
+     *  or ?trigger=... URL param). Consumers use this to suppress auto-start. */
+    isPreviewMode: isEditorMode,
+    // Computed signals
+    isActive,
+    isLoading,
+    isCompleted,
+    hasError,
+    canRespond,
+    currentInteraction,
+    currentStepInfo,
+    // Methods
+    async startFlow(flowType, context, workflowId) {
+      const isDryRun = isEditorMode;
+      updateState({
+        status: "loading",
+        error: null,
+        flowParams: context,
+        flowType,
+        dryRun: isDryRun,
+        ...RUN_SCOPED_RESET
+      });
+      try {
+        const data = await api.start(
+          flowType,
+          context,
+          workflowId,
+          isDryRun || void 0
+        );
+        if (data.status === "no_workflow") {
+          service.reset();
+          return;
+        }
+        if (data.status === "completed_silently") {
+          updateState({
+            status: "completed",
+            currentStepId: null,
+            currentInteraction: null,
+            result: null,
+            invalidatedResources: data.invalidatedResources ?? [],
+            outcome: data.outcome || null,
+            completionData: data.completionData || null
+          });
+          return;
+        }
+        initWorkflowRootBlock(data);
+        await initWorkflowState(data);
+        handleFlowResponse(data);
+        maybeApplyPreviewStep(flowType, data);
+      } catch (error) {
+        handleError(error);
+      }
+    },
+    async respond(responseType, responseData) {
+      const { runId, runVersion, currentInteraction: currentInteraction2 } = _state.value;
+      if (!runId || !currentInteraction2) {
+        throw new Error("No active interaction to respond to");
+      }
+      updateState({ status: "loading" });
+      try {
+        const data = await api.respond(
+          runId,
+          currentInteraction2.interactionId,
+          responseType,
+          responseData,
+          runVersion ?? void 0
+        );
+        if (_state.value.firstPollReason == null && currentInteraction2.actionType === "poll") {
+          const reason = responseData == null ? void 0 : responseData.reason;
+          if (typeof reason === "string" && reason.length > 0) {
+            updateState({ firstPollReason: reason });
+          }
+        }
+        if (!_state.value.feedbackCollected && currentInteraction2.actionType === "collect_feedback" && responseType === "submitted") {
+          const feedback = responseData == null ? void 0 : responseData.feedback;
+          if (typeof feedback === "string" && feedback.trim().length > 0) {
+            updateState({ feedbackCollected: true });
+          }
+        }
+        handleFlowResponse(data);
+      } catch (error) {
+        handleError(error);
+      }
+    },
+    async cancel() {
+      const { runId, status } = _state.value;
+      const isTerminal = status === "completed" || status === "error";
+      if (runId && !isTerminal) {
+        try {
+          const data = await api.cancel(runId);
+          if (data.outcome) {
+            updateState({
+              status: "completed",
+              flowType: null,
+              workflowId: null,
+              workflowVersion: null,
+              runId: null,
+              runVersion: null,
+              currentStepId: null,
+              currentInteraction: null,
+              error: null,
+              result: null,
+              flowParams: null,
+              invalidatedResources: data.invalidatedResources ?? [],
+              outcome: data.outcome || null,
+              dryRun: null
+            });
+            return;
+          }
+        } catch {
+        }
+      }
+      service.reset();
+    },
+    reset() {
+      _backendInteractionId.value = null;
+      updateState({
+        status: "idle",
+        flowType: null,
+        workflowId: null,
+        workflowVersion: null,
+        runId: null,
+        runVersion: null,
+        currentStepId: null,
+        currentInteraction: null,
+        error: null,
+        result: null,
+        flowParams: null,
+        invalidatedResources: [],
+        outcome: null,
+        completionData: null,
+        ...RUN_SCOPED_RESET
+      });
+    },
+    async refresh() {
+      const { runId } = _state.value;
+      if (!runId) return;
+      try {
+        const data = await api.getState(runId);
+        handleFlowResponse(data);
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  };
+  if (previewWorkflowTrigger) {
+    void service.startFlow(
+      previewWorkflowTrigger,
+      {},
+      previewWorkflowId ?? void 0
+    );
+  }
+  return service;
+}
 const MOCK_FLOWS = {
   cancellation: [
     {
@@ -1471,35 +1955,277 @@ function createMockWorkflowApiAdapter() {
     }
   };
 }
+class JuoWorkflowElement extends HTMLElement {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "workflowService", null);
+    __publicField(this, "unsubscribeContext", null);
+    __publicField(this, "unsubscribeEffect", null);
+    /** Tracks which step is currently mounted to avoid unnecessary DOM teardown. */
+    __publicField(this, "renderedStepId", null);
+    /**
+     * Optional function to wrap rendered content (step blocks).
+     * Must be set before workflow becomes active for correct behavior.
+     */
+    __publicField(this, "blockWrapper", null);
+  }
+  connectedCallback() {
+    this.style.display = "contents";
+    this.unsubscribeContext = subscribeContext(
+      this,
+      WorkflowServiceContext,
+      (service) => {
+        this.workflowService = service;
+        this.setupSubscription();
+      }
+    );
+  }
+  disconnectedCallback() {
+    var _a, _b;
+    (_a = this.unsubscribeContext) == null ? void 0 : _a.call(this);
+    (_b = this.unsubscribeEffect) == null ? void 0 : _b.call(this);
+    this.unsubscribeContext = null;
+    this.unsubscribeEffect = null;
+    this.renderedStepId = null;
+  }
+  setupSubscription() {
+    var _a;
+    if (!this.workflowService) return;
+    (_a = this.unsubscribeEffect) == null ? void 0 : _a.call(this);
+    this.unsubscribeEffect = E(() => {
+      var _a2, _b;
+      const status = ((_a2 = this.workflowService) == null ? void 0 : _a2.state.value.status) ?? "idle";
+      const stepInfo = (_b = this.workflowService) == null ? void 0 : _b.currentStepInfo.value;
+      const stepId = (stepInfo == null ? void 0 : stepInfo.stepId) ?? null;
+      queueMicrotask(() => {
+        if (this.isConnected) {
+          this.render(status, stepId);
+        }
+      });
+    });
+  }
+  render(status, stepId) {
+    var _a;
+    if ((status === "active" || status === "loading") && stepId) {
+      if (this.renderedStepId !== stepId) {
+        this.innerHTML = "";
+        this.renderedStepId = stepId;
+        const extensionRoot = document.createElement(
+          "juo-extension-root"
+        );
+        extensionRoot.setAttribute("surface", "overlay");
+        extensionRoot.setAttribute("name", stepId);
+        extensionRoot.blockWrapper = this.blockWrapper;
+        this.appendChild(extensionRoot);
+      }
+      return;
+    }
+    this.innerHTML = "";
+    this.renderedStepId = null;
+    if (status === "error") {
+      const error = ((_a = this.workflowService) == null ? void 0 : _a.state.value.error) ?? "Unknown error";
+      this.dispatchEvent(
+        new CustomEvent("juo-workflow-error", {
+          bubbles: true,
+          composed: true,
+          detail: { error }
+        })
+      );
+    }
+  }
+}
+if (typeof customElements !== "undefined" && !customElements.get("juo-workflow")) {
+  customElements.define("juo-workflow", JuoWorkflowElement);
+}
+const gridV1Engine = {
+  id: GRID_V1_ENGINE_ID,
+  applyCommand(doc, cmd, ctx2) {
+    const next = structuredClone(doc);
+    const existing = next.layouts[ctx2.breakpoint];
+    const layout = existing ?? {
+      grid: { cols: ctx2.cols, gap: ctx2.gap, rowUnit: ctx2.rowUnit },
+      items: {}
+    };
+    layout.grid = { cols: ctx2.cols, gap: ctx2.gap, rowUnit: ctx2.rowUnit };
+    switch (cmd.kind) {
+      case "add": {
+        layout.items[cmd.blockId] = cmd.rect ? clampRect(cmd.rect, ctx2.cols) : findFreeRect(layout.items, { w: ctx2.cols, h: 1 }, ctx2.cols);
+        break;
+      }
+      case "move": {
+        const current = layout.items[cmd.blockId];
+        if (current) {
+          layout.items[cmd.blockId] = clampRect(
+            { ...current, c: cmd.to.c, r: cmd.to.r },
+            ctx2.cols
+          );
+        }
+        break;
+      }
+      case "resize": {
+        const current = layout.items[cmd.blockId];
+        if (current) {
+          const w3 = Math.max(1, Math.min(cmd.size.w, ctx2.cols - current.c));
+          const h = Math.max(1, cmd.size.h);
+          layout.items[cmd.blockId] = { ...current, w: w3, h };
+        }
+        break;
+      }
+      case "remove": {
+        delete layout.items[cmd.blockId];
+        layout.items = compactItems(layout.items, ctx2.cols);
+        break;
+      }
+      case "setRects": {
+        for (const [blockId, rect] of Object.entries(cmd.rects)) {
+          const prev = layout.items[blockId];
+          const clamped = clampRect(rect, ctx2.cols);
+          clamped.fill = (prev == null ? void 0 : prev.fill) === true && rect.w === prev.w;
+          if (!clamped.fill) delete clamped.fill;
+          layout.items[blockId] = clamped;
+        }
+        break;
+      }
+      case "fillWidth": {
+        const current = layout.items[cmd.blockId];
+        if (current) {
+          const nextFill = current.fill !== true;
+          layout.items[cmd.blockId] = nextFill ? { ...current, fill: true } : (() => {
+            const { fill, ...rest } = current;
+            return rest;
+          })();
+        }
+        break;
+      }
+    }
+    layout.items = applyFillExpansion(layout.items, ctx2.cols);
+    next.layouts[ctx2.breakpoint] = layout;
+    return next;
+  },
+  reflow(doc, ctx2) {
+    const next = structuredClone(doc);
+    const layout = next.layouts[ctx2.breakpoint];
+    if (layout) {
+      layout.grid = { cols: ctx2.cols, gap: ctx2.gap, rowUnit: ctx2.rowUnit };
+      for (const id of Object.keys(layout.items)) {
+        layout.items[id] = clampRect(layout.items[id], ctx2.cols);
+      }
+      layout.items = applyFillExpansion(layout.items, ctx2.cols);
+    }
+    return next;
+  }
+};
+function resetBreakpoint(doc, breakpointId) {
+  var _a;
+  const baseId = (_a = doc.breakpoints[0]) == null ? void 0 : _a.id;
+  if (breakpointId === baseId) return doc;
+  if (!doc.layouts[breakpointId]) return doc;
+  const next = structuredClone(doc);
+  delete next.layouts[breakpointId];
+  return next;
+}
+const DEFAULT_NEW_BLOCK_HEIGHT = 4;
+function insertRectRelative(doc, args) {
+  var _a, _b;
+  const next = structuredClone(doc);
+  const newHeight = DEFAULT_NEW_BLOCK_HEIGHT;
+  let changed = false;
+  for (const [breakpointId, layout] of Object.entries(next.layouts)) {
+    if (!layout) continue;
+    const target = layout.items[args.targetId];
+    if (!target) continue;
+    const cols = ((_a = doc.breakpoints.find((b2) => b2.id === breakpointId)) == null ? void 0 : _a.cols) ?? ((_b = layout.grid) == null ? void 0 : _b.cols) ?? DEFAULT_GRID.cols;
+    const insertRow = args.position === "before" ? target.r : target.r + target.h;
+    for (const [id, rect] of Object.entries(layout.items)) {
+      if (id === args.blockId) continue;
+      if (rect.r >= insertRow) {
+        layout.items[id] = { ...rect, r: rect.r + newHeight };
+      }
+    }
+    layout.items[args.blockId] = clampRect(
+      { c: target.c, r: insertRow, w: target.w, h: newHeight },
+      cols
+    );
+    changed = true;
+  }
+  return changed ? next : doc;
+}
+const canvasMode = d(false);
+const ctx = {};
+function setActiveSurfaceContext(surface, id) {
+  if (id == null) {
+    delete ctx[surface];
+    return;
+  }
+  ctx[surface] = { id };
+}
+function getActiveSurfaceContext(surface) {
+  return ctx[surface] ?? null;
+}
+function clearAllSurfaceContexts() {
+  for (const key of Object.keys(ctx)) {
+    delete ctx[key];
+  }
+}
+let currentEmitter = null;
+function setLayoutCommandEmitter(emitter) {
+  currentEmitter = emitter;
+}
+function emitLayoutSetRects(event) {
+  currentEmitter == null ? void 0 : currentEmitter(event);
+}
+let currentDispatcher = null;
+function setLayoutCommandDispatcher(dispatcher) {
+  currentDispatcher = dispatcher;
+}
+function emitLayoutCommand(event) {
+  currentDispatcher == null ? void 0 : currentDispatcher(event);
+}
 export {
   AuthenticationError,
   AuthenticationErrorReason,
   B as BlockWrapperEvent,
-  C as ContextProvideEvent,
-  a as ContextRequestEvent,
+  v as ContextProvideEvent,
+  x as ContextRequestEvent,
   CustomerServiceContext,
-  D as DEFAULT_GLOBAL_STYLES,
+  y as DEFAULT_BREAKPOINTS,
+  z as DEFAULT_GLOBAL_STYLES,
+  DEFAULT_GRID,
+  DEFAULT_NEW_BLOCK_HEIGHT,
   DISCOUNT_REJECTION_REASONS,
+  GRID_V1_ENGINE_ID,
+  L as LAYOUT_SCOPE_ATTR,
   LoginServiceContext,
   OrdersServiceContext,
+  P as PAGE_ROOT_SLOT,
   ProductServiceContext,
   RouterServiceContext,
   S as SelectedBlockContext,
   u as Signal,
   StateContext,
   SubscriptionServiceContext,
-  T as ThemeStateContext,
-  b as TranslationContext,
-  W as WorkflowServiceContext,
-  e as attachEmptyTracking,
-  f as backfillInstanceDefaults,
+  c as ThemeStateContext,
+  T as TranslationContext,
+  WorkflowServiceContext,
+  A as attachEmptyTracking,
+  d2 as backfillInstanceDefaults,
+  b as buildGridLayout,
+  F as buildLayoutCss,
+  canvasMode,
+  clampRect,
+  H as classifyRowDividers,
+  clearAllSurfaceContexts,
+  clearLayoutModeAdapter,
+  compactItems,
+  I as compactLayoutDocument,
   w as computed,
-  g as createBlockInstance,
-  h as createBlockInstanceFromJSON,
-  i as createBlockInstanceFromObject,
-  j as createCeRenderer,
+  createBlockInstance,
+  J as createBlockInstanceFromJSON,
+  K as createBlockInstanceFromObject,
+  N as createCeRenderer,
   createContext,
   createCustomerService,
+  O as createDefaultLayoutDocument,
   createMockOrdersAdapter,
   createMockProductAdapter,
   createMockRouterService,
@@ -1508,33 +2234,56 @@ export {
   createOrdersService,
   createProductService,
   createRouterService,
-  k as createSelectedBlock,
+  Q as createSelectedBlock,
   createState,
   createSubscriptionService,
-  l as createThemeState,
-  m as createTranslationService,
-  n as createWorkflowApiAdapter,
-  o as createWorkflowService,
-  p as defineBlock,
-  q as defineBlockRuntime,
+  R as createThemeState,
+  U as createTranslationService,
+  createWorkflowApiAdapter,
+  createWorkflowService,
+  defineBlock,
+  V as defineBlockRuntime,
+  W as deriveLayout,
   E as effect,
-  s as getDefaultBlockForAction,
-  t as getDefinedBlocks,
-  v as hasDefaultBlockForAction,
-  x as hasRenderedContent,
-  y as indexOverrides,
-  z as injectContext,
-  A as isEditorPreview,
-  F as isStubDefinition,
+  emitLayoutCommand,
+  emitLayoutSetRects,
+  X as expandFillLayoutDocument,
+  findFreeRect,
+  getActiveSurfaceContext,
+  getDefaultBlockForAction,
+  getDefinedBlocks,
+  getLayoutModeAdapter,
+  gridV1Engine,
+  hasDefaultBlockForAction,
+  Y as hasRenderedContent,
+  Z as indexOverrides,
+  i as injectContext,
+  insertRectRelative,
+  _ as isEditorPreview,
+  a as isStubDefinition,
+  $ as layoutScopeSelector,
+  a0 as layoutSystemEnabled,
   loadBlockRegistry,
   loginService,
-  G as onRegisterBlock,
-  H as provideContext,
+  o as onRegisterBlock,
+  a1 as projectToCss,
+  p as projectToGridStack,
+  a2 as provideContext,
+  a3 as readingOrder,
+  e as reconcileLayout,
+  a4 as rectsOverlap,
   registerBlock,
-  I as serializeBlocks,
+  registerLayoutModeAdapter,
+  resetBreakpoint,
+  r as resolveLayout,
+  a5 as serializeBlocks,
+  setActiveSurfaceContext,
+  setLayoutCommandDispatcher,
+  setLayoutCommandEmitter,
+  a6 as setLayoutSystemEnabled,
   d as signal,
-  J as subscribeContext,
-  K as untracked,
+  subscribeContext,
+  a7 as untracked,
   waitForDevBlocksUrl,
-  L as withWrapper
+  w2 as withWrapper
 };