@measured/puck 0.18.2-canary.5db6f4d → 0.18.2-canary.73bb338

package/dist/index.js

@@ -169,14 +169,12 @@ __export(core_exports, {
   Button: () => Button,
   Drawer: () => Drawer,
   DropZone: () => DropZone,
-  DropZoneProvider: () => DropZoneProvider,
   FieldLabel: () => FieldLabel,
   Group: () => Group,
   IconButton: () => IconButton,
   Label: () => Label,
   Puck: () => Puck,
   Render: () => Render,
-  dropZoneContext: () => dropZoneContext,
   migrate: () => migrate,
   overrideKeys: () => overrideKeys,
   resolveAllData: () => resolveAllData,
@@ -262,7 +260,7 @@ var get_class_name_factory_default = getClassNameFactory;
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/ActionBar/styles.module.css#css-module
 init_react_import();
-var styles_module_default = { "ActionBar": "_ActionBar_194sn_1", "ActionBar-label": "_ActionBar-label_194sn_18", "ActionBar-action": "_ActionBar-action_194sn_30", "ActionBar-group": "_ActionBar-group_194sn_38" };
+var styles_module_default = { "ActionBar": "_ActionBar_rvadt_1", "ActionBar-label": "_ActionBar-label_rvadt_18", "ActionBar-action": "_ActionBar-action_rvadt_30", "ActionBar-group": "_ActionBar-group_rvadt_38" };
 
 // components/ActionBar/index.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
@@ -308,10 +306,10 @@ init_react_import();
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/AutoField/styles.module.css#css-module
 init_react_import();
-var styles_module_default2 = { "InputWrapper": "_InputWrapper_1h1p1_1", "Input-label": "_Input-label_1h1p1_5", "Input-labelIcon": "_Input-labelIcon_1h1p1_14", "Input-disabledIcon": "_Input-disabledIcon_1h1p1_21", "Input-input": "_Input-input_1h1p1_26", "Input": "_Input_1h1p1_1", "Input--readOnly": "_Input--readOnly_1h1p1_70", "Input-radioGroupItems": "_Input-radioGroupItems_1h1p1_81", "Input-radio": "_Input-radio_1h1p1_81", "Input-radioInner": "_Input-radioInner_1h1p1_98", "Input-radioInput": "_Input-radioInput_1h1p1_143" };
+var styles_module_default2 = { "InputWrapper": "_InputWrapper_g5w3n_1", "Input-label": "_Input-label_g5w3n_5", "Input-labelIcon": "_Input-labelIcon_g5w3n_14", "Input-disabledIcon": "_Input-disabledIcon_g5w3n_21", "Input-input": "_Input-input_g5w3n_26", "Input": "_Input_g5w3n_1", "Input--readOnly": "_Input--readOnly_g5w3n_74", "Input-radioGroupItems": "_Input-radioGroupItems_g5w3n_85", "Input-radio": "_Input-radio_g5w3n_85", "Input-radioInner": "_Input-radioInner_g5w3n_102", "Input-radioInput": "_Input-radioInput_g5w3n_147" };
 
 // components/AutoField/index.tsx
-var import_react20 = require("react");
+var import_react21 = require("react");
 
 // components/AutoField/fields/index.tsx
 init_react_import();
@@ -321,7 +319,7 @@ init_react_import();
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/AutoField/fields/ArrayField/styles.module.css#css-module
 init_react_import();
-var styles_module_default3 = { "ArrayField": "_ArrayField_1jcbq_5", "ArrayField--isDraggingFrom": "_ArrayField--isDraggingFrom_1jcbq_13", "ArrayField-addButton": "_ArrayField-addButton_1jcbq_18", "ArrayField--hasItems": "_ArrayField--hasItems_1jcbq_33", "ArrayFieldItem": "_ArrayFieldItem_1jcbq_63", "ArrayFieldItem--isDragging": "_ArrayFieldItem--isDragging_1jcbq_71", "ArrayFieldItem--isExpanded": "_ArrayFieldItem--isExpanded_1jcbq_81", "ArrayFieldItem-summary": "_ArrayFieldItem-summary_1jcbq_97", "ArrayField--addDisabled": "_ArrayField--addDisabled_1jcbq_128", "ArrayFieldItem-body": "_ArrayFieldItem-body_1jcbq_164", "ArrayFieldItem-fieldset": "_ArrayFieldItem-fieldset_1jcbq_173", "ArrayFieldItem-rhs": "_ArrayFieldItem-rhs_1jcbq_181", "ArrayFieldItem-actions": "_ArrayFieldItem-actions_1jcbq_187" };
+var styles_module_default3 = { "ArrayField": "_ArrayField_14u8o_5", "ArrayField--isDraggingFrom": "_ArrayField--isDraggingFrom_14u8o_13", "ArrayField-addButton": "_ArrayField-addButton_14u8o_18", "ArrayField--hasItems": "_ArrayField--hasItems_14u8o_33", "ArrayField-inner": "_ArrayField-inner_14u8o_59", "ArrayFieldItem": "_ArrayFieldItem_14u8o_67", "ArrayFieldItem--isDragging": "_ArrayFieldItem--isDragging_14u8o_78", "ArrayFieldItem--isExpanded": "_ArrayFieldItem--isExpanded_14u8o_82", "ArrayFieldItem-summary": "_ArrayFieldItem-summary_14u8o_97", "ArrayField--addDisabled": "_ArrayField--addDisabled_14u8o_127", "ArrayFieldItem-body": "_ArrayFieldItem-body_14u8o_166", "ArrayFieldItem-fieldset": "_ArrayFieldItem-fieldset_14u8o_175", "ArrayFieldItem-rhs": "_ArrayFieldItem-rhs_14u8o_183", "ArrayFieldItem-actions": "_ArrayFieldItem-actions_14u8o_189" };
 
 // ../../node_modules/lucide-react/dist/esm/lucide-react.js
 init_react_import();
@@ -771,7 +769,7 @@ var IconButton = ({
 };
 
 // components/AutoField/fields/ArrayField/index.tsx
-var import_react12 = require("react");
+var import_react13 = require("react");
 
 // components/DragIcon/index.tsx
 init_react_import();
@@ -1279,8 +1277,8 @@ function useAppContext() {
 
 // components/Sortable/index.tsx
 init_react_import();
-var import_react9 = require("@dnd-kit/react");
-var import_react10 = require("react");
+var import_react10 = require("@dnd-kit/react");
+var import_react11 = require("react");
 
 // lib/dnd/dnd-kit/safe.ts
 init_react_import();
@@ -1308,187 +1306,843 @@ function useSortableSafe(input) {
   return (0, import_sortable.useSortable)(input);
 }
 
-// components/Sortable/index.tsx
-var import_jsx_runtime6 = require("react/jsx-runtime");
-var SortableProvider = ({
-  children,
-  onMove
-}) => {
-  const [move, setMove] = (0, import_react10.useState)({ source: -1, target: -1 });
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
-    import_react9.DragDropProvider,
-    {
-      onDragOver: (event) => {
-        const { operation } = event;
-        if (operation.source && operation.target) {
-          const newMove = {
-            source: operation.source.data.index,
-            target: operation.target.data.index
-          };
-          if (newMove.source !== newMove.target) {
-            setMove({
-              source: operation.source.data.index,
-              target: operation.target.data.index
-            });
-          }
-        }
-      },
-      onDragEnd: () => {
-        if (move.source !== -1 && move.target !== -1) {
-          onMove(move);
-        }
-      },
-      children
-    }
-  );
-};
-var Sortable = ({
-  id,
-  index,
-  disabled,
-  children,
-  type = "item"
-}) => {
-  const { ref: sortableRef, status } = useSortableSafe({
-    id,
-    type,
-    index,
-    disabled,
-    data: { index }
-  });
-  return children({ status, ref: sortableRef });
-};
-
-// components/AutoField/context.tsx
+// lib/dnd/use-sensors.ts
 init_react_import();
-var import_react11 = require("react");
-var import_jsx_runtime7 = require("react/jsx-runtime");
-var NestedFieldContext = (0, import_react11.createContext)({});
-var useNestedFieldContext = () => {
-  const context = (0, import_react11.useContext)(NestedFieldContext);
-  return __spreadProps(__spreadValues({}, context), {
-    readOnlyFields: context.readOnlyFields || {}
-  });
-};
-var NestedFieldProvider = ({
-  children,
-  name,
-  subName,
-  wildcardName = name,
-  readOnlyFields
-}) => {
-  const subPath = `${name}.${subName}`;
-  const wildcardSubPath = `${wildcardName}.${subName}`;
-  const subReadOnlyFields = (0, import_react11.useMemo)(
-    () => Object.keys(readOnlyFields).reduce((acc, readOnlyKey) => {
-      const isLocal = readOnlyKey.indexOf(subPath) > -1 || readOnlyKey.indexOf(wildcardSubPath) > -1;
-      if (isLocal) {
-        const subPathPattern = new RegExp(
-          `^(${name}|${wildcardName}).`.replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/\./g, "\\.").replace(/\*/g, "\\*")
-        );
-        const localName = readOnlyKey.replace(subPathPattern, "");
-        return __spreadProps(__spreadValues({}, acc), {
-          [localName]: readOnlyFields[readOnlyKey]
-        });
-      }
-      return acc;
-    }, {}),
-    [name, subName, wildcardName, readOnlyFields]
-  );
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
-    NestedFieldContext.Provider,
-    {
-      value: { readOnlyFields: subReadOnlyFields, localName: subName },
-      children
-    }
-  );
-};
+var import_react9 = require("react");
 
-// components/AutoField/fields/ArrayField/index.tsx
-var import_jsx_runtime8 = require("react/jsx-runtime");
-var getClassName5 = get_class_name_factory_default("ArrayField", styles_module_default3);
-var getClassNameItem = get_class_name_factory_default("ArrayFieldItem", styles_module_default3);
-var ArrayField = ({
-  field,
-  onChange,
-  value: _value,
-  name,
-  label,
-  readOnly,
-  id,
-  Label: Label2 = (props) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", __spreadValues({}, props))
-}) => {
-  const { state, setUi, selectedItem, getPermissions } = useAppContext();
-  const { readOnlyFields, localName = name } = useNestedFieldContext();
-  const value = _value;
-  const arrayState = state.ui.arrayState[id] || {
-    items: Array.from(value || []).map((item, idx) => {
-      return {
-        _originalIndex: idx,
-        _arrayId: `${id}-${idx}`
+// lib/dnd/PointerSensor.ts
+init_react_import();
+var import_state = require("@dnd-kit/state");
+var import_abstract = require("@dnd-kit/abstract");
+var import_geometry = require("@dnd-kit/geometry");
+var import_utilities = require("@dnd-kit/dom/utilities");
+var _clearTimeout;
+var _PointerSensor = class _PointerSensor extends import_abstract.Sensor {
+  constructor(manager, options) {
+    super(manager);
+    this.manager = manager;
+    this.options = options;
+    this.listeners = new import_utilities.Listeners();
+    this.cleanup = /* @__PURE__ */ new Set();
+    this.source = void 0;
+    __privateAdd(this, _clearTimeout);
+    this.handleCancel = this.handleCancel.bind(this);
+    this.handlePointerUp = this.handlePointerUp.bind(this);
+    this.handleKeyDown = this.handleKeyDown.bind(this);
+    (0, import_state.effect)(() => {
+      const unbindGlobal = this.bindGlobal(options != null ? options : {});
+      return () => {
+        unbindGlobal();
       };
-    }),
-    openId: ""
-  };
-  const [localState, setLocalState] = (0, import_react12.useState)({ arrayState, value });
-  (0, import_react12.useEffect)(() => {
-    setLocalState({ arrayState, value });
-  }, [value, state.ui.arrayState[id]]);
-  const mapArrayStateToUi = (0, import_react12.useCallback)(
-    (partialArrayState) => {
-      return {
-        arrayState: __spreadProps(__spreadValues({}, state.ui.arrayState), {
-          [id]: __spreadValues(__spreadValues({}, arrayState), partialArrayState)
-        })
+    });
+  }
+  bind(source, options = this.options) {
+    const unbind = (0, import_state.effect)(() => {
+      var _a;
+      const target = (_a = source.handle) != null ? _a : source.element;
+      const listener = (event) => {
+        if ((0, import_utilities.isPointerEvent)(event)) {
+          this.handlePointerDown(event, source, options);
+        }
       };
-    },
-    [arrayState]
-  );
-  const getHighestIndex = (0, import_react12.useCallback)(() => {
-    return arrayState.items.reduce(
-      (acc, item) => item._originalIndex > acc ? item._originalIndex : acc,
-      -1
-    );
-  }, [arrayState]);
-  const regenerateArrayState = (0, import_react12.useCallback)(
-    (value2) => {
-      let highestIndex = getHighestIndex();
-      const newItems = Array.from(value2 || []).map((item, idx) => {
-        var _a;
-        const arrayStateItem = arrayState.items[idx];
-        const newItem = {
-          _originalIndex: typeof (arrayStateItem == null ? void 0 : arrayStateItem._originalIndex) !== "undefined" ? arrayStateItem._originalIndex : highestIndex + 1,
-          _arrayId: ((_a = arrayState.items[idx]) == null ? void 0 : _a._arrayId) || `${id}-${highestIndex + 1}`
+      if (target) {
+        patchWindow(target.ownerDocument.defaultView);
+        target.addEventListener("pointerdown", listener);
+        return () => {
+          target.removeEventListener("pointerdown", listener);
         };
-        if (newItem._originalIndex > highestIndex) {
-          highestIndex = newItem._originalIndex;
+      }
+    });
+    return unbind;
+  }
+  bindGlobal(options) {
+    const documents = /* @__PURE__ */ new Set();
+    for (const draggable of this.manager.registry.draggables.value) {
+      if (draggable.element) {
+        documents.add((0, import_utilities.getDocument)(draggable.element));
+      }
+    }
+    for (const droppable of this.manager.registry.droppables.value) {
+      if (droppable.element) {
+        documents.add((0, import_utilities.getDocument)(droppable.element));
+      }
+    }
+    const unbindFns = Array.from(documents).map(
+      (doc) => this.listeners.bind(doc, [
+        {
+          type: "pointermove",
+          listener: (event) => this.handlePointerMove(event, doc, options)
+        },
+        {
+          type: "pointerup",
+          listener: this.handlePointerUp,
+          options: {
+            capture: true
+          }
+        },
+        {
+          // Cancel activation if there is a competing Drag and Drop interaction
+          type: "dragstart",
+          listener: this.handleDragStart
         }
-        return newItem;
-      });
-      return __spreadProps(__spreadValues({}, arrayState), { items: newItems });
-    },
-    [arrayState]
-  );
-  (0, import_react12.useEffect)(() => {
-    if (arrayState.items.length > 0) {
-      setUi(mapArrayStateToUi(arrayState));
+      ])
+    );
+    return () => {
+      unbindFns.forEach((unbind) => unbind());
+    };
+  }
+  handlePointerDown(event, source, options = {}) {
+    if (this.disabled || !event.isPrimary || event.button !== 0 || !(0, import_utilities.isElement)(event.target) || source.disabled) {
+      return;
     }
-  }, []);
-  const forceReadOnly = getPermissions({ item: selectedItem }).edit === false;
-  if (field.type !== "array" || !field.arrayFields) {
-    return null;
+    const offset = (0, import_utilities.getFrameTransform)(source.element);
+    this.initialCoordinates = {
+      x: event.clientX * offset.scaleX + offset.x,
+      y: event.clientY * offset.scaleY + offset.y
+    };
+    this.source = source;
+    const { activationConstraints } = options;
+    const constraints = typeof activationConstraints === "function" ? activationConstraints(event, source) : activationConstraints;
+    event.stopImmediatePropagation();
+    if (!(constraints == null ? void 0 : constraints.delay) && !(constraints == null ? void 0 : constraints.distance)) {
+      this.handleStart(source, event);
+    } else {
+      const { delay } = constraints;
+      if (delay) {
+        const timeout3 = setTimeout(
+          () => this.handleStart(source, event),
+          delay.value
+        );
+        __privateSet(this, _clearTimeout, () => {
+          clearTimeout(timeout3);
+          __privateSet(this, _clearTimeout, void 0);
+        });
+      }
+    }
+    const cleanup = () => {
+      var _a;
+      (_a = __privateGet(this, _clearTimeout)) == null ? void 0 : _a.call(this);
+      this.initialCoordinates = void 0;
+      this.source = void 0;
+    };
+    this.cleanup.add(cleanup);
   }
-  const addDisabled = field.max !== void 0 && localState.arrayState.items.length >= field.max || readOnly;
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
-    Label2,
-    {
-      label: label || name,
+  handlePointerMove(event, doc, options) {
+    if (!this.source) {
+      return;
+    }
+    const ownerDocument = this.source.element && (0, import_utilities.getDocument)(this.source.element);
+    if (doc !== ownerDocument) {
+      return;
+    }
+    const coordinates = {
+      x: event.clientX,
+      y: event.clientY
+    };
+    const offset = (0, import_utilities.getFrameTransform)(this.source.element);
+    coordinates.x = coordinates.x * offset.scaleX + offset.x;
+    coordinates.y = coordinates.y * offset.scaleY + offset.y;
+    if (this.manager.dragOperation.status.dragging) {
+      event.preventDefault();
+      event.stopPropagation();
+      this.manager.actions.move({ to: coordinates });
+      return;
+    }
+    if (!this.initialCoordinates) {
+      return;
+    }
+    const delta = {
+      x: coordinates.x - this.initialCoordinates.x,
+      y: coordinates.y - this.initialCoordinates.y
+    };
+    const { activationConstraints } = options;
+    const constraints = typeof activationConstraints === "function" ? activationConstraints(event, this.source) : activationConstraints;
+    const { distance, delay } = constraints != null ? constraints : {};
+    if (distance) {
+      if (distance.tolerance != null && (0, import_geometry.exceedsDistance)(delta, distance.tolerance)) {
+        return this.handleCancel();
+      }
+      if ((0, import_geometry.exceedsDistance)(delta, distance.value)) {
+        return this.handleStart(this.source, event);
+      }
+    }
+    if (delay) {
+      if ((0, import_geometry.exceedsDistance)(delta, delay.tolerance)) {
+        return this.handleCancel();
+      }
+    }
+  }
+  handlePointerUp(event) {
+    if (!this.source) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    const { status } = this.manager.dragOperation;
+    if (!status.idle) {
+      const canceled = !status.initialized;
+      this.manager.actions.stop({ canceled });
+    }
+    this.cleanup.forEach((cleanup) => cleanup());
+    this.cleanup.clear();
+  }
+  handleKeyDown(event) {
+    if (event.key === "Escape") {
+      event.preventDefault();
+      this.handleCancel();
+    }
+  }
+  handleStart(source, event) {
+    var _a;
+    const { manager, initialCoordinates } = this;
+    (_a = __privateGet(this, _clearTimeout)) == null ? void 0 : _a.call(this);
+    if (!initialCoordinates || manager.dragOperation.status.initialized) {
+      return;
+    }
+    if (event.defaultPrevented) {
+      return;
+    }
+    event.preventDefault();
+    (0, import_state.batch)(() => {
+      manager.actions.setDragSource(source.id);
+      manager.actions.start({ coordinates: initialCoordinates, event });
+    });
+    const ownerDocument = (0, import_utilities.getDocument)(event.target);
+    const unbind = this.listeners.bind(ownerDocument, [
+      {
+        // Prevent scrolling on touch devices
+        type: "touchmove",
+        listener: preventDefault,
+        options: {
+          passive: false
+        }
+      },
+      {
+        // Prevent click events
+        type: "click",
+        listener: preventDefault
+      },
+      {
+        type: "keydown",
+        listener: this.handleKeyDown
+      }
+    ]);
+    ownerDocument.body.setPointerCapture(event.pointerId);
+    this.cleanup.add(unbind);
+  }
+  handleDragStart(event) {
+    const { target } = event;
+    if (!(0, import_utilities.isElement)(target)) {
+      return;
+    }
+    const isNativeDraggable = (0, import_utilities.isHTMLElement)(target) && target.draggable && target.getAttribute("draggable") === "true";
+    if (isNativeDraggable) {
+      this.handleCancel();
+    } else {
+      preventDefault(event);
+    }
+  }
+  handleCancel() {
+    const { dragOperation } = this.manager;
+    if (dragOperation.status.initialized) {
+      this.manager.actions.stop({ canceled: true });
+    }
+    this.cleanup.forEach((cleanup) => cleanup());
+    this.cleanup.clear();
+  }
+  destroy() {
+    this.listeners.clear();
+  }
+};
+_clearTimeout = new WeakMap();
+_PointerSensor.configure = (0, import_abstract.configurator)(_PointerSensor);
+var PointerSensor = _PointerSensor;
+function preventDefault(event) {
+  event.preventDefault();
+}
+function noop() {
+}
+var windows = /* @__PURE__ */ new WeakSet();
+function patchWindow(window2) {
+  if (!window2 || windows.has(window2)) {
+    return;
+  }
+  window2.addEventListener("touchmove", noop, {
+    capture: false,
+    passive: false
+  });
+  windows.add(window2);
+}
+
+// lib/dnd/use-sensors.ts
+var import_utilities2 = require("@dnd-kit/dom/utilities");
+var useSensors = () => {
+  const [sensors] = (0, import_react9.useState)(() => [
+    PointerSensor.configure({
+      activationConstraints(event, source) {
+        var _a;
+        const { pointerType, target } = event;
+        if (pointerType === "mouse" && (0, import_utilities2.isElement)(target) && (source.handle === target || ((_a = source.handle) == null ? void 0 : _a.contains(target)))) {
+          return void 0;
+        }
+        const delay = { value: 200, tolerance: 10 };
+        if (pointerType === "touch") {
+          return { delay };
+        }
+        return {
+          delay,
+          distance: { value: 5 }
+        };
+      }
+    })
+  ]);
+  return sensors;
+};
+
+// lib/dnd/collision/dynamic/index.ts
+init_react_import();
+var import_abstract9 = require("@dnd-kit/abstract");
+
+// lib/dnd/collision/directional/index.ts
+init_react_import();
+var import_abstract2 = require("@dnd-kit/abstract");
+
+// lib/dnd/collision/collision-debug.ts
+init_react_import();
+var DEBUG = false;
+var debugElements = {};
+var timeout;
+var collisionDebug = (a, b, id, color, label) => {
+  if (!DEBUG) return;
+  const debugId = `${id}-debug`;
+  clearTimeout(timeout);
+  timeout = setTimeout(() => {
+    Object.entries(debugElements).forEach(([id2, { svg }]) => {
+      svg.remove();
+      delete debugElements[id2];
+    });
+  }, 1e3);
+  requestAnimationFrame(() => {
+    var _a, _b;
+    const existingEl = debugElements[debugId];
+    let line = (_a = debugElements[debugId]) == null ? void 0 : _a.line;
+    let text = (_b = debugElements[debugId]) == null ? void 0 : _b.text;
+    if (!existingEl) {
+      const svgNs = "http://www.w3.org/2000/svg";
+      const svg = document.createElementNS(svgNs, "svg");
+      line = document.createElementNS(svgNs, "line");
+      text = document.createElementNS(svgNs, "text");
+      svg.setAttribute("id", debugId);
+      svg.setAttribute(
+        "style",
+        "position: fixed; height: 100%; width: 100%; pointer-events: none;"
+      );
+      svg.appendChild(line);
+      svg.appendChild(text);
+      text.setAttribute("fill", `black`);
+      document.body.appendChild(svg);
+      debugElements[debugId] = { svg, line, text };
+    }
+    line.setAttribute("x1", a.x.toString());
+    line.setAttribute("x2", b.x.toString());
+    line.setAttribute("y1", a.y.toString());
+    line.setAttribute("y2", b.y.toString());
+    line.setAttribute("style", `stroke:${color};stroke-width:2`);
+    text.setAttribute("x", (a.x - (a.x - b.x) / 2).toString());
+    text.setAttribute("y", (a.y - (a.y - b.y) / 2).toString());
+    if (label) {
+      text.innerHTML = label;
+    }
+  });
+};
+
+// lib/dnd/collision/directional/index.ts
+var distanceChange = "increasing";
+var directionalCollision = (input, previous) => {
+  var _a;
+  const { dragOperation, droppable } = input;
+  const { shape: dropShape } = droppable;
+  const { position } = dragOperation;
+  const dragShape = (_a = dragOperation.shape) == null ? void 0 : _a.current;
+  if (!dragShape || !dropShape) return null;
+  const dropCenter = dropShape.center;
+  const distanceToPrevious = Math.sqrt(
+    Math.pow(dropCenter.x - previous.x, 2) + Math.pow(dropCenter.y - previous.y, 2)
+  );
+  const distanceToCurrent = Math.sqrt(
+    Math.pow(dropCenter.x - position.current.x, 2) + Math.pow(dropCenter.y - position.current.y, 2)
+  );
+  distanceChange = distanceToCurrent === distanceToPrevious ? distanceChange : distanceToCurrent < distanceToPrevious ? "decreasing" : "increasing";
+  collisionDebug(
+    dragShape.center,
+    dropCenter,
+    droppable.id.toString(),
+    "rebeccapurple"
+  );
+  if (distanceChange === "decreasing") {
+    return {
+      id: droppable.id,
+      value: 1,
+      type: import_abstract2.CollisionType.Collision
+    };
+  }
+  return null;
+};
+
+// lib/dnd/collision/dynamic/get-direction.ts
+init_react_import();
+var getDirection = (dragAxis, delta) => {
+  if (dragAxis === "dynamic") {
+    if (Math.abs(delta.y) > Math.abs(delta.x)) {
+      return delta.y === 0 ? null : delta.y > 0 ? "down" : "up";
+    } else {
+      return delta.x === 0 ? null : delta.x > 0 ? "right" : "left";
+    }
+  } else if (dragAxis === "x") {
+    return delta.x === 0 ? null : delta.x > 0 ? "right" : "left";
+  }
+  return delta.y === 0 ? null : delta.y > 0 ? "down" : "up";
+};
+
+// lib/dnd/collision/dynamic/get-midpoint-impact.ts
+init_react_import();
+var getMidpointImpact = (dragShape, dropShape, direction, offsetMultiplier = 0) => {
+  const dragRect = dragShape.boundingRectangle;
+  const dropCenter = dropShape.center;
+  if (direction === "down") {
+    const offset2 = offsetMultiplier * dropShape.boundingRectangle.height;
+    return dragRect.bottom >= dropCenter.y + offset2;
+  } else if (direction === "up") {
+    const offset2 = offsetMultiplier * dropShape.boundingRectangle.height;
+    return dragRect.top < dropCenter.y - offset2;
+  } else if (direction === "left") {
+    const offset2 = offsetMultiplier * dropShape.boundingRectangle.width;
+    return dropCenter.x - offset2 >= dragRect.left;
+  }
+  const offset = offsetMultiplier * dropShape.boundingRectangle.width;
+  return dragRect.right - offset >= dropCenter.x;
+};
+
+// lib/dnd/collision/dynamic/track-movement-interval.ts
+init_react_import();
+var import_geometry2 = require("@dnd-kit/geometry");
+var INTERVAL_SENSITIVITY = 10;
+var intervalCache = {
+  current: { x: 0, y: 0 },
+  delta: { x: 0, y: 0 },
+  previous: { x: 0, y: 0 },
+  direction: null
+};
+var trackMovementInterval = (point, dragAxis = "dynamic") => {
+  intervalCache.current = point;
+  intervalCache.delta = {
+    x: point.x - intervalCache.previous.x,
+    y: point.y - intervalCache.previous.y
+  };
+  intervalCache.direction = getDirection(dragAxis, intervalCache.delta) || intervalCache.direction;
+  if (Math.abs(intervalCache.delta.x) > INTERVAL_SENSITIVITY || Math.abs(intervalCache.delta.y) > INTERVAL_SENSITIVITY) {
+    intervalCache.previous = import_geometry2.Point.from(point);
+  }
+  return intervalCache;
+};
+
+// ../../node_modules/@dnd-kit/collision/dist/index.js
+init_react_import();
+var import_abstract3 = require("@dnd-kit/abstract");
+var import_geometry3 = require("@dnd-kit/geometry");
+var import_abstract4 = require("@dnd-kit/abstract");
+var import_geometry4 = require("@dnd-kit/geometry");
+var import_abstract5 = require("@dnd-kit/abstract");
+var import_geometry5 = require("@dnd-kit/geometry");
+var import_abstract6 = require("@dnd-kit/abstract");
+var import_geometry6 = require("@dnd-kit/geometry");
+var import_abstract7 = require("@dnd-kit/abstract");
+var import_geometry7 = require("@dnd-kit/geometry");
+var import_abstract8 = require("@dnd-kit/abstract");
+var import_geometry8 = require("@dnd-kit/geometry");
+var pointerIntersection = ({
+  dragOperation,
+  droppable
+}) => {
+  const pointerCoordinates = dragOperation.position.current;
+  if (!pointerCoordinates) {
+    return null;
+  }
+  const { id } = droppable;
+  if (!droppable.shape) {
+    return null;
+  }
+  if (droppable.shape.containsPoint(pointerCoordinates)) {
+    const distance = import_geometry3.Point.distance(droppable.shape.center, pointerCoordinates);
+    return {
+      id,
+      value: 1 / distance,
+      type: import_abstract3.CollisionType.PointerIntersection,
+      priority: import_abstract3.CollisionPriority.High
+    };
+  }
+  return null;
+};
+var closestCorners = (input) => {
+  const { dragOperation, droppable } = input;
+  const { shape, position } = dragOperation;
+  if (!droppable.shape) {
+    return null;
+  }
+  const { left, top, right, bottom } = droppable.shape.boundingRectangle;
+  const corners = [
+    {
+      x: left,
+      y: top
+    },
+    {
+      x: right,
+      y: top
+    },
+    {
+      x: left,
+      y: bottom
+    },
+    {
+      x: right,
+      y: bottom
+    }
+  ];
+  const distance = corners.reduce(
+    (acc, corner) => {
+      var _a;
+      return acc + import_geometry5.Point.distance(
+        import_geometry5.Point.from(corner),
+        (_a = shape == null ? void 0 : shape.current.center) != null ? _a : position.current
+      );
+    },
+    0
+  );
+  const value = distance / 4;
+  return {
+    id: droppable.id,
+    value: 1 / value,
+    type: import_abstract5.CollisionType.Collision,
+    priority: import_abstract5.CollisionPriority.Normal
+  };
+};
+
+// lib/dnd/collision/dynamic/store.ts
+init_react_import();
+var import_vanilla = require("zustand/vanilla");
+var collisionStore = (0, import_vanilla.createStore)(() => ({
+  fallbackEnabled: false
+}));
+
+// lib/dnd/collision/dynamic/index.ts
+var flushNext = "";
+var createDynamicCollisionDetector = (dragAxis, midpointOffset = 0.05) => (input) => {
+  var _a, _b, _c, _d, _e;
+  const { dragOperation, droppable } = input;
+  const { position } = dragOperation;
+  const dragShape = (_a = dragOperation.shape) == null ? void 0 : _a.current;
+  const { shape: dropShape } = droppable;
+  if (!dragShape || !dropShape) {
+    return null;
+  }
+  const { center: dragCenter } = dragShape;
+  const { fallbackEnabled } = collisionStore.getState();
+  const interval = trackMovementInterval(position.current, dragAxis);
+  dragOperation.data = __spreadProps(__spreadValues({}, dragOperation.data), {
+    direction: interval.direction
+  });
+  const collisionMap = dragOperation.data.collisionMap || {};
+  dragOperation.data.collisionMap = collisionMap;
+  collisionMap[droppable.id] = {
+    direction: interval.direction
+  };
+  const { center: dropCenter } = dropShape;
+  const overMidpoint = getMidpointImpact(
+    dragShape,
+    dropShape,
+    interval.direction,
+    midpointOffset
+  );
+  if (((_b = dragOperation.source) == null ? void 0 : _b.id) === droppable.id) {
+    const collision = directionalCollision(input, interval.previous);
+    collisionDebug(dragCenter, dropCenter, droppable.id.toString(), "yellow");
+    if (collision) {
+      return __spreadProps(__spreadValues({}, collision), {
+        priority: import_abstract9.CollisionPriority.Highest
+      });
+    }
+  }
+  const intersectionArea = dragShape.intersectionArea(dropShape);
+  const intersectionRatio = intersectionArea / dropShape.area;
+  if (intersectionArea && overMidpoint) {
+    collisionDebug(
+      dragCenter,
+      dropCenter,
+      droppable.id.toString(),
+      "green",
+      interval.direction
+    );
+    const collision = {
+      id: droppable.id,
+      value: intersectionRatio,
+      priority: import_abstract9.CollisionPriority.High,
+      type: import_abstract9.CollisionType.Collision
+    };
+    const shouldFlushId = flushNext === droppable.id;
+    flushNext = "";
+    return __spreadProps(__spreadValues({}, collision), { id: shouldFlushId ? "flush" : collision.id });
+  }
+  if (fallbackEnabled && ((_c = dragOperation.source) == null ? void 0 : _c.id) !== droppable.id) {
+    const xAxisIntersection = dropShape.boundingRectangle.right > dragShape.boundingRectangle.left && dropShape.boundingRectangle.left < dragShape.boundingRectangle.right;
+    const yAxisIntersection = dropShape.boundingRectangle.bottom > dragShape.boundingRectangle.top && dropShape.boundingRectangle.top < dragShape.boundingRectangle.bottom;
+    if (dragAxis === "y" && xAxisIntersection || yAxisIntersection) {
+      const fallbackCollision = closestCorners(input);
+      if (fallbackCollision) {
+        const direction = getDirection(dragAxis, {
+          x: dragShape.center.x - (((_d = droppable.shape) == null ? void 0 : _d.center.x) || 0),
+          y: dragShape.center.y - (((_e = droppable.shape) == null ? void 0 : _e.center.y) || 0)
+        });
+        collisionMap[droppable.id] = {
+          direction
+        };
+        if (intersectionArea) {
+          collisionDebug(
+            dragCenter,
+            dropCenter,
+            droppable.id.toString(),
+            "red",
+            direction || ""
+          );
+          flushNext = droppable.id;
+          return __spreadProps(__spreadValues({}, fallbackCollision), {
+            priority: import_abstract9.CollisionPriority.Low
+          });
+        }
+        collisionDebug(
+          dragCenter,
+          dropCenter,
+          droppable.id.toString(),
+          "orange",
+          direction || ""
+        );
+        return __spreadProps(__spreadValues({}, fallbackCollision), { priority: import_abstract9.CollisionPriority.Lowest });
+      }
+    }
+  }
+  collisionDebug(dragCenter, dropCenter, droppable.id.toString(), "hotpink");
+  delete collisionMap[droppable.id];
+  return null;
+};
+
+// components/Sortable/index.tsx
+var import_modifiers = require("@dnd-kit/dom/modifiers");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var SortableProvider = ({
+  children,
+  onDragStart,
+  onDragEnd,
+  onMove
+}) => {
+  const [move, setMove] = (0, import_react11.useState)({ source: -1, target: -1 });
+  const sensors = useSensors();
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    import_react10.DragDropProvider,
+    {
+      sensors,
+      modifiers: [
+        import_modifiers.RestrictToElement.configure({
+          element() {
+            return document.querySelector("[data-dnd-container]");
+          }
+        })
+      ],
+      onDragStart,
+      onDragOver: (event, manager) => {
+        var _a, _b;
+        const { operation } = event;
+        const { source, target } = operation;
+        if (!source || !target) return;
+        let sourceIndex = source.data.index;
+        let targetIndex = target.data.index;
+        const collisionData = (_b = (_a = manager.dragOperation.data) == null ? void 0 : _a.collisionMap) == null ? void 0 : _b[target.id];
+        if (sourceIndex !== targetIndex && source.id !== target.id) {
+          const collisionPosition = (collisionData == null ? void 0 : collisionData.direction) === "up" ? "before" : "after";
+          if (targetIndex >= sourceIndex) {
+            targetIndex = targetIndex - 1;
+          }
+          if (collisionPosition === "after") {
+            targetIndex = targetIndex + 1;
+          }
+          setMove({
+            source: sourceIndex,
+            target: targetIndex
+          });
+        }
+      },
+      onDragEnd: () => {
+        setTimeout(() => {
+          if (move.source !== -1 && move.target !== -1) {
+            onMove(move);
+          }
+          onDragEnd();
+        }, 250);
+        setMove({ source: -1, target: -1 });
+      },
+      children
+    }
+  );
+};
+var Sortable = ({
+  id,
+  index,
+  disabled,
+  children,
+  type = "item"
+}) => {
+  const { ref: sortableRef, status } = useSortableSafe({
+    id,
+    type,
+    index,
+    disabled,
+    data: { index },
+    collisionDetector: createDynamicCollisionDetector("y")
+  });
+  return children({ status, ref: sortableRef });
+};
+
+// components/AutoField/context.tsx
+init_react_import();
+var import_react12 = require("react");
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var NestedFieldContext = (0, import_react12.createContext)({});
+var useNestedFieldContext = () => {
+  const context = (0, import_react12.useContext)(NestedFieldContext);
+  return __spreadProps(__spreadValues({}, context), {
+    readOnlyFields: context.readOnlyFields || {}
+  });
+};
+var NestedFieldProvider = ({
+  children,
+  name,
+  subName,
+  wildcardName = name,
+  readOnlyFields
+}) => {
+  const subPath = `${name}.${subName}`;
+  const wildcardSubPath = `${wildcardName}.${subName}`;
+  const subReadOnlyFields = (0, import_react12.useMemo)(
+    () => Object.keys(readOnlyFields).reduce((acc, readOnlyKey) => {
+      const isLocal = readOnlyKey.indexOf(subPath) > -1 || readOnlyKey.indexOf(wildcardSubPath) > -1;
+      if (isLocal) {
+        const subPathPattern = new RegExp(
+          `^(${name}|${wildcardName}).`.replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/\./g, "\\.").replace(/\*/g, "\\*")
+        );
+        const localName = readOnlyKey.replace(subPathPattern, "");
+        return __spreadProps(__spreadValues({}, acc), {
+          [localName]: readOnlyFields[readOnlyKey]
+        });
+      }
+      return acc;
+    }, {}),
+    [name, subName, wildcardName, readOnlyFields]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    NestedFieldContext.Provider,
+    {
+      value: { readOnlyFields: subReadOnlyFields, localName: subName },
+      children
+    }
+  );
+};
+
+// components/AutoField/fields/ArrayField/index.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var getClassName5 = get_class_name_factory_default("ArrayField", styles_module_default3);
+var getClassNameItem = get_class_name_factory_default("ArrayFieldItem", styles_module_default3);
+var ArrayField = ({
+  field,
+  onChange,
+  value: _value,
+  name,
+  label,
+  readOnly,
+  id,
+  Label: Label2 = (props) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", __spreadValues({}, props))
+}) => {
+  const { state, setUi, selectedItem, getPermissions } = useAppContext();
+  const { readOnlyFields, localName = name } = useNestedFieldContext();
+  const value = _value;
+  const arrayState = state.ui.arrayState[id] || {
+    items: Array.from(value || []).map((item, idx) => {
+      return {
+        _originalIndex: idx,
+        _arrayId: `${id}-${idx}`
+      };
+    }),
+    openId: ""
+  };
+  const [localState, setLocalState] = (0, import_react13.useState)({ arrayState, value });
+  (0, import_react13.useEffect)(() => {
+    setLocalState({ arrayState, value });
+  }, [value, state.ui.arrayState[id]]);
+  const mapArrayStateToUi = (0, import_react13.useCallback)(
+    (partialArrayState) => {
+      return {
+        arrayState: __spreadProps(__spreadValues({}, state.ui.arrayState), {
+          [id]: __spreadValues(__spreadValues({}, arrayState), partialArrayState)
+        })
+      };
+    },
+    [arrayState]
+  );
+  const getHighestIndex = (0, import_react13.useCallback)(() => {
+    return arrayState.items.reduce(
+      (acc, item) => item._originalIndex > acc ? item._originalIndex : acc,
+      -1
+    );
+  }, [arrayState]);
+  const regenerateArrayState = (0, import_react13.useCallback)(
+    (value2) => {
+      let highestIndex = getHighestIndex();
+      const newItems = Array.from(value2 || []).map((item, idx) => {
+        var _a;
+        const arrayStateItem = arrayState.items[idx];
+        const newItem = {
+          _originalIndex: typeof (arrayStateItem == null ? void 0 : arrayStateItem._originalIndex) !== "undefined" ? arrayStateItem._originalIndex : highestIndex + 1,
+          _arrayId: ((_a = arrayState.items[idx]) == null ? void 0 : _a._arrayId) || `${id}-${highestIndex + 1}`
+        };
+        if (newItem._originalIndex > highestIndex) {
+          highestIndex = newItem._originalIndex;
+        }
+        return newItem;
+      });
+      return __spreadProps(__spreadValues({}, arrayState), { items: newItems });
+    },
+    [arrayState]
+  );
+  (0, import_react13.useEffect)(() => {
+    if (arrayState.items.length > 0) {
+      setUi(mapArrayStateToUi(arrayState));
+    }
+  }, []);
+  const [isDragging, setIsDragging] = (0, import_react13.useState)(false);
+  const forceReadOnly = getPermissions({ item: selectedItem }).edit === false;
+  if (field.type !== "array" || !field.arrayFields) {
+    return null;
+  }
+  const addDisabled = field.max !== void 0 && localState.arrayState.items.length >= field.max || readOnly;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    Label2,
+    {
+      label: label || name,
       icon: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(List, { size: 16 }),
       el: "div",
       readOnly,
       children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
         SortableProvider,
         {
+          onDragStart: () => setIsDragging(true),
+          onDragEnd: () => setIsDragging(false),
           onMove: (move) => {
             const newValue = reorder(value, move.source, move.target);
             const newArrayStateItems = reorder(
@@ -1519,7 +2173,7 @@ var ArrayField = ({
                 e.preventDefault();
               },
               children: [
-                localState.arrayState.items.map((item, i) => {
+                /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: getClassName5("inner"), "data-dnd-container": true, children: localState.arrayState.items.map((item, i) => {
                   const { _arrayId = `${id}-${i}`, _originalIndex = i } = item;
                   const data = Array.from(localState.value || [])[i] || {};
                   return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
@@ -1542,6 +2196,7 @@ var ArrayField = ({
                               "div",
                               {
                                 onClick: (e) => {
+                                  if (isDragging) return;
                                   e.preventDefault();
                                   e.stopPropagation();
                                   if (arrayState.openId === _arrayId) {
@@ -1571,7 +2226,11 @@ var ArrayField = ({
                                           onClick: (e) => {
                                             e.stopPropagation();
                                             const existingValue = [...value || []];
-                                            existingValue.splice(i, 0, existingValue[i]);
+                                            existingValue.splice(
+                                              i,
+                                              0,
+                                              existingValue[i]
+                                            );
                                             onChange(
                                               existingValue,
                                               mapArrayStateToUi(
@@ -1613,62 +2272,72 @@ var ArrayField = ({
                                 ]
                               }
                             ),
-                            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: getClassNameItem("body"), children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("fieldset", { className: getClassNameItem("fieldset"), children: Object.keys(field.arrayFields).map((subName) => {
-                              const subField = field.arrayFields[subName];
-                              const indexName = `${name}[${i}]`;
-                              const subPath = `${indexName}.${subName}`;
-                              const localIndexName = `${localName}[${i}]`;
-                              const localWildcardName = `${localName}[*]`;
-                              const localSubPath = `${localIndexName}.${subName}`;
-                              const localWildcardSubPath = `${localWildcardName}.${subName}`;
-                              const subReadOnly = forceReadOnly ? forceReadOnly : typeof readOnlyFields[subPath] !== "undefined" ? readOnlyFields[localSubPath] : readOnlyFields[localWildcardSubPath];
-                              const label2 = subField.label || subName;
-                              return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
-                                NestedFieldProvider,
-                                {
-                                  name: localIndexName,
-                                  wildcardName: localWildcardName,
-                                  subName,
-                                  readOnlyFields,
-                                  children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
-                                    AutoFieldPrivate,
-                                    {
-                                      name: subPath,
-                                      label: label2,
-                                      id: `${_arrayId}_${subName}`,
-                                      readOnly: subReadOnly,
-                                      field: __spreadProps(__spreadValues({}, subField), {
-                                        label: label2
-                                        // May be used by custom fields
-                                      }),
-                                      value: data[subName],
-                                      onChange: (val, ui) => {
-                                        onChange(
-                                          replace(value, i, __spreadProps(__spreadValues({}, data), {
-                                            [subName]: val
-                                          })),
-                                          ui
-                                        );
-                                      }
-                                    }
-                                  )
+                            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: getClassNameItem("body"), children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                              "fieldset",
+                              {
+                                className: getClassNameItem("fieldset"),
+                                onPointerDownCapture: (e) => {
+                                  e.stopPropagation();
                                 },
-                                subPath
-                              );
-                            }) }) })
+                                children: Object.keys(field.arrayFields).map((subName) => {
+                                  const subField = field.arrayFields[subName];
+                                  const indexName = `${name}[${i}]`;
+                                  const subPath = `${indexName}.${subName}`;
+                                  const localIndexName = `${localName}[${i}]`;
+                                  const localWildcardName = `${localName}[*]`;
+                                  const localSubPath = `${localIndexName}.${subName}`;
+                                  const localWildcardSubPath = `${localWildcardName}.${subName}`;
+                                  const subReadOnly = forceReadOnly ? forceReadOnly : typeof readOnlyFields[subPath] !== "undefined" ? readOnlyFields[localSubPath] : readOnlyFields[localWildcardSubPath];
+                                  const label2 = subField.label || subName;
+                                  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                                    NestedFieldProvider,
+                                    {
+                                      name: localIndexName,
+                                      wildcardName: localWildcardName,
+                                      subName,
+                                      readOnlyFields,
+                                      children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                                        AutoFieldPrivate,
+                                        {
+                                          name: subPath,
+                                          label: label2,
+                                          id: `${_arrayId}_${subName}`,
+                                          readOnly: subReadOnly,
+                                          field: __spreadProps(__spreadValues({}, subField), {
+                                            label: label2
+                                            // May be used by custom fields
+                                          }),
+                                          value: data[subName],
+                                          onChange: (val, ui) => {
+                                            onChange(
+                                              replace(value, i, __spreadProps(__spreadValues({}, data), {
+                                                [subName]: val
+                                              })),
+                                              ui
+                                            );
+                                          }
+                                        }
+                                      )
+                                    },
+                                    subPath
+                                  );
+                                })
+                              }
+                            ) })
                           ]
                         }
                       )
                     },
                     _arrayId
                   );
-                }),
+                }) }),
                 !addDisabled && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
                   "button",
                   {
                     type: "button",
                     className: getClassName5("addButton"),
                     onClick: () => {
+                      if (isDragging) return;
                       const existingValue = value || [];
                       const newValue = [
                         ...existingValue,
@@ -1749,19 +2418,19 @@ var DefaultField = ({
 
 // components/AutoField/fields/ExternalField/index.tsx
 init_react_import();
-var import_react16 = require("react");
+var import_react17 = require("react");
 
 // components/ExternalInput/index.tsx
 init_react_import();
-var import_react15 = require("react");
+var import_react16 = require("react");
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/ExternalInput/styles.module.css#css-module
 init_react_import();
-var styles_module_default6 = { "ExternalInput-actions": "_ExternalInput-actions_8wgzm_1", "ExternalInput-button": "_ExternalInput-button_8wgzm_5", "ExternalInput--dataSelected": "_ExternalInput--dataSelected_8wgzm_24", "ExternalInput--readOnly": "_ExternalInput--readOnly_8wgzm_31", "ExternalInput-detachButton": "_ExternalInput-detachButton_8wgzm_35", "ExternalInput": "_ExternalInput_8wgzm_1", "ExternalInputModal": "_ExternalInputModal_8wgzm_79", "ExternalInputModal-grid": "_ExternalInputModal-grid_8wgzm_89", "ExternalInputModal--filtersToggled": "_ExternalInputModal--filtersToggled_8wgzm_100", "ExternalInputModal-filters": "_ExternalInputModal-filters_8wgzm_105", "ExternalInputModal-masthead": "_ExternalInputModal-masthead_8wgzm_124", "ExternalInputModal-tableWrapper": "_ExternalInputModal-tableWrapper_8wgzm_133", "ExternalInputModal-table": "_ExternalInputModal-table_8wgzm_133", "ExternalInputModal-thead": "_ExternalInputModal-thead_8wgzm_149", "ExternalInputModal-th": "_ExternalInputModal-th_8wgzm_149", "ExternalInputModal-td": "_ExternalInputModal-td_8wgzm_164", "ExternalInputModal-tr": "_ExternalInputModal-tr_8wgzm_169", "ExternalInputModal-tbody": "_ExternalInputModal-tbody_8wgzm_176", "ExternalInputModal--hasData": "_ExternalInputModal--hasData_8wgzm_202", "ExternalInputModal-loadingBanner": "_ExternalInputModal-loadingBanner_8wgzm_206", "ExternalInputModal--isLoading": "_ExternalInputModal--isLoading_8wgzm_223", "ExternalInputModal-searchForm": "_ExternalInputModal-searchForm_8wgzm_227", "ExternalInputModal-search": "_ExternalInputModal-search_8wgzm_227", "ExternalInputModal-searchIcon": "_ExternalInputModal-searchIcon_8wgzm_264", "ExternalInputModal-searchIconText": "_ExternalInputModal-searchIconText_8wgzm_289", "ExternalInputModal-searchInput": "_ExternalInputModal-searchInput_8wgzm_299", "ExternalInputModal-searchActions": "_ExternalInputModal-searchActions_8wgzm_313", "ExternalInputModal-searchActionIcon": "_ExternalInputModal-searchActionIcon_8wgzm_326", "ExternalInputModal-footerContainer": "_ExternalInputModal-footerContainer_8wgzm_330", "ExternalInputModal-footer": "_ExternalInputModal-footer_8wgzm_330" };
+var styles_module_default6 = { "ExternalInput-actions": "_ExternalInput-actions_91ls0_1", "ExternalInput-button": "_ExternalInput-button_91ls0_5", "ExternalInput--dataSelected": "_ExternalInput--dataSelected_91ls0_24", "ExternalInput--readOnly": "_ExternalInput--readOnly_91ls0_31", "ExternalInput-detachButton": "_ExternalInput-detachButton_91ls0_35", "ExternalInput": "_ExternalInput_91ls0_1", "ExternalInputModal": "_ExternalInputModal_91ls0_79", "ExternalInputModal-grid": "_ExternalInputModal-grid_91ls0_89", "ExternalInputModal--filtersToggled": "_ExternalInputModal--filtersToggled_91ls0_100", "ExternalInputModal-filters": "_ExternalInputModal-filters_91ls0_105", "ExternalInputModal-masthead": "_ExternalInputModal-masthead_91ls0_124", "ExternalInputModal-tableWrapper": "_ExternalInputModal-tableWrapper_91ls0_133", "ExternalInputModal-table": "_ExternalInputModal-table_91ls0_133", "ExternalInputModal-thead": "_ExternalInputModal-thead_91ls0_149", "ExternalInputModal-th": "_ExternalInputModal-th_91ls0_149", "ExternalInputModal-td": "_ExternalInputModal-td_91ls0_164", "ExternalInputModal-tr": "_ExternalInputModal-tr_91ls0_169", "ExternalInputModal-tbody": "_ExternalInputModal-tbody_91ls0_176", "ExternalInputModal--hasData": "_ExternalInputModal--hasData_91ls0_202", "ExternalInputModal-loadingBanner": "_ExternalInputModal-loadingBanner_91ls0_206", "ExternalInputModal--isLoading": "_ExternalInputModal--isLoading_91ls0_223", "ExternalInputModal-searchForm": "_ExternalInputModal-searchForm_91ls0_227", "ExternalInputModal-search": "_ExternalInputModal-search_91ls0_227", "ExternalInputModal-searchIcon": "_ExternalInputModal-searchIcon_91ls0_264", "ExternalInputModal-searchIconText": "_ExternalInputModal-searchIconText_91ls0_289", "ExternalInputModal-searchInput": "_ExternalInputModal-searchInput_91ls0_299", "ExternalInputModal-searchActions": "_ExternalInputModal-searchActions_91ls0_313", "ExternalInputModal-searchActionIcon": "_ExternalInputModal-searchActionIcon_91ls0_326", "ExternalInputModal-footerContainer": "_ExternalInputModal-footerContainer_91ls0_330", "ExternalInputModal-footer": "_ExternalInputModal-footer_91ls0_330", "ExternalInputModal-field": "_ExternalInputModal-field_91ls0_343" };
 
 // components/Modal/index.tsx
 init_react_import();
-var import_react13 = require("react");
+var import_react14 = require("react");
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/Modal/styles.module.css#css-module
 init_react_import();
@@ -1776,8 +2445,8 @@ var Modal = ({
   onClose,
   isOpen
 }) => {
-  const [rootEl, setRootEl] = (0, import_react13.useState)(null);
-  (0, import_react13.useEffect)(() => {
+  const [rootEl, setRootEl] = (0, import_react14.useState)(null);
+  (0, import_react14.useEffect)(() => {
     setRootEl(document.getElementById("puck-portal-root"));
   }, []);
   if (!rootEl) {
@@ -1824,11 +2493,11 @@ init_react_import();
 
 // components/Button/Button.tsx
 init_react_import();
-var import_react14 = require("react");
+var import_react15 = require("react");
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/Button/Button.module.css#css-module
 init_react_import();
-var Button_module_default = { "Button": "_Button_1t64k_1", "Button--medium": "_Button--medium_1t64k_29", "Button--large": "_Button--large_1t64k_37", "Button-icon": "_Button-icon_1t64k_44", "Button--primary": "_Button--primary_1t64k_48", "Button--secondary": "_Button--secondary_1t64k_67", "Button--flush": "_Button--flush_1t64k_84", "Button--disabled": "_Button--disabled_1t64k_88", "Button--fullWidth": "_Button--fullWidth_1t64k_95", "Button-spinner": "_Button-spinner_1t64k_100" };
+var Button_module_default = { "Button": "_Button_10byl_1", "Button--medium": "_Button--medium_10byl_29", "Button--large": "_Button--large_10byl_37", "Button-icon": "_Button-icon_10byl_44", "Button--primary": "_Button--primary_10byl_48", "Button--secondary": "_Button--secondary_10byl_67", "Button--flush": "_Button--flush_10byl_84", "Button--disabled": "_Button--disabled_10byl_88", "Button--fullWidth": "_Button--fullWidth_10byl_95", "Button-spinner": "_Button-spinner_10byl_100" };
 
 // lib/filter-data-attrs.ts
 init_react_import();
@@ -1874,8 +2543,8 @@ var Button = (_a) => {
     "size",
     "loading"
   ]);
-  const [loading, setLoading] = (0, import_react14.useState)(loadingProp);
-  (0, import_react14.useEffect)(() => setLoading(loadingProp), [loadingProp]);
+  const [loading, setLoading] = (0, import_react15.useState)(loadingProp);
+  (0, import_react15.useEffect)(() => setLoading(loadingProp), [loadingProp]);
   const ElementType = href ? "a" : type ? "button" : "span";
   const dataAttrs = filterDataAttrs(props);
   const el = /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
@@ -1930,28 +2599,28 @@ var ExternalInput = ({
     mapRow = (val) => val,
     filterFields
   } = field || {};
-  const [data, setData] = (0, import_react15.useState)([]);
-  const [isOpen, setOpen] = (0, import_react15.useState)(false);
-  const [isLoading, setIsLoading] = (0, import_react15.useState)(true);
+  const [data, setData] = (0, import_react16.useState)([]);
+  const [isOpen, setOpen] = (0, import_react16.useState)(false);
+  const [isLoading, setIsLoading] = (0, import_react16.useState)(true);
   const hasFilterFields = !!filterFields;
-  const [filters, setFilters] = (0, import_react15.useState)(field.initialFilters || {});
-  const [filtersToggled, setFiltersToggled] = (0, import_react15.useState)(hasFilterFields);
-  const mappedData = (0, import_react15.useMemo)(() => {
+  const [filters, setFilters] = (0, import_react16.useState)(field.initialFilters || {});
+  const [filtersToggled, setFiltersToggled] = (0, import_react16.useState)(hasFilterFields);
+  const mappedData = (0, import_react16.useMemo)(() => {
     return data.map(mapRow);
   }, [data]);
-  const keys = (0, import_react15.useMemo)(() => {
+  const keys = (0, import_react16.useMemo)(() => {
     const validKeys = /* @__PURE__ */ new Set();
     for (const item of mappedData) {
       for (const key of Object.keys(item)) {
-        if (typeof item[key] === "string" || typeof item[key] === "number" || (0, import_react15.isValidElement)(item[key])) {
+        if (typeof item[key] === "string" || typeof item[key] === "number" || (0, import_react16.isValidElement)(item[key])) {
           validKeys.add(key);
         }
       }
     }
     return Array.from(validKeys);
   }, [mappedData]);
-  const [searchQuery, setSearchQuery] = (0, import_react15.useState)(field.initialQuery || "");
-  const search = (0, import_react15.useCallback)(
+  const [searchQuery, setSearchQuery] = (0, import_react16.useState)(field.initialQuery || "");
+  const search = (0, import_react16.useCallback)(
     (query, filters2) => __async(void 0, null, function* () {
       setIsLoading(true);
       const cacheKey = `${id}-${query}-${JSON.stringify(filters2)}`;
@@ -1964,7 +2633,7 @@ var ExternalInput = ({
     }),
     [id, field]
   );
-  const Footer = (0, import_react15.useCallback)(
+  const Footer = (0, import_react16.useCallback)(
     (props) => field.renderFooter ? field.renderFooter(props) : /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("span", { className: getClassNameModal("footer"), children: [
       props.items.length,
       " result",
@@ -1972,7 +2641,7 @@ var ExternalInput = ({
     ] }),
     [field.renderFooter]
   );
-  (0, import_react15.useEffect)(() => {
+  (0, import_react16.useEffect)(() => {
     search(searchQuery, filters);
   }, []);
   return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
@@ -2065,18 +2734,26 @@ var ExternalInput = ({
                 hasFilterFields && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: getClassNameModal("filters"), children: hasFilterFields && Object.keys(filterFields).map((fieldName) => {
                   const filterField = filterFields[fieldName];
                   return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
-                    AutoFieldPrivate,
+                    "div",
                     {
-                      field: filterField,
-                      name: fieldName,
-                      id: `external_field_${fieldName}_filter`,
-                      label: filterField.label || fieldName,
-                      value: filters[fieldName],
-                      onChange: (value2) => {
-                        const newFilters = __spreadProps(__spreadValues({}, filters), { [fieldName]: value2 });
-                        setFilters(newFilters);
-                        search(searchQuery, newFilters);
-                      }
+                      className: getClassNameModal("field"),
+                      children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+                        AutoFieldPrivate,
+                        {
+                          field: filterField,
+                          name: fieldName,
+                          id: `external_field_${fieldName}_filter`,
+                          label: filterField.label || fieldName,
+                          value: filters[fieldName],
+                          onChange: (value2) => {
+                            const newFilters = __spreadProps(__spreadValues({}, filters), {
+                              [fieldName]: value2
+                            });
+                            setFilters(newFilters);
+                            search(searchQuery, newFilters);
+                          }
+                        }
+                      )
                     },
                     fieldName
                   );
@@ -2135,7 +2812,7 @@ var ExternalField = ({
   var _a, _b, _c;
   const validField = field;
   const deprecatedField = field;
-  (0, import_react16.useEffect)(() => {
+  (0, import_react17.useEffect)(() => {
     if (deprecatedField.adaptor) {
       console.error(
         "Warning: The `adaptor` API is deprecated. Please use updated APIs on the `external` field instead. This will be a breaking change in a future release."
@@ -2170,7 +2847,7 @@ var ExternalField = ({
 
 // components/AutoField/fields/RadioField/index.tsx
 init_react_import();
-var import_react17 = require("react");
+var import_react18 = require("react");
 
 // lib/safe-json-parse.ts
 init_react_import();
@@ -2196,7 +2873,7 @@ var RadioField = ({
   label,
   Label: Label2
 }) => {
-  const flatOptions = (0, import_react17.useMemo)(
+  const flatOptions = (0, import_react18.useMemo)(
     () => field.type === "radio" ? field.options.map(({ value: value2 }) => value2) : [],
     [field]
   );
@@ -2246,7 +2923,7 @@ var RadioField = ({
 
 // components/AutoField/fields/SelectField/index.tsx
 init_react_import();
-var import_react18 = require("react");
+var import_react19 = require("react");
 var import_jsx_runtime16 = require("react/jsx-runtime");
 var getClassName12 = get_class_name_factory_default("Input", styles_module_default2);
 var SelectField = ({
@@ -2259,7 +2936,7 @@ var SelectField = ({
   readOnly,
   id
 }) => {
-  const flatOptions = (0, import_react18.useMemo)(
+  const flatOptions = (0, import_react19.useMemo)(
     () => field.type === "select" ? field.options.map(({ value: value2 }) => value2) : [],
     [field]
   );
@@ -2411,7 +3088,7 @@ var ObjectField = ({
 
 // lib/use-safe-id.ts
 init_react_import();
-var import_react19 = __toESM(require("react"));
+var import_react20 = __toESM(require("react"));
 
 // lib/generate-id.ts
 init_react_import();
@@ -2420,10 +3097,10 @@ var generateId = (type) => type ? `${type}-${(0, import_uuid.v4)()}` : (0, impor
 
 // lib/use-safe-id.ts
 var useSafeId = () => {
-  if (typeof import_react19.default.useId !== "undefined") {
-    return import_react19.default.useId();
+  if (typeof import_react20.default.useId !== "undefined") {
+    return import_react20.default.useId();
   }
-  const [id] = (0, import_react19.useState)(generateId());
+  const [id] = (0, import_react20.useState)(generateId());
   return id;
 };
 
@@ -2457,7 +3134,7 @@ var FieldLabelInternal = ({
   readOnly
 }) => {
   const { overrides } = useAppContext();
-  const Wrapper = (0, import_react20.useMemo)(
+  const Wrapper = (0, import_react21.useMemo)(
     () => overrides.fieldLabel || FieldLabel,
     [overrides]
   );
@@ -2479,7 +3156,7 @@ var FieldLabelInternal = ({
 function AutoFieldInternal(props) {
   var _a, _b, _c, _d, _e, _f, _g, _h;
   const { dispatch, overrides, selectedItem } = useAppContext();
-  const nestedFieldContext = (0, import_react20.useContext)(NestedFieldContext);
+  const nestedFieldContext = (0, import_react21.useContext)(NestedFieldContext);
   const { id, Label: Label2 = FieldLabelInternal } = props;
   const field = props.field;
   const label = field.label;
@@ -2511,9 +3188,9 @@ function AutoFieldInternal(props) {
     Label: Label2,
     id: resolvedId
   });
-  const onFocus = (0, import_react20.useCallback)(
+  const onFocus = (0, import_react21.useCallback)(
     (e) => {
-      if (mergedProps.name && e.target.nodeName === "INPUT") {
+      if (mergedProps.name && (e.target.nodeName === "INPUT" || e.target.nodeName === "TEXTAREA")) {
         e.stopPropagation();
         dispatch({
           type: "setUi",
@@ -2525,7 +3202,7 @@ function AutoFieldInternal(props) {
     },
     [mergedProps.name]
   );
-  const onBlur = (0, import_react20.useCallback)((e) => {
+  const onBlur = (0, import_react21.useCallback)((e) => {
     if ("name" in e.target) {
       dispatch({
         type: "setUi",
@@ -2569,7 +3246,7 @@ function AutoFieldInternal(props) {
 function AutoFieldPrivate(props) {
   const { state } = useAppContext();
   const { value, onChange } = props;
-  const [localValue, setLocalValue] = (0, import_react20.useState)(value);
+  const [localValue, setLocalValue] = (0, import_react21.useState)(value);
   const onChangeDb = (0, import_use_debounce.useDebouncedCallback)(
     (val, ui) => {
       onChange(val, ui);
@@ -2577,11 +3254,11 @@ function AutoFieldPrivate(props) {
     50,
     { leading: true }
   );
-  const onChangeLocal = (0, import_react20.useCallback)((val, ui) => {
+  const onChangeLocal = (0, import_react21.useCallback)((val, ui) => {
     setLocalValue(val);
     onChangeDb(val, ui);
   }, []);
-  (0, import_react20.useEffect)(() => {
+  (0, import_react21.useEffect)(() => {
     if (state.ui.field.focus !== props.name) {
       setLocalValue(value);
     }
@@ -2593,7 +3270,7 @@ function AutoFieldPrivate(props) {
   return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(AutoFieldInternal, __spreadValues(__spreadValues({}, props), localProps));
 }
 function AutoField(props) {
-  const DefaultLabel = (0, import_react20.useMemo)(() => {
+  const DefaultLabel = (0, import_react21.useMemo)(() => {
     const DefaultLabel2 = (labelProps) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
       "div",
       __spreadProps(__spreadValues({}, labelProps), {
@@ -2603,373 +3280,38 @@ function AutoField(props) {
     return DefaultLabel2;
   }, [props.readOnly]);
   return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(AutoFieldInternal, __spreadProps(__spreadValues({}, props), { Label: DefaultLabel }));
-}
-
-// components/Drawer/index.tsx
-init_react_import();
-
-// css-module:/home/runner/work/puck/puck/packages/core/components/Drawer/styles.module.css#css-module
-init_react_import();
-var styles_module_default10 = { "Drawer": "_Drawer_fkqfo_1", "Drawer-draggable": "_Drawer-draggable_fkqfo_8", "Drawer-draggableBg": "_Drawer-draggableBg_fkqfo_12", "Drawer-draggableFg": "_Drawer-draggableFg_fkqfo_21", "DrawerItem-draggable": "_DrawerItem-draggable_fkqfo_25", "DrawerItem--disabled": "_DrawerItem--disabled_fkqfo_38", "DrawerItem": "_DrawerItem_fkqfo_25", "Drawer--isDraggingFrom": "_Drawer--isDraggingFrom_fkqfo_48", "DrawerItem-name": "_DrawerItem-name_fkqfo_66" };
-
-// components/Drawer/index.tsx
-var import_react32 = require("react");
-
-// components/DragDropContext/index.tsx
-init_react_import();
-var import_react30 = require("@dnd-kit/react");
-var import_react31 = require("react");
-var import_dom = require("@dnd-kit/dom");
-
-// components/DropZone/index.tsx
-init_react_import();
-var import_react29 = require("react");
-
-// components/DraggableComponent/index.tsx
-init_react_import();
-var import_react23 = require("react");
-
-// css-module:/home/runner/work/puck/puck/packages/core/components/DraggableComponent/styles.module.css#css-module
-init_react_import();
-var styles_module_default11 = { "DraggableComponent": "_DraggableComponent_1ukn8_1", "DraggableComponent-overlay": "_DraggableComponent-overlay_1ukn8_12", "DraggableComponent-loadingOverlay": "_DraggableComponent-loadingOverlay_1ukn8_29", "DraggableComponent--hover": "_DraggableComponent--hover_1ukn8_45", "DraggableComponent--isLocked": "_DraggableComponent--isLocked_1ukn8_45", "DraggableComponent--isSelected": "_DraggableComponent--isSelected_1ukn8_54", "DraggableComponent-actionsOverlay": "_DraggableComponent-actionsOverlay_1ukn8_66", "DraggableComponent-actions": "_DraggableComponent-actions_1ukn8_66" };
-
-// components/DraggableComponent/index.tsx
-var import_react_dom2 = require("react-dom");
-
-// lib/dnd/collision/dynamic/index.ts
-init_react_import();
-var import_abstract8 = require("@dnd-kit/abstract");
-
-// lib/dnd/collision/directional/index.ts
-init_react_import();
-var import_abstract = require("@dnd-kit/abstract");
-
-// lib/dnd/collision/collision-debug.ts
-init_react_import();
-var DEBUG = false;
-var debugElements = {};
-var timeout;
-var collisionDebug = (a, b, id, color, label) => {
-  if (!DEBUG) return;
-  const debugId = `${id}-debug`;
-  clearTimeout(timeout);
-  timeout = setTimeout(() => {
-    Object.entries(debugElements).forEach(([id2, { svg }]) => {
-      svg.remove();
-      delete debugElements[id2];
-    });
-  }, 1e3);
-  requestAnimationFrame(() => {
-    var _a, _b;
-    const existingEl = debugElements[debugId];
-    let line = (_a = debugElements[debugId]) == null ? void 0 : _a.line;
-    let text = (_b = debugElements[debugId]) == null ? void 0 : _b.text;
-    if (!existingEl) {
-      const svgNs = "http://www.w3.org/2000/svg";
-      const svg = document.createElementNS(svgNs, "svg");
-      line = document.createElementNS(svgNs, "line");
-      text = document.createElementNS(svgNs, "text");
-      svg.setAttribute("id", debugId);
-      svg.setAttribute(
-        "style",
-        "position: fixed; height: 100%; width: 100%; pointer-events: none;"
-      );
-      svg.appendChild(line);
-      svg.appendChild(text);
-      text.setAttribute("fill", `black`);
-      document.body.appendChild(svg);
-      debugElements[debugId] = { svg, line, text };
-    }
-    line.setAttribute("x1", a.x.toString());
-    line.setAttribute("x2", b.x.toString());
-    line.setAttribute("y1", a.y.toString());
-    line.setAttribute("y2", b.y.toString());
-    line.setAttribute("style", `stroke:${color};stroke-width:2`);
-    text.setAttribute("x", (a.x - (a.x - b.x) / 2).toString());
-    text.setAttribute("y", (a.y - (a.y - b.y) / 2).toString());
-    if (label) {
-      text.innerHTML = label;
-    }
-  });
-};
-
-// lib/dnd/collision/directional/index.ts
-var distanceChange = "increasing";
-var directionalCollision = (input, previous) => {
-  var _a;
-  const { dragOperation, droppable } = input;
-  const { shape: dropShape } = droppable;
-  const { position } = dragOperation;
-  const dragShape = (_a = dragOperation.shape) == null ? void 0 : _a.current;
-  if (!dragShape || !dropShape) return null;
-  const dropCenter = dropShape.center;
-  const distanceToPrevious = Math.sqrt(
-    Math.pow(dropCenter.x - previous.x, 2) + Math.pow(dropCenter.y - previous.y, 2)
-  );
-  const distanceToCurrent = Math.sqrt(
-    Math.pow(dropCenter.x - position.current.x, 2) + Math.pow(dropCenter.y - position.current.y, 2)
-  );
-  distanceChange = distanceToCurrent === distanceToPrevious ? distanceChange : distanceToCurrent < distanceToPrevious ? "decreasing" : "increasing";
-  collisionDebug(
-    dragShape.center,
-    dropCenter,
-    droppable.id.toString(),
-    "rebeccapurple"
-  );
-  if (distanceChange === "decreasing") {
-    return {
-      id: droppable.id,
-      value: 1,
-      type: import_abstract.CollisionType.Collision
-    };
-  }
-  return null;
-};
+}
 
-// lib/dnd/collision/dynamic/get-direction.ts
+// components/Drawer/index.tsx
 init_react_import();
-var getDirection = (dragAxis, delta) => {
-  if (dragAxis === "dynamic") {
-    if (Math.abs(delta.y) > Math.abs(delta.x)) {
-      return delta.y === 0 ? null : delta.y > 0 ? "down" : "up";
-    } else {
-      return delta.x === 0 ? null : delta.x > 0 ? "right" : "left";
-    }
-  } else if (dragAxis === "x") {
-    return delta.x === 0 ? null : delta.x > 0 ? "right" : "left";
-  }
-  return delta.y === 0 ? null : delta.y > 0 ? "down" : "up";
-};
 
-// lib/dnd/collision/dynamic/get-midpoint-impact.ts
+// css-module:/home/runner/work/puck/puck/packages/core/components/Drawer/styles.module.css#css-module
 init_react_import();
-var getMidpointImpact = (dragShape, dropShape, direction, offsetMultiplier = 0) => {
-  const dragRect = dragShape.boundingRectangle;
-  const dropCenter = dropShape.center;
-  if (direction === "down") {
-    const offset2 = offsetMultiplier * dropShape.boundingRectangle.height;
-    return dragRect.bottom >= dropCenter.y + offset2;
-  } else if (direction === "up") {
-    const offset2 = offsetMultiplier * dropShape.boundingRectangle.height;
-    return dragRect.top < dropCenter.y - offset2;
-  } else if (direction === "left") {
-    const offset2 = offsetMultiplier * dropShape.boundingRectangle.width;
-    return dropCenter.x - offset2 >= dragRect.left;
-  }
-  const offset = offsetMultiplier * dropShape.boundingRectangle.width;
-  return dragRect.right - offset >= dropCenter.x;
-};
+var styles_module_default10 = { "Drawer": "_Drawer_fkqfo_1", "Drawer-draggable": "_Drawer-draggable_fkqfo_8", "Drawer-draggableBg": "_Drawer-draggableBg_fkqfo_12", "Drawer-draggableFg": "_Drawer-draggableFg_fkqfo_21", "DrawerItem-draggable": "_DrawerItem-draggable_fkqfo_25", "DrawerItem--disabled": "_DrawerItem--disabled_fkqfo_38", "DrawerItem": "_DrawerItem_fkqfo_25", "Drawer--isDraggingFrom": "_Drawer--isDraggingFrom_fkqfo_48", "DrawerItem-name": "_DrawerItem-name_fkqfo_66" };
 
-// lib/dnd/collision/dynamic/track-movement-interval.ts
+// components/Drawer/index.tsx
+var import_react33 = require("react");
+
+// components/DragDropContext/index.tsx
 init_react_import();
-var import_geometry = require("@dnd-kit/geometry");
-var INTERVAL_SENSITIVITY = 10;
-var intervalCache = {
-  current: { x: 0, y: 0 },
-  delta: { x: 0, y: 0 },
-  previous: { x: 0, y: 0 },
-  direction: null
-};
-var trackMovementInterval = (point, dragAxis = "dynamic") => {
-  intervalCache.current = point;
-  intervalCache.delta = {
-    x: point.x - intervalCache.previous.x,
-    y: point.y - intervalCache.previous.y
-  };
-  intervalCache.direction = getDirection(dragAxis, intervalCache.delta) || intervalCache.direction;
-  if (Math.abs(intervalCache.delta.x) > INTERVAL_SENSITIVITY || Math.abs(intervalCache.delta.y) > INTERVAL_SENSITIVITY) {
-    intervalCache.previous = import_geometry.Point.from(point);
-  }
-  return intervalCache;
-};
+var import_react31 = require("@dnd-kit/react");
+var import_react32 = require("react");
+var import_dom = require("@dnd-kit/dom");
 
-// ../../node_modules/@dnd-kit/collision/dist/index.js
+// components/DropZone/index.tsx
 init_react_import();
-var import_abstract2 = require("@dnd-kit/abstract");
-var import_geometry2 = require("@dnd-kit/geometry");
-var import_abstract3 = require("@dnd-kit/abstract");
-var import_geometry3 = require("@dnd-kit/geometry");
-var import_abstract4 = require("@dnd-kit/abstract");
-var import_geometry4 = require("@dnd-kit/geometry");
-var import_abstract5 = require("@dnd-kit/abstract");
-var import_geometry5 = require("@dnd-kit/geometry");
-var import_abstract6 = require("@dnd-kit/abstract");
-var import_geometry6 = require("@dnd-kit/geometry");
-var import_abstract7 = require("@dnd-kit/abstract");
-var import_geometry7 = require("@dnd-kit/geometry");
-var pointerIntersection = ({
-  dragOperation,
-  droppable
-}) => {
-  const pointerCoordinates = dragOperation.position.current;
-  if (!pointerCoordinates) {
-    return null;
-  }
-  const { id } = droppable;
-  if (!droppable.shape) {
-    return null;
-  }
-  if (droppable.shape.containsPoint(pointerCoordinates)) {
-    const distance = import_geometry2.Point.distance(droppable.shape.center, pointerCoordinates);
-    return {
-      id,
-      value: 1 / distance,
-      type: import_abstract2.CollisionType.PointerIntersection,
-      priority: import_abstract2.CollisionPriority.High
-    };
-  }
-  return null;
-};
-var closestCorners = (input) => {
-  const { dragOperation, droppable } = input;
-  const { shape, position } = dragOperation;
-  if (!droppable.shape) {
-    return null;
-  }
-  const { left, top, right, bottom } = droppable.shape.boundingRectangle;
-  const corners = [
-    {
-      x: left,
-      y: top
-    },
-    {
-      x: right,
-      y: top
-    },
-    {
-      x: left,
-      y: bottom
-    },
-    {
-      x: right,
-      y: bottom
-    }
-  ];
-  const distance = corners.reduce(
-    (acc, corner) => {
-      var _a;
-      return acc + import_geometry4.Point.distance(
-        import_geometry4.Point.from(corner),
-        (_a = shape == null ? void 0 : shape.current.center) != null ? _a : position.current
-      );
-    },
-    0
-  );
-  const value = distance / 4;
-  return {
-    id: droppable.id,
-    value: 1 / value,
-    type: import_abstract4.CollisionType.Collision,
-    priority: import_abstract4.CollisionPriority.Normal
-  };
-};
+var import_react30 = require("react");
 
-// lib/dnd/collision/dynamic/store.ts
+// components/DraggableComponent/index.tsx
 init_react_import();
-var import_vanilla = require("zustand/vanilla");
-var collisionStore = (0, import_vanilla.createStore)(() => ({
-  fallbackEnabled: false
-}));
+var import_react24 = require("react");
 
-// lib/dnd/collision/dynamic/index.ts
-var flushNext = "";
-var createDynamicCollisionDetector = (dragAxis, midpointOffset = 0.05) => (input) => {
-  var _a, _b, _c, _d, _e;
-  const { dragOperation, droppable } = input;
-  const { position } = dragOperation;
-  const dragShape = (_a = dragOperation.shape) == null ? void 0 : _a.current;
-  const { shape: dropShape } = droppable;
-  if (!dragShape || !dropShape) {
-    return null;
-  }
-  const { center: dragCenter } = dragShape;
-  const { fallbackEnabled } = collisionStore.getState();
-  const interval = trackMovementInterval(position.current, dragAxis);
-  dragOperation.data = __spreadProps(__spreadValues({}, dragOperation.data), {
-    direction: interval.direction
-  });
-  const collisionMap = dragOperation.data.collisionMap || {};
-  dragOperation.data.collisionMap = collisionMap;
-  collisionMap[droppable.id] = {
-    direction: interval.direction
-  };
-  const { center: dropCenter } = dropShape;
-  const overMidpoint = getMidpointImpact(
-    dragShape,
-    dropShape,
-    interval.direction,
-    midpointOffset
-  );
-  if (((_b = dragOperation.source) == null ? void 0 : _b.id) === droppable.id) {
-    const collision = directionalCollision(input, interval.previous);
-    collisionDebug(dragCenter, dropCenter, droppable.id.toString(), "yellow");
-    if (collision) {
-      return __spreadProps(__spreadValues({}, collision), {
-        priority: import_abstract8.CollisionPriority.Highest
-      });
-    }
-  }
-  const intersectionArea = dragShape.intersectionArea(dropShape);
-  const intersectionRatio = intersectionArea / dropShape.area;
-  if (intersectionArea && overMidpoint) {
-    collisionDebug(
-      dragCenter,
-      dropCenter,
-      droppable.id.toString(),
-      "green",
-      interval.direction
-    );
-    const collision = {
-      id: droppable.id,
-      value: intersectionRatio,
-      priority: import_abstract8.CollisionPriority.High,
-      type: import_abstract8.CollisionType.Collision
-    };
-    const shouldFlushId = flushNext === droppable.id;
-    flushNext = "";
-    return __spreadProps(__spreadValues({}, collision), { id: shouldFlushId ? "flush" : collision.id });
-  }
-  if (fallbackEnabled && ((_c = dragOperation.source) == null ? void 0 : _c.id) !== droppable.id) {
-    const xAxisIntersection = dropShape.boundingRectangle.right > dragShape.boundingRectangle.left && dropShape.boundingRectangle.left < dragShape.boundingRectangle.right;
-    const yAxisIntersection = dropShape.boundingRectangle.bottom > dragShape.boundingRectangle.top && dropShape.boundingRectangle.top < dragShape.boundingRectangle.bottom;
-    if (dragAxis === "y" && xAxisIntersection || yAxisIntersection) {
-      const fallbackCollision = closestCorners(input);
-      if (fallbackCollision) {
-        const direction = getDirection(dragAxis, {
-          x: dragShape.center.x - (((_d = droppable.shape) == null ? void 0 : _d.center.x) || 0),
-          y: dragShape.center.y - (((_e = droppable.shape) == null ? void 0 : _e.center.y) || 0)
-        });
-        collisionMap[droppable.id] = {
-          direction
-        };
-        if (intersectionArea) {
-          collisionDebug(
-            dragCenter,
-            dropCenter,
-            droppable.id.toString(),
-            "red",
-            direction || ""
-          );
-          flushNext = droppable.id;
-          return __spreadProps(__spreadValues({}, fallbackCollision), {
-            priority: import_abstract8.CollisionPriority.Low
-          });
-        }
-        collisionDebug(
-          dragCenter,
-          dropCenter,
-          droppable.id.toString(),
-          "orange",
-          direction || ""
-        );
-        return __spreadProps(__spreadValues({}, fallbackCollision), { priority: import_abstract8.CollisionPriority.Lowest });
-      }
-    }
-  }
-  collisionDebug(dragCenter, dropCenter, droppable.id.toString(), "hotpink");
-  delete collisionMap[droppable.id];
-  return null;
-};
+// css-module:/home/runner/work/puck/puck/packages/core/components/DraggableComponent/styles.module.css#css-module
+init_react_import();
+var styles_module_default11 = { "DraggableComponent": "_DraggableComponent_1ukn8_1", "DraggableComponent-overlay": "_DraggableComponent-overlay_1ukn8_12", "DraggableComponent-loadingOverlay": "_DraggableComponent-loadingOverlay_1ukn8_29", "DraggableComponent--hover": "_DraggableComponent--hover_1ukn8_45", "DraggableComponent--isLocked": "_DraggableComponent--isLocked_1ukn8_45", "DraggableComponent--isSelected": "_DraggableComponent--isSelected_1ukn8_54", "DraggableComponent-actionsOverlay": "_DraggableComponent-actionsOverlay_1ukn8_66", "DraggableComponent-actions": "_DraggableComponent-actions_1ukn8_66" };
+
+// components/DraggableComponent/index.tsx
+var import_react_dom2 = require("react-dom");
 
 // lib/get-deep-scroll-position.ts
 init_react_import();
@@ -2992,11 +3334,11 @@ function getDeepScrollPosition(element) {
 
 // components/DropZone/context.tsx
 init_react_import();
-var import_react21 = require("react");
+var import_react22 = require("react");
 var import_zustand = require("zustand");
 var import_jsx_runtime20 = require("react/jsx-runtime");
-var dropZoneContext = (0, import_react21.createContext)(null);
-var ZoneStoreContext = (0, import_react21.createContext)(
+var dropZoneContext = (0, import_react22.createContext)(null);
+var ZoneStoreContext = (0, import_react22.createContext)(
   (0, import_zustand.createStore)(() => ({
     zoneDepthIndex: {},
     nextZoneDepthIndex: {},
@@ -3016,19 +3358,19 @@ var DropZoneProvider = ({
   children,
   value
 }) => {
-  const [hoveringComponent, setHoveringComponent] = (0, import_react21.useState)();
-  const [areasWithZones, setAreasWithZones] = (0, import_react21.useState)(
+  const [hoveringComponent, setHoveringComponent] = (0, import_react22.useState)();
+  const [areasWithZones, setAreasWithZones] = (0, import_react22.useState)(
     {}
   );
-  const [activeZones, setActiveZones] = (0, import_react21.useState)({});
+  const [activeZones, setActiveZones] = (0, import_react22.useState)({});
   const { dispatch } = useAppContext();
-  const registerZoneArea = (0, import_react21.useCallback)(
+  const registerZoneArea = (0, import_react22.useCallback)(
     (area) => {
       setAreasWithZones((latest) => __spreadProps(__spreadValues({}, latest), { [area]: true }));
     },
     [setAreasWithZones]
   );
-  const registerZone = (0, import_react21.useCallback)(
+  const registerZone = (0, import_react22.useCallback)(
     (zoneCompound) => {
       if (!dispatch) {
         return;
@@ -3041,7 +3383,7 @@ var DropZoneProvider = ({
     },
     [setActiveZones, dispatch]
   );
-  const unregisterZone = (0, import_react21.useCallback)(
+  const unregisterZone = (0, import_react22.useCallback)(
     (zoneCompound) => {
       if (!dispatch) {
         return;
@@ -3056,7 +3398,7 @@ var DropZoneProvider = ({
     },
     [setActiveZones, dispatch]
   );
-  const memoValue = (0, import_react21.useMemo)(
+  const memoValue = (0, import_react22.useMemo)(
     () => __spreadValues({
       hoveringComponent,
       setHoveringComponent,
@@ -3073,11 +3415,11 @@ var DropZoneProvider = ({
 
 // lib/use-context-store.ts
 init_react_import();
-var import_react22 = require("react");
+var import_react23 = require("react");
 var import_zustand2 = require("zustand");
 var import_shallow = require("zustand/react/shallow");
 function useContextStore(context, selector) {
-  const store = (0, import_react22.useContext)(context);
+  const store = (0, import_react23.useContext)(context);
   if (!store) {
     throw new Error("useContextStore must be used inside context");
   }
@@ -3136,9 +3478,9 @@ var DraggableComponent = ({
     iframe,
     state
   } = useAppContext();
-  const ctx = (0, import_react23.useContext)(dropZoneContext);
-  const [localZones, setLocalZones] = (0, import_react23.useState)({});
-  const registerLocalZone = (0, import_react23.useCallback)(
+  const ctx = (0, import_react24.useContext)(dropZoneContext);
+  const [localZones, setLocalZones] = (0, import_react24.useState)({});
+  const registerLocalZone = (0, import_react24.useCallback)(
     (zoneCompound2, active) => {
       var _a;
       (_a = ctx == null ? void 0 : ctx.registerLocalZone) == null ? void 0 : _a.call(ctx, zoneCompound2, active);
@@ -3148,7 +3490,7 @@ var DraggableComponent = ({
     },
     [setLocalZones]
   );
-  const unregisterLocalZone = (0, import_react23.useCallback)(
+  const unregisterLocalZone = (0, import_react24.useCallback)(
     (zoneCompound2) => {
       var _a;
       (_a = ctx == null ? void 0 : ctx.unregisterLocalZone) == null ? void 0 : _a.call(ctx, zoneCompound2);
@@ -3162,8 +3504,8 @@ var DraggableComponent = ({
   );
   const containsActiveZone = Object.values(localZones).filter(Boolean).length > 0;
   const { path = [] } = ctx || {};
-  const [canDrag, setCanDrag] = (0, import_react23.useState)(false);
-  (0, import_react23.useEffect)(() => {
+  const [canDrag, setCanDrag] = (0, import_react24.useState)(false);
+  (0, import_react24.useEffect)(() => {
     var _a;
     const item = getItem({ index, zone: zoneCompound }, state.data);
     if (item) {
@@ -3179,7 +3521,7 @@ var DraggableComponent = ({
   );
   const canCollide = canDrag || userIsDragging;
   const disabled = !isEnabled || !canCollide;
-  const [dragAxis, setDragAxis] = (0, import_react23.useState)(userDragAxis || autoDragAxis);
+  const [dragAxis, setDragAxis] = (0, import_react24.useState)(userDragAxis || autoDragAxis);
   const { ref: sortableRef, status } = useSortableSafe({
     id,
     index,
@@ -3205,8 +3547,8 @@ var DraggableComponent = ({
     }
   });
   const thisIsDragging = status === "dragging";
-  const ref = (0, import_react23.useRef)(null);
-  const refSetter = (0, import_react23.useCallback)(
+  const ref = (0, import_react24.useRef)(null);
+  const refSetter = (0, import_react24.useCallback)(
     (el) => {
       sortableRef(el);
       if (el) {
@@ -3215,14 +3557,14 @@ var DraggableComponent = ({
     },
     [sortableRef]
   );
-  const [portalEl, setPortalEl] = (0, import_react23.useState)();
-  (0, import_react23.useEffect)(() => {
+  const [portalEl, setPortalEl] = (0, import_react24.useState)();
+  (0, import_react24.useEffect)(() => {
     var _a, _b, _c;
     setPortalEl(
       iframe.enabled ? (_a = ref.current) == null ? void 0 : _a.ownerDocument.body : (_c = (_b = ref.current) == null ? void 0 : _b.closest("[data-puck-preview]")) != null ? _c : document.body
     );
   }, [iframe.enabled, ref.current]);
-  const getStyle = (0, import_react23.useCallback)(() => {
+  const getStyle = (0, import_react24.useCallback)(() => {
     var _a, _b, _c;
     if (!ref.current) return;
     const rect = ref.current.getBoundingClientRect();
@@ -3242,11 +3584,11 @@ var DraggableComponent = ({
     };
     return style2;
   }, [ref.current]);
-  const [style, setStyle] = (0, import_react23.useState)();
-  const sync = (0, import_react23.useCallback)(() => {
+  const [style, setStyle] = (0, import_react24.useState)();
+  const sync = (0, import_react24.useCallback)(() => {
     setStyle(getStyle());
   }, [ref.current, iframe]);
-  (0, import_react23.useEffect)(() => {
+  (0, import_react24.useEffect)(() => {
     if (ref.current && !userIsDragging) {
       const observer = new ResizeObserver(sync);
       observer.observe(ref.current);
@@ -3255,7 +3597,7 @@ var DraggableComponent = ({
       };
     }
   }, [ref.current, userIsDragging]);
-  (0, import_react23.useEffect)(() => {
+  (0, import_react24.useEffect)(() => {
     ctx == null ? void 0 : ctx.registerPath(
       id,
       {
@@ -3269,14 +3611,14 @@ var DraggableComponent = ({
       (_a = ctx == null ? void 0 : ctx.unregisterPath) == null ? void 0 : _a.call(ctx, id);
     };
   }, [id, zoneCompound, index, componentType]);
-  const CustomActionBar = (0, import_react23.useMemo)(
+  const CustomActionBar = (0, import_react24.useMemo)(
     () => overrides.actionBar || DefaultActionBar,
     [overrides.actionBar]
   );
   const permissions = getPermissions({
     item: selectedItem
   });
-  const onClick = (0, import_react23.useCallback)(
+  const onClick = (0, import_react24.useCallback)(
     (e) => {
       e.stopPropagation();
       dispatch({
@@ -3288,7 +3630,7 @@ var DraggableComponent = ({
     },
     [index, zoneCompound, id]
   );
-  const onSelectParent = (0, import_react23.useCallback)(() => {
+  const onSelectParent = (0, import_react24.useCallback)(() => {
     if (!(ctx == null ? void 0 : ctx.areaId)) {
       return;
     }
@@ -3306,23 +3648,23 @@ var DraggableComponent = ({
       }
     });
   }, [ctx, path]);
-  const onDuplicate = (0, import_react23.useCallback)(() => {
+  const onDuplicate = (0, import_react24.useCallback)(() => {
     dispatch({
       type: "duplicate",
       sourceIndex: index,
       sourceZone: zoneCompound
     });
   }, [index, zoneCompound]);
-  const onDelete = (0, import_react23.useCallback)(() => {
+  const onDelete = (0, import_react24.useCallback)(() => {
     dispatch({
       type: "remove",
       index,
       zone: zoneCompound
     });
   }, [index, zoneCompound]);
-  const [hover, setHover] = (0, import_react23.useState)(false);
+  const [hover, setHover] = (0, import_react24.useState)(false);
   const indicativeHover = (ctx == null ? void 0 : ctx.hoveringComponent) === id;
-  (0, import_react23.useEffect)(() => {
+  (0, import_react24.useEffect)(() => {
     if (!ref.current) {
       return;
     }
@@ -3372,7 +3714,7 @@ var DraggableComponent = ({
     thisIsDragging,
     inDroppableZone
   ]);
-  (0, import_react23.useEffect)(() => {
+  (0, import_react24.useEffect)(() => {
     if (ref.current && disabled) {
       ref.current.setAttribute("data-puck-disabled", "");
       return () => {
@@ -3381,8 +3723,8 @@ var DraggableComponent = ({
       };
     }
   }, [disabled, ref]);
-  const [isVisible, setIsVisible] = (0, import_react23.useState)(false);
-  (0, import_react23.useEffect)(() => {
+  const [isVisible, setIsVisible] = (0, import_react24.useState)(false);
+  (0, import_react24.useEffect)(() => {
     sync();
     if ((isSelected || hover || indicativeHover) && !userIsDragging) {
       setIsVisible(true);
@@ -3390,7 +3732,7 @@ var DraggableComponent = ({
       setIsVisible(false);
     }
   }, [isSelected, hover, indicativeHover, iframe, state.data, userIsDragging]);
-  const syncActionsPosition = (0, import_react23.useCallback)(
+  const syncActionsPosition = (0, import_react24.useCallback)(
     (el) => {
       if (el) {
         const view = el.ownerDocument.defaultView;
@@ -3407,7 +3749,7 @@ var DraggableComponent = ({
     },
     [zoomConfig]
   );
-  (0, import_react23.useEffect)(() => {
+  (0, import_react24.useEffect)(() => {
     if (userDragAxis) {
       setDragAxis(userDragAxis);
       return;
@@ -3501,14 +3843,14 @@ var styles_module_default12 = { "DropZone": "_DropZone_kmkdc_1", "DropZone--isAc
 
 // components/DropZone/lib/use-min-empty-height.ts
 init_react_import();
-var import_react24 = require("react");
+var import_react25 = require("react");
 var useMinEmptyHeight = ({
   zoneCompound,
   userMinEmptyHeight,
   ref
 }) => {
-  const [prevHeight, setPrevHeight] = (0, import_react24.useState)(0);
-  const [isAnimating, setIsAnimating] = (0, import_react24.useState)(false);
+  const [prevHeight, setPrevHeight] = (0, import_react25.useState)(0);
+  const [isAnimating, setIsAnimating] = (0, import_react25.useState)(false);
   const { draggedItem, isZone } = useContextStore(ZoneStoreContext, (s) => {
     var _a, _b;
     return {
@@ -3516,7 +3858,7 @@ var useMinEmptyHeight = ({
       isZone: ((_b = s.draggedItem) == null ? void 0 : _b.data.zone) === zoneCompound
     };
   });
-  (0, import_react24.useEffect)(() => {
+  (0, import_react25.useEffect)(() => {
     if (draggedItem && ref.current) {
       if (isZone) {
         const rect = ref.current.getBoundingClientRect();
@@ -3550,15 +3892,15 @@ function assignRefs(refs, node) {
 
 // components/DropZone/lib/use-content-with-preview.ts
 init_react_import();
-var import_react27 = require("react");
+var import_react28 = require("react");
 
 // lib/dnd/use-rendered-callback.ts
 init_react_import();
-var import_react25 = require("@dnd-kit/react");
-var import_react26 = require("react");
+var import_react26 = require("@dnd-kit/react");
+var import_react27 = require("react");
 function useRenderedCallback(callback, deps) {
-  const manager = (0, import_react25.useDragDropManager)();
-  return (0, import_react26.useCallback)(
+  const manager = (0, import_react26.useDragDropManager)();
+  return (0, import_react27.useCallback)(
     (...args) => __async(this, null, function* () {
       yield manager == null ? void 0 : manager.renderer.rendering;
       return callback(...args);
@@ -3593,8 +3935,8 @@ var useContentWithPreview = (content, zoneCompound) => {
       ui: { isDragging }
     }
   } = useAppContext();
-  const [contentWithPreview, setContentWithPreview] = (0, import_react27.useState)(content);
-  const [localPreview, setLocalPreview] = (0, import_react27.useState)(
+  const [contentWithPreview, setContentWithPreview] = (0, import_react28.useState)(content);
+  const [localPreview, setLocalPreview] = (0, import_react28.useState)(
     preview
   );
   const updateContent = useRenderedCallback(
@@ -3635,7 +3977,7 @@ var useContentWithPreview = (content, zoneCompound) => {
     },
     [draggedItemId, previewExists]
   );
-  (0, import_react27.useEffect)(() => {
+  (0, import_react28.useEffect)(() => {
     updateContent(content, preview, isDragging);
   }, [content, preview, isDragging]);
   return [contentWithPreview, localPreview];
@@ -3643,16 +3985,16 @@ var useContentWithPreview = (content, zoneCompound) => {
 
 // components/DropZone/lib/use-drag-axis.ts
 init_react_import();
-var import_react28 = require("react");
+var import_react29 = require("react");
 var GRID_DRAG_AXIS = "dynamic";
 var FLEX_ROW_DRAG_AXIS = "x";
 var DEFAULT_DRAG_AXIS = "y";
 var useDragAxis = (ref, collisionAxis) => {
   const { status } = useAppContext();
-  const [dragAxis, setDragAxis] = (0, import_react28.useState)(
+  const [dragAxis, setDragAxis] = (0, import_react29.useState)(
     collisionAxis || DEFAULT_DRAG_AXIS
   );
-  const calculateDragAxis = (0, import_react28.useCallback)(() => {
+  const calculateDragAxis = (0, import_react29.useCallback)(() => {
     if (ref.current) {
       const computedStyle = window.getComputedStyle(ref.current);
       if (computedStyle.display === "grid") {
@@ -3664,7 +4006,7 @@ var useDragAxis = (ref, collisionAxis) => {
       }
     }
   }, [ref.current]);
-  (0, import_react28.useEffect)(() => {
+  (0, import_react29.useEffect)(() => {
     const onViewportChange = () => {
       calculateDragAxis();
     };
@@ -3673,7 +4015,7 @@ var useDragAxis = (ref, collisionAxis) => {
       window.removeEventListener("viewportchange", onViewportChange);
     };
   }, []);
-  (0, import_react28.useEffect)(calculateDragAxis, [status, collisionAxis]);
+  (0, import_react29.useEffect)(calculateDragAxis, [status, collisionAxis]);
   return [dragAxis, calculateDragAxis];
 };
 
@@ -3683,7 +4025,7 @@ var getClassName17 = get_class_name_factory_default("DropZone", styles_module_de
 var getRandomColor = () => `#${Math.floor(Math.random() * 16777215).toString(16)}`;
 var RENDER_DEBUG = false;
 var DropZoneEditPure = (props) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(DropZoneEdit, __spreadValues({}, props));
-var DropZoneEdit = (0, import_react29.forwardRef)(
+var DropZoneEdit = (0, import_react30.forwardRef)(
   function DropZoneEditInternal({
     zone,
     allow,
@@ -3694,7 +4036,7 @@ var DropZoneEdit = (0, import_react29.forwardRef)(
     collisionAxis
   }, userRef) {
     const appContext2 = useAppContext();
-    const ctx = (0, import_react29.useContext)(dropZoneContext);
+    const ctx = (0, import_react30.useContext)(dropZoneContext);
     const {
       // These all need setting via context
       data,
@@ -3730,12 +4072,12 @@ var DropZoneEdit = (0, import_react29.forwardRef)(
       };
     });
     const { itemSelector } = appContext2.state.ui;
-    (0, import_react29.useEffect)(() => {
+    (0, import_react30.useEffect)(() => {
       if (areaId && registerZoneArea) {
         registerZoneArea(areaId);
       }
     }, [areaId]);
-    (0, import_react29.useEffect)(() => {
+    (0, import_react30.useEffect)(() => {
       if (ctx == null ? void 0 : ctx.registerZone) {
         ctx == null ? void 0 : ctx.registerZone(zoneCompound);
       }
@@ -3745,14 +4087,14 @@ var DropZoneEdit = (0, import_react29.forwardRef)(
         }
       };
     }, []);
-    const content = (0, import_react29.useMemo)(() => {
+    const content = (0, import_react30.useMemo)(() => {
       if (areaId && zone !== rootDroppableId) {
         return setupZone(data, zoneCompound).zones[zoneCompound];
       }
       return data.content || [];
     }, [data, zoneCompound]);
-    const ref = (0, import_react29.useRef)(null);
-    const acceptsTarget = (0, import_react29.useCallback)(
+    const ref = (0, import_react30.useRef)(null);
+    const acceptsTarget = (0, import_react30.useCallback)(
       (componentType) => {
         if (!componentType) {
           return true;
@@ -3774,7 +4116,7 @@ var DropZoneEdit = (0, import_react29.forwardRef)(
       },
       [allow, disallow]
     );
-    (0, import_react29.useEffect)(() => {
+    (0, import_react30.useEffect)(() => {
       if (registerLocalZone) {
         registerLocalZone(zoneCompound, acceptsTarget(draggedComponentType));
       }
@@ -3909,13 +4251,13 @@ var DropZoneEdit = (0, import_react29.forwardRef)(
   }
 );
 var DropZoneRenderPure = (props) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(DropZoneRender, __spreadValues({}, props));
-var DropZoneRender = (0, import_react29.forwardRef)(
+var DropZoneRender = (0, import_react30.forwardRef)(
   function DropZoneRenderInternal({ className, style, zone }, ref) {
-    const ctx = (0, import_react29.useContext)(dropZoneContext);
+    const ctx = (0, import_react30.useContext)(dropZoneContext);
     const { data, areaId = "root", config } = ctx || {};
     let zoneCompound = rootDroppableId;
     let content = (data == null ? void 0 : data.content) || [];
-    (0, import_react29.useEffect)(() => {
+    (0, import_react30.useEffect)(() => {
       if (ctx == null ? void 0 : ctx.registerZone) {
         ctx == null ? void 0 : ctx.registerZone(zoneCompound);
       }
@@ -3961,944 +4303,710 @@ var DropZoneRender = (0, import_react29.forwardRef)(
     }) });
   }
 );
-var DropZone = (0, import_react29.forwardRef)(
+var DropZonePure = (props) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(DropZone, __spreadValues({}, props));
+var DropZone = (0, import_react30.forwardRef)(
   function DropZone2(props, ref) {
-    const ctx = (0, import_react29.useContext)(dropZoneContext);
+    const ctx = (0, import_react30.useContext)(dropZoneContext);
     if ((ctx == null ? void 0 : ctx.mode) === "edit") {
       return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_jsx_runtime22.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(DropZoneEdit, __spreadProps(__spreadValues({}, props), { ref })) });
-    }
-    return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_jsx_runtime22.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(DropZoneRender, __spreadProps(__spreadValues({}, props), { ref })) });
-  }
-);
-
-// lib/get-zone-id.ts
-init_react_import();
-var getZoneId = (zoneCompound) => {
-  if (!zoneCompound) {
-    return [];
-  }
-  if (zoneCompound && zoneCompound.indexOf(":") > -1) {
-    return zoneCompound.split(":");
-  }
-  return [rootDroppableId, zoneCompound];
-};
-
-// lib/dnd/NestedDroppablePlugin.ts
-init_react_import();
-var import_abstract9 = require("@dnd-kit/abstract");
-var import_state = require("@dnd-kit/state");
-
-// lib/throttle.ts
-init_react_import();
-function timeout2(callback, duration) {
-  const id = setTimeout(callback, duration);
-  return () => clearTimeout(id);
-}
-function throttle(func, limit) {
-  const time = () => performance.now();
-  let cancel;
-  let lastRan = 0;
-  return function(...args) {
-    const now = time();
-    const context = this;
-    if (now - lastRan >= limit) {
-      func.apply(context, args);
-      lastRan = now;
-    } else {
-      cancel == null ? void 0 : cancel();
-      cancel = timeout2(() => {
-        func.apply(context, args);
-        lastRan = time();
-      }, limit - (now - lastRan));
-    }
-  };
-}
-
-// lib/get-frame.ts
-init_react_import();
-var getFrame = () => {
-  if (typeof window === "undefined") return;
-  let frameEl = document.querySelector("#preview-frame");
-  if ((frameEl == null ? void 0 : frameEl.tagName) === "IFRAME") {
-    return frameEl.contentDocument || document;
-  }
-  return (frameEl == null ? void 0 : frameEl.ownerDocument) || document;
-};
-
-// lib/global-position.ts
-init_react_import();
-var GlobalPosition = class {
-  constructor(target, original) {
-    this.scaleFactor = 1;
-    this.frameEl = null;
-    this.frameRect = null;
-    var _a;
-    this.target = target;
-    this.original = original;
-    this.frameEl = document.querySelector("iframe");
-    if (this.frameEl) {
-      this.frameRect = this.frameEl.getBoundingClientRect();
-      this.scaleFactor = this.frameRect.width / (((_a = this.frameEl.contentWindow) == null ? void 0 : _a.innerWidth) || 1);
-    }
-  }
-  get x() {
-    return this.original.x;
-  }
-  get y() {
-    return this.original.y;
-  }
-  get global() {
-    if (document !== this.target.ownerDocument && this.frameRect) {
-      return {
-        x: this.x * this.scaleFactor + this.frameRect.left,
-        y: this.y * this.scaleFactor + this.frameRect.top
-      };
-    }
-    return this.original;
-  }
-  get frame() {
-    if (document === this.target.ownerDocument && this.frameRect) {
-      return {
-        x: (this.x - this.frameRect.left) / this.scaleFactor,
-        y: (this.y - this.frameRect.top) / this.scaleFactor
-      };
-    }
-    return this.original;
-  }
-};
-
-// lib/dnd/NestedDroppablePlugin.ts
-var depthSort = (candidates) => {
-  return candidates.sort((a, b) => {
-    const aData = a.data;
-    const bData = b.data;
-    if (aData.depth > bData.depth) {
-      return 1;
-    }
-    if (bData.depth > aData.depth) {
-      return -1;
-    }
-    return 0;
-  });
-};
-var getZoneId2 = (candidate) => {
-  let id = candidate == null ? void 0 : candidate.id;
-  if (!candidate) return null;
-  if (candidate.type === "component") {
-    const data = candidate.data;
-    if (data.containsActiveZone) {
-      id = null;
-    } else {
-      id = data.zone;
-    }
-  } else if (candidate.type === "void") {
-    return "void";
-  }
-  return id;
-};
-var getPointerCollisions = (position, manager) => {
-  const candidates = [];
-  let elements = position.target.ownerDocument.elementsFromPoint(
-    position.x,
-    position.y
-  );
-  const previewFrame = elements.find(
-    (el) => el.getAttribute("data-puck-preview")
-  );
-  const drawer = elements.find((el) => el.getAttribute("data-puck-drawer"));
-  if (drawer) {
-    elements = [drawer];
-  }
-  if (previewFrame) {
-    const frame = getFrame();
-    if (frame) {
-      elements = frame.elementsFromPoint(position.frame.x, position.frame.y);
-    }
-  }
-  if (elements) {
-    for (let i = 0; i < elements.length; i++) {
-      const element = elements[i];
-      const dropzoneId = element.getAttribute("data-puck-dropzone");
-      if (dropzoneId) {
-        const droppable = manager.registry.droppables.get(dropzoneId);
-        if (droppable) {
-          candidates.push(droppable);
-        }
-      }
-      const id = element.getAttribute("data-puck-dnd");
-      if (id) {
-        const droppable = manager.registry.droppables.get(id);
-        if (droppable) {
-          candidates.push(droppable);
-        }
-      }
-    }
-  }
-  return candidates;
-};
-var findDeepestCandidate = (position, manager) => {
-  var _a;
-  const candidates = getPointerCollisions(position, manager);
-  if (candidates.length > 0) {
-    const sortedCandidates = depthSort(candidates);
-    const draggable = manager.dragOperation.source;
-    const draggedCandidateIndex = sortedCandidates.findIndex(
-      (candidate) => candidate.id === (draggable == null ? void 0 : draggable.id)
-    );
-    const draggedCandidateId = draggable == null ? void 0 : draggable.id;
-    let filteredCandidates = [...sortedCandidates];
-    if (draggedCandidateId && draggedCandidateIndex > -1) {
-      filteredCandidates.splice(draggedCandidateIndex, 1);
-    }
-    filteredCandidates = filteredCandidates.filter((candidate) => {
-      const candidateData = candidate.data;
-      if (draggedCandidateId && draggedCandidateIndex > -1) {
-        if (candidateData.path.indexOf(draggedCandidateId) > -1) {
-          return false;
-        }
-      }
-      if (candidate.type === "dropzone") {
-        const candidateData2 = candidate.data;
-        if (!candidateData2.isDroppableTarget) {
-          return false;
-        }
-        if (candidateData2.areaId === draggedCandidateId) {
-          return false;
-        }
-      } else if (candidate.type === "component") {
-        const candidateData2 = candidate.data;
-        if (!candidateData2.inDroppableZone) {
-          return false;
-        }
-      }
-      return true;
-    });
-    filteredCandidates.reverse();
-    const zone = getZoneId2(filteredCandidates[0]);
-    const area = (_a = filteredCandidates[0]) == null ? void 0 : _a.data.areaId;
-    return { zone, area };
-  }
-  return {
-    zone: "default-zone",
-    area: null
-  };
-};
-var createNestedDroppablePlugin = ({ onChange }, id) => class NestedDroppablePlugin extends import_abstract9.Plugin {
-  constructor(manager, options) {
-    super(manager);
-    if (typeof window === "undefined") {
-      return;
-    }
-    const cleanupEffect = (0, import_state.effects)(() => {
-      const handleMove = (event) => {
-        const target = event.originalTarget || event.target;
-        const position = new GlobalPosition(target, {
-          x: event.clientX,
-          y: event.clientY
-        });
-        const elements = document.elementsFromPoint(
-          position.global.x,
-          position.global.y
-        );
-        const overEl = elements.some((el) => el.id === id);
-        if (overEl) {
-          onChange(findDeepestCandidate(position, manager), manager);
-        }
-      };
-      const handleMoveThrottled = throttle(handleMove, 50);
-      const handlePointerMove = (event) => {
-        handleMoveThrottled(event);
-      };
-      document.body.addEventListener("pointermove", handlePointerMove, {
-        capture: true
-        // dndkit's PointerSensor prevents propagation during drag
-      });
-      this.destroy = () => {
-        document.body.removeEventListener("pointermove", handlePointerMove, {
-          capture: true
-        });
-        cleanupEffect();
-      };
-    });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_jsx_runtime22.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(DropZoneRender, __spreadProps(__spreadValues({}, props), { ref })) });
   }
-};
-
-// lib/insert-component.ts
-init_react_import();
-
-// reducer/index.ts
-init_react_import();
-
-// reducer/data.ts
-init_react_import();
+);
 
-// lib/remove.ts
+// lib/get-zone-id.ts
 init_react_import();
-var remove = (list, index) => {
-  const result = Array.from(list);
-  result.splice(index, 1);
-  return result;
+var getZoneId = (zoneCompound) => {
+  if (!zoneCompound) {
+    return [];
+  }
+  if (zoneCompound && zoneCompound.indexOf(":") > -1) {
+    return zoneCompound.split(":");
+  }
+  return [rootDroppableId, zoneCompound];
 };
 
-// lib/reduce-related-zones.ts
+// lib/dnd/NestedDroppablePlugin.ts
 init_react_import();
-function reduceRelatedZones(item, data, fn) {
-  return __spreadProps(__spreadValues({}, data), {
-    zones: Object.keys(data.zones || {}).reduce(
-      (acc, key) => {
-        const [parentId] = getZoneId(key);
-        if (parentId === item.props.id) {
-          const zones = data.zones;
-          return fn(acc, key, zones[key]);
-        }
-        return __spreadProps(__spreadValues({}, acc), { [key]: data.zones[key] });
-      },
-      {}
-    )
-  });
-}
-var findRelatedByZoneId = (zoneId, data) => {
-  const [zoneParentId] = getZoneId(zoneId);
-  return (data.zones[zoneId] || []).reduce(
-    (acc, zoneItem) => {
-      const related = findRelatedByItem(zoneItem, data);
-      if (zoneItem.props.id === zoneParentId) {
-        return __spreadProps(__spreadValues(__spreadValues({}, acc), related), { [zoneId]: zoneItem });
-      }
-      return __spreadValues(__spreadValues({}, acc), related);
-    },
-    {}
-  );
-};
-var findRelatedByItem = (item, data) => {
-  return Object.keys(data.zones || {}).reduce(
-    (acc, zoneId) => {
-      const [zoneParentId] = getZoneId(zoneId);
-      if (item.props.id === zoneParentId) {
-        const related = findRelatedByZoneId(zoneId, data);
-        return __spreadProps(__spreadValues(__spreadValues({}, acc), related), {
-          [zoneId]: data.zones[zoneId]
-        });
-      }
-      return acc;
-    },
-    {}
-  );
-};
-var removeRelatedZones = (item, data) => {
-  const newData = __spreadValues({}, data);
-  const related = findRelatedByItem(item, data);
-  Object.keys(related).forEach((key) => {
-    delete newData.zones[key];
-  });
-  return newData;
-};
-function duplicateRelatedZones(item, data, newId) {
-  return reduceRelatedZones(item, data, (acc, key, zone) => {
-    const dupedZone = zone.map((zoneItem) => __spreadProps(__spreadValues({}, zoneItem), {
-      props: __spreadProps(__spreadValues({}, zoneItem.props), { id: generateId(zoneItem.type) })
-    }));
-    const dupeOfDupes = dupedZone.reduce(
-      (dupeOfDupes2, item2, index) => __spreadValues(__spreadValues({}, dupeOfDupes2), duplicateRelatedZones(zone[index], data, item2.props.id).zones),
-      acc
-    );
-    const [_, zoneId] = getZoneId(key);
-    return __spreadProps(__spreadValues({}, dupeOfDupes), {
-      [key]: zone,
-      [`${newId}:${zoneId}`]: dupedZone
-    });
-  });
-}
+var import_abstract10 = require("@dnd-kit/abstract");
+var import_state2 = require("@dnd-kit/state");
 
-// reducer/data.ts
-var zoneCache = {};
-var addToZoneCache = (key, data) => {
-  zoneCache[key] = data;
-};
-var replaceAction = (data, action) => {
-  if (action.destinationZone === rootDroppableId) {
-    return __spreadProps(__spreadValues({}, data), {
-      content: replace(data.content, action.destinationIndex, action.data)
-    });
-  }
-  const newData = setupZone(data, action.destinationZone);
-  return __spreadProps(__spreadValues({}, newData), {
-    zones: __spreadProps(__spreadValues({}, newData.zones), {
-      [action.destinationZone]: replace(
-        newData.zones[action.destinationZone],
-        action.destinationIndex,
-        action.data
-      )
-    })
-  });
-};
-function insertAction(data, action, config) {
-  const emptyComponentData = {
-    type: action.componentType,
-    props: __spreadProps(__spreadValues({}, config.components[action.componentType].defaultProps || {}), {
-      id: action.id || generateId(action.componentType)
-    })
-  };
-  if (action.destinationZone === rootDroppableId) {
-    return __spreadProps(__spreadValues({}, data), {
-      content: insert(
-        data.content,
-        action.destinationIndex,
-        emptyComponentData
-      )
-    });
-  }
-  const newData = setupZone(data, action.destinationZone);
-  return __spreadProps(__spreadValues({}, data), {
-    zones: __spreadProps(__spreadValues({}, newData.zones), {
-      [action.destinationZone]: insert(
-        newData.zones[action.destinationZone],
-        action.destinationIndex,
-        emptyComponentData
-      )
-    })
-  });
+// lib/throttle.ts
+init_react_import();
+function timeout2(callback, duration) {
+  const id = setTimeout(callback, duration);
+  return () => clearTimeout(id);
 }
-var reorderAction = (data, action) => {
-  if (action.destinationZone === rootDroppableId) {
-    return __spreadProps(__spreadValues({}, data), {
-      content: reorder(
-        data.content,
-        action.sourceIndex,
-        action.destinationIndex
-      )
-    });
-  }
-  const newData = setupZone(data, action.destinationZone);
-  return __spreadProps(__spreadValues({}, data), {
-    zones: __spreadProps(__spreadValues({}, newData.zones), {
-      [action.destinationZone]: reorder(
-        newData.zones[action.destinationZone],
-        action.sourceIndex,
-        action.destinationIndex
-      )
-    })
-  });
-};
-function reduceData(data, action, config) {
-  if (action.type === "insert") {
-    return insertAction(data, action, config);
-  }
-  if (action.type === "duplicate") {
-    const item = getItem(
-      { index: action.sourceIndex, zone: action.sourceZone },
-      data
-    );
-    const newItem = __spreadProps(__spreadValues({}, item), {
-      props: __spreadProps(__spreadValues({}, item.props), {
-        id: generateId(item.type)
-      })
-    });
-    const dataWithRelatedDuplicated = duplicateRelatedZones(
-      item,
-      data,
-      newItem.props.id
-    );
-    if (action.sourceZone === rootDroppableId) {
-      return __spreadProps(__spreadValues({}, dataWithRelatedDuplicated), {
-        content: insert(data.content, action.sourceIndex + 1, newItem)
-      });
-    }
-    return __spreadProps(__spreadValues({}, dataWithRelatedDuplicated), {
-      zones: __spreadProps(__spreadValues({}, dataWithRelatedDuplicated.zones), {
-        [action.sourceZone]: insert(
-          dataWithRelatedDuplicated.zones[action.sourceZone],
-          action.sourceIndex + 1,
-          newItem
-        )
-      })
-    });
-  }
-  if (action.type === "reorder") {
-    return reorderAction(data, action);
-  }
-  if (action.type === "move") {
-    if (action.sourceZone === action.destinationZone && action.sourceIndex === action.destinationIndex) {
-      return data;
-    }
-    const newData = setupZone(
-      setupZone(data, action.sourceZone),
-      action.destinationZone
-    );
-    const item = getItem(
-      { zone: action.sourceZone, index: action.sourceIndex },
-      newData
-    );
-    if (action.sourceZone === action.destinationZone) {
-      return reorderAction(data, __spreadProps(__spreadValues({}, action), { type: "reorder" }));
-    }
-    if (action.sourceZone === rootDroppableId) {
-      return __spreadProps(__spreadValues({}, newData), {
-        content: remove(newData.content, action.sourceIndex),
-        zones: __spreadProps(__spreadValues({}, newData.zones), {
-          [action.destinationZone]: insert(
-            newData.zones[action.destinationZone],
-            action.destinationIndex,
-            item
-          )
-        })
-      });
-    }
-    if (action.destinationZone === rootDroppableId) {
-      return __spreadProps(__spreadValues({}, newData), {
-        content: insert(newData.content, action.destinationIndex, item),
-        zones: __spreadProps(__spreadValues({}, newData.zones), {
-          [action.sourceZone]: remove(
-            newData.zones[action.sourceZone],
-            action.sourceIndex
-          )
-        })
-      });
+function throttle(func, limit) {
+  const time = () => performance.now();
+  let cancel;
+  let lastRan = 0;
+  return function(...args) {
+    const now = time();
+    const context = this;
+    if (now - lastRan >= limit) {
+      func.apply(context, args);
+      lastRan = now;
+    } else {
+      cancel == null ? void 0 : cancel();
+      cancel = timeout2(() => {
+        func.apply(context, args);
+        lastRan = time();
+      }, limit - (now - lastRan));
     }
-    return __spreadProps(__spreadValues({}, newData), {
-      zones: __spreadProps(__spreadValues({}, newData.zones), {
-        [action.sourceZone]: remove(
-          newData.zones[action.sourceZone],
-          action.sourceIndex
-        ),
-        [action.destinationZone]: insert(
-          newData.zones[action.destinationZone],
-          action.destinationIndex,
-          item
-        )
-      })
-    });
-  }
-  if (action.type === "replace") {
-    return replaceAction(data, action);
+  };
+}
+
+// lib/get-frame.ts
+init_react_import();
+var getFrame = () => {
+  if (typeof window === "undefined") return;
+  let frameEl = document.querySelector("#preview-frame");
+  if ((frameEl == null ? void 0 : frameEl.tagName) === "IFRAME") {
+    return frameEl.contentDocument || document;
   }
-  if (action.type === "remove") {
-    const item = getItem({ index: action.index, zone: action.zone }, data);
-    const dataWithRelatedRemoved = setupZone(
-      removeRelatedZones(item, data),
-      action.zone
-    );
-    if (action.zone === rootDroppableId) {
-      return __spreadProps(__spreadValues({}, dataWithRelatedRemoved), {
-        content: remove(data.content, action.index)
-      });
+  return (frameEl == null ? void 0 : frameEl.ownerDocument) || document;
+};
+
+// lib/global-position.ts
+init_react_import();
+var GlobalPosition = class {
+  constructor(target, original) {
+    this.scaleFactor = 1;
+    this.frameEl = null;
+    this.frameRect = null;
+    var _a;
+    this.target = target;
+    this.original = original;
+    this.frameEl = document.querySelector("iframe");
+    if (this.frameEl) {
+      this.frameRect = this.frameEl.getBoundingClientRect();
+      this.scaleFactor = this.frameRect.width / (((_a = this.frameEl.contentWindow) == null ? void 0 : _a.innerWidth) || 1);
     }
-    return __spreadProps(__spreadValues({}, dataWithRelatedRemoved), {
-      zones: __spreadProps(__spreadValues({}, dataWithRelatedRemoved.zones), {
-        [action.zone]: remove(
-          dataWithRelatedRemoved.zones[action.zone],
-          action.index
-        )
-      })
-    });
   }
-  if (action.type === "registerZone") {
-    if (zoneCache[action.zone]) {
-      return __spreadProps(__spreadValues({}, data), {
-        zones: __spreadProps(__spreadValues({}, data.zones), {
-          [action.zone]: zoneCache[action.zone]
-        })
-      });
-    }
-    return setupZone(data, action.zone);
+  get x() {
+    return this.original.x;
   }
-  if (action.type === "unregisterZone") {
-    const _zones = __spreadValues({}, data.zones || {});
-    if (_zones[action.zone]) {
-      zoneCache[action.zone] = _zones[action.zone];
-      delete _zones[action.zone];
+  get y() {
+    return this.original.y;
+  }
+  get global() {
+    if (document !== this.target.ownerDocument && this.frameRect) {
+      return {
+        x: this.x * this.scaleFactor + this.frameRect.left,
+        y: this.y * this.scaleFactor + this.frameRect.top
+      };
     }
-    return __spreadProps(__spreadValues({}, data), { zones: _zones });
+    return this.original;
   }
-  if (action.type === "setData") {
-    if (typeof action.data === "object") {
-      return __spreadValues(__spreadValues({}, data), action.data);
+  get frame() {
+    if (document === this.target.ownerDocument && this.frameRect) {
+      return {
+        x: (this.x - this.frameRect.left) / this.scaleFactor,
+        y: (this.y - this.frameRect.top) / this.scaleFactor
+      };
     }
-    return __spreadValues(__spreadValues({}, data), action.data(data));
+    return this.original;
   }
-  return data;
-}
+};
 
-// reducer/state.ts
+// lib/bubble-pointer-event.ts
 init_react_import();
-var reduceUi = (ui, action) => {
-  if (action.type === "setUi") {
-    if (typeof action.ui === "object") {
-      return __spreadValues(__spreadValues({}, ui), action.ui);
+var BaseEvent = typeof PointerEvent !== "undefined" ? PointerEvent : Event;
+var BubbledPointerEvent = class extends BaseEvent {
+  constructor(type, data) {
+    super(type, data);
+    this._originalTarget = null;
+    this.originalTarget = data.originalTarget;
+  }
+  // Necessary for Firefox
+  set originalTarget(target) {
+    this._originalTarget = target;
+  }
+  // Necessary for Firefox
+  get originalTarget() {
+    return this._originalTarget;
+  }
+};
+
+// lib/dnd/NestedDroppablePlugin.ts
+var depthSort = (candidates) => {
+  return candidates.sort((a, b) => {
+    const aData = a.data;
+    const bData = b.data;
+    if (aData.depth > bData.depth) {
+      return 1;
     }
-    return __spreadValues(__spreadValues({}, ui), action.ui(ui));
+    if (bData.depth > aData.depth) {
+      return -1;
+    }
+    return 0;
+  });
+};
+var getZoneId2 = (candidate) => {
+  let id = candidate == null ? void 0 : candidate.id;
+  if (!candidate) return null;
+  if (candidate.type === "component") {
+    const data = candidate.data;
+    if (data.containsActiveZone) {
+      id = null;
+    } else {
+      id = data.zone;
+    }
+  } else if (candidate.type === "void") {
+    return "void";
   }
-  if (action.type === "duplicate") {
-    return __spreadProps(__spreadValues({}, ui), {
-      itemSelector: { index: action.sourceIndex + 1, zone: action.sourceZone }
+  return id;
+};
+var getPointerCollisions = (position, manager) => {
+  const candidates = [];
+  let elements = position.target.ownerDocument.elementsFromPoint(
+    position.x,
+    position.y
+  );
+  const previewFrame = elements.find(
+    (el) => el.getAttribute("data-puck-preview")
+  );
+  const drawer = elements.find((el) => el.getAttribute("data-puck-drawer"));
+  if (drawer) {
+    elements = [drawer];
+  }
+  if (previewFrame) {
+    const frame = getFrame();
+    if (frame) {
+      elements = frame.elementsFromPoint(position.frame.x, position.frame.y);
+    }
+  }
+  if (elements) {
+    for (let i = 0; i < elements.length; i++) {
+      const element = elements[i];
+      const dropzoneId = element.getAttribute("data-puck-dropzone");
+      if (dropzoneId) {
+        const droppable = manager.registry.droppables.get(dropzoneId);
+        if (droppable) {
+          candidates.push(droppable);
+        }
+      }
+      const id = element.getAttribute("data-puck-dnd");
+      if (id) {
+        const droppable = manager.registry.droppables.get(id);
+        if (droppable) {
+          candidates.push(droppable);
+        }
+      }
+    }
+  }
+  return candidates;
+};
+var findDeepestCandidate = (position, manager) => {
+  var _a;
+  const candidates = getPointerCollisions(position, manager);
+  if (candidates.length > 0) {
+    const sortedCandidates = depthSort(candidates);
+    const draggable = manager.dragOperation.source;
+    const draggedCandidateIndex = sortedCandidates.findIndex(
+      (candidate) => candidate.id === (draggable == null ? void 0 : draggable.id)
+    );
+    const draggedCandidateId = draggable == null ? void 0 : draggable.id;
+    let filteredCandidates = [...sortedCandidates];
+    if (draggedCandidateId && draggedCandidateIndex > -1) {
+      filteredCandidates.splice(draggedCandidateIndex, 1);
+    }
+    filteredCandidates = filteredCandidates.filter((candidate) => {
+      const candidateData = candidate.data;
+      if (draggedCandidateId && draggedCandidateIndex > -1) {
+        if (candidateData.path.indexOf(draggedCandidateId) > -1) {
+          return false;
+        }
+      }
+      if (candidate.type === "dropzone") {
+        const candidateData2 = candidate.data;
+        if (!candidateData2.isDroppableTarget) {
+          return false;
+        }
+        if (candidateData2.areaId === draggedCandidateId) {
+          return false;
+        }
+      } else if (candidate.type === "component") {
+        const candidateData2 = candidate.data;
+        if (!candidateData2.inDroppableZone) {
+          return false;
+        }
+      }
+      return true;
     });
+    filteredCandidates.reverse();
+    const zone = getZoneId2(filteredCandidates[0]);
+    const area = (_a = filteredCandidates[0]) == null ? void 0 : _a.data.areaId;
+    return { zone, area };
   }
-  if (action.type === "remove") {
-    return __spreadProps(__spreadValues({}, ui), {
-      itemSelector: null
+  return {
+    zone: "default-zone",
+    area: null
+  };
+};
+var createNestedDroppablePlugin = ({ onChange }, id) => class NestedDroppablePlugin extends import_abstract10.Plugin {
+  constructor(manager, options) {
+    super(manager);
+    if (typeof window === "undefined") {
+      return;
+    }
+    const cleanupEffect = (0, import_state2.effects)(() => {
+      const handleMove = (event) => {
+        const target = event instanceof BubbledPointerEvent ? event.originalTarget || event.target : event.target;
+        const position = new GlobalPosition(target, {
+          x: event.clientX,
+          y: event.clientY
+        });
+        const elements = document.elementsFromPoint(
+          position.global.x,
+          position.global.y
+        );
+        const overEl = elements.some((el) => el.id === id);
+        if (overEl) {
+          onChange(findDeepestCandidate(position, manager), manager);
+        }
+      };
+      const handleMoveThrottled = throttle(handleMove, 50);
+      const handlePointerMove = (event) => {
+        handleMoveThrottled(event);
+      };
+      document.body.addEventListener("pointermove", handlePointerMove, {
+        capture: true
+        // dndkit's PointerSensor prevents propagation during drag
+      });
+      this.destroy = () => {
+        document.body.removeEventListener("pointermove", handlePointerMove, {
+          capture: true
+        });
+        cleanupEffect();
+      };
     });
   }
-  return ui;
 };
 
-// reducer/actions.tsx
+// lib/insert-component.ts
 init_react_import();
 
 // reducer/index.ts
-function storeInterceptor(reducer, record, onAction) {
-  return (state, action) => {
-    const newAppState = reducer(state, action);
-    const isValidType = ![
-      "registerZone",
-      "unregisterZone",
-      "setData",
-      "setUi",
-      "set"
-    ].includes(action.type);
-    if (typeof action.recordHistory !== "undefined" ? action.recordHistory : isValidType) {
-      if (record) record(newAppState);
-    }
-    onAction == null ? void 0 : onAction(action, newAppState, state);
-    return newAppState;
-  };
+init_react_import();
+
+// reducer/data.ts
+init_react_import();
+
+// lib/remove.ts
+init_react_import();
+var remove = (list, index) => {
+  const result = Array.from(list);
+  result.splice(index, 1);
+  return result;
+};
+
+// lib/reduce-related-zones.ts
+init_react_import();
+function reduceRelatedZones(item, data, fn) {
+  return __spreadProps(__spreadValues({}, data), {
+    zones: Object.keys(data.zones || {}).reduce(
+      (acc, key) => {
+        const [parentId] = getZoneId(key);
+        if (parentId === item.props.id) {
+          const zones = data.zones;
+          return fn(acc, key, zones[key]);
+        }
+        return __spreadProps(__spreadValues({}, acc), { [key]: data.zones[key] });
+      },
+      {}
+    )
+  });
 }
-var setAction = (state, action) => {
-  if (typeof action.state === "object") {
-    return __spreadValues(__spreadValues({}, state), action.state);
-  }
-  return __spreadValues(__spreadValues({}, state), action.state(state));
+var findRelatedByZoneId = (zoneId, data) => {
+  const [zoneParentId] = getZoneId(zoneId);
+  return (data.zones[zoneId] || []).reduce(
+    (acc, zoneItem) => {
+      const related = findRelatedByItem(zoneItem, data);
+      if (zoneItem.props.id === zoneParentId) {
+        return __spreadProps(__spreadValues(__spreadValues({}, acc), related), { [zoneId]: zoneItem });
+      }
+      return __spreadValues(__spreadValues({}, acc), related);
+    },
+    {}
+  );
 };
-function createReducer({
-  config,
-  record,
-  onAction
-}) {
-  return storeInterceptor(
-    (state, action) => {
-      const data = reduceData(state.data, action, config);
-      const ui = reduceUi(state.ui, action);
-      if (action.type === "set") {
-        return setAction(state, action);
+var findRelatedByItem = (item, data) => {
+  return Object.keys(data.zones || {}).reduce(
+    (acc, zoneId) => {
+      const [zoneParentId] = getZoneId(zoneId);
+      if (item.props.id === zoneParentId) {
+        const related = findRelatedByZoneId(zoneId, data);
+        return __spreadProps(__spreadValues(__spreadValues({}, acc), related), {
+          [zoneId]: data.zones[zoneId]
+        });
       }
-      return { data, ui };
+      return acc;
     },
-    record,
-    onAction
+    {}
   );
+};
+var removeRelatedZones = (item, data) => {
+  const newData = __spreadValues({}, data);
+  const related = findRelatedByItem(item, data);
+  Object.keys(related).forEach((key) => {
+    delete newData.zones[key];
+  });
+  return newData;
+};
+function duplicateRelatedZones(item, data, newId) {
+  return reduceRelatedZones(item, data, (acc, key, zone) => {
+    const dupedZone = zone.map((zoneItem) => __spreadProps(__spreadValues({}, zoneItem), {
+      props: __spreadProps(__spreadValues({}, zoneItem.props), { id: generateId(zoneItem.type) })
+    }));
+    const dupeOfDupes = dupedZone.reduce(
+      (dupeOfDupes2, item2, index) => __spreadValues(__spreadValues({}, dupeOfDupes2), duplicateRelatedZones(zone[index], data, item2.props.id).zones),
+      acc
+    );
+    const [_, zoneId] = getZoneId(key);
+    return __spreadProps(__spreadValues({}, dupeOfDupes), {
+      [key]: zone,
+      [`${newId}:${zoneId}`]: dupedZone
+    });
+  });
 }
 
-// lib/insert-component.ts
-var insertComponent = (componentType, zone, index, {
-  config,
-  dispatch,
-  resolveData,
-  state
-}) => {
-  const id = generateId(componentType);
-  const insertActionData = {
-    type: "insert",
-    componentType,
-    destinationIndex: index,
-    destinationZone: zone,
-    id
-  };
-  const insertedData = insertAction(state.data, insertActionData, config);
-  dispatch(__spreadProps(__spreadValues({}, insertActionData), {
-    // Dispatch insert rather set, as user's may rely on this via onAction
-    // We must always record history here so the insert is added to user history
-    // If the user has defined a resolveData method, they will end up with 2 history
-    // entries on insert - one for the initial insert, and one when the data resolves
-    recordHistory: true
-  }));
-  const itemSelector = {
-    index,
-    zone
-  };
-  dispatch({ type: "setUi", ui: { itemSelector } });
-  resolveData({
-    data: insertedData,
-    ui: __spreadProps(__spreadValues({}, state.ui), { itemSelector })
+// reducer/data.ts
+var zoneCache = {};
+var addToZoneCache = (key, data) => {
+  zoneCache[key] = data;
+};
+var replaceAction = (data, action) => {
+  if (action.destinationZone === rootDroppableId) {
+    return __spreadProps(__spreadValues({}, data), {
+      content: replace(data.content, action.destinationIndex, action.data)
+    });
+  }
+  const newData = setupZone(data, action.destinationZone);
+  return __spreadProps(__spreadValues({}, newData), {
+    zones: __spreadProps(__spreadValues({}, newData.zones), {
+      [action.destinationZone]: replace(
+        newData.zones[action.destinationZone],
+        action.destinationIndex,
+        action.data
+      )
+    })
   });
 };
-
-// components/DragDropContext/index.tsx
-var import_use_debounce2 = require("use-debounce");
-var import_utilities2 = require("@dnd-kit/dom/utilities");
-
-// lib/dnd/PointerSensor.ts
-init_react_import();
-var import_state3 = require("@dnd-kit/state");
-var import_abstract10 = require("@dnd-kit/abstract");
-var import_geometry8 = require("@dnd-kit/geometry");
-var import_utilities = require("@dnd-kit/dom/utilities");
-var _clearTimeout;
-var _PointerSensor = class _PointerSensor extends import_abstract10.Sensor {
-  constructor(manager, options) {
-    super(manager);
-    this.manager = manager;
-    this.options = options;
-    this.listeners = new import_utilities.Listeners();
-    this.cleanup = /* @__PURE__ */ new Set();
-    this.source = void 0;
-    __privateAdd(this, _clearTimeout);
-    this.handleCancel = this.handleCancel.bind(this);
-    this.handlePointerUp = this.handlePointerUp.bind(this);
-    this.handleKeyDown = this.handleKeyDown.bind(this);
-    (0, import_state3.effect)(() => {
-      const unbindGlobal = this.bindGlobal(options != null ? options : {});
-      return () => {
-        unbindGlobal();
-      };
+function insertAction(data, action, config) {
+  const emptyComponentData = {
+    type: action.componentType,
+    props: __spreadProps(__spreadValues({}, config.components[action.componentType].defaultProps || {}), {
+      id: action.id || generateId(action.componentType)
+    })
+  };
+  if (action.destinationZone === rootDroppableId) {
+    return __spreadProps(__spreadValues({}, data), {
+      content: insert(
+        data.content,
+        action.destinationIndex,
+        emptyComponentData
+      )
     });
   }
-  bind(source, options = this.options) {
-    const unbind = (0, import_state3.effect)(() => {
-      var _a;
-      const target = (_a = source.handle) != null ? _a : source.element;
-      const listener = (event) => {
-        if ((0, import_utilities.isPointerEvent)(event)) {
-          this.handlePointerDown(event, source, options);
-        }
-      };
-      if (target) {
-        patchWindow(target.ownerDocument.defaultView);
-        target.addEventListener("pointerdown", listener);
-        return () => {
-          target.removeEventListener("pointerdown", listener);
-        };
-      }
+  const newData = setupZone(data, action.destinationZone);
+  return __spreadProps(__spreadValues({}, data), {
+    zones: __spreadProps(__spreadValues({}, newData.zones), {
+      [action.destinationZone]: insert(
+        newData.zones[action.destinationZone],
+        action.destinationIndex,
+        emptyComponentData
+      )
+    })
+  });
+}
+var reorderAction = (data, action) => {
+  if (action.destinationZone === rootDroppableId) {
+    return __spreadProps(__spreadValues({}, data), {
+      content: reorder(
+        data.content,
+        action.sourceIndex,
+        action.destinationIndex
+      )
     });
-    return unbind;
   }
-  bindGlobal(options) {
-    const documents = /* @__PURE__ */ new Set();
-    for (const draggable of this.manager.registry.draggables.value) {
-      if (draggable.element) {
-        documents.add((0, import_utilities.getDocument)(draggable.element));
-      }
-    }
-    for (const droppable of this.manager.registry.droppables.value) {
-      if (droppable.element) {
-        documents.add((0, import_utilities.getDocument)(droppable.element));
-      }
-    }
-    const unbindFns = Array.from(documents).map(
-      (doc) => this.listeners.bind(doc, [
-        {
-          type: "pointermove",
-          listener: (event) => this.handlePointerMove(event, doc, options)
-        },
-        {
-          type: "pointerup",
-          listener: this.handlePointerUp,
-          options: {
-            capture: true
-          }
-        },
-        {
-          // Cancel activation if there is a competing Drag and Drop interaction
-          type: "dragstart",
-          listener: this.handleDragStart
-        }
-      ])
+  const newData = setupZone(data, action.destinationZone);
+  return __spreadProps(__spreadValues({}, data), {
+    zones: __spreadProps(__spreadValues({}, newData.zones), {
+      [action.destinationZone]: reorder(
+        newData.zones[action.destinationZone],
+        action.sourceIndex,
+        action.destinationIndex
+      )
+    })
+  });
+};
+function reduceData(data, action, config) {
+  if (action.type === "insert") {
+    return insertAction(data, action, config);
+  }
+  if (action.type === "duplicate") {
+    const item = getItem(
+      { index: action.sourceIndex, zone: action.sourceZone },
+      data
     );
-    return () => {
-      unbindFns.forEach((unbind) => unbind());
-    };
-  }
-  handlePointerDown(event, source, options = {}) {
-    if (this.disabled || !event.isPrimary || event.button !== 0 || !(0, import_utilities.isElement)(event.target) || source.disabled) {
-      return;
-    }
-    const offset = (0, import_utilities.getFrameTransform)(source.element);
-    this.initialCoordinates = {
-      x: event.clientX * offset.scaleX + offset.x,
-      y: event.clientY * offset.scaleY + offset.y
-    };
-    this.source = source;
-    const { activationConstraints } = options;
-    const constraints = typeof activationConstraints === "function" ? activationConstraints(event, source) : activationConstraints;
-    event.stopImmediatePropagation();
-    if (!(constraints == null ? void 0 : constraints.delay) && !(constraints == null ? void 0 : constraints.distance)) {
-      this.handleStart(source, event);
-    } else {
-      const { delay } = constraints;
-      if (delay) {
-        const timeout3 = setTimeout(
-          () => this.handleStart(source, event),
-          delay.value
-        );
-        __privateSet(this, _clearTimeout, () => {
-          clearTimeout(timeout3);
-          __privateSet(this, _clearTimeout, void 0);
-        });
-      }
+    const newItem = __spreadProps(__spreadValues({}, item), {
+      props: __spreadProps(__spreadValues({}, item.props), {
+        id: generateId(item.type)
+      })
+    });
+    const dataWithRelatedDuplicated = duplicateRelatedZones(
+      item,
+      data,
+      newItem.props.id
+    );
+    if (action.sourceZone === rootDroppableId) {
+      return __spreadProps(__spreadValues({}, dataWithRelatedDuplicated), {
+        content: insert(data.content, action.sourceIndex + 1, newItem)
+      });
     }
-    const cleanup = () => {
-      var _a;
-      (_a = __privateGet(this, _clearTimeout)) == null ? void 0 : _a.call(this);
-      this.initialCoordinates = void 0;
-      this.source = void 0;
-    };
-    this.cleanup.add(cleanup);
+    return __spreadProps(__spreadValues({}, dataWithRelatedDuplicated), {
+      zones: __spreadProps(__spreadValues({}, dataWithRelatedDuplicated.zones), {
+        [action.sourceZone]: insert(
+          dataWithRelatedDuplicated.zones[action.sourceZone],
+          action.sourceIndex + 1,
+          newItem
+        )
+      })
+    });
   }
-  handlePointerMove(event, doc, options) {
-    if (!this.source) {
-      return;
-    }
-    const ownerDocument = this.source.element && (0, import_utilities.getDocument)(this.source.element);
-    if (doc !== ownerDocument) {
-      return;
-    }
-    const coordinates = {
-      x: event.clientX,
-      y: event.clientY
-    };
-    const offset = (0, import_utilities.getFrameTransform)(this.source.element);
-    coordinates.x = coordinates.x * offset.scaleX + offset.x;
-    coordinates.y = coordinates.y * offset.scaleY + offset.y;
-    if (this.manager.dragOperation.status.dragging) {
-      event.preventDefault();
-      event.stopPropagation();
-      this.manager.actions.move({ to: coordinates });
-      return;
-    }
-    if (!this.initialCoordinates) {
-      return;
-    }
-    const delta = {
-      x: coordinates.x - this.initialCoordinates.x,
-      y: coordinates.y - this.initialCoordinates.y
-    };
-    const { activationConstraints } = options;
-    const constraints = typeof activationConstraints === "function" ? activationConstraints(event, this.source) : activationConstraints;
-    const { distance, delay } = constraints != null ? constraints : {};
-    if (distance) {
-      if (distance.tolerance != null && (0, import_geometry8.exceedsDistance)(delta, distance.tolerance)) {
-        return this.handleCancel();
-      }
-      if ((0, import_geometry8.exceedsDistance)(delta, distance.value)) {
-        return this.handleStart(this.source, event);
-      }
-    }
-    if (delay) {
-      if ((0, import_geometry8.exceedsDistance)(delta, delay.tolerance)) {
-        return this.handleCancel();
-      }
-    }
+  if (action.type === "reorder") {
+    return reorderAction(data, action);
   }
-  handlePointerUp(event) {
-    if (!this.source) {
-      return;
-    }
-    event.preventDefault();
-    event.stopPropagation();
-    const { status } = this.manager.dragOperation;
-    if (!status.idle) {
-      const canceled = !status.initialized;
-      this.manager.actions.stop({ canceled });
+  if (action.type === "move") {
+    if (action.sourceZone === action.destinationZone && action.sourceIndex === action.destinationIndex) {
+      return data;
     }
-    this.cleanup.forEach((cleanup) => cleanup());
-    this.cleanup.clear();
-  }
-  handleKeyDown(event) {
-    if (event.key === "Escape") {
-      event.preventDefault();
-      this.handleCancel();
+    const newData = setupZone(
+      setupZone(data, action.sourceZone),
+      action.destinationZone
+    );
+    const item = getItem(
+      { zone: action.sourceZone, index: action.sourceIndex },
+      newData
+    );
+    if (action.sourceZone === action.destinationZone) {
+      return reorderAction(data, __spreadProps(__spreadValues({}, action), { type: "reorder" }));
     }
-  }
-  handleStart(source, event) {
-    var _a;
-    const { manager, initialCoordinates } = this;
-    (_a = __privateGet(this, _clearTimeout)) == null ? void 0 : _a.call(this);
-    if (!initialCoordinates || manager.dragOperation.status.initialized) {
-      return;
+    if (action.sourceZone === rootDroppableId) {
+      return __spreadProps(__spreadValues({}, newData), {
+        content: remove(newData.content, action.sourceIndex),
+        zones: __spreadProps(__spreadValues({}, newData.zones), {
+          [action.destinationZone]: insert(
+            newData.zones[action.destinationZone],
+            action.destinationIndex,
+            item
+          )
+        })
+      });
     }
-    if (event.defaultPrevented) {
-      return;
+    if (action.destinationZone === rootDroppableId) {
+      return __spreadProps(__spreadValues({}, newData), {
+        content: insert(newData.content, action.destinationIndex, item),
+        zones: __spreadProps(__spreadValues({}, newData.zones), {
+          [action.sourceZone]: remove(
+            newData.zones[action.sourceZone],
+            action.sourceIndex
+          )
+        })
+      });
     }
-    event.preventDefault();
-    (0, import_state3.batch)(() => {
-      manager.actions.setDragSource(source.id);
-      manager.actions.start({ coordinates: initialCoordinates, event });
+    return __spreadProps(__spreadValues({}, newData), {
+      zones: __spreadProps(__spreadValues({}, newData.zones), {
+        [action.sourceZone]: remove(
+          newData.zones[action.sourceZone],
+          action.sourceIndex
+        ),
+        [action.destinationZone]: insert(
+          newData.zones[action.destinationZone],
+          action.destinationIndex,
+          item
+        )
+      })
+    });
+  }
+  if (action.type === "replace") {
+    return replaceAction(data, action);
+  }
+  if (action.type === "remove") {
+    const item = getItem({ index: action.index, zone: action.zone }, data);
+    const dataWithRelatedRemoved = setupZone(
+      removeRelatedZones(item, data),
+      action.zone
+    );
+    if (action.zone === rootDroppableId) {
+      return __spreadProps(__spreadValues({}, dataWithRelatedRemoved), {
+        content: remove(data.content, action.index)
+      });
+    }
+    return __spreadProps(__spreadValues({}, dataWithRelatedRemoved), {
+      zones: __spreadProps(__spreadValues({}, dataWithRelatedRemoved.zones), {
+        [action.zone]: remove(
+          dataWithRelatedRemoved.zones[action.zone],
+          action.index
+        )
+      })
     });
-    const ownerDocument = (0, import_utilities.getDocument)(event.target);
-    const unbind = this.listeners.bind(ownerDocument, [
-      {
-        // Prevent scrolling on touch devices
-        type: "touchmove",
-        listener: preventDefault,
-        options: {
-          passive: false
-        }
-      },
-      {
-        // Prevent click events
-        type: "click",
-        listener: preventDefault
-      },
-      {
-        type: "keydown",
-        listener: this.handleKeyDown
-      }
-    ]);
-    ownerDocument.body.setPointerCapture(event.pointerId);
-    this.cleanup.add(unbind);
   }
-  handleDragStart(event) {
-    const { target } = event;
-    if (!(0, import_utilities.isElement)(target)) {
-      return;
+  if (action.type === "registerZone") {
+    if (zoneCache[action.zone]) {
+      return __spreadProps(__spreadValues({}, data), {
+        zones: __spreadProps(__spreadValues({}, data.zones), {
+          [action.zone]: zoneCache[action.zone]
+        })
+      });
     }
-    const isNativeDraggable = (0, import_utilities.isHTMLElement)(target) && target.draggable && target.getAttribute("draggable") === "true";
-    if (isNativeDraggable) {
-      this.handleCancel();
-    } else {
-      preventDefault(event);
+    return setupZone(data, action.zone);
+  }
+  if (action.type === "unregisterZone") {
+    const _zones = __spreadValues({}, data.zones || {});
+    if (_zones[action.zone]) {
+      zoneCache[action.zone] = _zones[action.zone];
+      delete _zones[action.zone];
     }
+    return __spreadProps(__spreadValues({}, data), { zones: _zones });
   }
-  handleCancel() {
-    const { dragOperation } = this.manager;
-    if (dragOperation.status.initialized) {
-      this.manager.actions.stop({ canceled: true });
+  if (action.type === "setData") {
+    if (typeof action.data === "object") {
+      return __spreadValues(__spreadValues({}, data), action.data);
     }
-    this.cleanup.forEach((cleanup) => cleanup());
-    this.cleanup.clear();
+    return __spreadValues(__spreadValues({}, data), action.data(data));
   }
-  destroy() {
-    this.listeners.clear();
+  return data;
+}
+
+// reducer/state.ts
+init_react_import();
+var reduceUi = (ui, action) => {
+  if (action.type === "setUi") {
+    if (typeof action.ui === "object") {
+      return __spreadValues(__spreadValues({}, ui), action.ui);
+    }
+    return __spreadValues(__spreadValues({}, ui), action.ui(ui));
+  }
+  if (action.type === "duplicate") {
+    return __spreadProps(__spreadValues({}, ui), {
+      itemSelector: { index: action.sourceIndex + 1, zone: action.sourceZone }
+    });
+  }
+  if (action.type === "remove") {
+    return __spreadProps(__spreadValues({}, ui), {
+      itemSelector: null
+    });
   }
+  return ui;
 };
-_clearTimeout = new WeakMap();
-_PointerSensor.configure = (0, import_abstract10.configurator)(_PointerSensor);
-var PointerSensor = _PointerSensor;
-function preventDefault(event) {
-  event.preventDefault();
-}
-function noop() {
+
+// reducer/actions.tsx
+init_react_import();
+
+// reducer/index.ts
+function storeInterceptor(reducer, record, onAction) {
+  return (state, action) => {
+    const newAppState = reducer(state, action);
+    const isValidType = ![
+      "registerZone",
+      "unregisterZone",
+      "setData",
+      "setUi",
+      "set"
+    ].includes(action.type);
+    if (typeof action.recordHistory !== "undefined" ? action.recordHistory : isValidType) {
+      if (record) record(newAppState);
+    }
+    onAction == null ? void 0 : onAction(action, newAppState, state);
+    return newAppState;
+  };
 }
-var windows = /* @__PURE__ */ new WeakSet();
-function patchWindow(window2) {
-  if (!window2 || windows.has(window2)) {
-    return;
+var setAction = (state, action) => {
+  if (typeof action.state === "object") {
+    return __spreadValues(__spreadValues({}, state), action.state);
   }
-  window2.addEventListener("touchmove", noop, {
-    capture: false,
-    passive: false
-  });
-  windows.add(window2);
+  return __spreadValues(__spreadValues({}, state), action.state(state));
+};
+function createReducer({
+  config,
+  record,
+  onAction
+}) {
+  return storeInterceptor(
+    (state, action) => {
+      const data = reduceData(state.data, action, config);
+      const ui = reduceUi(state.ui, action);
+      if (action.type === "set") {
+        return setAction(state, action);
+      }
+      return { data, ui };
+    },
+    record,
+    onAction
+  );
 }
 
+// lib/insert-component.ts
+var insertComponent = (componentType, zone, index, {
+  config,
+  dispatch,
+  resolveData,
+  state
+}) => {
+  const id = generateId(componentType);
+  const insertActionData = {
+    type: "insert",
+    componentType,
+    destinationIndex: index,
+    destinationZone: zone,
+    id
+  };
+  const insertedData = insertAction(state.data, insertActionData, config);
+  dispatch(__spreadProps(__spreadValues({}, insertActionData), {
+    // Dispatch insert rather set, as user's may rely on this via onAction
+    // We must always record history here so the insert is added to user history
+    // If the user has defined a resolveData method, they will end up with 2 history
+    // entries on insert - one for the initial insert, and one when the data resolves
+    recordHistory: true
+  }));
+  const itemSelector = {
+    index,
+    zone
+  };
+  dispatch({ type: "setUi", ui: { itemSelector } });
+  resolveData({
+    data: insertedData,
+    ui: __spreadProps(__spreadValues({}, state.ui), { itemSelector })
+  });
+};
+
 // components/DragDropContext/index.tsx
+var import_use_debounce2 = require("use-debounce");
 var import_zustand3 = require("zustand");
+
+// lib/get-deep-dir.ts
+init_react_import();
+function getDeepDir(el) {
+  function findDir(node) {
+    if (!node) return "ltr";
+    const d = node.getAttribute("dir");
+    return d || findDir(node.parentElement);
+  }
+  return el ? findDir(el) : "ltr";
+}
+
+// components/DragDropContext/index.tsx
 var import_jsx_runtime23 = require("react/jsx-runtime");
 var DEBUG3 = false;
-var dragListenerContext = (0, import_react31.createContext)({
+var dragListenerContext = (0, import_react32.createContext)({
   dragListeners: {}
 });
 function useDragListener(type, fn, deps = []) {
-  const { setDragListeners } = (0, import_react31.useContext)(dragListenerContext);
-  (0, import_react31.useEffect)(() => {
+  const { setDragListeners } = (0, import_react32.useContext)(dragListenerContext);
+  (0, import_react32.useEffect)(() => {
     if (setDragListeners) {
       setDragListeners((old) => __spreadProps(__spreadValues({}, old), {
         [type]: [...old[type] || [], fn]
@@ -4908,8 +5016,8 @@ function useDragListener(type, fn, deps = []) {
 }
 var AREA_CHANGE_DEBOUNCE_MS = 100;
 var useTempDisableFallback = (timeout3) => {
-  const lastFallbackDisable = (0, import_react31.useRef)(null);
-  return (0, import_react31.useCallback)((manager) => {
+  const lastFallbackDisable = (0, import_react32.useRef)(null);
+  return (0, import_react32.useCallback)((manager) => {
     collisionStore.setState({ fallbackEnabled: false });
     const fallbackId = generateId();
     lastFallbackDisable.current = fallbackId;
@@ -4926,11 +5034,11 @@ var DragDropContextClient = ({
   disableAutoScroll
 }) => {
   const { state, config, dispatch, resolveData } = useAppContext();
-  const id = (0, import_react31.useId)();
+  const id = (0, import_react32.useId)();
   const { data } = state;
-  const debouncedParamsRef = (0, import_react31.useRef)(null);
+  const debouncedParamsRef = (0, import_react32.useRef)(null);
   const tempDisableFallback = useTempDisableFallback(100);
-  const [zoneStore] = (0, import_react31.useState)(
+  const [zoneStore] = (0, import_react32.useState)(
     () => (0, import_zustand3.createStore)(() => ({
       zoneDepthIndex: {},
       nextZoneDepthIndex: {},
@@ -4940,7 +5048,7 @@ var DragDropContextClient = ({
       previewIndex: {}
     }))
   );
-  const getChanged2 = (0, import_react31.useCallback)(
+  const getChanged2 = (0, import_react32.useCallback)(
     (params, id2) => {
       const { zoneDepthIndex = {}, areaDepthIndex = {} } = zoneStore.getState() || {};
       const stateHasZone = Object.keys(zoneDepthIndex).length > 0;
@@ -4961,7 +5069,7 @@ var DragDropContextClient = ({
     },
     [zoneStore]
   );
-  const setDeepestAndCollide = (0, import_react31.useCallback)(
+  const setDeepestAndCollide = (0, import_react32.useCallback)(
     (params, manager) => {
       const { zoneChanged, areaChanged } = getChanged2(params, id);
       if (!zoneChanged && !areaChanged) return;
@@ -4985,7 +5093,7 @@ var DragDropContextClient = ({
     setDeepestDb.cancel();
     debouncedParamsRef.current = null;
   };
-  (0, import_react31.useEffect)(() => {
+  (0, import_react32.useEffect)(() => {
     if (DEBUG3) {
       zoneStore.subscribe(
         (s) => {
@@ -4999,7 +5107,7 @@ var DragDropContextClient = ({
       );
     }
   }, []);
-  const [plugins] = (0, import_react31.useState)(() => [
+  const [plugins] = (0, import_react32.useState)(() => [
     ...disableAutoScroll ? import_dom.defaultPreset.plugins.filter((plugin) => plugin !== import_dom.AutoScroller) : import_dom.defaultPreset.plugins,
     createNestedDroppablePlugin(
       {
@@ -5046,29 +5154,11 @@ var DragDropContextClient = ({
       id
     )
   ]);
-  const [sensors] = (0, import_react31.useState)(() => [
-    PointerSensor.configure({
-      activationConstraints(event, source) {
-        var _a;
-        const { pointerType, target } = event;
-        if (pointerType === "mouse" && (0, import_utilities2.isElement)(target) && (source.handle === target || ((_a = source.handle) == null ? void 0 : _a.contains(target)))) {
-          return void 0;
-        }
-        const delay = { value: 200, tolerance: 10 };
-        if (pointerType === "touch") {
-          return { delay };
-        }
-        return {
-          delay,
-          distance: { value: 5 }
-        };
-      }
-    })
-  ]);
-  const [dragListeners, setDragListeners] = (0, import_react31.useState)({});
-  const [pathData, setPathData] = (0, import_react31.useState)();
-  const dragMode = (0, import_react31.useRef)(null);
-  const registerPath = (0, import_react31.useCallback)(
+  const sensors = useSensors();
+  const [dragListeners, setDragListeners] = (0, import_react32.useState)({});
+  const [pathData, setPathData] = (0, import_react32.useState)();
+  const dragMode = (0, import_react32.useRef)(null);
+  const registerPath = (0, import_react32.useCallback)(
     (id2, selector, label) => {
       const [area] = getZoneId(selector.zone);
       setPathData((latestPathData = {}) => {
@@ -5086,7 +5176,7 @@ var DragDropContextClient = ({
     },
     [data, setPathData]
   );
-  const unregisterPath = (0, import_react31.useCallback)(
+  const unregisterPath = (0, import_react32.useCallback)(
     (id2) => {
       setPathData((latestPathData = {}) => {
         const newPathData = __spreadValues({}, latestPathData);
@@ -5096,7 +5186,7 @@ var DragDropContextClient = ({
     },
     [data, setPathData]
   );
-  const initialSelector = (0, import_react31.useRef)(void 0);
+  const initialSelector = (0, import_react32.useRef)(void 0);
   return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { id, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
     dragListenerContext.Provider,
     {
@@ -5105,7 +5195,7 @@ var DragDropContextClient = ({
         setDragListeners
       },
       children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
-        import_react30.DragDropProvider,
+        import_react31.DragDropProvider,
         {
           plugins,
           sensors,
@@ -5127,6 +5217,13 @@ var DragDropContextClient = ({
                 (_a2 = dragListeners.dragend) == null ? void 0 : _a2.forEach((fn) => {
                   fn(event, manager);
                 });
+                dispatch({
+                  type: "setUi",
+                  ui: {
+                    itemSelector: null,
+                    isDragging: false
+                  }
+                });
                 return;
               }
               if (thisPreview) {
@@ -5184,7 +5281,8 @@ var DragDropContextClient = ({
               targetZone = targetData.zone;
               targetIndex = targetData.index;
               const collisionData = (_c = (_b = manager.dragOperation.data) == null ? void 0 : _b.collisionMap) == null ? void 0 : _c[targetId];
-              const collisionPosition = (collisionData == null ? void 0 : collisionData.direction) === "up" || (collisionData == null ? void 0 : collisionData.direction) === "left" ? "before" : "after";
+              const dir = getDeepDir(target.element);
+              const collisionPosition = (collisionData == null ? void 0 : collisionData.direction) === "up" || dir === "ltr" && (collisionData == null ? void 0 : collisionData.direction) === "left" || dir === "rtl" && (collisionData == null ? void 0 : collisionData.direction) === "right" ? "before" : "after";
               if (targetIndex >= sourceIndex && sourceZone === targetZone) {
                 targetIndex = targetIndex - 1;
               }
@@ -5326,7 +5424,7 @@ var DrawerItemInner = ({
   dragRef,
   isDragDisabled
 }) => {
-  const CustomInner = (0, import_react32.useMemo)(
+  const CustomInner = (0, import_react33.useMemo)(
     () => children || (({ children: children2 }) => /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("div", { className: getClassNameItem2("default"), children: children2 })),
     [children]
   );
@@ -5380,7 +5478,7 @@ var DrawerItem = ({
   isDragDisabled
 }) => {
   const resolvedId = id || name;
-  const [dynamicId, setDynamicId] = (0, import_react32.useState)(generateId(resolvedId));
+  const [dynamicId, setDynamicId] = (0, import_react33.useState)(generateId(resolvedId));
   if (typeof index !== "undefined") {
     console.error(
       "Warning: The `index` prop on Drawer.Item is deprecated and no longer required."
@@ -5419,7 +5517,7 @@ var Drawer = ({
       "Warning: The `direction` prop on Drawer is deprecated and no longer required to achieve multi-directional dragging."
     );
   }
-  const id = (0, import_react32.useId)();
+  const id = (0, import_react33.useId)();
   const { ref } = useDroppableSafe({
     id,
     type: "void",
@@ -5441,18 +5539,18 @@ Drawer.Item = DrawerItem;
 
 // components/Puck/index.tsx
 init_react_import();
-var import_react50 = require("react");
+var import_react51 = require("react");
 
 // components/SidebarSection/index.tsx
 init_react_import();
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/SidebarSection/styles.module.css#css-module
 init_react_import();
-var styles_module_default13 = { "SidebarSection": "_SidebarSection_125qe_1", "SidebarSection-title": "_SidebarSection-title_125qe_12", "SidebarSection--noBorderTop": "_SidebarSection--noBorderTop_125qe_20", "SidebarSection-content": "_SidebarSection-content_125qe_24", "SidebarSection--noPadding": "_SidebarSection--noPadding_125qe_28", "SidebarSection-breadcrumbLabel": "_SidebarSection-breadcrumbLabel_125qe_41", "SidebarSection-breadcrumbs": "_SidebarSection-breadcrumbs_125qe_70", "SidebarSection-breadcrumb": "_SidebarSection-breadcrumb_125qe_41", "SidebarSection-heading": "_SidebarSection-heading_125qe_82", "SidebarSection-loadingOverlay": "_SidebarSection-loadingOverlay_125qe_86" };
+var styles_module_default13 = { "SidebarSection": "_SidebarSection_8boj8_1", "SidebarSection-title": "_SidebarSection-title_8boj8_12", "SidebarSection--noBorderTop": "_SidebarSection--noBorderTop_8boj8_20", "SidebarSection-content": "_SidebarSection-content_8boj8_24", "SidebarSection--noPadding": "_SidebarSection--noPadding_8boj8_28", "SidebarSection-breadcrumbLabel": "_SidebarSection-breadcrumbLabel_8boj8_41", "SidebarSection-breadcrumbs": "_SidebarSection-breadcrumbs_8boj8_70", "SidebarSection-breadcrumb": "_SidebarSection-breadcrumb_8boj8_41", "SidebarSection-heading": "_SidebarSection-heading_8boj8_82", "SidebarSection-loadingOverlay": "_SidebarSection-loadingOverlay_8boj8_86" };
 
 // lib/use-breadcrumbs.ts
 init_react_import();
-var import_react33 = require("react");
+var import_react34 = require("react");
 var convertPathDataToBreadcrumbs = (selectedItem, pathData, data) => {
   const id = selectedItem ? selectedItem == null ? void 0 : selectedItem.props.id : "";
   const currentPathData = pathData && id && pathData[id] ? __spreadValues({}, pathData[id]) : { label: "Page", path: [] };
@@ -5502,8 +5600,8 @@ var useBreadcrumbs = (renderCount) => {
     state: { data },
     selectedItem
   } = useAppContext();
-  const dzContext = (0, import_react33.useContext)(dropZoneContext);
-  return (0, import_react33.useMemo)(() => {
+  const dzContext = (0, import_react34.useContext)(dropZoneContext);
+  return (0, import_react34.useMemo)(() => {
     const breadcrumbs = convertPathDataToBreadcrumbs(
       selectedItem,
       dzContext == null ? void 0 : dzContext.pathData,
@@ -5627,7 +5725,7 @@ function MenuBar({
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/Puck/styles.module.css#css-module
 init_react_import();
-var styles_module_default15 = { "Puck": "_Puck_12s9r_19", "Puck-portal": "_Puck-portal_12s9r_24", "PuckLayout-inner": "_PuckLayout-inner_12s9r_31", "PuckLayout--mounted": "_PuckLayout--mounted_12s9r_43", "PuckLayout--leftSideBarVisible": "_PuckLayout--leftSideBarVisible_12s9r_47", "PuckLayout--rightSideBarVisible": "_PuckLayout--rightSideBarVisible_12s9r_53", "PuckLayout-mounted": "_PuckLayout-mounted_12s9r_67", "PuckLayout": "_PuckLayout_12s9r_31", "PuckLayout-header": "_PuckLayout-header_12s9r_108", "PuckLayout-headerInner": "_PuckLayout-headerInner_12s9r_117", "PuckLayout-headerToggle": "_PuckLayout-headerToggle_12s9r_127", "PuckLayout-rightSideBarToggle": "_PuckLayout-rightSideBarToggle_12s9r_134", "PuckLayout-leftSideBarToggle": "_PuckLayout-leftSideBarToggle_12s9r_135", "PuckLayout-headerTitle": "_PuckLayout-headerTitle_12s9r_139", "PuckLayout-headerPath": "_PuckLayout-headerPath_12s9r_143", "PuckLayout-headerTools": "_PuckLayout-headerTools_12s9r_150", "PuckLayout-menuButton": "_PuckLayout-menuButton_12s9r_156", "PuckLayout--menuOpen": "_PuckLayout--menuOpen_12s9r_161", "PuckLayout-leftSideBar": "_PuckLayout-leftSideBar_12s9r_135", "PuckLayout-rightSideBar": "_PuckLayout-rightSideBar_12s9r_134" };
+var styles_module_default15 = { "Puck": "_Puck_11o75_19", "Puck-portal": "_Puck-portal_11o75_24", "PuckLayout-inner": "_PuckLayout-inner_11o75_31", "PuckLayout--mounted": "_PuckLayout--mounted_11o75_43", "PuckLayout--leftSideBarVisible": "_PuckLayout--leftSideBarVisible_11o75_47", "PuckLayout--rightSideBarVisible": "_PuckLayout--rightSideBarVisible_11o75_53", "PuckLayout-mounted": "_PuckLayout-mounted_11o75_67", "PuckLayout": "_PuckLayout_11o75_31", "PuckLayout-header": "_PuckLayout-header_11o75_108", "PuckLayout-headerInner": "_PuckLayout-headerInner_11o75_117", "PuckLayout-headerToggle": "_PuckLayout-headerToggle_11o75_127", "PuckLayout-rightSideBarToggle": "_PuckLayout-rightSideBarToggle_11o75_134", "PuckLayout-leftSideBarToggle": "_PuckLayout-leftSideBarToggle_11o75_135", "PuckLayout-headerTitle": "_PuckLayout-headerTitle_11o75_139", "PuckLayout-headerPath": "_PuckLayout-headerPath_11o75_143", "PuckLayout-headerTools": "_PuckLayout-headerTools_11o75_150", "PuckLayout-menuButton": "_PuckLayout-menuButton_11o75_156", "PuckLayout--menuOpen": "_PuckLayout--menuOpen_11o75_161", "PuckLayout-leftSideBar": "_PuckLayout-leftSideBar_11o75_135", "PuckLayout-rightSideBar": "_PuckLayout-rightSideBar_11o75_134" };
 
 // components/Puck/components/Fields/index.tsx
 init_react_import();
@@ -5637,15 +5735,15 @@ init_react_import();
 var styles_module_default16 = { "PuckFields": "_PuckFields_10bh7_1", "PuckFields--isLoading": "_PuckFields--isLoading_10bh7_6", "PuckFields-loadingOverlay": "_PuckFields-loadingOverlay_10bh7_10", "PuckFields-loadingOverlayInner": "_PuckFields-loadingOverlayInner_10bh7_25", "PuckFields-field": "_PuckFields-field_10bh7_32", "PuckFields--wrapFields": "_PuckFields--wrapFields_10bh7_36" };
 
 // components/Puck/components/Fields/index.tsx
-var import_react37 = require("react");
+var import_react38 = require("react");
 
 // lib/use-resolved-fields.ts
 init_react_import();
-var import_react36 = require("react");
+var import_react37 = require("react");
 
 // lib/use-parent.ts
 init_react_import();
-var import_react34 = require("react");
+var import_react35 = require("react");
 var getParent = (itemSelector, pathData, data) => {
   var _a;
   if (!itemSelector) return null;
@@ -5657,8 +5755,8 @@ var getParent = (itemSelector, pathData, data) => {
 };
 var useGetParent = () => {
   const { state } = useAppContext();
-  const { pathData } = (0, import_react34.useContext)(dropZoneContext) || {};
-  return (0, import_react34.useCallback)(
+  const { pathData } = (0, import_react35.useContext)(dropZoneContext) || {};
+  return (0, import_react35.useCallback)(
     () => getParent(state.ui.itemSelector, pathData, state.data),
     [state.ui.itemSelector, pathData, state.data]
   );
@@ -5669,10 +5767,10 @@ var useParent = () => {
 
 // lib/use-on-value-change.ts
 init_react_import();
-var import_react35 = require("react");
+var import_react36 = require("react");
 function useOnValueChange(value, onChange, compare = Object.is, deps = []) {
-  const tracked = (0, import_react35.useRef)(value);
-  (0, import_react35.useEffect)(() => {
+  const tracked = (0, import_react36.useRef)(value);
+  (0, import_react36.useEffect)(() => {
     const oldValue = tracked.current;
     if (!compare(value, oldValue)) {
       tracked.current = value;
@@ -5689,28 +5787,37 @@ var selectorIs = (a, b) => (a == null ? void 0 : a.zone) === (b == null ? void 0
 var defaultPageFields = {
   title: { type: "text" }
 };
-var useResolvedFields = () => {
+var useResolvedFields = ({
+  _skipValueCheck,
+  _skipIdCheck
+} = {}) => {
   var _a, _b;
   const { selectedItem, state, config } = useAppContext();
   const parent = useParent();
   const { data } = state;
   const rootFields = ((_a = config.root) == null ? void 0 : _a.fields) || defaultPageFields;
   const componentConfig = selectedItem ? config.components[selectedItem.type] : null;
-  const defaultFields = (0, import_react36.useMemo)(
+  const defaultFields = (0, import_react37.useMemo)(
     () => (selectedItem ? componentConfig == null ? void 0 : componentConfig.fields : rootFields) || {},
     [selectedItem, rootFields, componentConfig == null ? void 0 : componentConfig.fields]
   );
   const rootProps = data.root.props || data.root;
-  const [lastSelectedData, setLastSelectedData] = (0, import_react36.useState)({});
-  const [resolvedFields, setResolvedFields] = (0, import_react36.useState)(defaultFields);
-  const [fieldsLoading, setFieldsLoading] = (0, import_react36.useState)(false);
-  const lastFields = (0, import_react36.useRef)(defaultFields);
+  const [lastSelectedData, setLastSelectedData] = (0, import_react37.useState)({});
+  const [resolvedFields, setResolvedFields] = (0, import_react37.useState)({
+    fields: defaultFields,
+    id: selectedItem == null ? void 0 : selectedItem.props.id
+  });
+  const [fieldsLoading, setFieldsLoading] = (0, import_react37.useState)(false);
+  const lastFields = (0, import_react37.useRef)(defaultFields);
   const defaultResolveFields = (_componentData, _params) => defaultFields;
-  const componentData = selectedItem ? selectedItem : { props: rootProps, readOnly: data.root.readOnly };
+  const componentData = (0, import_react37.useMemo)(
+    () => selectedItem ? selectedItem : { props: rootProps, readOnly: data.root.readOnly || {} },
+    [selectedItem, rootProps, data.root.readOnly]
+  );
   const hasComponentResolver = selectedItem && (componentConfig == null ? void 0 : componentConfig.resolveFields);
   const hasRootResolver = !selectedItem && ((_b = config.root) == null ? void 0 : _b.resolveFields);
   const hasResolver = hasComponentResolver || hasRootResolver;
-  const resolveFields = (0, import_react36.useCallback)(
+  const resolveFields = (0, import_react37.useCallback)(
     (..._0) => __async(void 0, [..._0], function* (fields = {}) {
       var _a2;
       const lastData = ((_a2 = lastSelectedData.props) == null ? void 0 : _a2.id) === componentData.props.id ? lastSelectedData : null;
@@ -5748,21 +5855,31 @@ var useResolvedFields = () => {
     }),
     [data, config, componentData, selectedItem, state, parent]
   );
-  const triggerResolver = (0, import_react36.useCallback)(() => {
+  const triggerResolver = (0, import_react37.useCallback)(() => {
     var _a2, _b2;
     if (!((_a2 = state.ui.itemSelector) == null ? void 0 : _a2.zone) || ((_b2 = state.ui.itemSelector) == null ? void 0 : _b2.zone) === "default-zone" || parent) {
       if (hasResolver) {
         setFieldsLoading(true);
         resolveFields(defaultFields).then((fields) => {
-          setResolvedFields(fields || {});
+          setResolvedFields({
+            fields: fields || {},
+            id: selectedItem == null ? void 0 : selectedItem.props.id
+          });
           lastFields.current = fields;
           setFieldsLoading(false);
         });
         return;
       }
     }
-    setResolvedFields(defaultFields);
-  }, [defaultFields, state.ui.itemSelector, hasResolver, parent]);
+    setResolvedFields({ fields: defaultFields, id: selectedItem == null ? void 0 : selectedItem.props.id });
+  }, [
+    defaultFields,
+    state.ui.itemSelector,
+    selectedItem,
+    hasResolver,
+    parent,
+    resolveFields
+  ]);
   useOnValueChange(
     state.ui.itemSelector,
     () => {
@@ -5773,14 +5890,18 @@ var useResolvedFields = () => {
   useOnValueChange(
     { data, parent, itemSelector: state.ui.itemSelector },
     () => {
+      if (_skipValueCheck) return;
       triggerResolver();
     },
     (a, b) => JSON.stringify(a) === JSON.stringify(b)
   );
-  (0, import_react36.useEffect)(() => {
+  (0, import_react37.useEffect)(() => {
     triggerResolver();
   }, []);
-  return [resolvedFields, fieldsLoading];
+  if (resolvedFields.id !== (selectedItem == null ? void 0 : selectedItem.props.id) && !_skipIdCheck) {
+    return [defaultFields, fieldsLoading];
+  }
+  return [resolvedFields.fields, fieldsLoading];
 };
 
 // components/Puck/components/Fields/index.tsx
@@ -5809,7 +5930,7 @@ var Fields = ({ wrapFields = true }) => {
   const componentResolving = selectedItem ? ((_a = componentState[selectedItem == null ? void 0 : selectedItem.props.id]) == null ? void 0 : _a.loadingCount) > 0 : ((_b = componentState["puck-root"]) == null ? void 0 : _b.loadingCount) > 0;
   const isLoading = fieldsResolving || componentResolving;
   const rootProps = data.root.props || data.root;
-  const Wrapper = (0, import_react37.useMemo)(() => overrides.fields || DefaultFields, [overrides]);
+  const Wrapper = (0, import_react38.useMemo)(() => overrides.fields || DefaultFields, [overrides]);
   return /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(
     "form",
     {
@@ -5930,14 +6051,14 @@ init_react_import();
 
 // lib/use-component-list.tsx
 init_react_import();
-var import_react38 = require("react");
+var import_react39 = require("react");
 
 // components/ComponentList/index.tsx
 init_react_import();
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/ComponentList/styles.module.css#css-module
 init_react_import();
-var styles_module_default17 = { "ComponentList": "_ComponentList_odh9d_1", "ComponentList--isExpanded": "_ComponentList--isExpanded_odh9d_5", "ComponentList-content": "_ComponentList-content_odh9d_9", "ComponentList-title": "_ComponentList-title_odh9d_17", "ComponentList-titleIcon": "_ComponentList-titleIcon_odh9d_53" };
+var styles_module_default17 = { "ComponentList": "_ComponentList_1rrlt_1", "ComponentList--isExpanded": "_ComponentList--isExpanded_1rrlt_5", "ComponentList-content": "_ComponentList-content_1rrlt_9", "ComponentList-title": "_ComponentList-title_1rrlt_17", "ComponentList-titleIcon": "_ComponentList-titleIcon_1rrlt_53" };
 
 // components/ComponentList/index.tsx
 var import_jsx_runtime28 = require("react/jsx-runtime");
@@ -5997,8 +6118,8 @@ ComponentList.Item = ComponentListItem;
 // lib/use-component-list.tsx
 var import_jsx_runtime29 = require("react/jsx-runtime");
 var useComponentList = (config, ui) => {
-  const [componentList, setComponentList] = (0, import_react38.useState)();
-  (0, import_react38.useEffect)(() => {
+  const [componentList, setComponentList] = (0, import_react39.useState)();
+  (0, import_react39.useEffect)(() => {
     var _a, _b, _c;
     if (Object.keys(ui.componentList).length > 0) {
       const matchedComponents = [];
@@ -6067,22 +6188,22 @@ var useComponentList = (config, ui) => {
 };
 
 // components/Puck/components/Components/index.tsx
-var import_react39 = require("react");
+var import_react40 = require("react");
 var import_jsx_runtime30 = require("react/jsx-runtime");
 var Components = () => {
   const { config, state, overrides } = useAppContext();
   const componentList = useComponentList(config, state.ui);
-  const Wrapper = (0, import_react39.useMemo)(() => overrides.components || "div", [overrides]);
+  const Wrapper = (0, import_react40.useMemo)(() => overrides.components || "div", [overrides]);
   return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(Wrapper, { children: componentList ? componentList : /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(ComponentList, { id: "all" }) });
 };
 
 // components/Puck/components/Preview/index.tsx
 init_react_import();
-var import_react41 = require("react");
+var import_react42 = require("react");
 
 // components/AutoFrame/index.tsx
 init_react_import();
-var import_react40 = require("react");
+var import_react41 = require("react");
 var import_object_hash = __toESM(require("object-hash"));
 var import_react_dom3 = require("react-dom");
 var import_jsx_runtime31 = require("react/jsx-runtime");
@@ -6128,7 +6249,7 @@ var CopyHostStyles = ({
   onStylesLoaded = () => null
 }) => {
   const { document: doc, window: win } = useFrame();
-  (0, import_react40.useEffect)(() => {
+  (0, import_react41.useEffect)(() => {
     if (!win || !doc) {
       return () => {
       };
@@ -6287,8 +6408,8 @@ var CopyHostStyles = ({
   }, []);
   return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(import_jsx_runtime31.Fragment, { children });
 };
-var autoFrameContext = (0, import_react40.createContext)({});
-var useFrame = () => (0, import_react40.useContext)(autoFrameContext);
+var autoFrameContext = (0, import_react41.createContext)({});
+var useFrame = () => (0, import_react41.useContext)(autoFrameContext);
 function AutoFrame(_a) {
   var _b = _a, {
     children,
@@ -6305,10 +6426,10 @@ function AutoFrame(_a) {
     "onStylesLoaded",
     "frameRef"
   ]);
-  const [loaded, setLoaded] = (0, import_react40.useState)(false);
-  const [ctx, setCtx] = (0, import_react40.useState)({});
-  const [mountTarget, setMountTarget] = (0, import_react40.useState)();
-  (0, import_react40.useEffect)(() => {
+  const [loaded, setLoaded] = (0, import_react41.useState)(false);
+  const [ctx, setCtx] = (0, import_react41.useState)({});
+  const [mountTarget, setMountTarget] = (0, import_react41.useState)();
+  (0, import_react41.useEffect)(() => {
     var _a2;
     if (frameRef.current) {
       setCtx({
@@ -6370,13 +6491,14 @@ function Render({
           config.root.render,
           __spreadProps(__spreadValues({}, rootProps), {
             puck: {
-              renderDropZone: DropZone,
-              isEditing: false
+              renderDropZone: DropZonePure,
+              isEditing: false,
+              dragRef: null
             },
             title,
             editMode: false,
             id: "puck-root",
-            children: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(DropZone, { zone: rootDroppableId })
+            children: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(DropZonePure, { zone: rootDroppableId })
           })
         )
       }
@@ -6392,7 +6514,7 @@ function Render({
         depth: 0,
         path: []
       },
-      children: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(DropZone, { zone: rootDroppableId })
+      children: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(DropZonePure, { zone: rootDroppableId })
     }
   );
 }
@@ -6402,25 +6524,12 @@ var import_jsx_runtime33 = require("react/jsx-runtime");
 var getClassName23 = get_class_name_factory_default("PuckPreview", styles_module_default18);
 var useBubbleIframeEvents = (ref) => {
   const { status } = useAppContext();
-  (0, import_react41.useEffect)(() => {
+  (0, import_react42.useEffect)(() => {
     var _a;
     if (ref.current && status === "READY") {
       const iframe = ref.current;
-      class BubbledPointerEventClass extends PointerEvent {
-        constructor(type, data) {
-          super(type, data);
-          this._originalTarget = null;
-          this.originalTarget = data.originalTarget;
-        }
-        set originalTarget(target) {
-          this._originalTarget = target;
-        }
-        get originalTarget() {
-          return this._originalTarget;
-        }
-      }
       const handlePointerMove = (event) => {
-        const evt = new BubbledPointerEventClass("pointermove", __spreadProps(__spreadValues({}, event), {
+        const evt = new BubbledPointerEvent("pointermove", __spreadProps(__spreadValues({}, event), {
           bubbles: true,
           cancelable: false,
           clientX: event.clientX,
@@ -6448,7 +6557,7 @@ var useBubbleIframeEvents = (ref) => {
 };
 var Preview2 = ({ id = "puck-preview" }) => {
   const { config, dispatch, state, setStatus, iframe, overrides } = useAppContext();
-  const Page = (0, import_react41.useCallback)(
+  const Page = (0, import_react42.useCallback)(
     (pageProps) => {
       var _a, _b;
       return ((_a = config.root) == null ? void 0 : _a.render) ? (_b = config.root) == null ? void 0 : _b.render(__spreadValues({
@@ -6457,20 +6566,20 @@ var Preview2 = ({ id = "puck-preview" }) => {
     },
     [config.root]
   );
-  const Frame = (0, import_react41.useMemo)(() => overrides.iframe, [overrides]);
+  const Frame = (0, import_react42.useMemo)(() => overrides.iframe, [overrides]);
   const rootProps = state.data.root.props || state.data.root;
-  const ref = (0, import_react41.useRef)(null);
+  const ref = (0, import_react42.useRef)(null);
   useBubbleIframeEvents(ref);
   const inner = state.ui.previewMode === "edit" ? /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
     Page,
     __spreadProps(__spreadValues({}, rootProps), {
       puck: {
-        renderDropZone: DropZone,
+        renderDropZone: DropZonePure,
         isEditing: true,
         dragRef: null
       },
       editMode: true,
-      children: /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(DropZone, { zone: rootDroppableId })
+      children: /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(DropZonePure, { zone: rootDroppableId })
     })
   ) : /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(Render, { data: state.data, config });
   return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
@@ -6542,7 +6651,7 @@ init_react_import();
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/LayerTree/styles.module.css#css-module
 init_react_import();
-var styles_module_default19 = { "LayerTree": "_LayerTree_1pgw8_1", "LayerTree-zoneTitle": "_LayerTree-zoneTitle_1pgw8_11", "LayerTree-helper": "_LayerTree-helper_1pgw8_17", "Layer": "_Layer_1pgw8_1", "Layer-inner": "_Layer-inner_1pgw8_29", "Layer--containsZone": "_Layer--containsZone_1pgw8_35", "Layer-clickable": "_Layer-clickable_1pgw8_39", "Layer--isSelected": "_Layer--isSelected_1pgw8_61", "Layer-chevron": "_Layer-chevron_1pgw8_77", "Layer--childIsSelected": "_Layer--childIsSelected_1pgw8_78", "Layer-zones": "_Layer-zones_1pgw8_82", "Layer-title": "_Layer-title_1pgw8_96", "Layer-name": "_Layer-name_1pgw8_105", "Layer-icon": "_Layer-icon_1pgw8_111", "Layer-zoneIcon": "_Layer-zoneIcon_1pgw8_116" };
+var styles_module_default19 = { "LayerTree": "_LayerTree_7rx04_1", "LayerTree-zoneTitle": "_LayerTree-zoneTitle_7rx04_11", "LayerTree-helper": "_LayerTree-helper_7rx04_17", "Layer": "_Layer_7rx04_1", "Layer-inner": "_Layer-inner_7rx04_29", "Layer--containsZone": "_Layer--containsZone_7rx04_35", "Layer-clickable": "_Layer-clickable_7rx04_39", "Layer--isSelected": "_Layer--isSelected_7rx04_61", "Layer-chevron": "_Layer-chevron_7rx04_77", "Layer--childIsSelected": "_Layer--childIsSelected_7rx04_78", "Layer-zones": "_Layer-zones_7rx04_82", "Layer-title": "_Layer-title_7rx04_96", "Layer-name": "_Layer-name_7rx04_105", "Layer-icon": "_Layer-icon_7rx04_111", "Layer-zoneIcon": "_Layer-zoneIcon_7rx04_116" };
 
 // lib/scroll-into-view.ts
 init_react_import();
@@ -6556,7 +6665,7 @@ var scrollIntoView = (el) => {
 };
 
 // components/LayerTree/index.tsx
-var import_react42 = require("react");
+var import_react43 = require("react");
 
 // lib/is-child-of-zone.ts
 init_react_import();
@@ -6602,7 +6711,7 @@ var LayerTree = ({
   label
 }) => {
   const zones = data.zones || {};
-  const ctx = (0, import_react42.useContext)(dropZoneContext);
+  const ctx = (0, import_react43.useContext)(dropZoneContext);
   return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(import_jsx_runtime34.Fragment, { children: [
     label && /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("div", { className: getClassName24("zoneTitle"), children: [
       /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className: getClassName24("zoneIcon"), children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Layers, { size: "16" }) }),
@@ -6709,13 +6818,13 @@ var LayerTree = ({
 };
 
 // components/Puck/components/Outline/index.tsx
-var import_react43 = require("react");
+var import_react44 = require("react");
 var import_jsx_runtime35 = require("react/jsx-runtime");
 var Outline = () => {
   const { dispatch, state, overrides, config } = useAppContext();
   const { data, ui } = state;
   const { itemSelector } = ui;
-  const setItemSelector = (0, import_react43.useCallback)(
+  const setItemSelector = (0, import_react44.useCallback)(
     (newItemSelector) => {
       dispatch({
         type: "setUi",
@@ -6724,7 +6833,7 @@ var Outline = () => {
     },
     []
   );
-  const Wrapper = (0, import_react43.useMemo)(() => overrides.outline || "div", [overrides]);
+  const Wrapper = (0, import_react44.useMemo)(() => overrides.outline || "div", [overrides]);
   return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Wrapper, { children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(dropZoneContext.Consumer, { children: (ctx) => /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)(import_jsx_runtime35.Fragment, { children: [
     (ctx == null ? void 0 : ctx.activeZones) && (ctx == null ? void 0 : ctx.activeZones[rootDroppableId]) && /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
       LayerTree,
@@ -6838,19 +6947,19 @@ function usePuckHistory({
 
 // lib/use-history-store.ts
 init_react_import();
-var import_react44 = require("react");
+var import_react45 = require("react");
 var import_use_debounce3 = require("use-debounce");
 var EMPTY_HISTORY_INDEX = 0;
 function useHistoryStore(initialHistory) {
   var _a, _b;
-  const [histories, setHistories] = (0, import_react44.useState)(
+  const [histories, setHistories] = (0, import_react45.useState)(
     (_a = initialHistory == null ? void 0 : initialHistory.histories) != null ? _a : []
   );
   const updateHistories = (histories2) => {
     setHistories(histories2);
     setIndex(histories2.length - 1);
   };
-  const [index, setIndex] = (0, import_react44.useState)(
+  const [index, setIndex] = (0, import_react45.useState)(
     (_b = initialHistory == null ? void 0 : initialHistory.index) != null ? _b : EMPTY_HISTORY_INDEX
   );
   const hasPast = index > EMPTY_HISTORY_INDEX;
@@ -7010,15 +7119,15 @@ var getBox = function getBox2(el) {
 };
 
 // components/Puck/components/Canvas/index.tsx
-var import_react46 = require("react");
+var import_react47 = require("react");
 
 // components/ViewportControls/index.tsx
 init_react_import();
-var import_react45 = require("react");
+var import_react46 = require("react");
 
 // css-module:/home/runner/work/puck/puck/packages/core/components/ViewportControls/styles.module.css#css-module
 init_react_import();
-var styles_module_default20 = { "ViewportControls": "_ViewportControls_g1wgg_1", "ViewportControls-divider": "_ViewportControls-divider_g1wgg_15", "ViewportControls-zoomSelect": "_ViewportControls-zoomSelect_g1wgg_21", "ViewportButton--isActive": "_ViewportButton--isActive_g1wgg_34", "ViewportButton-inner": "_ViewportButton-inner_g1wgg_34" };
+var styles_module_default20 = { "ViewportControls": "_ViewportControls_gejzr_1", "ViewportControls-divider": "_ViewportControls-divider_gejzr_15", "ViewportControls-zoomSelect": "_ViewportControls-zoomSelect_gejzr_21", "ViewportButton--isActive": "_ViewportButton--isActive_gejzr_38", "ViewportButton-inner": "_ViewportButton-inner_gejzr_38" };
 
 // components/ViewportControls/index.tsx
 var import_jsx_runtime36 = require("react/jsx-runtime");
@@ -7037,8 +7146,8 @@ var ViewportButton = ({
   onClick
 }) => {
   const { state } = useAppContext();
-  const [isActive, setIsActive] = (0, import_react45.useState)(false);
-  (0, import_react45.useEffect)(() => {
+  const [isActive, setIsActive] = (0, import_react46.useState)(false);
+  (0, import_react46.useEffect)(() => {
     setIsActive(width === state.ui.viewports.current.width);
   }, [width, state.ui.viewports.current.width]);
   return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("span", { className: getClassNameButton({ isActive }), children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
@@ -7074,7 +7183,7 @@ var ViewportControls = ({
   const defaultsContainAutoZoom = defaultZoomOptions.find(
     (option) => option.value === autoZoom
   );
-  const zoomOptions = (0, import_react45.useMemo)(
+  const zoomOptions = (0, import_react46.useMemo)(
     () => [
       ...defaultZoomOptions,
       ...defaultsContainAutoZoom ? [] : [
@@ -7197,17 +7306,17 @@ var Canvas = () => {
   const { status, iframe } = useAppContext();
   const { dispatch, state, overrides, setUi, zoomConfig, setZoomConfig } = useAppContext();
   const { ui } = state;
-  const frameRef = (0, import_react46.useRef)(null);
-  const [showTransition, setShowTransition] = (0, import_react46.useState)(false);
-  const defaultRender = (0, import_react46.useMemo)(() => {
+  const frameRef = (0, import_react47.useRef)(null);
+  const [showTransition, setShowTransition] = (0, import_react47.useState)(false);
+  const defaultRender = (0, import_react47.useMemo)(() => {
     const PuckDefault = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(import_jsx_runtime37.Fragment, { children });
     return PuckDefault;
   }, []);
-  const CustomPreview = (0, import_react46.useMemo)(
+  const CustomPreview = (0, import_react47.useMemo)(
     () => overrides.preview || defaultRender,
     [overrides]
   );
-  const getFrameDimensions = (0, import_react46.useCallback)(() => {
+  const getFrameDimensions = (0, import_react47.useCallback)(() => {
     if (frameRef.current) {
       const frame = frameRef.current;
       const box = getBox(frame);
@@ -7215,7 +7324,7 @@ var Canvas = () => {
     }
     return { width: 0, height: 0 };
   }, [frameRef]);
-  const resetAutoZoom = (0, import_react46.useCallback)(
+  const resetAutoZoom = (0, import_react47.useCallback)(
     (ui2 = state.ui) => {
       if (frameRef.current) {
         setZoomConfig(
@@ -7225,11 +7334,11 @@ var Canvas = () => {
     },
     [frameRef, zoomConfig, state.ui]
   );
-  (0, import_react46.useEffect)(() => {
+  (0, import_react47.useEffect)(() => {
     setShowTransition(false);
     resetAutoZoom();
   }, [frameRef, ui.leftSideBarVisible, ui.rightSideBarVisible]);
-  (0, import_react46.useEffect)(() => {
+  (0, import_react47.useEffect)(() => {
     const { height: frameHeight } = getFrameDimensions();
     if (ui.viewports.current.height === "auto") {
       setZoomConfig(__spreadProps(__spreadValues({}, zoomConfig), {
@@ -7237,13 +7346,13 @@ var Canvas = () => {
       }));
     }
   }, [zoomConfig.zoom]);
-  (0, import_react46.useEffect)(() => {
+  (0, import_react47.useEffect)(() => {
     if (ZOOM_ON_CHANGE) {
       setShowTransition(true);
       resetAutoZoom(ui);
     }
   }, [ui.viewports.current.width]);
-  (0, import_react46.useEffect)(() => {
+  (0, import_react47.useEffect)(() => {
     const cb = () => {
       setShowTransition(false);
       resetAutoZoom();
@@ -7253,8 +7362,8 @@ var Canvas = () => {
       window.removeEventListener("resize", cb);
     };
   }, []);
-  const [showLoader, setShowLoader] = (0, import_react46.useState)(false);
-  (0, import_react46.useEffect)(() => {
+  const [showLoader, setShowLoader] = (0, import_react47.useState)(false);
+  (0, import_react47.useEffect)(() => {
     setTimeout(() => {
       setShowLoader(true);
     }, 500);
@@ -7332,7 +7441,7 @@ var Canvas = () => {
 
 // lib/use-loaded-overrides.ts
 init_react_import();
-var import_react47 = require("react");
+var import_react48 = require("react");
 
 // lib/load-overrides.ts
 init_react_import();
@@ -7371,7 +7480,7 @@ var useLoadedOverrides = ({
   overrides,
   plugins
 }) => {
-  return (0, import_react47.useMemo)(() => {
+  return (0, import_react48.useMemo)(() => {
     return loadOverrides({ overrides, plugins });
   }, [plugins, overrides]);
 };
@@ -7383,14 +7492,14 @@ var DefaultOverride = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime38
 
 // lib/use-inject-css.ts
 init_react_import();
-var import_react48 = require("react");
+var import_react49 = require("react");
 var styles = ``;
 var useInjectStyleSheet = (initialStyles, iframeEnabled) => {
-  const [el, setEl] = (0, import_react48.useState)();
-  (0, import_react48.useEffect)(() => {
+  const [el, setEl] = (0, import_react49.useState)();
+  (0, import_react49.useEffect)(() => {
     setEl(document.createElement("style"));
   }, []);
-  (0, import_react48.useEffect)(() => {
+  (0, import_react49.useEffect)(() => {
     var _a;
     if (!el || typeof window === "undefined") {
       return;
@@ -7410,10 +7519,10 @@ var useInjectGlobalCss = (iframeEnabled) => {
 
 // lib/use-preview-mode-hotkeys.ts
 init_react_import();
-var import_react49 = require("react");
+var import_react50 = require("react");
 var import_react_hotkeys_hook2 = require("react-hotkeys-hook");
 var usePreviewModeHotkeys = (dispatch, iframeEnabled) => {
-  const toggleInteractive = (0, import_react49.useCallback)(() => {
+  const toggleInteractive = (0, import_react50.useCallback)(() => {
     dispatch({
       type: "setUi",
       ui: (ui) => ({
@@ -7470,7 +7579,7 @@ function Puck({
     waitForStyles: true
   }, _iframe);
   useInjectGlobalCss(iframe.enabled);
-  const [generatedAppState] = (0, import_react50.useState)(() => {
+  const [generatedAppState] = (0, import_react51.useState)(() => {
     var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
     const initial = __spreadValues(__spreadValues({}, defaultAppState.ui), initialUi);
     let clientUiState = {};
@@ -7542,14 +7651,14 @@ function Puck({
     histories,
     index: initialHistoryIndex
   });
-  const [reducer] = (0, import_react50.useState)(
+  const [reducer] = (0, import_react51.useState)(
     () => createReducer({
       config,
       record: historyStore.record,
       onAction
     })
   );
-  const [appState, dispatch] = (0, import_react50.useReducer)(
+  const [appState, dispatch] = (0, import_react51.useReducer)(
     reducer,
     flushZones(initialAppState)
   );
@@ -7560,14 +7669,14 @@ function Puck({
     historyStore,
     iframeEnabled: (_a = _iframe == null ? void 0 : _iframe.enabled) != null ? _a : true
   });
-  const [menuOpen, setMenuOpen] = (0, import_react50.useState)(false);
+  const [menuOpen, setMenuOpen] = (0, import_react51.useState)(false);
   const { itemSelector, leftSideBarVisible, rightSideBarVisible } = ui;
   const selectedItem = itemSelector ? getItem(itemSelector, data) : null;
-  (0, import_react50.useEffect)(() => {
+  (0, import_react51.useEffect)(() => {
     if (onChange) onChange(data);
   }, [data]);
   const rootProps = data.root.props || data.root;
-  const toggleSidebars = (0, import_react50.useCallback)(
+  const toggleSidebars = (0, import_react51.useCallback)(
     (sidebar) => {
       const widerViewport = window.matchMedia("(min-width: 638px)").matches;
       const sideBarVisible = sidebar === "left" ? leftSideBarVisible : rightSideBarVisible;
@@ -7581,7 +7690,7 @@ function Puck({
     },
     [dispatch, leftSideBarVisible, rightSideBarVisible]
   );
-  (0, import_react50.useEffect)(() => {
+  (0, import_react51.useEffect)(() => {
     if (!window.matchMedia("(min-width: 638px)").matches) {
       dispatch({
         type: "setUi",
@@ -7604,7 +7713,7 @@ function Puck({
       window.removeEventListener("resize", handleResize);
     };
   }, []);
-  const defaultHeaderRender = (0, import_react50.useMemo)(() => {
+  const defaultHeaderRender = (0, import_react51.useMemo)(() => {
     if (renderHeader) {
       console.warn(
         "`renderHeader` is deprecated. Please use `overrides.header` and the `usePuck` hook instead"
@@ -7618,7 +7727,7 @@ function Puck({
     }
     return DefaultOverride;
   }, [renderHeader]);
-  const defaultHeaderActionsRender = (0, import_react50.useMemo)(() => {
+  const defaultHeaderActionsRender = (0, import_react51.useMemo)(() => {
     if (renderHeaderActions) {
       console.warn(
         "`renderHeaderActions` is deprecated. Please use `overrides.headerActions` and the `usePuck` hook instead."
@@ -7635,20 +7744,20 @@ function Puck({
     overrides,
     plugins
   });
-  const CustomPuck = (0, import_react50.useMemo)(
+  const CustomPuck = (0, import_react51.useMemo)(
     () => loadedOverrides.puck || DefaultOverride,
     [loadedOverrides]
   );
-  const CustomHeader = (0, import_react50.useMemo)(
+  const CustomHeader = (0, import_react51.useMemo)(
     () => loadedOverrides.header || defaultHeaderRender,
     [loadedOverrides]
   );
-  const CustomHeaderActions = (0, import_react50.useMemo)(
+  const CustomHeaderActions = (0, import_react51.useMemo)(
     () => loadedOverrides.headerActions || defaultHeaderActionsRender,
     [loadedOverrides]
   );
-  const [mounted, setMounted] = (0, import_react50.useState)(false);
-  (0, import_react50.useEffect)(() => {
+  const [mounted, setMounted] = (0, import_react51.useState)(false);
+  (0, import_react51.useEffect)(() => {
     setMounted(true);
   }, []);
   const selectedComponentConfig = selectedItem && config.components[selectedItem.type];
@@ -7953,14 +8062,12 @@ var usePuck = () => {
   Button,
   Drawer,
   DropZone,
-  DropZoneProvider,
   FieldLabel,
   Group,
   IconButton,
   Label,
   Puck,
   Render,
-  dropZoneContext,
   migrate,
   overrideKeys,
   resolveAllData,