@netlisian/softconfig 0.1.9 → 0.1.10

package/dist/puck/index.mjs

@@ -1,4 +1,5 @@
 'use client'
+"use client";
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -43,24 +44,42 @@ var __async = (__this, __arguments, generator) => {
 import { create } from "zustand";
 import { subscribeWithSelector } from "zustand/middleware";
 
-// src/puck/store/slices/builder.tsx
-import {
-  walkTree as walkTree3
-} from "@measured/puck";
-
-// src/puck/lib/get-root-props.ts
-var getRootProps = (appState) => appState.data.root.props;
+// src/puck/lib/root-action-handler.ts
+import isEqual from "react-fast-compare";
 
-// src/puck/lib/builder/root-config.tsx
-import { useEffect } from "react";
-import equal2 from "react-fast-compare";
-import {
-  createUsePuck,
-  walkTree
-} from "@measured/puck";
+// src/puck/lib/apply-mapping.ts
+import equal from "react-fast-compare";
 
-// src/puck/lib/get-field-settings.tsx
-import { AutoField } from "@measured/puck";
+// src/puck/lib/set-prop-by-path.ts
+function setPropertyByPath(props, path, value) {
+  const parts = path.replace(/\[(\w+)\]/g, ".$1").split(".");
+  const last = parts.pop();
+  let cur = props;
+  for (const p of parts) {
+    if (typeof cur[p] !== "object" || cur[p] === null) cur[p] = {};
+    cur = cur[p];
+  }
+  cur[last] = value;
+}
+function setImmutablePropertyByPath(obj, path, value) {
+  if (!path) return value;
+  const parts = path.replace(/\[(\w+)\]/g, ".$1").split(".");
+  const root = Array.isArray(obj) ? [...obj] : __spreadValues({}, obj);
+  let current = root;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const nextPart = parts[i + 1];
+    const isArrayNext = !isNaN(Number(nextPart));
+    if (current[part] === void 0 || current[part] === null) {
+      current[part] = isArrayNext ? [] : {};
+    } else {
+      current[part] = Array.isArray(current[part]) ? [...current[part]] : __spreadValues({}, current[part]);
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+  return root;
+}
 
 // src/puck/lib/get-settings-by-path.ts
 function getFieldSettingsByPath(fieldSettings, path) {
@@ -68,14 +87,6 @@ function getFieldSettingsByPath(fieldSettings, path) {
 }
 
 // src/puck/lib/array-field-utils.ts
-var primitiveFieldTypes = /* @__PURE__ */ new Set([
-  "text",
-  "textarea",
-  "number",
-  "select",
-  "radio",
-  "reference"
-]);
 var isPrimitiveValue = (value) => ["string", "number", "boolean"].includes(typeof value);
 var getFallbackValueForField = (type) => {
   switch (type) {
@@ -107,7 +118,6 @@ var resolveExpressionSummary = (item, index, expression) => {
   });
   return isValid ? result : "";
 };
-var isPrimitiveFieldType = (type) => primitiveFieldTypes.has(type);
 var buildArrayDefaultItemProps = (subFields = [], subFieldSettings = {}) => {
   if (!subFields.length) return void 0;
   const item = {};
@@ -160,486 +170,19 @@ var getArrayItemSubPath = (arrayPath) => {
   return match ? match[1] : null;
 };
 
-// src/puck/lib/custom-fields.ts
-var builtInSoftFieldTypes = /* @__PURE__ */ new Set([
-  "text",
-  "textarea",
-  "number",
-  "select",
-  "radio",
-  "array",
-  "object",
-  "reference"
-]);
-var warnedMessages = /* @__PURE__ */ new Set();
-var warnOnce = (message) => {
-  if (warnedMessages.has(message)) {
-    return;
-  }
-  warnedMessages.add(message);
-  console.warn(message);
-};
-var isBuiltInSoftFieldType = (fieldType) => {
-  return builtInSoftFieldTypes.has(fieldType);
-};
-var resolveCustomFieldDefinition = (fieldType, customFields) => {
-  if (isBuiltInSoftFieldType(fieldType)) {
-    return void 0;
-  }
-  return customFields == null ? void 0 : customFields[fieldType];
-};
-var resolveCustomFieldReturnType = (fieldType, customFields) => {
-  const customField = resolveCustomFieldDefinition(fieldType, customFields);
-  if (!customField) {
-    return null;
-  }
-  if (!customField.returnType) {
-    warnOnce(
-      `[soft-config] Custom field "${fieldType}" is missing a required returnType and will be skipped from mapping options.`
-    );
-    return null;
-  }
-  return customField.returnType;
-};
-var resolveCustomFieldSchema = (fieldType, customFields) => {
-  const customField = resolveCustomFieldDefinition(fieldType, customFields);
-  if (!customField) {
-    return null;
-  }
-  const returnType = resolveCustomFieldReturnType(fieldType, customFields);
-  if (!returnType) {
-    return null;
-  }
-  if (returnType !== "array" && returnType !== "object") {
-    return null;
-  }
-  const subFields = customField.subFields || [];
-  if (!subFields.length) {
-    warnOnce(
-      `[soft-config] Custom field "${fieldType}" returns ${returnType} but does not define subFields. It will be skipped from mapping options.`
-    );
-    return null;
-  }
-  return {
-    subFields,
-    subFieldSettings: customField.subFieldSettings || {}
-  };
-};
-var getCustomFieldTypeOptions = (customFields) => {
-  if (!customFields) {
-    return [];
-  }
-  return Object.entries(customFields).filter(([fieldType]) => !isBuiltInSoftFieldType(fieldType)).map(([fieldType, definition]) => ({
-    label: typeof definition.field.label === "string" && definition.field.label ? definition.field.label : fieldType,
-    value: fieldType
-  }));
-};
-var mapCustomReturnTypeToMappingType = (returnType) => {
-  switch (returnType) {
-    case "string":
-      return "textarea";
-    case "number":
-      return "number";
-    case "boolean":
-      return "select";
-    case "array":
-      return "array";
-    case "object":
-      return "object";
-    default:
-      return "textarea";
-  }
-};
-
-// src/puck/lib/get-field-settings.tsx
-import { jsx } from "react/jsx-runtime";
-var buildPuckField = (field, fieldSettings, customFields) => {
-  const customFieldDefinition = resolveCustomFieldDefinition(
-    field.type,
-    customFields
-  );
-  const customReturnType = resolveCustomFieldReturnType(field.type, customFields);
-  if (customFieldDefinition && customReturnType) {
-    return __spreadProps(__spreadValues({}, customFieldDefinition.field), {
-      type: "custom",
-      label: customFieldDefinition.field.label || field.name
-    });
-  }
-  const resolvedType = field.type;
-  switch (resolvedType) {
-    case "text":
-    case "textarea":
-      return { type: resolvedType, label: field.name };
-    case "number":
-      return {
-        type: resolvedType,
-        label: field.name,
-        min: fieldSettings == null ? void 0 : fieldSettings.min,
-        max: fieldSettings == null ? void 0 : fieldSettings.max,
-        step: fieldSettings == null ? void 0 : fieldSettings.step
-      };
-    case "select":
-    case "radio":
-      return {
-        type: resolvedType,
-        label: field.name,
-        options: (fieldSettings == null ? void 0 : fieldSettings.options) || []
-      };
-    case "array": {
-      const subFields = (fieldSettings == null ? void 0 : fieldSettings.subFields) || [];
-      const subFieldSettings = (fieldSettings == null ? void 0 : fieldSettings.subFieldSettings) || {};
-      return {
-        type: "array",
-        label: field.name,
-        min: fieldSettings == null ? void 0 : fieldSettings.min,
-        max: fieldSettings == null ? void 0 : fieldSettings.max,
-        arrayFields: buildDefaultEditorFields(
-          subFields,
-          subFieldSettings,
-          customFields
-        ),
-        defaultItemProps: buildArrayDefaultItemProps(subFields, subFieldSettings),
-        getItemSummary(item, index) {
-          return getArrayItemSummary(item, index, fieldSettings);
-        }
-      };
-    }
-    case "object":
-      return {
-        type: "object",
-        label: field.name,
-        objectFields: buildDefaultEditorFields(
-          (fieldSettings == null ? void 0 : fieldSettings.subFields) || [],
-          (fieldSettings == null ? void 0 : fieldSettings.subFieldSettings) || {},
-          customFields
-        )
-      };
-    default:
-      return { type: "text", label: field.name };
-  }
-};
-var buildDefaultEditorFields = (fields = [], fieldSettings = {}, customFields) => {
-  return fields.reduce((acc, field) => {
-    acc[field.name] = buildPuckField(
-      field,
-      fieldSettings[field.name],
-      customFields
-    );
-    return acc;
-  }, {});
-};
-var getFieldSettings = (_fields, _fieldSettings, customFields, deep) => {
-  const customTypeOptions = getCustomFieldTypeOptions(customFields);
-  return (_fields || []).reduce((fields, field) => {
-    const fieldSettings = {
-      // placeholder: { type: "text", label: "Placeholder" },
-    };
-    const currentFieldSettings = _fieldSettings == null ? void 0 : _fieldSettings[field.name];
-    const customFieldDefinition = resolveCustomFieldDefinition(
-      field.type,
-      customFields
-    );
-    const customReturnType = resolveCustomFieldReturnType(
-      field.type,
-      customFields
-    );
-    const resolvedType = field.type;
-    const customSchema = resolveCustomFieldSchema(field.type, customFields);
-    const resolvedSubFields = (customSchema == null ? void 0 : customSchema.subFields) || (currentFieldSettings == null ? void 0 : currentFieldSettings.subFields) || [];
-    const resolvedSubFieldSettings = (customSchema == null ? void 0 : customSchema.subFieldSettings) || (currentFieldSettings == null ? void 0 : currentFieldSettings.subFieldSettings) || {};
-    const customDefaultValueField = customFieldDefinition && customReturnType ? __spreadProps(__spreadValues({}, customFieldDefinition.field), {
-      type: "custom",
-      label: customFieldDefinition.field.label || "Default Value"
-    }) : null;
-    if (customDefaultValueField) {
-      fieldSettings.defaultValue = customDefaultValueField;
-    }
-    switch (resolvedType) {
-      case "text":
-      case "textarea":
-        if (!customDefaultValueField) {
-          fieldSettings.defaultValue = {
-            type: resolvedType,
-            label: "Default Value"
-          };
-        }
-        break;
-      case "number":
-        if (!customDefaultValueField) {
-          fieldSettings.defaultValue = {
-            type: resolvedType,
-            label: "Default Value"
-          };
-        }
-        fieldSettings.min = {
-          type: resolvedType,
-          label: "Minimum Value"
-        };
-        fieldSettings.max = {
-          type: resolvedType,
-          label: "Maximum Value"
-        };
-        fieldSettings.step = {
-          type: resolvedType,
-          label: "Step Size"
-        };
-        break;
-      case "radio":
-      case "select": {
-        const selectOptions = (currentFieldSettings == null ? void 0 : currentFieldSettings.options) || [];
-        if (!customDefaultValueField) {
-          fieldSettings.defaultValue = {
-            type: "custom",
-            label: "Default Value",
-            render: ({ value, onChange, id }) => /* @__PURE__ */ jsx(
-              AutoField,
-              {
-                field: {
-                  type: resolvedType,
-                  label: "Default Value",
-                  options: selectOptions
-                },
-                value,
-                onChange,
-                readOnly: false,
-                id
-              }
-            )
-          };
-        }
-        fieldSettings.options = {
-          type: "array",
-          label: "Options",
-          defaultItemProps: {
-            label: "New Option",
-            value: "new"
-          },
-          arrayFields: {
-            label: { type: "text", label: "Label" },
-            value: {
-              type: "text",
-              label: "Value"
-            }
-          },
-          getItemSummary(item, index) {
-            return item.label || `Option ${(index || 0) + 1}`;
-          }
-        };
-        break;
-      }
-      case "array":
-      case "object":
-        fieldSettings.subFields = {
-          type: "array",
-          label: "Sub Fields",
-          defaultItemProps: {
-            name: "New Sub Field",
-            type: "text"
-          },
-          arrayFields: {
-            name: { type: "text", label: "Name" },
-            type: {
-              type: "select",
-              options: deep ? [
-                {
-                  label: "Text",
-                  value: "text"
-                },
-                {
-                  label: "Number",
-                  value: "number"
-                },
-                {
-                  label: "Select",
-                  value: "select"
-                },
-                {
-                  label: "Radio",
-                  value: "radio"
-                },
-                ...customTypeOptions
-              ] : [
-                {
-                  label: "Text",
-                  value: "text"
-                },
-                {
-                  label: "Number",
-                  value: "number"
-                },
-                {
-                  label: "Select",
-                  value: "select"
-                },
-                {
-                  label: "Radio",
-                  value: "radio"
-                },
-                {
-                  label: "Array",
-                  value: "array"
-                },
-                {
-                  label: "Object",
-                  value: "object"
-                },
-                {
-                  label: "Reference",
-                  value: "reference"
-                },
-                ...customTypeOptions
-              ]
-            }
-          },
-          getItemSummary(item, index) {
-            return item.name || `Field ${(index || 0) + 1}`;
-          }
-        };
-        if (!deep)
-          fieldSettings.subFieldSettings = {
-            type: "object",
-            label: "Sub Field Settings",
-            objectFields: resolvedSubFields ? getFieldSettings(
-              resolvedSubFields,
-              resolvedSubFieldSettings,
-              customFields,
-              true
-            ) : {}
-          };
-        if (resolvedType === "array") {
-          if (!customDefaultValueField) {
-            fieldSettings.defaultValue = {
-              type: "array",
-              label: "Default Items",
-              arrayFields: buildDefaultEditorFields(
-                resolvedSubFields,
-                resolvedSubFieldSettings,
-                customFields
-              ),
-              defaultItemProps: buildArrayDefaultItemProps(
-                resolvedSubFields,
-                resolvedSubFieldSettings
-              ),
-              getItemSummary(item, index) {
-                return getArrayItemSummary(item, index, currentFieldSettings);
-              }
-            };
-          }
-          fieldSettings.min = {
-            type: "number",
-            label: "Minimum Items"
-          };
-          fieldSettings.max = {
-            type: "number",
-            label: "Maximum Items"
-          };
-          fieldSettings.summary = {
-            type: "select",
-            label: "Summary",
-            options: [
-              {
-                label: "Default Numbering / Count",
-                value: "count"
-              },
-              {
-                label: "Field",
-                value: "field"
-              },
-              {
-                label: "Expression",
-                value: "expression"
-              }
-            ]
-          };
-          if ((currentFieldSettings == null ? void 0 : currentFieldSettings.summary) === "field") {
-            fieldSettings.summaryField = {
-              type: "select",
-              label: "Summary Field",
-              options: [
-                {
-                  label: "Select a field",
-                  value: ""
-                },
-                ...resolvedSubFields.filter((subField) => isPrimitiveFieldType(subField.type)).map((subField) => ({
-                  label: subField.name,
-                  value: subField.name
-                }))
-              ]
-            };
-          }
-          if ((currentFieldSettings == null ? void 0 : currentFieldSettings.summary) === "expression") {
-            fieldSettings.summaryExpression = {
-              type: "text",
-              label: "Summary Expression"
-            };
-          }
-        }
-        break;
-    }
-    const overriddenFieldSettings = (customFieldDefinition == null ? void 0 : customFieldDefinition.fieldSettingsOverride) ? customFieldDefinition.fieldSettingsOverride({
-      fieldName: field.name,
-      fieldType: field.type,
-      fieldSettings: currentFieldSettings,
-      originalFieldSettings: fieldSettings
-    }) : fieldSettings;
-    fields[field.name] = {
-      type: "object",
-      label: field.name,
-      objectFields: overriddenFieldSettings
-    };
-    return fields;
-  }, {});
-};
-var get_field_settings_default = getFieldSettings;
-
-// src/puck/context/useStore.ts
-import { createContext, useContext } from "react";
-import { useStore } from "zustand";
-var appStoreContext = createContext(null);
-var createUseSoftConfig = () => {
-  return function useSoftConfig2(selector, equalityFn) {
-    const context = useContext(appStoreContext);
-    if (!context) {
-      throw new Error(
-        "useSoftConfig must be used inside a SoftConfigProvider. Wrap your tree with <SoftConfigProvider value={store}>"
-      );
-    }
-    if (equalityFn) {
-      return useStore(context, selector, equalityFn);
-    }
-    return useStore(context, selector);
-  };
-};
-var useSoftConfig = createUseSoftConfig();
-var useSoftConfigStore = () => {
-  const context = useContext(appStoreContext);
-  if (!context) {
-    throw new Error(
-      "useSoftConfigStore must be used inside a SoftConfigProvider."
-    );
-  }
-  return context;
-};
-
 // src/puck/lib/apply-mapping.ts
-import equal from "react-fast-compare";
-
-// src/puck/lib/set-prop-by-path.ts
-function setPropertyByPath(props, path, value) {
-  const parts = path.split(".");
-  const last = parts.pop();
-  let cur = props;
-  for (const p of parts) {
-    if (typeof cur[p] !== "object" || cur[p] === null) cur[p] = {};
-    cur = cur[p];
+var pathSegmentsCache = /* @__PURE__ */ new Map();
+var getPathSegments = (path) => {
+  let segments = pathSegmentsCache.get(path);
+  if (!segments) {
+    segments = path.split(".");
+    pathSegmentsCache.set(path, segments);
   }
-  cur[last] = value;
-}
-
-// src/puck/lib/apply-mapping.ts
+  return segments;
+};
 var resolveValueByPath = (source, path) => {
   if (!path) return source;
-  const segments = path.split(".");
+  const segments = getPathSegments(path);
   const resolveSegments = (current, index) => {
     if (current === null || current === void 0) return void 0;
     if (index >= segments.length) return current;
@@ -658,7 +201,7 @@ var resolveValueByPath = (source, path) => {
 };
 var resolveFieldSettingEntryByPath = (settings, path) => {
   if (!path) return void 0;
-  const segments = path.split(".");
+  const segments = getPathSegments(path);
   let currentSettings = settings;
   let currentEntry;
   for (const segmentWithArraySuffix of segments) {
@@ -676,11 +219,11 @@ var resolveFieldSettingEntryByPath = (settings, path) => {
 };
 function applyMapping(props, fieldSettings, map, resolveInput = "fieldSettings", options) {
   var _a, _b, _c;
-  const newProps = __spreadValues({}, props);
+  let newProps = props;
   const sourceProps = (_a = options == null ? void 0 : options.sourceProps) != null ? _a : props;
   const mappedArrayPaths = /* @__PURE__ */ new Set();
   let changed = false;
-  const changedArrayBases = /* @__PURE__ */ new Set();
+  const arrayRulesMap = /* @__PURE__ */ new Map();
   for (const entry of map) {
     const { from, to, transform } = entry;
     if (!from || !to) continue;
@@ -719,43 +262,21 @@ function applyMapping(props, fieldSettings, map, resolveInput = "fieldSettings",
     if (isSingleArrayTarget) {
       const toPath = toPaths[0];
       const arrayBase = getArrayBasePath(toPath);
-      const subProp = getArrayItemSubPath(toPath) || "";
       if (!arrayBase) continue;
-      const defaultArray = Array.isArray((_b = options == null ? void 0 : options.arrayDefaults) == null ? void 0 : _b[arrayBase]) ? (_c = options == null ? void 0 : options.arrayDefaults) == null ? void 0 : _c[arrayBase] : [];
-      const currentArrayAtPath = resolveValueByPath(newProps, arrayBase);
-      const currentArray = Array.isArray(currentArrayAtPath) ? currentArrayAtPath : [];
-      const isFromArrayPath = typeof fromPaths[0] === "string" && isArrayMappingPath(fromPaths[0]);
-      const sourceArray = isFromArrayPath ? Array.isArray(result) ? result : result !== void 0 ? [result] : [] : Array.isArray(result) ? result : defaultArray.map(() => result);
-      let defaults = entry.unmappedArrayItemDefaultValues || entry.defaultOverrides || {};
-      if (typeof defaults === "string") {
-        try {
-          defaults = JSON.parse(defaults);
-        } catch (e) {
-          defaults = {};
-        }
-      }
-      const targetLength = sourceArray.length;
-      const constructed = Array.from({ length: targetLength }).map((_, idx) => {
-        const mappedValue = sourceArray[idx];
-        const defaultItem = defaultArray[idx] && typeof defaultArray[idx] === "object" ? defaultArray[idx] : {};
-        const currentItem = currentArray[idx] && typeof currentArray[idx] === "object" ? currentArray[idx] : {};
-        const item = __spreadValues(__spreadValues(__spreadValues({}, defaultItem), defaults), currentItem);
-        if (subProp && mappedValue !== void 0) {
-          setPropertyByPath(item, subProp, mappedValue);
-        }
-        return item;
-      });
-      const originalArray = resolveValueByPath(newProps, arrayBase);
-      if (!equal(originalArray, constructed)) {
-        setPropertyByPath(newProps, arrayBase, constructed);
-        changedArrayBases.add(arrayBase);
+      let rules = arrayRulesMap.get(arrayBase);
+      if (!rules) {
+        rules = [];
+        arrayRulesMap.set(arrayBase, rules);
       }
+      rules.push({ entry, toPath, fromPaths, result });
       mappedArrayPaths.add(arrayBase);
-    } else if (toPaths.length === 1 && Array.isArray(result) && toPaths[0].includes("array")) {
+      continue;
+    }
+    if (toPaths.length === 1 && Array.isArray(result) && toPaths[0].includes("array")) {
       const toPath = toPaths[0];
       const original = resolveValueByPath(newProps, toPath);
       if (!equal(original, result)) {
-        setPropertyByPath(newProps, toPath, result);
+        newProps = setImmutablePropertyByPath(newProps, toPath, result);
         changed = true;
       }
     } else if (Array.isArray(result) && toPaths.length > 1) {
@@ -763,7 +284,7 @@ function applyMapping(props, fieldSettings, map, resolveInput = "fieldSettings",
         if (toPaths[idx]) {
           const orig = resolveValueByPath(newProps, toPaths[idx]);
           if (!equal(orig, val)) {
-            setPropertyByPath(newProps, toPaths[idx], val);
+            newProps = setImmutablePropertyByPath(newProps, toPaths[idx], val);
             changed = true;
           }
         }
@@ -772,565 +293,233 @@ function applyMapping(props, fieldSettings, map, resolveInput = "fieldSettings",
       const finalValue = result;
       const originalValue = resolveValueByPath(newProps, toPaths[0]);
       if (!equal(originalValue, finalValue)) {
-        setPropertyByPath(newProps, toPaths[0], finalValue);
+        newProps = setImmutablePropertyByPath(newProps, toPaths[0], finalValue);
         changed = true;
       }
     }
   }
-  const hasNetArrayChanges = Array.from(changedArrayBases).some(
-    (arrayBase) => !equal(resolveValueByPath(props, arrayBase), resolveValueByPath(newProps, arrayBase))
-  );
-  return { newProps, mappedArrayPaths, changed: changed || hasNetArrayChanges };
-}
-
-// src/puck/lib/builder/root-config.tsx
-import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
-var useCustomPuck = createUsePuck();
-var getSerializableProps = (props) => {
-  const cleanProps = {
-    id: props.id
-  };
-  for (const key in props) {
-    const value = props[key];
-    if (["children", "puck", "editMode"].includes(key)) continue;
-    if (value && typeof value === "object" && value.$$typeof) continue;
-    if (typeof value === "function") continue;
-    cleanProps[key] = value;
-  }
-  return cleanProps;
-};
-var builderRootConfig = (config, overrides, editingComponent, showVersionFields = true, customFields) => {
-  const customTypeOptions = getCustomFieldTypeOptions(customFields);
-  return {
-    fields: __spreadValues({
-      _name: overrides.name || {
-        type: "text",
-        label: "Soft Component Name"
-      },
-      _category: overrides.categories || {
-        type: "select",
-        label: "Category",
-        options: [
-          ...Object.keys(config.categories || {}).map((cat) => {
-            var _a;
-            return {
-              label: ((_a = config.categories) == null ? void 0 : _a[cat].title) || cat,
-              value: cat
-            };
-          }) || [],
-          {
-            label: Object.keys(config.categories || {}).length ? "Other" : "Uncategorized",
-            value: void 0
-          }
-        ]
-      },
-      _fields: {
-        type: "array",
-        label: "Fields",
-        defaultItemProps: {
-          name: "New Field",
-          type: "text"
-        },
-        getItemSummary(item, index) {
-          return item.name || `Field ${(index || 0) + 1}`;
-        },
-        arrayFields: {
-          name: { type: "text", label: "Name" },
-          type: {
-            type: "select",
-            label: "Type",
-            options: [
-              { label: "Text", value: "text" },
-              { label: "Textarea", value: "textarea" },
-              { label: "Number", value: "number" },
-              { label: "Select", value: "select" },
-              { label: "Radio", value: "radio" },
-              { label: "Array", value: "array" },
-              { label: "Object", value: "object" },
-              // { label: "Reference", value: "reference" },
-              ...customTypeOptions
-            ]
+  for (const [arrayBase, rules] of arrayRulesMap.entries()) {
+    const defaultArray = Array.isArray((_b = options == null ? void 0 : options.arrayDefaults) == null ? void 0 : _b[arrayBase]) ? (_c = options == null ? void 0 : options.arrayDefaults) == null ? void 0 : _c[arrayBase] : [];
+    const currentArrayAtPath = resolveValueByPath(newProps, arrayBase);
+    const currentArray = Array.isArray(currentArrayAtPath) ? currentArrayAtPath : [];
+    let targetLength = 0;
+    const ruleSourceArrays = rules.map(({ entry, fromPaths, result }) => {
+      const isFromArrayPath = typeof fromPaths[0] === "string" && isArrayMappingPath(fromPaths[0]);
+      const sourceArray = isFromArrayPath ? Array.isArray(result) ? result : result !== void 0 ? [result] : [] : Array.isArray(result) ? result : defaultArray.map(() => result);
+      targetLength = Math.max(targetLength, sourceArray.length);
+      return sourceArray;
+    });
+    const constructed = Array.from({ length: targetLength }).map((_, idx) => {
+      const defaultItem = defaultArray[idx] && typeof defaultArray[idx] === "object" ? defaultArray[idx] : {};
+      const currentItem = currentArray[idx] && typeof currentArray[idx] === "object" ? currentArray[idx] : {};
+      let mergedDefaults = {};
+      for (const rule of rules) {
+        let ruleDefaults = rule.entry.unmappedArrayItemDefaultValues || rule.entry.defaultOverrides || {};
+        if (typeof ruleDefaults === "string") {
+          try {
+            ruleDefaults = JSON.parse(ruleDefaults);
+          } catch (e) {
           }
         }
+        mergedDefaults = __spreadValues(__spreadValues({}, mergedDefaults), ruleDefaults);
       }
-    }, overrides.additionalRootFields || {}),
-    resolveFields({ props: data }, { fields, changed }) {
-      const newFields = __spreadValues({}, fields);
-      const rootFields = Array.isArray(
-        data == null ? void 0 : data._fields
-      ) ? (data == null ? void 0 : data._fields) || [] : [];
-      const rootFieldSettings = (data == null ? void 0 : data._fieldSettings) || {};
-      if (changed._fields || changed._fieldSettings) {
-        if (rootFields.length) {
-          newFields._fieldSettings = {
-            type: "object",
-            label: "Field Settings",
-            objectFields: get_field_settings_default(
-              rootFields,
-              rootFieldSettings,
-              customFields
-            )
-          };
-        } else {
-          delete newFields._fieldSettings;
-        }
-      }
-      return newFields;
-    },
-    // resolveData: (props, params) => {
-    //   if (overrides.resolveRootData) {
-    //     return overrides.resolveRootData(props, params, { editingComponent });
-    //   }
-    //   const result: {
-    //     props: RootData<AsFieldProps<WithChildren<BuilderRootConfig>>>;
-    //     readOnly: Readonly<Record<string, boolean>> | undefined;
-    //   } = {
-    //     props,
-    //     readOnly: undefined,
-    //   };
-    //   return result;
-    // },
-    render: (props) => {
-      const fieldSettings = props == null ? void 0 : props._fieldSettings;
-      const data = useCustomPuck((s) => s.appState.data);
-      const dispatch = useCustomPuck((s) => s.dispatch);
-      const getSelectorForId = useCustomPuck((s) => s.getSelectorForId);
-      const setVersion = useSoftConfig((s) => s.builder.setVersion);
-      const state = useSoftConfig((s) => s.state);
-      useEffect(() => {
-        if (!fieldSettings || Object.keys(fieldSettings).length === 0) return;
-        const replacements = [];
-        walkTree(
-          {
-            content: (data == null ? void 0 : data.content) || [],
-            root: (data == null ? void 0 : data.root) || {}
-          },
-          {
-            components: config.components
-          },
-          (content) => content.map((child) => {
-            var _a;
-            const map = ((_a = child.props) == null ? void 0 : _a._map) || [];
-            if (!map.length) return child;
-            const cleanProps = getSerializableProps(child.props);
-            const { newProps, changed } = applyMapping(
-              cleanProps,
-              fieldSettings,
-              map,
-              "fieldSettings"
-            );
-            if (!changed || equal2(cleanProps, newProps)) return child;
-            replacements.push({
-              id: child.props.id,
-              data: __spreadProps(__spreadValues({}, child), { props: newProps })
-            });
-            return child;
-          })
-        );
-        if (!replacements.length) return;
-        replacements.forEach((replacement) => {
-          const itemSelector = getSelectorForId(replacement.id);
-          if (!itemSelector) return;
-          dispatch({
-            type: "replace",
-            data: replacement.data,
-            destinationIndex: itemSelector.index,
-            destinationZone: itemSelector.zone
-          });
-        });
-      }, [fieldSettings, data, dispatch, getSelectorForId]);
-      useEffect(() => {
-        var _a;
-        if (state !== "remodeling" || !(props == null ? void 0 : props._version) || !(props == null ? void 0 : props._name)) return;
-        const currentVersion = props._version;
-        if (((_a = props._versions) == null ? void 0 : _a.includes(currentVersion)) && props._versions.length > 1) {
-          setVersion(props._name, currentVersion, props, dispatch);
+      const baseItem = __spreadValues(__spreadValues({}, defaultItem), mergedDefaults);
+      let newItem = void 0;
+      for (const key of Object.keys(baseItem)) {
+        if (!(key in currentItem) && baseItem[key] !== void 0) {
+          if (!newItem) newItem = __spreadValues({}, currentItem);
+          if (newItem) {
+            newItem[key] = baseItem[key];
+          }
         }
-      }, [props == null ? void 0 : props._version]);
-      return /* @__PURE__ */ jsx2(Fragment, { children: props.children });
-    }
-  };
-};
-
-// src/puck/lib/builder/generate-field-options.ts
-var hasArrayMappingPath = (value) => value.includes("[]");
-var isBareArrayPath = (value) => !hasArrayMappingPath(value) && !value.includes(".");
-function filterToOptionsForFrom(fromPath, toOptions) {
-  if (!fromPath) return toOptions;
-  const fromHasArrayMapping = hasArrayMappingPath(fromPath);
-  const fromIsBareArray = isBareArrayPath(fromPath);
-  return toOptions.filter((option) => {
-    const optionHasArrayMapping = hasArrayMappingPath(option.value);
-    if (fromHasArrayMapping) {
-      return optionHasArrayMapping;
-    }
-    if (fromIsBareArray) {
-      return isBareArrayPath(option.value);
-    }
-    return !optionHasArrayMapping;
-  });
-}
-function generateFieldOptions(fields, prefix = "") {
-  const opts = [];
-  function recurse(current, prefix2) {
-    Object.entries(current).forEach(([key, fld]) => {
-      if (fld.type === "slot") return;
-      if (key === "_map") return;
-      if (key === "_slotEnabled") return;
-      const path = prefix2 ? `${prefix2}.${key}` : key;
-      if (fld.type === "object" && fld.objectFields) {
-        recurse(fld.objectFields, path);
-      } else if (fld.type === "array" && fld.arrayFields) {
-        recurse(
-          fld.arrayFields,
-          path + "[]"
-        );
-      } else {
-        opts.push({ label: path, value: path, type: fld.type });
       }
-    });
-  }
-  recurse(fields, prefix);
-  return opts;
-}
-function generateDynamicFieldOptions(_fields, _fieldSettings, customFields, prefix = "") {
-  const opts = [];
-  if (!_fields) return opts;
-  function recurse(fields, fieldSettings, currentPrefix) {
-    fields.forEach((field) => {
-      var _a;
-      const settings = fieldSettings[field.name];
-      const customReturnType = resolveCustomFieldReturnType(
-        field.type,
-        customFields
-      );
-      const path = currentPrefix ? `${currentPrefix}.${field.name}` : field.name;
-      if (customReturnType) {
-        if (customReturnType === "array" || customReturnType === "object") {
-          const customSchema = resolveCustomFieldSchema(field.type, customFields);
-          if (!customSchema) {
-            return;
+      for (let i = 0; i < rules.length; i++) {
+        const { toPath } = rules[i];
+        const subProp = getArrayItemSubPath(toPath) || "";
+        const mappedValue = ruleSourceArrays[i][idx];
+        if (subProp && mappedValue !== void 0) {
+          const existingValue = resolveValueByPath(newItem || currentItem, subProp);
+          if (!equal(existingValue, mappedValue)) {
+            newItem = setImmutablePropertyByPath(newItem || currentItem, subProp, mappedValue);
           }
-          recurse(
-            customSchema.subFields,
-            customSchema.subFieldSettings,
-            path + (customReturnType === "array" ? "[]" : "")
-          );
-          return;
         }
-        opts.push({
-          label: path,
-          value: path,
-          type: mapCustomReturnTypeToMappingType(customReturnType)
-        });
-        return;
-      }
-      if (!isBuiltInSoftFieldType(field.type)) {
-        return;
-      }
-      if ((_a = settings == null ? void 0 : settings.subFields) == null ? void 0 : _a.length) {
-        recurse(
-          settings.subFields,
-          settings.subFieldSettings || {},
-          path + (field.type === "array" ? "[]" : "")
-        );
-      } else if (field.type !== "array" && field.type !== "object") {
-        opts.push({ label: path, value: path, type: field.type });
       }
+      return newItem !== void 0 ? newItem : currentItem;
     });
+    let arrayChanged = currentArray.length !== constructed.length;
+    if (!arrayChanged) {
+      for (let i = 0; i < currentArray.length; i++) {
+        if (currentArray[i] !== constructed[i]) {
+          arrayChanged = true;
+          break;
+        }
+      }
+    }
+    if (arrayChanged) {
+      newProps = setImmutablePropertyByPath(newProps, arrayBase, constructed);
+      changed = true;
+    }
   }
-  recurse(_fields, _fieldSettings || {}, prefix);
-  return opts;
-}
-
-// src/puck/components/error-boundary/index.tsx
-import { Component } from "react";
-
-// src/puck/lib/get-class-name-factory.ts
-import classnames from "classnames";
-var getClassNameFactory = (rootClass, styles, config = { baseClass: "" }) => (options = {}) => {
-  if (typeof options === "string") {
-    const descendant = options;
-    const style = styles[`${rootClass}-${descendant}`];
-    if (style) {
-      return config.baseClass + styles[`${rootClass}-${descendant}`] || "";
-    }
-    return "";
-  } else if (typeof options === "object") {
-    const modifiers = options;
-    const prefixedModifiers = {};
-    for (let modifier in modifiers) {
-      prefixedModifiers[styles[`${rootClass}--${modifier}`]] = modifiers[modifier];
-    }
-    const c = styles[rootClass];
-    return config.baseClass + classnames(__spreadValues({
-      [c]: !!c
-    }, prefixedModifiers));
-  } else {
-    return config.baseClass + styles[rootClass] || "";
-  }
-};
-var get_class_name_factory_default = getClassNameFactory;
-
-// css-module:/home/osamu/Documents/netlisian-soft/packages/soft-config/src/puck/components/error-boundary/styles.module.css#css-module
-var styles_module_default = { "ErrorBoundary": "_ErrorBoundary_1xl05_5", "ErrorBoundary-title": "_ErrorBoundary-title_1xl05_21", "ErrorBoundary-details": "_ErrorBoundary-details_1xl05_31", "ErrorBoundary-button": "_ErrorBoundary-button_1xl05_39" };
-
-// src/puck/components/error-boundary/index.tsx
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
-var getClassName = get_class_name_factory_default("ErrorBoundary", styles_module_default);
-var ErrorBoundary = class extends Component {
-  constructor(props) {
-    super(props);
-    this.resetError = () => {
-      this.setState({
-        hasError: false,
-        error: null
-      });
-    };
-    this.state = {
-      hasError: false,
-      error: null
-    };
-  }
-  static getDerivedStateFromError(error) {
-    return {
-      hasError: true,
-      error
-    };
+  return { newProps, mappedArrayPaths, changed };
+}
+
+// src/puck/lib/root-action-handler.ts
+var currentGeneration = 0;
+function hasDefaultValueChanged(prev, curr) {
+  var _a, _b;
+  if (!prev && !curr) return false;
+  if (!prev || !curr) return true;
+  if (!isEqual(prev == null ? void 0 : prev.defaultValue, curr == null ? void 0 : curr.defaultValue)) return true;
+  if ((prev == null ? void 0 : prev.subFieldSettings) || (curr == null ? void 0 : curr.subFieldSettings)) {
+    const subKeys = /* @__PURE__ */ new Set([
+      ...Object.keys((prev == null ? void 0 : prev.subFieldSettings) || {}),
+      ...Object.keys((curr == null ? void 0 : curr.subFieldSettings) || {})
+    ]);
+    for (const subKey of subKeys) {
+      if (hasDefaultValueChanged(
+        (_a = prev == null ? void 0 : prev.subFieldSettings) == null ? void 0 : _a[subKey],
+        (_b = curr == null ? void 0 : curr.subFieldSettings) == null ? void 0 : _b[subKey]
+      )) {
+        return true;
+      }
+    }
   }
-  componentDidCatch(error, errorInfo) {
-    console.error("Error caught by ErrorBoundary:", error, errorInfo);
+  return false;
+}
+var processReplacements = (appState, get, fieldSettings, changedKeys, zones, nodes) => __async(null, null, function* () {
+  var _a, _b;
+  const generation = ++currentGeneration;
+  yield new Promise((resolve) => setTimeout(resolve, 150));
+  if (generation !== currentGeneration) return;
+  const { puckDispatch, editableComponentIds } = get();
+  if (!puckDispatch) return;
+  if (changedKeys.size === 0) return;
+  const replacements = [];
+  const editableSet = new Set(editableComponentIds || []);
+  const hasEditableFilter = editableSet.size > 0;
+  const nodeEntries = Object.entries(nodes);
+  for (let i = 0; i < nodeEntries.length; i++) {
+    if (generation !== currentGeneration) return;
+    if (i > 0 && i % 50 === 0) {
+      yield new Promise((resolve) => setTimeout(resolve, 0));
+      if (generation !== currentGeneration) return;
+    }
+    const [id, node] = nodeEntries[i];
+    if (hasEditableFilter && !editableSet.has(id)) {
+      continue;
+    }
+    const map = ((_a = node.data.props) == null ? void 0 : _a._map) || [];
+    if (!map.length) continue;
+    let isAffected = false;
+    const flatProps = ((_b = node.flatData) == null ? void 0 : _b.props) || {};
+    for (const [flatKey, flatValue] of Object.entries(flatProps)) {
+      if (flatKey.includes("_map") && flatKey.includes("from") && typeof flatValue === "string") {
+        if (changedKeys.has(flatValue) || Array.from(changedKeys).some(
+          (ck) => flatValue.startsWith(ck + ".") || flatValue.startsWith(ck + "[")
+        )) {
+          isAffected = true;
+          break;
+        }
+      }
+    }
+    if (!isAffected) continue;
+    const { newProps } = applyMapping(
+      __spreadValues({}, node.data.props),
+      fieldSettings,
+      map,
+      "fieldSettings"
+    );
+    replacements.push({
+      id,
+      data: __spreadProps(__spreadValues({}, node.data), {
+        props: __spreadValues(__spreadValues({}, node.data.props), newProps)
+      })
+    });
   }
-  render() {
-    if (this.state.hasError) {
-      if (typeof this.props.fallback === "function") {
-        return this.props.fallback(this.state.error, this.resetError);
+  if (!replacements.length) return;
+  requestAnimationFrame(() => {
+    replacements.forEach((replacement) => {
+      var _a2;
+      const node = nodes[replacement.id];
+      if (!node) return;
+      const zoneName = `${node.parentId}:${node.zone}`;
+      const index = (_a2 = zones[zoneName]) == null ? void 0 : _a2.contentIds.indexOf(replacement.id);
+      if (index !== void 0 && index !== -1) {
+        puckDispatch({
+          type: "replace",
+          destinationIndex: index,
+          destinationZone: zoneName,
+          data: replacement.data,
+          ui: void 0
+        });
       }
-      if (this.props.fallback) {
-        return this.props.fallback;
+    });
+  });
+});
+var processVersionChange = (rootProps, get, zones, nodes) => {
+  const currentVersion = rootProps._version;
+  const versions = rootProps._versions || [];
+  if (versions.includes(currentVersion) && versions.length > 1) {
+    const puckDispatch = get().puckDispatch;
+    if (puckDispatch) {
+      get().builder.setVersion(
+        rootProps._name,
+        currentVersion,
+        rootProps,
+        puckDispatch,
+        // Mock getItemBySelector using indexes
+        (selector) => {
+          var _a;
+          if (!selector.zone) return void 0;
+          const id = (_a = zones[selector.zone]) == null ? void 0 : _a.contentIds[selector.index];
+          return id ? nodes[id].data : void 0;
+        },
+        // Mock getSelectorForId using indexes
+        (id) => {
+          var _a;
+          const node = nodes[id];
+          if (!node) return void 0;
+          const index = (_a = zones[node.zone]) == null ? void 0 : _a.contentIds.indexOf(id);
+          return { zone: node.zone, index };
+        }
+      );
+    }
+  }
+};
+var rootActionHandler = (set, get) => (action, appState, previousState) => {
+  const storeState = get().state;
+  if (storeState !== "building" && storeState !== "remodeling" || action.type !== "replaceRoot") {
+    return;
+  }
+  const { zones, nodes } = appState.indexes;
+  const rootProps = appState.data.root.props;
+  const previousRootProps = (previousState == null ? void 0 : previousState.data.root).props;
+  const fieldSettings = rootProps == null ? void 0 : rootProps._fieldSettings;
+  const previousFieldSettings = previousRootProps == null ? void 0 : previousRootProps._fieldSettings;
+  if (fieldSettings) {
+    const changedKeys = /* @__PURE__ */ new Set();
+    const allKeys = /* @__PURE__ */ new Set([
+      ...Object.keys(previousFieldSettings || {}),
+      ...Object.keys(fieldSettings || {})
+    ]);
+    for (const key of allKeys) {
+      if (hasDefaultValueChanged(previousFieldSettings == null ? void 0 : previousFieldSettings[key], fieldSettings == null ? void 0 : fieldSettings[key])) {
+        changedKeys.add(key);
       }
-      return /* @__PURE__ */ jsxs("div", { className: getClassName(), children: [
-        /* @__PURE__ */ jsx3("h3", { className: getClassName("title"), children: "Component Error" }),
-        /* @__PURE__ */ jsxs("details", { className: getClassName("details"), children: [
-          /* @__PURE__ */ jsx3("summary", { children: "Show error details" }),
-          this.state.error && this.state.error.toString()
-        ] }),
-        /* @__PURE__ */ jsx3(
-          "button",
-          {
-            onClick: this.resetError,
-            className: getClassName("button"),
-            children: "Try Again"
-          }
-        )
-      ] });
     }
-    return this.props.children;
+    if (changedKeys.size > 0) {
+      processReplacements(appState, get, fieldSettings, changedKeys, zones, nodes);
+    }
+  }
+  if (storeState === "remodeling" && (rootProps == null ? void 0 : rootProps._version) && (rootProps == null ? void 0 : rootProps._name) && (rootProps == null ? void 0 : rootProps._version) !== (previousRootProps == null ? void 0 : previousRootProps._version)) {
+    processVersionChange(rootProps, get, zones, nodes);
   }
 };
 
-// src/puck/lib/builder/builder-config.tsx
-import { jsx as jsx4 } from "react/jsx-runtime";
-var builderConfig = (config, overrides, editingComponent, showVersionFields = true, dependents, customFields) => ({
-  root: builderRootConfig(
-    config,
-    overrides,
-    editingComponent,
-    showVersionFields,
-    customFields
-  ),
-  components: Object.entries(__spreadValues({}, config.components)).reduce(
-    (acc, [name, component]) => {
-      const tempComponent = __spreadProps(__spreadValues({}, component), {
-        permissions: {
-          insert: editingComponent !== name && !(dependents == null ? void 0 : dependents.has(name))
-        },
-        resolveFields(data, params) {
-          return __async(this, null, function* () {
-            var _a2;
-            let fields = {};
-            if (!fields._slot) {
-              const slotFields = Object.entries(params.fields).filter(
-                ([_, field]) => field.type === "slot"
-              );
-              if (slotFields.length)
-                fields._slot = {
-                  type: "array",
-                  label: "Enable Dropdown Slots",
-                  getItemSummary(item, index) {
-                    return item.slot || `Slot ${(index || 0) + 1}`;
-                  },
-                  arrayFields: {
-                    slot: {
-                      type: "select",
-                      label: "Slot",
-                      options: [
-                        { label: "Select a slot", value: "" },
-                        ...slotFields.filter(
-                          ([fieldName, field]) => {
-                            var _a3;
-                            return field.type === "slot" && !(((_a3 = data.props) == null ? void 0 : _a3._slot) || []).some(
-                              (s) => s.slot === fieldName
-                            );
-                          }
-                        ).map(([fieldName, field]) => ({
-                          label: field.label || fieldName,
-                          value: fieldName
-                        }))
-                      ]
-                    },
-                    name: {
-                      type: "text",
-                      label: "Name",
-                      placeholder: "Optional Slot Name"
-                    }
-                  }
-                };
-            }
-            const defaultFields = component.resolveFields ? yield component.resolveFields(data, params) : component.fields || {};
-            if (!fields._map || params.changed._map) {
-              const rootProps = getRootProps(params.appState);
-              const fromOptions = generateDynamicFieldOptions(
-                (rootProps == null ? void 0 : rootProps._fields) || [],
-                (rootProps == null ? void 0 : rootProps._fieldSettings) || {},
-                customFields
-              );
-              const toOptionsFields = component.resolveFields && ((_a2 = data.props) == null ? void 0 : _a2._map) ? yield component.resolveFields(
-                __spreadProps(__spreadValues({}, data), { props: __spreadProps(__spreadValues({}, data.props), { _map: void 0 }) }),
-                params
-              ) : defaultFields;
-              const toOptions = generateFieldOptions(toOptionsFields);
-              fields._map = overrides.map ? {
-                type: "custom",
-                render: ({ value, onChange, id }) => {
-                  const rootProps2 = getRootProps(params.appState);
-                  return overrides.map({
-                    rootProps: rootProps2,
-                    value,
-                    onChange,
-                    id,
-                    props: data.props || {},
-                    fromOptions,
-                    toOptions
-                  });
-                }
-              } : (() => {
-                var _a3;
-                const mapEntries = ((_a3 = data.props) == null ? void 0 : _a3._map) || [];
-                const toPaths = mapEntries.flatMap(
-                  (entry) => Array.isArray(entry.to) ? entry.to : entry.to ? [entry.to] : []
-                );
-                const toPath = toPaths.find(
-                  (path) => typeof path === "string" && isArrayMappingPath(path)
-                );
-                const arrayBaseName = toPath ? getArrayBasePath(toPath) : null;
-                const targetArrayField = arrayBaseName ? defaultFields[arrayBaseName] : null;
-                const mappedSubProps = /* @__PURE__ */ new Set();
-                if (arrayBaseName) {
-                  toPaths.forEach((path) => {
-                    if (typeof path !== "string") return;
-                    if (getArrayBasePath(path) !== arrayBaseName) return;
-                    const subProp = getArrayItemSubPath(path);
-                    if (subProp) mappedSubProps.add(subProp);
-                  });
-                }
-                const defaultValueFields = {};
-                if (targetArrayField && targetArrayField.type === "array" && targetArrayField.arrayFields) {
-                  const arrayFields = targetArrayField.arrayFields;
-                  Object.entries(arrayFields).forEach(([key, fld]) => {
-                    if (mappedSubProps.has(key)) return;
-                    if (fld.type === "array" || fld.type === "object" || fld.type === "slot") return;
-                    defaultValueFields[key] = __spreadProps(__spreadValues({}, fld), { label: fld.label || key });
-                  });
-                }
-                const baseArrayFields = {
-                  from: {
-                    type: "select",
-                    label: "From",
-                    options: [
-                      { label: "Select a field", value: "" },
-                      ...fromOptions.map(({ label, value }) => ({
-                        label,
-                        value
-                      }))
-                    ]
-                  },
-                  to: {
-                    type: "select",
-                    label: "To",
-                    options: [
-                      { label: "Select a field", value: "" },
-                      ...toOptions.map(({ label, value }) => ({
-                        label,
-                        value
-                      }))
-                    ]
-                  }
-                };
-                if (arrayBaseName && Object.keys(defaultValueFields).length > 0) {
-                  baseArrayFields.unmappedArrayItemDefaultValues = {
-                    type: "object",
-                    label: "Default Item Values",
-                    objectFields: defaultValueFields
-                  };
-                }
-                return {
-                  type: "array",
-                  label: "Dynamic Field Map",
-                  arrayFields: baseArrayFields
-                };
-              })();
-            }
-            fields = __spreadValues(__spreadValues({}, fields), defaultFields);
-            return fields;
-          });
-        },
-        resolveData: ({ props }, { lastData }) => {
-          const _map = (props._map || []).map((item) => {
-            const newItem = __spreadValues({}, item);
-            if (typeof newItem.unmappedArrayItemDefaultValues === "string") {
-              try {
-                newItem.unmappedArrayItemDefaultValues = JSON.parse(
-                  newItem.unmappedArrayItemDefaultValues
-                );
-              } catch (e) {
-                newItem.unmappedArrayItemDefaultValues = {};
-              }
-            } else if (!newItem.unmappedArrayItemDefaultValues) {
-              newItem.unmappedArrayItemDefaultValues = {};
-            }
-            return newItem;
-          });
-          const readOnlyFields = _map.flatMap((item) => item.to);
-          const readOnlyArrayBases = readOnlyFields.filter((field) => typeof field === "string").map(getArrayBasePath).filter((base) => base !== null);
-          if (_map.length) {
-            return {
-              props: __spreadProps(__spreadValues({}, props), { _map }),
-              readOnly: [
-                ...readOnlyFields.map((f) => String(f)),
-                ...readOnlyArrayBases
-              ].reduce(
-                (acc2, field) => __spreadProps(__spreadValues({}, acc2), { [field]: true }),
-                {}
-              )
-            };
-          }
-          return {
-            props: __spreadProps(__spreadValues({}, props), { _map }),
-            readOnly: {}
-          };
-        },
-        render: (props) => {
-          return /* @__PURE__ */ jsx4(ErrorBoundary, { children: component.render(props) });
-        }
-      });
-      acc[name] = tempComponent;
-      return acc;
-    },
-    {}
-  ),
-  categories: config.categories || {}
-});
+// src/puck/store/slices/builder.tsx
+import {
+  walkTree as walkTree2
+} from "@measured/puck";
 
 // src/puck/lib/soft-component-constants.ts
 var TECHNICAL_KEYS = /* @__PURE__ */ new Set(["_map", "_slot", "id", "_version"]);
@@ -1354,6 +543,72 @@ var sanitizeComponent = (component, allowedTypes) => {
   });
 };
 
+// src/puck/lib/custom-fields.ts
+var builtInSoftFieldTypes = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "number",
+  "select",
+  "radio",
+  "array",
+  "object",
+  "reference"
+]);
+var warnedMessages = /* @__PURE__ */ new Set();
+var warnOnce = (message) => {
+  if (warnedMessages.has(message)) {
+    return;
+  }
+  warnedMessages.add(message);
+  console.warn(message);
+};
+var isBuiltInSoftFieldType = (fieldType) => {
+  return builtInSoftFieldTypes.has(fieldType);
+};
+var resolveCustomFieldDefinition = (fieldType, customFields) => {
+  if (isBuiltInSoftFieldType(fieldType)) {
+    return void 0;
+  }
+  return customFields == null ? void 0 : customFields[fieldType];
+};
+var resolveCustomFieldReturnType = (fieldType, customFields) => {
+  const customField = resolveCustomFieldDefinition(fieldType, customFields);
+  if (!customField) {
+    return null;
+  }
+  if (!customField.returnType) {
+    warnOnce(
+      `[soft-config] Custom field "${fieldType}" is missing a required returnType and will be skipped from mapping options.`
+    );
+    return null;
+  }
+  return customField.returnType;
+};
+var resolveCustomFieldSchema = (fieldType, customFields) => {
+  const customField = resolveCustomFieldDefinition(fieldType, customFields);
+  if (!customField) {
+    return null;
+  }
+  const returnType = resolveCustomFieldReturnType(fieldType, customFields);
+  if (!returnType) {
+    return null;
+  }
+  if (returnType !== "array" && returnType !== "object") {
+    return null;
+  }
+  const subFields = customField.subFields || [];
+  if (!subFields.length) {
+    warnOnce(
+      `[soft-config] Custom field "${fieldType}" returns ${returnType} but does not define subFields. It will be skipped from mapping options.`
+    );
+    return null;
+  }
+  return {
+    subFields,
+    subFieldSettings: customField.subFieldSettings || {}
+  };
+};
+
 // src/puck/lib/soft-component-from-appstate.ts
 var getSubComponents = (content, componentConfigs, fieldSettings, slots) => {
   if (!content || !Array.isArray(content)) return [];
@@ -1509,8 +764,8 @@ var softComponentFromAppState = (appState, configComponents, editedItem, metadat
   var _a;
   const rootProps = ((_a = appState.data.root) == null ? void 0 : _a.props) || {};
   const fields = rootProps._fields || [];
-  const field_settings = rootProps._fieldSettings || {};
-  const normalizedFieldSettings = __spreadValues({}, field_settings);
+  const fieldSettings = rootProps._fieldSettings || {};
+  const normalizedFieldSettings = __spreadValues({}, fieldSettings);
   (fields || []).forEach((field) => {
     const customFieldDefinition = resolveCustomFieldDefinition(
       field.type,
@@ -1836,12 +1091,100 @@ var rootZone = "default-zone";
 var rootDroppableId = `${rootAreaId}:${rootZone}`;
 
 // src/puck/components/soft-render/index.tsx
-import React3, { useMemo, memo } from "react";
-import equal3 from "react-fast-compare";
-import { Fragment as Fragment2, jsx as jsx5 } from "react/jsx-runtime";
+import React2, { useMemo, memo } from "react";
+import equal2 from "react-fast-compare";
+
+// src/puck/components/error-boundary/index.tsx
+import { Component } from "react";
+
+// src/puck/lib/get-class-name-factory.ts
+import classnames from "classnames";
+var getClassNameFactory = (rootClass, styles, config = { baseClass: "" }) => (options = {}) => {
+  if (typeof options === "string") {
+    const descendant = options;
+    const style = styles[`${rootClass}-${descendant}`];
+    if (style) {
+      return config.baseClass + styles[`${rootClass}-${descendant}`] || "";
+    }
+    return "";
+  } else if (typeof options === "object") {
+    const modifiers = options;
+    const prefixedModifiers = {};
+    for (let modifier in modifiers) {
+      prefixedModifiers[styles[`${rootClass}--${modifier}`]] = modifiers[modifier];
+    }
+    const c = styles[rootClass];
+    return config.baseClass + classnames(__spreadValues({
+      [c]: !!c
+    }, prefixedModifiers));
+  } else {
+    return config.baseClass + styles[rootClass] || "";
+  }
+};
+var get_class_name_factory_default = getClassNameFactory;
+
+// css-module:/home/osamu/Documents/netlisian-soft/packages/soft-config/src/puck/components/error-boundary/styles.module.css#css-module
+var styles_module_default = { "ErrorBoundary": "_ErrorBoundary_1xl05_5", "ErrorBoundary-title": "_ErrorBoundary-title_1xl05_21", "ErrorBoundary-details": "_ErrorBoundary-details_1xl05_31", "ErrorBoundary-button": "_ErrorBoundary-button_1xl05_39" };
+
+// src/puck/components/error-boundary/index.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var getClassName = get_class_name_factory_default("ErrorBoundary", styles_module_default);
+var ErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.resetError = () => {
+      this.setState({
+        hasError: false,
+        error: null
+      });
+    };
+    this.state = {
+      hasError: false,
+      error: null
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return {
+      hasError: true,
+      error
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("Error caught by ErrorBoundary:", error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError) {
+      if (typeof this.props.fallback === "function") {
+        return this.props.fallback(this.state.error, this.resetError);
+      }
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+      return /* @__PURE__ */ jsxs("div", { className: getClassName(), children: [
+        /* @__PURE__ */ jsx("h3", { className: getClassName("title"), children: "Component Error" }),
+        /* @__PURE__ */ jsxs("details", { className: getClassName("details"), children: [
+          /* @__PURE__ */ jsx("summary", { children: "Show error details" }),
+          this.state.error && this.state.error.toString()
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: this.resetError,
+            className: getClassName("button"),
+            children: "Try Again"
+          }
+        )
+      ] });
+    }
+    return this.props.children;
+  }
+};
+
+// src/puck/components/soft-render/index.tsx
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
 function isPlainObject(val) {
   if (typeof val !== "object" || val === null) return false;
-  if (React3.isValidElement(val)) return false;
+  if (React2.isValidElement(val)) return false;
   if ("$$typeof" in val) return false;
   const proto = Object.getPrototypeOf(val);
   return proto === Object.prototype || proto === null;
@@ -1849,12 +1192,27 @@ function isPlainObject(val) {
 function cloneData(value) {
   if (value === null || value === void 0) return value;
   if (typeof value === "function") return value;
-  if (Array.isArray(value)) return value.map(cloneData);
+  if (Array.isArray(value))
+    return value.map(cloneData);
   if (!isPlainObject(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([k, v]) => [k, cloneData(v)])
   );
 }
+function shallowEqual(objA, objB) {
+  if (Object.is(objA, objB)) return true;
+  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null)
+    return false;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (let i = 0; i < keysA.length; i++) {
+    if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) {
+      return false;
+    }
+  }
+  return true;
+}
 var SubComponentRenderer = memo(
   ({
     subComponent,
@@ -1906,7 +1264,7 @@ var SubComponentRenderer = memo(
               style
             }) => {
               var _a3, _b2;
-              return /* @__PURE__ */ jsx5("div", { className, style, children: /* @__PURE__ */ jsx5(
+              return /* @__PURE__ */ jsx2("div", { className, style, children: /* @__PURE__ */ jsx2(
                 SoftRender,
                 {
                   softComponentFields,
@@ -1933,7 +1291,7 @@ var SubComponentRenderer = memo(
     ]);
     if (!componentConfig) return null;
     const ComponentRender = componentConfig.render;
-    return /* @__PURE__ */ jsx5(ErrorBoundary, { children: /* @__PURE__ */ jsx5(
+    return /* @__PURE__ */ jsx2(ErrorBoundary, { children: /* @__PURE__ */ jsx2(
       ComponentRender,
       __spreadValues({
         id: stableId,
@@ -1942,14 +1300,11 @@ var SubComponentRenderer = memo(
       }, finalProps)
     ) });
   },
-  // Custom comparator for SubComponentRenderer.
-  //
-  // Uses deep equality on subComponent (it may be a new reference even when
-  // semantically unchanged if the parent SoftRender array is reconstructed)
-  // and on props (the primary driver of field-mapping changes).
-  // configComponents and softComponentFields are treated as stable config
-  // references — reference equality is intentional and fast here.
-  (prev, next) => prev.depth === next.depth && prev.index === next.index && prev.configComponents === next.configComponents && prev.softComponentFields === next.softComponentFields && equal3(prev.props, next.props) && equal3(prev.subComponent, next.subComponent) && equal3(prev.softComponentFieldSettings, next.softComponentFieldSettings)
+  (prev, next) => prev.depth === next.depth && prev.index === next.index && prev.configComponents === next.configComponents && prev.softComponentFields === next.softComponentFields && // Shallow compare: props may contain functions/React nodes; deep equality
+  // would risk retaining stale closures and is unnecessarily expensive here.
+  shallowEqual(prev.props, next.props) && // Deep compare: subComponent and fieldSettings are plain JSON configuration
+  // objects with no functions, so structural equality is safe and correct.
+  equal2(prev.subComponent, next.subComponent) && equal2(prev.softComponentFieldSettings, next.softComponentFieldSettings)
 );
 SubComponentRenderer.displayName = "SubComponentRenderer";
 var SoftRender = memo(
@@ -1962,9 +1317,9 @@ var SoftRender = memo(
     depth = 0
   }) => {
     if (!(softSubComponent == null ? void 0 : softSubComponent.length)) return null;
-    return /* @__PURE__ */ jsx5(Fragment2, { children: softSubComponent.map((subComponent, index) => {
+    return /* @__PURE__ */ jsx2(Fragment, { children: softSubComponent.map((subComponent, index) => {
       var _a;
-      return /* @__PURE__ */ jsx5(
+      return /* @__PURE__ */ jsx2(
         SubComponentRenderer,
         {
           subComponent,
@@ -1979,16 +1334,14 @@ var SoftRender = memo(
       );
     }) });
   },
-  // Covers all five props — not just `props` and `softSubComponent`.
-  // configComponents / softComponentFields: reference equality (stable config).
-  // softComponentFieldSettings: deep equality (may carry dynamic defaults).
-  // props / softSubComponent: deep equality (primary render drivers).
-  (prev, next) => prev.configComponents === next.configComponents && prev.softComponentFields === next.softComponentFields && equal3(prev.props, next.props) && equal3(prev.softSubComponent, next.softSubComponent) && equal3(prev.softComponentFieldSettings, next.softComponentFieldSettings)
+  (prev, next) => prev.configComponents === next.configComponents && prev.softComponentFields === next.softComponentFields && // Shallow compare: props may contain functions/React nodes; see shallowEqual.
+  shallowEqual(prev.props, next.props) && // Deep compare: softSubComponent and fieldSettings are plain JSON schemas.
+  equal2(prev.softSubComponent, next.softSubComponent) && equal2(prev.softComponentFieldSettings, next.softComponentFieldSettings)
 );
 SoftRender.displayName = "SoftRender";
 
 // src/puck/lib/create-versioned-component-config.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { jsx as jsx3 } from "react/jsx-runtime";
 var hydrateCustomField = (fieldName, field, fieldSettings, customFields) => {
   var _a;
   if (field.type !== "custom") {
@@ -2046,7 +1399,7 @@ var createVersionedComponentConfig = (componentName, displayName, version, allVe
       var _a2;
       const selectedVersion = props.version || version;
       const versionedComponent = (_a2 = softComponents[componentName]) == null ? void 0 : _a2.versions[selectedVersion];
-      return /* @__PURE__ */ jsx6(
+      return /* @__PURE__ */ jsx3(
         SoftRender,
         {
           softComponentFields: versionedComponent.fields,
@@ -2061,7 +1414,7 @@ var createVersionedComponentConfig = (componentName, displayName, version, allVe
 };
 
 // src/puck/lib/builder/sub-component-decomposer.tsx
-var subComponentDecomposer = (componentRootData, softSubComponent) => {
+var subComponentDecomposer = (componentRootData, softSubComponent, keepMapField) => {
   var _a;
   const resolvedProps = __spreadValues({}, softSubComponent.fixedProps);
   (_a = softSubComponent.map) == null ? void 0 : _a.forEach((mapItem) => {
@@ -2084,21 +1437,21 @@ var subComponentDecomposer = (componentRootData, softSubComponent) => {
   Object.entries(softSubComponent.components).forEach(
     ([slotKey, subComponents]) => {
       resolvedProps[slotKey] = subComponents.map(
-        (subComponent) => subComponentDecomposer(componentRootData, subComponent)
+        (subComponent) => subComponentDecomposer(componentRootData, subComponent, keepMapField)
       );
     }
   );
   const accItem = {
     type: softSubComponent.type,
-    props: __spreadProps(__spreadValues({}, resolvedProps), {
+    props: __spreadValues(__spreadProps(__spreadValues({}, resolvedProps), {
       id: generateId(softSubComponent.type)
-    })
+    }), keepMapField ? { _map: softSubComponent.map } : {})
   };
   return accItem;
 };
 
 // src/puck/lib/builder/resolve-soft-component-data.ts
-var resolveSoftComponentData = (props, _fieldSettings = {}) => {
+var resolveSoftComponentData = (props, _fieldSettings = {}, keepMapField) => {
   const map = props._map;
   if (!(map == null ? void 0 : map.length)) return __spreadValues({}, props);
   const { newProps } = applyMapping(
@@ -2107,11 +1460,16 @@ var resolveSoftComponentData = (props, _fieldSettings = {}) => {
     map,
     "propsFirst"
   );
+  if (keepMapField) {
+    return __spreadProps(__spreadValues({}, newProps), {
+      _map: map
+    });
+  }
   return newProps;
 };
 
 // src/puck/lib/decompose-soft-component.ts
-function decomposeSoftComponent(componentData, softComponents, fieldSettings) {
+function decomposeSoftComponent(componentData, softComponents, fieldSettings, keepMapField) {
   var _a, _b, _c, _d;
   if (!(componentData == null ? void 0 : componentData.type) || !(componentData == null ? void 0 : componentData.props.id)) {
     throw new Error("Component data must have type and id to decompose.");
@@ -2135,7 +1493,11 @@ function decomposeSoftComponent(componentData, softComponents, fieldSettings) {
   }
   const decomposedComponentData = softComponent.components.map(
     (softSubComponent) => {
-      return subComponentDecomposer(resolvedComponentData, softSubComponent);
+      return subComponentDecomposer(
+        resolvedComponentData,
+        softSubComponent,
+        keepMapField
+      );
     }
   );
   return decomposedComponentData;
@@ -2145,9 +1507,9 @@ function isSoftComponent(componentType, softComponents) {
 }
 
 // src/puck/lib/demolish-soft-component.ts
-import { walkTree as walkTree2 } from "@measured/puck";
+import { walkTree } from "@measured/puck";
 function demolishSoftComponent(componentName, data, config, softComponents) {
-  const resolvedData = walkTree2(data, config, (components) => {
+  const resolvedData = walkTree(data, config, (components) => {
     components.forEach((componentData, index) => {
       if (componentData.type === componentName) {
         const decomposed = decomposeSoftComponent(componentData, softComponents);
@@ -2234,24 +1596,15 @@ var clearEditVisibility = (doc) => {
 };
 
 // src/puck/store/slices/builder.tsx
-var createBuildersSlice = (set, get, initialConfig) => ({
+var createBuildersSlice = (set, get) => ({
   build: (history, selectedItem, itemSelector, puckDispatch, name) => {
     if (!selectedItem || !itemSelector) {
       throw new Error("No item selected to build from.");
     }
-    const config = __spreadValues({}, get().softConfig);
-    const overrides = get().overrides;
-    const buildConfig = builderConfig(
-      config,
-      overrides,
-      void 0,
-      get().showVersionFields,
-      void 0,
-      get().customFields
-    );
+    const config = get().softConfig;
     const editableIds = /* @__PURE__ */ new Set([selectedItem.props.id]);
     const initialContent = [__spreadValues({}, selectedItem)];
-    walkTree3(
+    walkTree2(
       {
         root: {},
         content: initialContent
@@ -2271,8 +1624,6 @@ var createBuildersSlice = (set, get, initialConfig) => ({
       })
     );
     set((s) => __spreadProps(__spreadValues({}, s), {
-      softConfig: buildConfig,
-      storedConfig: config,
       originalHistory: history,
       itemSelector: {
         index: itemSelector.index,
@@ -2282,28 +1633,24 @@ var createBuildersSlice = (set, get, initialConfig) => ({
       editableComponentIds: editableIds,
       state: "building"
     }));
-    requestAnimationFrame(
-      () => puckDispatch({
-        type: "set",
-        state: (previous) => {
-          var _a;
-          return {
-            ui: __spreadProps(__spreadValues({}, previous.ui), {
-              itemSelector: null
-            }),
-            data: __spreadProps(__spreadValues({}, previous.data), {
-              root: __spreadProps(__spreadValues({}, previous.data.root), {
-                props: __spreadProps(__spreadValues({}, (_a = previous.data.root) == null ? void 0 : _a.props), {
-                  _name: name || "New Soft Component"
-                })
-              })
-            })
-          };
-        }
-      })
-    );
+    requestAnimationFrame(() => {
+      puckDispatch({
+        type: "setUi",
+        ui: { itemSelector: null },
+        recordHistory: false
+      });
+      puckDispatch({
+        type: "replaceRoot",
+        root: {
+          props: {
+            _name: name || "New Soft Component"
+          }
+        },
+        recordHistory: false
+      });
+    });
   },
-  remodel: (history, selectedItem, itemSelector, puckDispatch) => {
+  remodel: (history, selectedItem, itemSelector, puckDispatch, refreshPermission) => {
     var _a, _b;
     if (!selectedItem || !itemSelector) {
       throw new Error("No item selected to build from.");
@@ -2323,7 +1670,7 @@ var createBuildersSlice = (set, get, initialConfig) => ({
         `Soft component "${softComponentName}" with version "${softComponentVersion}" not found.`
       );
     }
-    const { root, content } = softComponentToAppState(
+    const { root } = softComponentToAppState(
       softComponent,
       softComponentName,
       softComponentVersion,
@@ -2335,91 +1682,104 @@ var createBuildersSlice = (set, get, initialConfig) => ({
       softComponentMeta == null ? void 0 : softComponentMeta.category,
       get().customFields
     );
-    const config = __spreadValues({}, get().softConfig);
-    const overrides = get().overrides;
+    const config = get().softConfig;
     const dependents = get().dependencyGraph.get(softComponentName) || /* @__PURE__ */ new Set();
-    const buildConfig = builderConfig(
-      config,
-      overrides,
-      softComponentName,
-      get().showVersionFields,
-      dependents,
-      get().customFields
-    );
-    const editableIds = /* @__PURE__ */ new Set([]);
-    const decomposedComponents = get().builder.decompose(selectedItem);
-    walkTree3(
-      { root: {}, content: decomposedComponents || [] },
+    const decomposedComponents = get().builder.decompose(selectedItem, true);
+    const editableIds = /* @__PURE__ */ new Set([decomposedComponents[0].props.id]);
+    const { content: decomposedComponentsWithId } = walkTree2(
+      { root: {}, content: decomposedComponents },
       { components: config.components },
       (components) => {
-        components.forEach((comp) => {
-          editableIds.add(comp.props.id);
+        components.forEach((comp2) => {
+          const id2 = generateId(comp2.type);
+          comp2.props.id = id2;
+          editableIds.add(id2);
         });
         return components;
       }
     );
-    requestAnimationFrame(() => {
-      puckDispatch({
-        type: "set",
-        state: (previous) => ({
-          data: {
-            root: __spreadProps(__spreadValues({}, root), { _versions: versions }),
-            content: walkTree3(
-              __spreadValues({}, previous.data),
-              __spreadValues({}, config),
-              (components) => {
-                const next = components.map((component) => __spreadProps(__spreadValues({}, component), {
-                  props: __spreadValues({}, component.props)
-                }));
-                const index = next.findIndex(
-                  (component) => component.props.id === selectedItem.props.id
-                );
-                if (index !== -1) {
-                  next.splice(
-                    index,
-                    1,
-                    ...decomposedComponents.map((component) => __spreadProps(__spreadValues({}, component), {
-                      props: __spreadValues({}, component.props)
-                    }))
-                  );
-                }
-                return next;
-              }
-            ).content
-          },
-          ui: __spreadProps(__spreadValues({}, previous.ui), {
-            itemSelector: null
-          })
-        })
-      });
-      setEditVisibility(get().iframeDoc, {
-        mode: "remodel",
-        editableIds
-      });
-    });
     set((s) => __spreadProps(__spreadValues({}, s), {
-      storedConfig: config,
-      softConfig: buildConfig,
       originalHistory: history,
       itemSelector: {
         index: itemSelector.index,
         zone: itemSelector.zone || rootDroppableId
       },
-      editingComponentId: selectedItem.props.id,
       editingComponent: softComponentName,
+      editingDependents: dependents,
       editableComponentIds: editableIds,
-      state: "remodeling"
+      state: "assessing"
     }));
-    requestAnimationFrame(
-      () => puckDispatch({
-        type: "replaceRoot",
-        root: {
-          title: root.props.title,
-          _name: root.props._name,
+    puckDispatch({
+      type: "remove",
+      index: itemSelector.index,
+      zone: itemSelector.zone || rootDroppableId,
+      recordHistory: false
+    });
+    const comp = decomposedComponentsWithId[0];
+    if (!comp) {
+      throw new Error("No decomposed components found.");
+    }
+    const id = comp.props.id;
+    puckDispatch({
+      type: "insert",
+      destinationIndex: itemSelector.index,
+      destinationZone: itemSelector.zone || rootDroppableId,
+      componentType: comp.type,
+      recordHistory: false,
+      id
+    });
+    requestAnimationFrame(() => {
+      var _a2;
+      const _map = ((_a2 = comp.props) == null ? void 0 : _a2._map) || [];
+      const readOnlyFields = _map.flatMap((item) => item.to);
+      const readOnlyArrayBases = readOnlyFields.filter((field) => typeof field === "string").map(getArrayBasePath).filter((base) => base !== null);
+      const readOnly = [
+        ...readOnlyFields.map((f) => String(f)),
+        ...readOnlyArrayBases
+      ].reduce((acc, field) => __spreadProps(__spreadValues({}, acc), { [field]: true }), {});
+      puckDispatch({
+        type: "replace",
+        destinationIndex: itemSelector.index,
+        destinationZone: itemSelector.zone || rootDroppableId,
+        data: __spreadProps(__spreadValues({}, comp), {
+          props: __spreadProps(__spreadValues({}, comp.props), {
+            id
+          }),
+          readOnly
+        }),
+        recordHistory: false
+      });
+      set((s) => __spreadProps(__spreadValues({}, s), {
+        state: "remodeling"
+      }));
+      setEditVisibility(get().iframeDoc, {
+        mode: "remodel",
+        editableIds: new Set(editableIds)
+      });
+    });
+    puckDispatch({
+      type: "replaceRoot",
+      root: {
+        props: __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, root.props), root.props.title !== void 0 && {
+          title: root.props.title
+        }), root.props._name !== void 0 && {
+          _name: root.props._name
+        }), root.props._category !== void 0 && {
           _category: root.props._category
-        }
-      })
-    );
+        }), {
+          _versions: versions
+        })
+      },
+      recordHistory: false
+    });
+    requestAnimationFrame(() => {
+      puckDispatch({
+        type: "setUi",
+        ui: { itemSelector: null },
+        recordHistory: false
+      });
+      refreshPermission();
+    });
   },
   complete: (appState, setHistories, getItemBySelector) => {
     var _a, _b, _c, _d, _e, _f, _g;
@@ -2459,7 +1819,7 @@ var createBuildersSlice = (set, get, initialConfig) => ({
     }
     const storedHistories = get().originalHistory;
     setHistories([...storedHistories]);
-    const config = __spreadValues({}, get().softConfig || initialConfig);
+    const config = __spreadValues({}, get().softConfig);
     const mapComponentConfig = get().overrides.mapComponentConfig;
     const newSoftComponentConfig = mapComponentConfig ? mapComponentConfig(componentName, defaultSoftComponentConfig, rootProps) : defaultSoftComponentConfig;
     set((s) => {
@@ -2497,11 +1857,9 @@ var createBuildersSlice = (set, get, initialConfig) => ({
       }) : categories;
       return __spreadProps(__spreadValues({}, s), {
         softConfig: __spreadProps(__spreadValues({}, config), {
-          root: __spreadValues({}, initialConfig.root),
           components: nextComponents,
           categories: nextCategories
         }),
-        storedConfig: void 0,
         state: "inspecting",
         // Temporarily shift state to inspect() before finalizing back to ready
         originalHistory: []
@@ -2523,7 +1881,7 @@ var createBuildersSlice = (set, get, initialConfig) => ({
       softComponent: completedSoftComponent
     };
   },
-  inspect: (componentName, puckDispatch) => {
+  inspect: (componentName, puckDispatch, selectedItemSelector) => {
     if (get().state !== "inspecting") {
       throw new Error("Not in inspecting state.");
     }
@@ -2532,59 +1890,72 @@ var createBuildersSlice = (set, get, initialConfig) => ({
       throw new Error("No selector found for last item.");
     }
     const editableComponentId = get().editingComponentId;
+    const itemSelector = get().itemSelector;
     requestAnimationFrame(() => {
-      const config = get().softConfig;
-      const newComponent = config.components[componentName];
-      const reconstructedTree = (data) => walkTree3(data, config, (components) => {
-        return components.map((comp) => {
-          if (comp.props.id === editableComponentId) {
-            return {
-              type: componentName,
-              props: __spreadProps(__spreadValues({}, newComponent.defaultProps), {
-                id: generateId(componentName)
-              })
-            };
-          }
-          return comp;
+      var _a;
+      if (editableComponentId && !Object.keys(get().softComponents).includes(
+        (_a = editableComponentId == null ? void 0 : editableComponentId.split(":")) == null ? void 0 : _a[0].split("-")[0]
+      )) {
+        requestAnimationFrame(() => {
+          puckDispatch({
+            type: "remove",
+            index: itemSelector.index,
+            zone: itemSelector.zone,
+            recordHistory: true
+          });
+          puckDispatch({
+            type: "insert",
+            destinationIndex: itemSelector.index,
+            destinationZone: itemSelector.zone,
+            componentType: componentName,
+            recordHistory: true
+          });
         });
-      });
-      puckDispatch({
-        type: "setData",
-        data: (data) => {
-          return reconstructedTree(data);
-        },
-        recordHistory: true
-        // Record this swap on the standard undo/redo stack
-      });
+      }
       clearEditVisibility(get().iframeDoc);
+      if (!selectedItemSelector && selector.index !== void 0) {
+        puckDispatch({
+          type: "setUi",
+          ui: { itemSelector: selector },
+          recordHistory: false
+        });
+      }
       set((s) => __spreadProps(__spreadValues({}, s), {
         state: "ready",
         setItemSelector: void 0,
         setOriginalItem: void 0,
+        itemSelector: null,
         editingComponent: null,
         editingComponentId: null,
         editableComponentIds: /* @__PURE__ */ new Set()
       }));
     });
   },
-  cancel: (setHistories) => {
+  cancel: (setHistories, puckDispatch, selectedItemSelector) => {
     const storedHistories = get().originalHistory;
+    const itemSelector = get().itemSelector;
     set((s) => __spreadProps(__spreadValues({}, s), {
       state: "cancelling"
     }));
     setHistories([...storedHistories]);
     requestAnimationFrame(() => {
       clearEditVisibility(get().iframeDoc);
+      if (!selectedItemSelector && itemSelector) {
+        puckDispatch({
+          type: "setUi",
+          ui: { itemSelector },
+          recordHistory: false
+        });
+      }
       set((s) => __spreadProps(__spreadValues({}, s), {
-        softConfig: get().storedConfig || initialConfig,
-        storedConfig: void 0,
         originalHistory: [],
         itemSelector: null,
         originalItem: null,
         state: "ready",
         editingComponent: null,
         editingComponentId: null,
-        editableComponentIds: /* @__PURE__ */ new Set()
+        editableComponentIds: /* @__PURE__ */ new Set(),
+        editingDependents: /* @__PURE__ */ new Set()
       }));
     });
   },
@@ -2631,11 +2002,16 @@ var createBuildersSlice = (set, get, initialConfig) => ({
     get().setSoftComponent(componentName, version, softComponent);
     return [newSoftComponentConfig, version];
   },
-  decompose: (componentData) => {
+  decompose: (componentData, keepMapField) => {
     if (!(componentData == null ? void 0 : componentData.type) || !(componentData == null ? void 0 : componentData.props.id)) {
       throw new Error("Component data must have type and id to decompose.");
     }
-    return decomposeSoftComponent(componentData, get().softComponents);
+    return decomposeSoftComponent(
+      componentData,
+      get().softComponents,
+      void 0,
+      keepMapField
+    );
   },
   demolish: (componentName, data, puckDispatch) => {
     if (get().state !== "ready") {
@@ -2656,7 +2032,7 @@ var createBuildersSlice = (set, get, initialConfig) => ({
       softConfig: result.config
     }));
   },
-  setVersion: (componentName, newVersion, currentProps, puckDispatch) => {
+  setVersion: (componentName, newVersion, currentProps, puckDispatch, getItemBySelector, getSelectorForId) => {
     var _a;
     if (get().state !== "remodeling") {
       throw new Error("Can only switch versions during remodeling.");
@@ -2683,12 +2059,91 @@ var createBuildersSlice = (set, get, initialConfig) => ({
       softComponentMeta == null ? void 0 : softComponentMeta.category,
       get().customFields
     );
-    puckDispatch({
-      type: "setData",
-      data: (previous) => __spreadProps(__spreadValues({}, previous), {
-        root: __spreadProps(__spreadValues({}, root), { props: __spreadProps(__spreadValues({}, root.props), { _versions: versions }) }),
-        content: content || []
-      })
+    const editableIds = get().editableComponentIds;
+    if (!editableIds || editableIds.size === 0) return;
+    const firstId = Array.from(editableIds)[0];
+    const itemSelector = getSelectorForId(firstId);
+    if (!itemSelector) return;
+    requestAnimationFrame(() => {
+      const countToRemove = Array.from(editableIds).filter(
+        (id) => {
+          var _a2;
+          return ((_a2 = getSelectorForId(id)) == null ? void 0 : _a2.zone) === itemSelector.zone;
+        }
+      ).length;
+      for (let i = 0; i < countToRemove; i++) {
+        puckDispatch({
+          type: "remove",
+          index: itemSelector.index,
+          zone: itemSelector.zone,
+          recordHistory: false
+        });
+      }
+      const newContent = content || [];
+      const comp = newContent[0];
+      if (comp) {
+        puckDispatch({
+          type: "insert",
+          destinationIndex: itemSelector.index,
+          destinationZone: itemSelector.zone,
+          componentType: comp.type,
+          recordHistory: false
+        });
+      }
+      requestAnimationFrame(() => {
+        if (comp) {
+          const insertedItem = getItemBySelector({
+            index: itemSelector.index,
+            zone: itemSelector.zone
+          });
+          if (insertedItem) {
+            puckDispatch({
+              type: "replace",
+              destinationIndex: itemSelector.index,
+              destinationZone: itemSelector.zone,
+              data: __spreadProps(__spreadValues({}, comp), {
+                props: __spreadProps(__spreadValues({}, comp.props), {
+                  id: insertedItem.props.id
+                })
+              }),
+              recordHistory: false
+            });
+          }
+        }
+        puckDispatch({
+          type: "replaceRoot",
+          root: {
+            props: __spreadProps(__spreadValues({}, root.props), {
+              _versions: versions
+            })
+          },
+          recordHistory: false
+        });
+        requestAnimationFrame(() => {
+          const newEditableIds = /* @__PURE__ */ new Set();
+          if (comp) {
+            const finalItem = getItemBySelector({
+              index: itemSelector.index,
+              zone: itemSelector.zone
+            });
+            if (finalItem) {
+              walkTree2(
+                { root: {}, content: [finalItem] },
+                { components: get().softConfig.components },
+                (components) => {
+                  components.forEach((c) => newEditableIds.add(c.props.id));
+                  return components;
+                }
+              );
+            }
+          }
+          set((s) => __spreadProps(__spreadValues({}, s), { editableComponentIds: newEditableIds }));
+          setEditVisibility(get().iframeDoc, {
+            mode: "remodel",
+            editableIds: newEditableIds
+          });
+        });
+      });
     });
   }
 });
@@ -2905,7 +2360,7 @@ function buildInitialSoftComponents(hardConfig, softComponents, overrides, showV
 }
 
 // src/puck/store/index.tsx
-var createSoftConfigStore = (hardConfig = { components: {} }, softComponents = {}, overrides = {}, onActions, showVersionFields = true, customFields = {}) => {
+var createSoftConfigStore = (hardConfig = { components: {} }, softComponents = {}, overrides = {}, onActions, showVersionFields = true, customFields = {}, contentAreaNames) => {
   const normalizedSoftComponents = Object.fromEntries(
     Object.entries(softComponents || {}).filter(([key]) => !hardConfig.components || !hardConfig.components[key]).map(([key, value]) => [key, __spreadProps(__spreadValues({}, value), { name: value.name || key })])
   );
@@ -2935,6 +2390,11 @@ var createSoftConfigStore = (hardConfig = { components: {} }, softComponents = {
       softComponents: hydratedSoftComponents,
       dependencyGraph: initialDependencyGraph,
       showVersionFields,
+      contentAreaNames,
+      setContentAreaNames: (names) => set({ contentAreaNames: names }),
+      puckDispatch: null,
+      setPuckDispatch: (dispatch) => set({ puckDispatch: dispatch }),
+      rootActionHandler: rootActionHandler(set, get),
       // ─── Initial softConfig ─────────────────────────────────────────────────
       softConfig: __spreadProps(__spreadValues({}, hardConfig), {
         components: __spreadValues(__spreadValues({}, hardConfig.components), buildInitialSoftComponents(
@@ -3206,7 +2666,7 @@ var createSoftConfigStore = (hardConfig = { components: {} }, softComponents = {
         })
       })),
       // ─── Builder Slice ────────────────────────────────────────────────────────
-      builder: createBuildersSlice(set, get, hardConfig),
+      builder: createBuildersSlice(set, get),
       // ─── Dependency Graph ─────────────────────────────────────────────────────
       rebuildDependents: (componentName) => {
         const state = get();
@@ -3239,8 +2699,39 @@ var createSoftConfigStore = (hardConfig = { components: {} }, softComponents = {
 };
 
 // src/puck/context/storeProvider.tsx
-import { useEffect as useEffect2, useMemo as useMemo2, useState } from "react";
-import { jsx as jsx7 } from "react/jsx-runtime";
+import { useEffect, useMemo as useMemo2, useState } from "react";
+
+// src/puck/context/useStore.ts
+import { createContext, useContext } from "react";
+import { useStore } from "zustand";
+var appStoreContext = createContext(null);
+var createUseSoftConfig = () => {
+  return function useSoftConfig2(selector, equalityFn) {
+    const context = useContext(appStoreContext);
+    if (!context) {
+      throw new Error(
+        "useSoftConfig must be used inside a SoftConfigProvider. Wrap your tree with <SoftConfigProvider value={store}>"
+      );
+    }
+    if (equalityFn) {
+      return useStore(context, selector, equalityFn);
+    }
+    return useStore(context, selector);
+  };
+};
+var useSoftConfig = createUseSoftConfig();
+var useSoftConfigStore = () => {
+  const context = useContext(appStoreContext);
+  if (!context) {
+    throw new Error(
+      "useSoftConfigStore must be used inside a SoftConfigProvider."
+    );
+  }
+  return context;
+};
+
+// src/puck/context/storeProvider.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
 var SoftConfigProvider = ({
   children,
   hardConfig,
@@ -3249,7 +2740,8 @@ var SoftConfigProvider = ({
   overrides,
   value,
   onActions,
-  useVersioning = false
+  useVersioning = false,
+  contentAreaNames
 }) => {
   const store = useMemo2(
     () => value != null ? value : createSoftConfigStore(
@@ -3258,18 +2750,15 @@ var SoftConfigProvider = ({
       overrides,
       onActions,
       useVersioning,
-      customFields
+      customFields,
+      contentAreaNames
     ),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [value]
-    // Intentionally omitting the rest: createSoftConfigStore params are
-    // treated as initialisation-time values. If callers need to react to
-    // prop changes they should pass a new `value` store instead.
   );
   const [softConfig, setSoftConfig] = useState(
     () => store.getState().softConfig
   );
-  useEffect2(() => {
+  useEffect(() => {
     let prev = store.getState().softConfig;
     const unsubscribe = store.subscribe((state) => {
       if (state.softConfig !== prev) {
@@ -3279,17 +2768,17 @@ var SoftConfigProvider = ({
     });
     return unsubscribe;
   }, [store]);
-  return /* @__PURE__ */ jsx7(appStoreContext.Provider, { value: store, children: children(softConfig) });
+  return /* @__PURE__ */ jsx4(appStoreContext.Provider, { value: store, children: children(softConfig) });
 };
 
 // src/puck/actions/useBuild.tsx
-import { createUsePuck as createUsePuck2 } from "@measured/puck";
+import { createUsePuck } from "@measured/puck";
 
 // src/puck/lib/notify.ts
 var customHandler = null;
 var defaultHandler = (message, type) => {
   if (type === "error") {
-    console.error(`[Error] ${message}`);
+    alert(`[Error] ${message}`);
   } else {
     console.log(`[Success] ${message}`);
   }
@@ -3328,13 +2817,13 @@ var useActionEvent = () => {
 };
 
 // src/puck/actions/useBuild.tsx
-var useCustomPuck2 = createUsePuck2();
+var useCustomPuck = createUsePuck();
 var useBuild = (name) => {
   const build = useSoftConfig((s) => s.builder.build);
-  const history = useCustomPuck2((s) => s.history.histories);
-  const selectedItem = useCustomPuck2((s) => s.selectedItem);
-  const itemSelector = useCustomPuck2((s) => s.appState.ui.itemSelector);
-  const dispatch = useCustomPuck2((s) => s.dispatch);
+  const history = useCustomPuck((s) => s.history.histories);
+  const selectedItem = useCustomPuck((s) => s.selectedItem);
+  const itemSelector = useCustomPuck((s) => s.appState.ui.itemSelector);
+  const dispatch = useCustomPuck((s) => s.dispatch);
   const status = useSoftConfig((s) => s.state);
   const { triggerAction } = useActionEvent();
   const handleBuild = () => {
@@ -3353,7 +2842,7 @@ var useBuild = (name) => {
         });
       }
     } catch (error) {
-      console.error("Failed to build:", error);
+      alert("Failed to build: " + error);
       notify.error(
         "Failed to build: " + (error instanceof Error ? error.message : String(error))
       );
@@ -3363,17 +2852,17 @@ var useBuild = (name) => {
 };
 
 // src/puck/actions/useRemodel.tsx
-import { createUsePuck as createUsePuck3 } from "@measured/puck";
-var useCustomPuck3 = createUsePuck3();
+import { createUsePuck as createUsePuck2 } from "@measured/puck";
+var useCustomPuck2 = createUsePuck2();
 var useRemodel = () => {
   const remodel = useSoftConfig((s) => s.builder.remodel);
-  const history = useCustomPuck3((s) => s.history.histories);
-  const selectedItem = useCustomPuck3((s) => s.selectedItem);
-  const itemSelector = useCustomPuck3((s) => s.appState.ui.itemSelector);
-  const dispatch = useCustomPuck3((s) => s.dispatch);
+  const history = useCustomPuck2((s) => s.history.histories);
+  const selectedItem = useCustomPuck2((s) => s.selectedItem);
+  const itemSelector = useCustomPuck2((s) => s.appState.ui.itemSelector);
+  const dispatch = useCustomPuck2((s) => s.dispatch);
   const status = useSoftConfig((s) => s.state);
   const softComponents = useSoftConfig((s) => s.softComponents);
-  const refreshPermissions = useCustomPuck3((s) => s.refreshPermissions);
+  const refreshPermissions = useCustomPuck2((s) => s.refreshPermissions);
   const { triggerAction } = useActionEvent();
   const handleRemodel = (componentName) => {
     var _a, _b, _c;
@@ -3389,7 +2878,13 @@ var useRemodel = () => {
     const selectedVersion = ((_a = selectedItem == null ? void 0 : selectedItem.props) == null ? void 0 : _a.version) || ((_b = softComponents[name]) == null ? void 0 : _b.defaultVersion);
     const selectedSoftComponent = selectedVersion ? (_c = softComponents[name]) == null ? void 0 : _c.versions[selectedVersion] : void 0;
     try {
-      remodel(history, selectedItem, itemSelector, dispatch, refreshPermissions);
+      remodel(
+        history,
+        selectedItem,
+        itemSelector,
+        dispatch,
+        refreshPermissions
+      );
       void triggerAction({
         type: "remodel",
         payload: {
@@ -3407,9 +2902,9 @@ var useRemodel = () => {
       }
       return { id: name, version: selectedVersion };
     } catch (error) {
-      console.error("Failed to remodel:", error);
+      alert("Failed to remodel: " + error);
       notify.error(
-        "Failed to remodel: " + (error instanceof Error ? error.message : String(error))
+        "Failed to remodel: " + (error instanceof Error ? error.message : String(error)) + " " + String()
       );
       return null;
     }
@@ -3422,14 +2917,14 @@ var useRemodel = () => {
 };
 
 // src/puck/actions/useComplete.tsx
-import { createUsePuck as createUsePuck4 } from "@measured/puck";
+import { createUsePuck as createUsePuck3 } from "@measured/puck";
 import { useState as useState2, useCallback as useCallback2 } from "react";
-var useCustomPuck4 = createUsePuck4();
+var useCustomPuck3 = createUsePuck3();
 var useComplete = () => {
   const complete = useSoftConfig((s) => s.builder.complete);
-  const appState = useCustomPuck4((s) => s.appState);
-  const setHistories = useCustomPuck4((s) => s.history.setHistories);
-  const getItemBySelector = useCustomPuck4((s) => s.getItemBySelector);
+  const appState = useCustomPuck3((s) => s.appState);
+  const setHistories = useCustomPuck3((s) => s.history.setHistories);
+  const getItemBySelector = useCustomPuck3((s) => s.getItemBySelector);
   const status = useSoftConfig((s) => s.state);
   const [newComponent, setNewComponent] = useState2(null);
   const { triggerAction } = useActionEvent();
@@ -3467,11 +2962,13 @@ var useComplete = () => {
 };
 
 // src/puck/actions/useCancel.tsx
-import { createUsePuck as createUsePuck5 } from "@measured/puck";
-var useCustomPuck5 = createUsePuck5();
+import { createUsePuck as createUsePuck4 } from "@measured/puck";
+var useCustomPuck4 = createUsePuck4();
 var useCancel = () => {
   const cancel = useSoftConfig((s) => s.builder.cancel);
-  const setHistories = useCustomPuck5((s) => s.history.setHistories);
+  const setHistories = useCustomPuck4((s) => s.history.setHistories);
+  const puckDispatch = useCustomPuck4((s) => s.dispatch);
+  const selectedItemSelector = useCustomPuck4((s) => s.appState.ui.itemSelector);
   const status = useSoftConfig((s) => s.state);
   const { triggerAction } = useActionEvent();
   const handleCancel = () => {
@@ -3480,13 +2977,13 @@ var useCancel = () => {
       return;
     }
     try {
-      cancel(setHistories);
+      cancel(setHistories, puckDispatch, selectedItemSelector);
       void triggerAction({
         type: "cancel",
         payload: {}
       });
     } catch (error) {
-      console.error("Failed to cancel:", error);
+      alert("Failed to cancel: " + error);
       notify.error(
         "Failed to cancel: " + (error instanceof Error ? error.message : String(error))
       );
@@ -3497,22 +2994,22 @@ var useCancel = () => {
 };
 
 // src/puck/actions/useInspect.tsx
-import { createUsePuck as createUsePuck6 } from "@measured/puck";
-import { useEffect as useEffect3 } from "react";
-var useCustomPuck6 = createUsePuck6();
+import { createUsePuck as createUsePuck5 } from "@measured/puck";
+import { useEffect as useEffect2 } from "react";
+var useCustomPuck5 = createUsePuck5();
 var useInspect = (component) => {
   const inspect = useSoftConfig((s) => s.builder.inspect);
-  const dispatch = useCustomPuck6((s) => s.dispatch);
+  const dispatch = useCustomPuck5((s) => s.dispatch);
   const status = useSoftConfig((s) => s.state);
   const { triggerAction } = useActionEvent();
-  useEffect3(() => {
+  useEffect2(() => {
     if (status !== "inspecting") return;
     if (!component) {
       notify.error("No component to inspect.");
       return;
     }
     try {
-      inspect(component.id, dispatch);
+      inspect(component.id, dispatch, null);
       void triggerAction({
         type: "inspect",
         payload: {
@@ -3531,16 +3028,24 @@ var useInspect = (component) => {
 };
 
 // src/puck/actions/useDecompose.tsx
-import { createUsePuck as createUsePuck7, walkTree as walkTree4 } from "@measured/puck";
-var useCustomPuck7 = createUsePuck7();
+import { createUsePuck as createUsePuck6, walkTree as walkTree3 } from "@measured/puck";
+
+// src/puck/lib/get-prop-by-path.ts
+function getPropertyByPath(props, path) {
+  return path.replace(/\[(\w+)\]/g, ".$1").split(".").reduce((o, key) => o ? o[key] : void 0, props);
+}
+
+// src/puck/actions/useDecompose.tsx
+var useCustomPuck6 = createUsePuck6();
 var useDecompose = () => {
   const decompose = useSoftConfig((s) => s.builder.decompose);
-  const appState = useCustomPuck7((s) => s.appState);
-  const dispatch = useCustomPuck7((s) => s.dispatch);
-  const selectedItem = useCustomPuck7((s) => s.selectedItem);
+  const appState = useCustomPuck6((s) => s.appState);
+  const dispatch = useCustomPuck6((s) => s.dispatch);
+  const selectedItem = useCustomPuck6((s) => s.selectedItem);
   const status = useSoftConfig((s) => s.state);
   const softComponents = useSoftConfig((s) => s.softComponents);
   const config = useSoftConfig((s) => s.softConfig);
+  const contentAreaNames = useSoftConfig((s) => s.contentAreaNames);
   const { triggerAction } = useActionEvent();
   const handleDecompose = (componentData) => {
     if (status !== "ready") {
@@ -3563,12 +3068,22 @@ var useDecompose = () => {
         notify.error("Nothing to decompose.");
         return;
       }
-      const newData = walkTree4(appState.data, config, (components) => {
-        const index = components.findIndex((c) => c.props.id === target.props.id);
-        if (index !== -1) {
-          components.splice(index, 1, ...decomposedComponents);
-        }
-        return components;
+      let newData = __spreadValues({}, appState.data);
+      const targetAreas = contentAreaNames && contentAreaNames.length > 0 ? contentAreaNames : ["content"];
+      targetAreas.forEach((path) => {
+        const contentArray = getPropertyByPath(newData, path) || [];
+        const walkedData = walkTree3(
+          { content: contentArray, root: newData.root || {} },
+          config,
+          (components) => {
+            const index = components.findIndex((c) => c.props.id === target.props.id);
+            if (index !== -1) {
+              components.splice(index, 1, ...decomposedComponents);
+            }
+            return components;
+          }
+        );
+        setPropertyByPath(newData, path, walkedData.content);
       });
       dispatch({
         type: "setData",
@@ -3581,7 +3096,7 @@ var useDecompose = () => {
         }
       });
     } catch (error) {
-      console.error("Failed to decompose:", error);
+      alert("Failed to decompose: " + error);
       notify.error(
         "Failed to decompose: " + (error instanceof Error ? error.message : String(error))
       );
@@ -3595,12 +3110,12 @@ var useDecompose = () => {
 };
 
 // src/puck/actions/useDemolish.tsx
-import { createUsePuck as createUsePuck8 } from "@measured/puck";
-var useCustomPuck8 = createUsePuck8();
+import { createUsePuck as createUsePuck7 } from "@measured/puck";
+var useCustomPuck7 = createUsePuck7();
 var useDemolish = () => {
   const demolish = useSoftConfig((s) => s.builder.demolish);
-  const dispatch = useCustomPuck8((s) => s.dispatch);
-  const data = useCustomPuck8((s) => s.appState.data);
+  const dispatch = useCustomPuck7((s) => s.dispatch);
+  const data = useCustomPuck7((s) => s.appState.data);
   const status = useSoftConfig((s) => s.state);
   const softComponents = useSoftConfig((s) => s.softComponents);
   const { triggerAction } = useActionEvent();
@@ -3622,7 +3137,7 @@ var useDemolish = () => {
         }
       });
     } catch (error) {
-      console.error("Failed to demolish:", error);
+      alert("Failed to demolish: " + error);
       notify.error(
         "Failed to demolish: " + (error instanceof Error ? error.message : String(error))
       );
@@ -3689,11 +3204,11 @@ import { Button } from "@measured/puck";
 var Header_module_default = { "Header": "_Header_19oj9_1" };
 
 // src/puck/actions/usePublish.tsx
-import { createUsePuck as createUsePuck9 } from "@measured/puck";
-var useCustomPuck9 = createUsePuck9();
+import { createUsePuck as createUsePuck8 } from "@measured/puck";
+var useCustomPuck8 = createUsePuck8();
 var usePublish = () => {
   const components = useSoftConfig((s) => s.softComponents);
-  const data = useCustomPuck9((s) => s.appState.data);
+  const data = useCustomPuck8((s) => s.appState.data);
   const status = useSoftConfig((s) => s.state);
   const { triggerAction } = useActionEvent();
   const handlePublish = (publish) => {
@@ -3724,7 +3239,7 @@ var usePublish = () => {
 };
 
 // src/puck/overrides/Header.tsx
-import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
 var getClassName2 = get_class_name_factory_default("Header", Header_module_default);
 var Header = ({
   onPublish,
@@ -3734,9 +3249,9 @@ var Header = ({
   const { handleCancel, canCancel } = useCancel();
   const { handlePublish } = usePublish();
   useInspect(newComponent);
-  return /* @__PURE__ */ jsx8("div", { className: getClassName2(), children: canCancel ? /* @__PURE__ */ jsxs2(Fragment3, { children: [
-    /* @__PURE__ */ jsx8(Button, { onClick: handleCancel, children: "Cancel" }),
-    /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsx5("div", { className: getClassName2(), children: canCancel ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsx5(Button, { onClick: handleCancel, children: "Cancel" }),
+    /* @__PURE__ */ jsx5(
       Button,
       {
         variant: "primary",
@@ -3749,7 +3264,7 @@ var Header = ({
         children: "Complete"
       }
     )
-  ] }) : children ? children : /* @__PURE__ */ jsx8(
+  ] }) : children ? children : /* @__PURE__ */ jsx5(
     Button,
     {
       variant: "primary",
@@ -3765,7 +3280,7 @@ var Header = ({
 
 // src/puck/overrides/ActionBar.tsx
 import { useMemo as useMemo3 } from "react";
-import { ActionBar, createUsePuck as createUsePuck11 } from "@measured/puck";
+import { ActionBar, createUsePuck as createUsePuck10 } from "@measured/puck";
 import { Combine, ComponentIcon, EditIcon } from "lucide-react";
 
 // css-module:/home/osamu/Documents/netlisian-soft/packages/soft-config/src/puck/overrides/ActionBar.module.css#css-module
@@ -3773,9 +3288,9 @@ var ActionBar_module_default = { "ActionBar": "_ActionBar_pvuie_5", "ActionBar-l
 
 // src/puck/overrides/ActionBar.tsx
 import { shallow } from "zustand/shallow";
-import { Fragment as Fragment4, jsx as jsx9, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+var useCustomPuck9 = createUsePuck10();
 var getClassName3 = get_class_name_factory_default("ActionBar", ActionBar_module_default);
-var usePuck = createUsePuck11();
 var ActionBarOverride = (props) => {
   var _a, _b;
   const { handleBuild } = useBuild(props.label ? props.label + " Soft Component" : "New Soft Component");
@@ -3784,10 +3299,11 @@ var ActionBarOverride = (props) => {
   const overrides = useSoftConfig((s) => s.overrides);
   const softComponents = useSoftConfig((s) => s.softComponents, shallow);
   const editableIds = useSoftConfig((s) => s.editableComponentIds);
-  const selectedItem = usePuck((s) => s.selectedItem);
-  const rootProps = usePuck((s) => s.appState.data.root.props);
+  const selectedItem = useCustomPuck9((s) => s.selectedItem);
+  const appState = useCustomPuck9((s) => s.appState);
+  const rootProps = appState.data.root.props;
   const status = useSoftConfig((s) => s.state);
-  const itemSelector = usePuck((s) => s.appState.ui.itemSelector);
+  const itemSelector = appState.ui.itemSelector;
   const softKeys = Object.keys(softComponents);
   const key = useMemo3(() => {
     const selectedType = selectedItem == null ? void 0 : selectedItem.type;
@@ -3817,35 +3333,35 @@ var ActionBarOverride = (props) => {
     }
     return props.label || "";
   }, [isSoftComponent2, key, props.label, overrides, softComponents]);
-  return /* @__PURE__ */ jsx9("div", { className: getClassName3(), children: /* @__PURE__ */ jsxs3(ActionBar, { children: [
+  return /* @__PURE__ */ jsx6("div", { className: getClassName3(), children: /* @__PURE__ */ jsxs3(ActionBar, { children: [
     /* @__PURE__ */ jsxs3(ActionBar.Group, { children: [
       props.parentAction,
-      /* @__PURE__ */ jsx9(ActionBar.Label, { label })
+      /* @__PURE__ */ jsx6(ActionBar.Label, { label })
     ] }),
     /* @__PURE__ */ jsxs3(ActionBar.Group, { children: [
-      status === "ready" ? isSoftComponent2 ? /* @__PURE__ */ jsxs3(Fragment4, { children: [
-        /* @__PURE__ */ jsx9(
+      status === "ready" ? isSoftComponent2 ? /* @__PURE__ */ jsxs3(Fragment3, { children: [
+        /* @__PURE__ */ jsx6(
           ActionBar.Action,
           {
             onClick: () => handleRemodel(key),
             label: "Remodel Soft Component",
-            children: /* @__PURE__ */ jsx9(EditIcon, { size: 16 })
+            children: /* @__PURE__ */ jsx6(EditIcon, { size: 16 })
           }
         ),
-        /* @__PURE__ */ jsx9(
+        /* @__PURE__ */ jsx6(
           ActionBar.Action,
           {
             onClick: () => handleDecompose(),
             label: "Decompose Soft Component",
-            children: /* @__PURE__ */ jsx9(Combine, { size: 16 })
+            children: /* @__PURE__ */ jsx6(Combine, { size: 16 })
           }
         )
-      ] }) : /* @__PURE__ */ jsx9(
+      ] }) : /* @__PURE__ */ jsx6(
         ActionBar.Action,
         {
           onClick: handleBuild,
           label: "Build Soft Component",
-          children: /* @__PURE__ */ jsx9(ComponentIcon, { size: 16 })
+          children: /* @__PURE__ */ jsx6(ComponentIcon, { size: 16 })
         }
       ) : null,
       status !== "ready" && !isEditable ? null : props.children
@@ -3855,7 +3371,7 @@ var ActionBarOverride = (props) => {
 
 // src/puck/overrides/DrawerItem.tsx
 import { useState as useState4 } from "react";
-import { Button as Button2, IconButton, createUsePuck as createUsePuck12 } from "@measured/puck";
+import { Button as Button2, IconButton, createUsePuck as createUsePuck11 } from "@measured/puck";
 import { GripVertical, Check, X, Trash2, Cog } from "lucide-react";
 
 // src/puck/lib/confirm.ts
@@ -3870,7 +3386,7 @@ var confirm = (message) => __async(null, null, function* () {
     const result = confirmHandler(message);
     return result instanceof Promise ? yield result : result;
   } catch (error) {
-    console.error("Confirm handler error:", error);
+    alert("Confirm handler error: " + error);
     return false;
   }
 });
@@ -3879,14 +3395,14 @@ var confirm = (message) => __async(null, null, function* () {
 var DrawerItem_module_default = { "DrawerItem": "_DrawerItem_182aj_1", "DrawerItem--insertDisabled": "_DrawerItem--insertDisabled_182aj_14", "DrawerItem-content": "_DrawerItem-content_182aj_21", "DrawerItem-name": "_DrawerItem-name_182aj_31", "DrawerItem-version": "_DrawerItem-version_182aj_35", "DrawerItem-actions": "_DrawerItem-actions_182aj_40", "DrawerItem-settingsButton": "_DrawerItem-settingsButton_182aj_46", "DrawerItem-grip": "_DrawerItem-grip_182aj_56", "DrawerItem-modal": "_DrawerItem-modal_182aj_63", "DrawerItem-modalHeader": "_DrawerItem-modalHeader_182aj_71", "DrawerItem-modalTitle": "_DrawerItem-modalTitle_182aj_77", "DrawerItem-modalSubtitle": "_DrawerItem-modalSubtitle_182aj_84", "DrawerItem-modalBody": "_DrawerItem-modalBody_182aj_90", "DrawerItem-section": "_DrawerItem-section_182aj_100", "DrawerItem-sectionTitle": "_DrawerItem-sectionTitle_182aj_106", "DrawerItem-sectionDescription": "_DrawerItem-sectionDescription_182aj_113", "DrawerItem-versionList": "_DrawerItem-versionList_182aj_119", "DrawerItem-versionRow": "_DrawerItem-versionRow_182aj_125", "DrawerItem-versionRow--isDefault": "_DrawerItem-versionRow--isDefault_182aj_136", "DrawerItem-versionRow--isMarkedForDeletion": "_DrawerItem-versionRow--isMarkedForDeletion_182aj_141", "DrawerItem-versionInfo": "_DrawerItem-versionInfo_182aj_146", "DrawerItem-versionNumber": "_DrawerItem-versionNumber_182aj_153", "DrawerItem-defaultBadge": "_DrawerItem-defaultBadge_182aj_159", "DrawerItem-deleteBadge": "_DrawerItem-deleteBadge_182aj_170", "DrawerItem-versionActions": "_DrawerItem-versionActions_182aj_181", "DrawerItem-migrationOptions": "_DrawerItem-migrationOptions_182aj_187", "DrawerItem-migrationList": "_DrawerItem-migrationList_182aj_191", "DrawerItem-migrationOption": "_DrawerItem-migrationOption_182aj_187", "DrawerItem-migrationOption--isSelected": "_DrawerItem-migrationOption--isSelected_182aj_229", "DrawerItem-migrationOptionLabel": "_DrawerItem-migrationOptionLabel_182aj_234", "DrawerItem-modalFooter": "_DrawerItem-modalFooter_182aj_240", "DrawerItem-footerLeft": "_DrawerItem-footerLeft_182aj_250", "DrawerItem-footerRight": "_DrawerItem-footerRight_182aj_255" };
 
 // src/puck/components/modal/index.tsx
-import { useEffect as useEffect4, useState as useState3 } from "react";
+import { useEffect as useEffect3, useState as useState3 } from "react";
 import { createPortal } from "react-dom";
 
 // css-module:/home/osamu/Documents/netlisian-soft/packages/soft-config/src/puck/components/modal/styles.module.css#css-module
 var styles_module_default2 = { "Modal": "_Modal_1t9ot_1", "Modal--isOpen": "_Modal--isOpen_1t9ot_29", "Modal-inner": "_Modal-inner_1t9ot_37" };
 
 // src/puck/components/modal/index.tsx
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 var getClassName4 = get_class_name_factory_default("Modal", styles_module_default2);
 var Modal = ({
   children,
@@ -3894,10 +3410,10 @@ var Modal = ({
   isOpen
 }) => {
   const [rootEl, setRootEl] = useState3(null);
-  useEffect4(() => {
+  useEffect3(() => {
     setRootEl(document.getElementById("puck-portal-root"));
   }, []);
-  useEffect4(() => {
+  useEffect3(() => {
     if (!isOpen) {
       return;
     }
@@ -3910,10 +3426,10 @@ var Modal = ({
     return () => document.removeEventListener("keydown", handleEscape);
   }, [isOpen, onClose]);
   if (!rootEl) {
-    return /* @__PURE__ */ jsx10("div", {});
+    return /* @__PURE__ */ jsx7("div", {});
   }
   return createPortal(
-    /* @__PURE__ */ jsx10(
+    /* @__PURE__ */ jsx7(
       "div",
       {
         className: getClassName4({ isOpen }),
@@ -3922,7 +3438,7 @@ var Modal = ({
             onClose();
           }
         },
-        children: /* @__PURE__ */ jsx10(
+        children: /* @__PURE__ */ jsx7(
           "div",
           {
             className: getClassName4("inner"),
@@ -3940,16 +3456,16 @@ var Modal = ({
 
 // src/puck/overrides/DrawerItem.tsx
 import { shallow as shallow2 } from "zustand/shallow";
-import { Fragment as Fragment5, jsx as jsx11, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+var useCustomPuck10 = createUsePuck11();
 var getClassName5 = get_class_name_factory_default("DrawerItem", DrawerItem_module_default);
-var usePuck2 = createUsePuck12();
 var DrawerItem = (props) => {
   const componentMeta = useSoftConfig((s) => s.softComponents[props.name]);
   const displayName = props.label || (componentMeta == null ? void 0 : componentMeta.name) || props.name;
   const softComponents = new Set(
     Object.keys(useSoftConfig((s) => s.softComponents, shallow2))
   );
-  const getPermissions = usePuck2((s) => s.getPermissions);
+  const getPermissions = useCustomPuck10((s) => s.getPermissions);
   const insertAllowed = getPermissions({ type: props.name }).insert;
   const removeSoftComponentVersion = useSoftConfig(
     (s) => s.removeSoftComponentVersion
@@ -4033,7 +3549,7 @@ var DrawerItem = (props) => {
         label: `Migrate to Version ${version}`
       }))
     ];
-    return /* @__PURE__ */ jsxs4(Fragment5, { children: [
+    return /* @__PURE__ */ jsxs4(Fragment4, { children: [
       /* @__PURE__ */ jsxs4(
         "div",
         {
@@ -4043,40 +3559,39 @@ var DrawerItem = (props) => {
           children: [
             props.label,
             /* @__PURE__ */ jsxs4("div", { className: getClassName5("content"), children: [
-              /* @__PURE__ */ jsx11("div", { className: getClassName5("name"), children: displayName }),
+              /* @__PURE__ */ jsx8("div", { className: getClassName5("name"), children: displayName }),
               useVersioning && /* @__PURE__ */ jsxs4("div", { className: getClassName5("version"), children: [
                 "v",
                 defaultVersion
               ] })
             ] }),
             /* @__PURE__ */ jsxs4("div", { className: getClassName5("actions"), children: [
-              isHovering && /* @__PURE__ */ jsx11("div", { className: getClassName5("settingsButton"), children: /* @__PURE__ */ jsx11(
+              isHovering && /* @__PURE__ */ jsx8("div", { className: getClassName5("settingsButton"), children: /* @__PURE__ */ jsx8(
                 IconButton,
                 {
                   title: "Settings",
-                  variant: "secondary",
                   onClick: (e) => {
                     e.stopPropagation();
                     setIsEditing(true);
                     setSelectedVersion(defaultVersion || "");
                   },
-                  children: /* @__PURE__ */ jsx11(Cog, { size: 12 })
+                  children: /* @__PURE__ */ jsx8(Cog, { size: 12 })
                 }
               ) }),
-              /* @__PURE__ */ jsx11("div", { className: getClassName5("grip"), children: /* @__PURE__ */ jsx11(GripVertical, { size: 16 }) })
+              /* @__PURE__ */ jsx8("div", { className: getClassName5("grip"), children: /* @__PURE__ */ jsx8(GripVertical, { size: 16 }) })
             ] })
           ]
         }
       ),
-      /* @__PURE__ */ jsx11(Modal, { isOpen: isEditing, onClose: handleCancel, children: /* @__PURE__ */ jsxs4("div", { className: getClassName5("modal"), children: [
+      /* @__PURE__ */ jsx8(Modal, { isOpen: isEditing, onClose: handleCancel, children: /* @__PURE__ */ jsxs4("div", { className: getClassName5("modal"), children: [
         /* @__PURE__ */ jsxs4("div", { className: getClassName5("modalHeader"), children: [
-          /* @__PURE__ */ jsx11("h2", { className: getClassName5("modalTitle"), children: displayName }),
-          /* @__PURE__ */ jsx11("p", { className: getClassName5("modalSubtitle"), children: "Component Settings" })
+          /* @__PURE__ */ jsx8("h2", { className: getClassName5("modalTitle"), children: displayName }),
+          /* @__PURE__ */ jsx8("p", { className: getClassName5("modalSubtitle"), children: "Component Settings" })
         ] }),
-        /* @__PURE__ */ jsx11("div", { className: getClassName5("modalBody"), children: useVersioning ? /* @__PURE__ */ jsxs4(Fragment5, { children: [
+        /* @__PURE__ */ jsx8("div", { className: getClassName5("modalBody"), children: useVersioning ? /* @__PURE__ */ jsxs4(Fragment4, { children: [
           /* @__PURE__ */ jsxs4("div", { className: getClassName5("section"), children: [
-            /* @__PURE__ */ jsx11("h3", { className: getClassName5("sectionTitle"), children: "Versions" }),
-            /* @__PURE__ */ jsx11("div", { className: getClassName5("versionList"), children: versions.map((version) => {
+            /* @__PURE__ */ jsx8("h3", { className: getClassName5("sectionTitle"), children: "Versions" }),
+            /* @__PURE__ */ jsx8("div", { className: getClassName5("versionList"), children: versions.map((version) => {
               const isDefault = version === (selectedVersion || defaultVersion);
               const isMarkedForDeletion = versionsToDelete.has(version);
               let rowClass = getClassName5("versionRow");
@@ -4088,16 +3603,16 @@ var DrawerItem = (props) => {
                     "Version ",
                     version
                   ] }),
-                  isDefault && /* @__PURE__ */ jsx11("span", { className: getClassName5("defaultBadge"), children: "Default" }),
-                  isMarkedForDeletion && /* @__PURE__ */ jsx11("span", { className: getClassName5("deleteBadge"), children: "Marked for deletion" })
+                  isDefault && /* @__PURE__ */ jsx8("span", { className: getClassName5("defaultBadge"), children: "Default" }),
+                  isMarkedForDeletion && /* @__PURE__ */ jsx8("span", { className: getClassName5("deleteBadge"), children: "Marked for deletion" })
                 ] }),
                 /* @__PURE__ */ jsxs4("div", { className: getClassName5("versionActions"), children: [
-                  !isDefault && !isMarkedForDeletion && /* @__PURE__ */ jsx11(Button2, { variant: "secondary", onClick: () => setSelectedVersion(version), children: "Set as Default" }),
-                  /* @__PURE__ */ jsx11(Button2, { variant: "secondary", onClick: () => toggleVersionForDeletion(version), children: isMarkedForDeletion ? /* @__PURE__ */ jsxs4(Fragment5, { children: [
-                    /* @__PURE__ */ jsx11(X, { size: 14 }),
+                  !isDefault && !isMarkedForDeletion && /* @__PURE__ */ jsx8(Button2, { variant: "secondary", onClick: () => setSelectedVersion(version), children: "Set as Default" }),
+                  /* @__PURE__ */ jsx8(Button2, { variant: "secondary", onClick: () => toggleVersionForDeletion(version), children: isMarkedForDeletion ? /* @__PURE__ */ jsxs4(Fragment4, { children: [
+                    /* @__PURE__ */ jsx8(X, { size: 14 }),
                     " Undo"
-                  ] }) : /* @__PURE__ */ jsxs4(Fragment5, { children: [
-                    /* @__PURE__ */ jsx11(Trash2, { size: 14 }),
+                  ] }) : /* @__PURE__ */ jsxs4(Fragment4, { children: [
+                    /* @__PURE__ */ jsx8(Trash2, { size: 14 }),
                     " Delete"
                   ] }) })
                 ] })
@@ -4105,8 +3620,8 @@ var DrawerItem = (props) => {
             }) })
           ] }),
           versionsToDelete.size > 0 && /* @__PURE__ */ jsxs4("div", { className: getClassName5("section"), children: [
-            /* @__PURE__ */ jsx11("h3", { className: getClassName5("sectionTitle"), children: "Migration Settings" }),
-            /* @__PURE__ */ jsx11("div", { className: getClassName5("migrationOptions"), children: /* @__PURE__ */ jsx11(
+            /* @__PURE__ */ jsx8("h3", { className: getClassName5("sectionTitle"), children: "Migration Settings" }),
+            /* @__PURE__ */ jsx8("div", { className: getClassName5("migrationOptions"), children: /* @__PURE__ */ jsx8(
               "div",
               {
                 className: getClassName5("migrationList"),
@@ -4124,8 +3639,8 @@ var DrawerItem = (props) => {
                       className: `${getClassName5("migrationOption")} ${isSelected ? getClassName5("migrationOption--isSelected") : ""}`,
                       onClick: () => setMigrationTarget(target.value),
                       children: [
-                        /* @__PURE__ */ jsx11("span", { className: getClassName5("migrationOptionLabel"), children: target.label }),
-                        isSelected && /* @__PURE__ */ jsx11(Check, { size: 14 })
+                        /* @__PURE__ */ jsx8("span", { className: getClassName5("migrationOptionLabel"), children: target.label }),
+                        isSelected && /* @__PURE__ */ jsx8(Check, { size: 14 })
                       ]
                     },
                     target.value
@@ -4133,49 +3648,48 @@ var DrawerItem = (props) => {
                 })
               }
             ) }),
-            /* @__PURE__ */ jsx11("p", { className: getClassName5("helpText"), children: "Choose where to move existing instances of the deleted versions." })
+            /* @__PURE__ */ jsx8("p", { className: getClassName5("helpText"), children: "Choose where to move existing instances of the deleted versions." })
           ] })
-        ] }) : /* @__PURE__ */ jsx11("div", { className: getClassName5("section"), children: /* @__PURE__ */ jsxs4("p", { children: [
+        ] }) : /* @__PURE__ */ jsx8("div", { className: getClassName5("section"), children: /* @__PURE__ */ jsxs4("p", { children: [
           "Manage high-level settings for the ",
-          /* @__PURE__ */ jsx11("strong", { children: displayName }),
+          /* @__PURE__ */ jsx8("strong", { children: displayName }),
           " component."
         ] }) }) }),
         /* @__PURE__ */ jsxs4("div", { className: getClassName5("modalFooter"), children: [
           /* @__PURE__ */ jsxs4("div", { className: getClassName5("footerLeft"), children: [
             useVersioning ? /* @__PURE__ */ jsxs4(Button2, { size: "medium", onClick: handleApply, children: [
-              /* @__PURE__ */ jsx11(Check, { size: 16 }),
+              /* @__PURE__ */ jsx8(Check, { size: 16 }),
               " Apply Changes"
-            ] }) : /* @__PURE__ */ jsx11(Button2, { size: "medium", onClick: handleCancel, children: "Close" }),
+            ] }) : /* @__PURE__ */ jsx8(Button2, { size: "medium", onClick: handleCancel, children: "Close" }),
             useVersioning && /* @__PURE__ */ jsxs4(Button2, { size: "medium", variant: "secondary", onClick: handleCancel, children: [
-              /* @__PURE__ */ jsx11(X, { size: 16 }),
+              /* @__PURE__ */ jsx8(X, { size: 16 }),
               " Cancel"
             ] })
           ] }),
-          /* @__PURE__ */ jsx11("div", { className: getClassName5("footerRight"), children: /* @__PURE__ */ jsxs4(Button2, { size: "medium", variant: "secondary", onClick: handleDemolishClick, children: [
-            /* @__PURE__ */ jsx11(Trash2, { size: 16 }),
+          /* @__PURE__ */ jsx8("div", { className: getClassName5("footerRight"), children: /* @__PURE__ */ jsxs4(Button2, { size: "medium", variant: "secondary", onClick: handleDemolishClick, children: [
+            /* @__PURE__ */ jsx8(Trash2, { size: 16 }),
             " Demolish Component"
           ] }) })
         ] })
       ] }) })
     ] });
   }
-  return /* @__PURE__ */ jsx11(Fragment5, { children: props.children });
+  return /* @__PURE__ */ jsx8(Fragment4, { children: props.children });
 };
-var ComponentItem = DrawerItem;
 
 // src/puck/overrides/Drawer.tsx
 import { useState as useState5 } from "react";
-import { createUsePuck as createUsePuck13, Drawer as PuckDrawer } from "@measured/puck";
+import { createUsePuck as createUsePuck12, Drawer as PuckDrawer } from "@measured/puck";
 import { ChevronDown, ChevronUp } from "lucide-react";
 
 // css-module:/home/osamu/Documents/netlisian-soft/packages/soft-config/src/puck/overrides/Drawer.module.css#css-module
 var Drawer_module_default = { "Drawer": "_Drawer_12zq5_1", "Drawer-category": "_Drawer-category_12zq5_7", "Drawer-category--isExpanded": "_Drawer-category--isExpanded_12zq5_15", "Drawer-categoryContent": "_Drawer-categoryContent_12zq5_19", "Drawer-categoryTitle": "_Drawer-categoryTitle_12zq5_27", "Drawer-categoryTitleIcon": "_Drawer-categoryTitleIcon_12zq5_63" };
 
 // src/puck/overrides/Drawer.tsx
-import { jsx as jsx12, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var useCustomPuck11 = createUsePuck12();
 var getClassName6 = get_class_name_factory_default("Drawer", Drawer_module_default);
 var getCategoryClassName = get_class_name_factory_default("Drawer-category", Drawer_module_default);
-var usePuck3 = createUsePuck13();
 var CategorySection = ({
   id,
   title,
@@ -4192,12 +3706,12 @@ var CategorySection = ({
       onClick: () => onToggle(id),
       title: expanded ? `Collapse ${title}` : `Expand ${title}`,
       children: [
-        /* @__PURE__ */ jsx12("span", { children: title }),
-        /* @__PURE__ */ jsx12("span", { className: getClassName6("categoryTitleIcon"), children: expanded ? /* @__PURE__ */ jsx12(ChevronUp, { size: 12 }) : /* @__PURE__ */ jsx12(ChevronDown, { size: 12 }) })
+        /* @__PURE__ */ jsx9("span", { children: title }),
+        /* @__PURE__ */ jsx9("span", { className: getClassName6("categoryTitleIcon"), children: expanded ? /* @__PURE__ */ jsx9(ChevronUp, { size: 12 }) : /* @__PURE__ */ jsx9(ChevronDown, { size: 12 }) })
       ]
     }
   ),
-  /* @__PURE__ */ jsx12("div", { className: getClassName6("categoryContent"), children: /* @__PURE__ */ jsx12(PuckDrawer, { children: componentKeys.map((key) => /* @__PURE__ */ jsx12(
+  /* @__PURE__ */ jsx9("div", { className: getClassName6("categoryContent"), children: /* @__PURE__ */ jsx9(PuckDrawer, { children: componentKeys.map((key) => /* @__PURE__ */ jsx9(
     PuckDrawer.Item,
     {
       name: key,
@@ -4209,8 +3723,8 @@ var CategorySection = ({
 ] });
 var Drawer = (_props) => {
   var _a, _b;
-  const config = usePuck3((s) => s.config);
-  const getPermissions = usePuck3((s) => s.getPermissions);
+  const config = useCustomPuck11((s) => s.config);
+  const getPermissions = useCustomPuck11((s) => s.getPermissions);
   const categories = (_a = config.categories) != null ? _a : {};
   const categorised = new Set(
     Object.values(categories).flatMap((cat) => {
@@ -4237,7 +3751,7 @@ var Drawer = (_props) => {
   });
   const toggle = (id) => setExpanded((prev) => __spreadProps(__spreadValues({}, prev), { [id]: !prev[id] }));
   if (categoryEntries.length === 0) {
-    return /* @__PURE__ */ jsx12(PuckDrawer, { children: allKeys.map((key) => /* @__PURE__ */ jsx12(
+    return /* @__PURE__ */ jsx9(PuckDrawer, { children: allKeys.map((key) => /* @__PURE__ */ jsx9(
       PuckDrawer.Item,
       {
         name: key,
@@ -4251,7 +3765,7 @@ var Drawer = (_props) => {
   return /* @__PURE__ */ jsxs5("div", { className: getClassName6(), children: [
     categoryEntries.map(([id, cat]) => {
       var _a2, _b2, _c;
-      return /* @__PURE__ */ jsx12(
+      return /* @__PURE__ */ jsx9(
         CategorySection,
         {
           id,
@@ -4266,7 +3780,7 @@ var Drawer = (_props) => {
         id
       );
     }),
-    otherKeys.length > 0 && /* @__PURE__ */ jsx12(
+    otherKeys.length > 0 && /* @__PURE__ */ jsx9(
       CategorySection,
       {
         id: "__other__",
@@ -4281,17 +3795,19 @@ var Drawer = (_props) => {
 };
 
 // src/puck/overrides/HeaderActions.tsx
-import { Button as Button3, createUsePuck as createUsePuck14 } from "@measured/puck";
-import { Fragment as Fragment6, jsx as jsx13, jsxs as jsxs6 } from "react/jsx-runtime";
-var usePuck4 = createUsePuck14();
+import { Button as Button3, createUsePuck as createUsePuck13 } from "@measured/puck";
+import { Fragment as Fragment5, jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var useCustomPuck12 = createUsePuck13();
 var HeaderActions = ({ children }) => {
   const { handleComplete } = useComplete();
   const { handleCancel, canCancel } = useCancel();
-  const dispatch = usePuck4((s) => s.dispatch);
+  const dispatch = useCustomPuck12((s) => s.dispatch);
+  const appState = useCustomPuck12((s) => s.appState);
+  const selectedItemSelector = appState.ui.itemSelector;
   const inspect = useSoftConfig((s) => s.builder.inspect);
-  return /* @__PURE__ */ jsx13(Fragment6, { children: canCancel ? /* @__PURE__ */ jsxs6(Fragment6, { children: [
-    /* @__PURE__ */ jsx13(Button3, { onClick: handleCancel, children: "Cancel" }),
-    /* @__PURE__ */ jsx13(
+  return /* @__PURE__ */ jsx10(Fragment5, { children: canCancel ? /* @__PURE__ */ jsxs6(Fragment5, { children: [
+    /* @__PURE__ */ jsx10(Button3, { onClick: handleCancel, children: "Cancel" }),
+    /* @__PURE__ */ jsx10(
       Button3,
       {
         variant: "primary",
@@ -4299,7 +3815,7 @@ var HeaderActions = ({ children }) => {
           const completedComponent = handleComplete();
           if (completedComponent) {
             try {
-              inspect(completedComponent.id, dispatch);
+              inspect(completedComponent.id, dispatch, selectedItemSelector);
             } catch (error) {
               notify.error(
                 "Failed to inspect after completion: " + (error instanceof Error ? error.message : String(error))
@@ -4522,17 +4038,36 @@ var resolveSoftConfig = (data, softComponents, config) => {
   if (process.env.NODE_ENV === "development") {
     const validation = validateOnlyHardComponents(dissolved, softComponents);
     if (!validation.isValid) {
-      console.warn(
-        "Warning: Soft components still present after dissolution:",
-        validation.softComponentsFound
+      alert(
+        "Warning: Soft components still present after dissolution: " + String(
+          validation.softComponentsFound
+        )
       );
     }
   }
   return dissolved;
 };
+
+// src/puck/lib/builder/generate-field-options.ts
+var hasArrayMappingPath = (value) => value.includes("[]");
+var isBareArrayPath = (value) => !hasArrayMappingPath(value) && !value.includes(".");
+function filterToOptionsForFrom(fromPath, toOptions) {
+  if (!fromPath) return toOptions;
+  const fromHasArrayMapping = hasArrayMappingPath(fromPath);
+  const fromIsBareArray = isBareArrayPath(fromPath);
+  return toOptions.filter((option) => {
+    const optionHasArrayMapping = hasArrayMappingPath(option.value);
+    if (fromHasArrayMapping) {
+      return optionHasArrayMapping;
+    }
+    if (fromIsBareArray) {
+      return isBareArrayPath(option.value);
+    }
+    return !optionHasArrayMapping;
+  });
+}
 export {
   ActionBarOverride as ActionBar,
-  ComponentItem,
   Drawer as ComponentList,
   Drawer,
   DrawerItem,