attaform 0.28.0 → 0.30.0

package/dist/shared/{attaform.Cs2Rbdlo.mjs → attaform.BK0cgu2K.mjs}

@@ -1,4 +1,4 @@
-import { NodeTypes, createCompoundExpression, createSimpleExpression, ElementTypes, processExpression } from '@vue/compiler-core';
+import { NodeTypes, ElementTypes, createCompoundExpression, createSimpleExpression, processExpression } from '@vue/compiler-core';
 import { S as SSR_COMPONENT_HOST_MODIFIER, V as V_REGISTER_COMPILED_MODIFIER } from './attaform.KvlEedlF.mjs';
 
 function getSummarizedProps(node) {
@@ -40,6 +40,10 @@ function removePropsByName(props, propNames) {
     props.splice(index, 1);
   }
 }
+function toExpressionArray(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value : [value];
+}
 function isExactKey(summarizedKey, name) {
   return summarizedKey === name || summarizedKey === `"${name}"`;
 }
@@ -64,54 +68,13 @@ function flattenExpression(exp) {
   return out;
 }
 
-function generateEqualityExpression$1(selectValue, optionValue, previousOptionExpressions) {
-  const multipleExpression = previousOptionExpressions?.[0];
-  if (multipleExpression === void 0) {
-    throw new Error(
-      "Programming error: `multiple` expression for `select` node not generated while transforming AST"
-    );
-  }
-  const optExpressions = previousOptionExpressions.slice(1);
-  const noMultipleOptExpressions = optExpressions.reduce(
-    (acc, curr, index) => {
-      if (index === 0) {
-        acc.push("(");
-      }
-      acc.push(...curr);
-      if (index < optExpressions.length - 1) {
-        acc.push(" || ");
-      }
-      if (index === optExpressions.length - 1) {
-        acc.push(")");
-      }
-      return acc;
-    },
-    []
-  );
+function generateEqualityExpression$1(selectValue, optionValue, multipleExpression) {
   const selectValueArr = Array.isArray(selectValue) ? selectValue : [selectValue];
   const optionValueArr = Array.isArray(optionValue) ? optionValue : [optionValue];
   function getImplicitTrueMultipleExpression(expression) {
     if (expression.length === 1 && expression[0] === "") return [`true`];
     return expression;
   }
-  previousOptionExpressions.push(["(", ...selectValueArr, ") === (", ...optionValueArr, ")"]);
-  if (!noMultipleOptExpressions.length) {
-    return [
-      "(",
-      ...getImplicitTrueMultipleExpression(multipleExpression),
-      `) ? ((`,
-      ...selectValueArr,
-      `)?.innerRef?.value?.findIndex?.(el => el === (`,
-      ...optionValueArr,
-      `)) > -1) : (typeof (`,
-      ...selectValueArr,
-      `)?.innerRef?.value !== 'object' && String((`,
-      ...selectValueArr,
-      `)?.innerRef?.value) === String((`,
-      ...optionValueArr,
-      `)))`
-    ];
-  }
   return [
     "(",
     ...getImplicitTrueMultipleExpression(multipleExpression),
@@ -119,16 +82,13 @@ function generateEqualityExpression$1(selectValue, optionValue, previousOptionEx
     ...selectValueArr,
     `)?.innerRef?.value?.findIndex?.(el => el === (`,
     ...optionValueArr,
-    `)) > -1) : ((`,
-    ...noMultipleOptExpressions,
-    // if true, we already found the relevant option
-    `) ? false : (typeof (`,
+    `)) > -1) : (typeof (`,
     ...selectValueArr,
-    `)?.innerRef?.value !== 'object' && String((`,
+    `)?.innerRef?.value !== 'object' && (`,
     ...selectValueArr,
-    `)?.innerRef?.value) === String((`,
+    `)?.displayValue?.value === String((`,
     ...optionValueArr,
-    `))))`
+    `)))`
   ];
 }
 function extractMultipleFromSelectSummarizedProps(props) {
@@ -143,7 +103,7 @@ function extractMultipleFromSelectSummarizedProps(props) {
   const value = props[priorityIndex]?.value;
   return typeof value === "string" ? value.replace(/'|"/g, "") : value ?? "true";
 }
-const RECURSABLE_NODE_TYPES$1 = /* @__PURE__ */ new Set([
+const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
   NodeTypes.ELEMENT,
   NodeTypes.FOR,
   NodeTypes.IF,
@@ -170,6 +130,57 @@ function inferOptionValueFromChildren(node) {
   const text = only.content.trim();
   return JSON.stringify(text);
 }
+const pendingOptionBindings = /* @__PURE__ */ new WeakMap();
+function applyPendingOptionBinding(node, pending) {
+  const optionProps = getSummarizedProps(node);
+  const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, "value"));
+  let optionValueSummarizedProp;
+  if (valueIndex >= 0 && valueIndex < optionProps.length) {
+    optionValueSummarizedProp = optionProps[valueIndex];
+  } else {
+    const fallback = inferOptionValueFromChildren(node);
+    if (fallback === null) {
+      return;
+    }
+    optionValueSummarizedProp = { key: "value", value: fallback };
+  }
+  const props = node.props;
+  const snapshot = [...props];
+  try {
+    removePropsByName(props, ["selected"]);
+    const authorSelectedArr = toExpressionArray(
+      optionProps.find((p) => isExactKey(p.key, "selected"))?.value
+    );
+    const registerArr = toExpressionArray(pending.registerValue) ?? ["undefined"];
+    const boundExpression = generateEqualityExpression$1(
+      pending.registerValue,
+      optionValueSummarizedProp?.value ?? "undefined",
+      pending.multiple
+    );
+    props.push({
+      arg: createSimpleExpression("selected", true),
+      exp: createCompoundExpression(
+        authorSelectedArr === void 0 ? boundExpression : [
+          "((",
+          ...registerArr,
+          ") == null ? (",
+          ...authorSelectedArr,
+          ") : (",
+          ...boundExpression,
+          "))"
+        ]
+      ),
+      name: "bind",
+      modifiers: [],
+      type: NodeTypes.DIRECTIVE,
+      loc: node.loc
+    });
+  } catch (err) {
+    props.length = 0;
+    props.push(...snapshot);
+    console.error("[attaform] component-bridge transform: option binding failed, skipping:", err);
+  }
+}
 const componentBridgeTransform = (node, context) => {
   const snapshots = [];
   const snapshotProps = (target) => {
@@ -177,51 +188,33 @@ const componentBridgeTransform = (node, context) => {
     snapshots.push({ target, snapshot: [...target] });
   };
   try {
-    let traverseSelectNode = function(_node, previousOptionExpressions2) {
+    let traverseSelectNode = function(_node, multipleExpression2) {
       const isOption = _node.type === NodeTypes.ELEMENT && _node.tag === "option";
       if (!isOption) {
-        if (!RECURSABLE_NODE_TYPES$1.has(_node.type)) return;
+        if (!RECURSABLE_NODE_TYPES.has(_node.type)) return;
         const hasChildren = "children" in _node;
         if (!hasChildren) return;
         for (const child of _node.children) {
           if (typeof child === "symbol" || typeof child === "string") continue;
           if (child.type === NodeTypes.SIMPLE_EXPRESSION) continue;
-          traverseSelectNode(child, previousOptionExpressions2);
+          traverseSelectNode(child, multipleExpression2);
         }
         return;
       }
       hasSlottedOptions = true;
-      const optionProps = getSummarizedProps(_node);
-      const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, "value"));
-      let optionValueSummarizedProp;
-      if (valueIndex >= 0 && valueIndex < optionProps.length) {
-        optionValueSummarizedProp = optionProps[valueIndex];
-      } else {
-        const fallback = inferOptionValueFromChildren(_node);
-        if (fallback === null) {
-          return;
-        }
-        optionValueSummarizedProp = { key: "value", value: fallback };
-      }
-      const props = _node.props;
-      snapshotProps(props);
-      removePropsByName(props, ["selected"]);
-      const newProp = {
-        arg: createSimpleExpression("selected", true),
-        exp: createCompoundExpression(
-          generateEqualityExpression$1(
-            registerSummarizedProp?.value ?? "undefined",
-            optionValueSummarizedProp?.value ?? "undefined",
-            previousOptionExpressions2
-          )
-        ),
-        name: "bind",
-        modifiers: [],
-        type: NodeTypes.DIRECTIVE,
-        loc: _node.loc
-      };
-      props.push(newProp);
+      pendingOptionBindings.set(_node, {
+        registerValue: registerSummarizedProp?.value ?? "undefined",
+        multiple: multipleExpression2
+      });
     };
+    if (node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.ELEMENT) {
+      const pending = pendingOptionBindings.get(node);
+      if (pending !== void 0) {
+        pendingOptionBindings.delete(node);
+        applyPendingOptionBinding(node, pending);
+        return;
+      }
+    }
     const isSelect = node.type === NodeTypes.ELEMENT && node.tag === "select";
     const isCustomComponent = node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.COMPONENT;
     const isKebabCustomElement = node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.ELEMENT && node.tag.includes("-") && !NATIVE_FORM_TAGS.has(node.tag);
@@ -233,25 +226,32 @@ const componentBridgeTransform = (node, context) => {
     const registerSummarizedProp = selectSummarizedProps[registerIndex];
     const selectLoc = node.loc;
     let hasSlottedOptions = false;
-    const multipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
-    const previousOptionExpressions = typeof multipleExpression === "string" ? [[multipleExpression]] : [multipleExpression];
+    const rawMultipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
+    const multipleExpression = typeof rawMultipleExpression === "string" ? [rawMultipleExpression] : rawMultipleExpression;
     for (const child of node.children) {
-      traverseSelectNode(child, previousOptionExpressions);
+      traverseSelectNode(child, multipleExpression);
     }
-    const isStaticallyNonMultiple = multipleExpression === "false";
+    const isStaticallyNonMultiple = rawMultipleExpression === "false";
     const isComponentHost = isCustomComponent || isKebabCustomElement;
     const isSelectLikeHost = isSelect || isComponentHost && hasSlottedOptions;
     const isPlainComponentHost = isComponentHost && !hasSlottedOptions;
     const selectProps = node.props;
+    const authorSelectValueArr = toExpressionArray(
+      selectSummarizedProps.find((p) => isExactKey(p.key, "value"))?.value
+    );
     snapshotProps(selectProps);
     removePropsByName(selectProps, ["value"]);
     if (isStaticallyNonMultiple && isSelectLikeHost) {
       const valuePropExpArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
-      const initExpression = createCompoundExpression([
-        "(",
-        ...valuePropExpArray,
-        ")?.displayValue.value"
-      ]);
+      const initExpression = createCompoundExpression(
+        authorSelectValueArr === void 0 ? ["(", ...valuePropExpArray, ")?.displayValue.value"] : [
+          "((",
+          ...valuePropExpArray,
+          ")?.displayValue.value ?? (",
+          ...authorSelectValueArr,
+          "))"
+        ]
+      );
       const simpleExpression = createSimpleExpression(flattenExpression(initExpression), false);
       let outputExp;
       try {
@@ -470,26 +470,41 @@ const inputTextAreaNodeTransform = (node) => {
       const isStaticRadio = typeProp !== void 0 && isStaticTypeOneOf(typeProp.value, ["radio"]);
       const isDynamicType = typeProp !== void 0 && isDynamicTypeValue(typeProp.value);
       const keepStaticValue = isStaticCheckbox || isStaticRadio || isDynamicType;
+      const authorCheckedProp = elementProps.find((p) => isExactKey(p.key, "checked"));
+      const authorValueProp = keepStaticValue ? void 0 : elementProps.find((p) => isExactKey(p.key, "value"));
       removePropsByName(props, keepStaticValue ? ["checked"] : ["checked", "value"]);
       const registerValueArr = Array.isArray(registerSummarizedProp2.value) ? registerSummarizedProp2.value : [registerSummarizedProp2.value];
-      const valueExpression = createCompoundExpression([
-        "(",
-        ...registerValueArr,
-        ")?.displayValue?.value"
-      ]);
+      const authorValueArr = toExpressionArray(authorValueProp?.value);
+      const valueExpression = createCompoundExpression(
+        authorValueArr === void 0 ? ["(", ...registerValueArr, ")?.displayValue?.value"] : ["((", ...registerValueArr, ")?.displayValue?.value ?? (", ...authorValueArr, "))"]
+      );
       const trueValueIndex = elementProps.findIndex((p) => isExactKey(p.key, "true-value"));
       const trueValueProp = elementProps[trueValueIndex];
       const scalarTarget = isStaticCheckbox ? trueValueProp !== void 0 ? trueValueProp.value : "true" : elementValueSummarizedProp2.value;
-      const coreExpression = [
-        "(",
-        ...elementSelectionLabelExpression.children,
-        ") === 'checked' ? (",
-        // resolves to a boolean
+      const authorCheckedArr = toExpressionArray(authorCheckedProp?.value);
+      const checkedExpression = authorCheckedArr === void 0 ? generateEqualityExpression(
+        registerSummarizedProp2.value,
+        elementValueSummarizedProp2.value,
+        scalarTarget
+      ) : [
+        "((",
+        ...registerValueArr,
+        ") == null ? (",
+        ...authorCheckedArr,
+        ") : (",
         ...generateEqualityExpression(
           registerSummarizedProp2.value,
           elementValueSummarizedProp2.value,
           scalarTarget
         ),
+        "))"
+      ];
+      const coreExpression = [
+        "(",
+        ...elementSelectionLabelExpression.children,
+        ") === 'checked' ? (",
+        // resolves to a boolean
+        ...checkedExpression,
         ") : (",
         // resolves to the provided register value
         ...valueExpression.children,
@@ -562,22 +577,10 @@ const inputTextAreaNodeTransform = (node) => {
   }
 };
 
-const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
-  NodeTypes.ELEMENT,
-  NodeTypes.FOR,
-  NodeTypes.IF,
-  NodeTypes.IF_BRANCH
-]);
-function findRedundantStateBinding(props, stateNames) {
+function findRedundantStateBinding(props) {
   for (const prop of props) {
-    if (prop.type === NodeTypes.ATTRIBUTE) {
-      if (stateNames.includes(prop.name)) return prop.name;
-      continue;
-    }
+    if (prop.type === NodeTypes.ATTRIBUTE) continue;
     if (prop.name === "model") return "v-model";
-    if (prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic && stateNames.includes(prop.arg.content)) {
-      return `:${prop.arg.content}`;
-    }
   }
   return null;
 }
@@ -602,42 +605,23 @@ function emitRedundantWarning(tag, binding) {
     `[attaform] \`${binding}\` is redundant beside v-register on <${tag}>. v-register already drives this field's value, so keep v-register alone and drop \`${binding}\`. (An identity \`:value\` on a radio or <option> is expected and stays silent.)`
   );
 }
-function walkOptionsForSelected(selectNode) {
-  const visit = (candidate) => {
-    if (candidate.type === NodeTypes.ELEMENT && candidate.tag === "option") {
-      const found = findRedundantStateBinding(candidate.props, ["selected"]);
-      if (found !== null) emitRedundantWarning("option", found);
-      return;
-    }
-    if (!RECURSABLE_NODE_TYPES.has(candidate.type)) return;
-    if (!("children" in candidate)) return;
-    for (const child of candidate.children) {
-      if (typeof child === "string" || typeof child === "symbol") continue;
-      if (child.type === NodeTypes.SIMPLE_EXPRESSION) continue;
-      visit(child);
-    }
-  };
-  for (const child of selectNode.children) visit(child);
-}
 function warnIfRedundant(node) {
   if (node.tagType !== ElementTypes.ELEMENT) return;
   const tag = node.tag;
   if (tag === "select") {
-    const found2 = findRedundantStateBinding(node.props, ["value"]);
+    const found2 = findRedundantStateBinding(node.props);
     if (found2 !== null) emitRedundantWarning("select", found2);
-    walkOptionsForSelected(node);
     return;
   }
   if (tag === "textarea") {
-    const found2 = findRedundantStateBinding(node.props, ["value"]);
+    const found2 = findRedundantStateBinding(node.props);
     if (found2 !== null) emitRedundantWarning("textarea", found2);
     return;
   }
   if (tag !== "input") return;
   const kind = classifyInput(node.props);
   if (kind === "dynamic" || kind === "file") return;
-  const stateNames = kind === "checkbox" || kind === "radio" ? ["checked"] : ["value"];
-  const found = findRedundantStateBinding(node.props, stateNames);
+  const found = findRedundantStateBinding(node.props);
   if (found !== null) emitRedundantWarning("input", found);
 }
 const redundantBindingWarnTransform = (node) => {

package/dist/{dev/shared/attaform-dev.By4PRjt0.mjs → shared/attaform.BRDDQeHV.mjs}

@@ -1,4 +1,4 @@
-import { f as pathsEqual, i as isPathPrefix } from './attaform-dev.Dr2YzS5B.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform.CdZIEf7_.mjs';
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -7,15 +7,8 @@ const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
 const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
 const DEFAULT_MAX_RECURSION_DEPTH = 64;
 function normalizeNumericOption(config) {
-  const { value, source, allowInfinity, min, defaultValue } = config;
-  if (allowInfinity && value === Infinity) return Infinity;
-  if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
-    {
-      const acceptedDescription = allowInfinity ? "a non-negative integer or Infinity" : "a non-negative finite integer";
-      console.warn(
-        `[attaform] ${source} must be ${acceptedDescription}; got ${String(value)}. Falling back to ${String(defaultValue)}.`
-      );
-    }
+  const { value, source, min, defaultValue } = config;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
     return defaultValue;
   }
   return Math.max(min, Math.floor(value));
@@ -28,6 +21,49 @@ function pickDefined(bag) {
   return out;
 }
 
+function callConsumerSchemaFn(fn, fallback, site) {
+  try {
+    return fn();
+  } catch (err) {
+    return fallback;
+  }
+}
+function readConsumerProp(obj, key) {
+  try {
+    return obj[key];
+  } catch {
+    return void 0;
+  }
+}
+function consumerKeys(obj) {
+  try {
+    return Object.keys(obj);
+  } catch {
+    return [];
+  }
+}
+function readConsumerIndex(arr, i) {
+  try {
+    return arr[i];
+  } catch {
+    return void 0;
+  }
+}
+function consumerSymbolKeys(obj) {
+  try {
+    return Object.getOwnPropertySymbols(obj);
+  } catch {
+    return [];
+  }
+}
+function consumerHas(obj, key) {
+  try {
+    return key in obj;
+  } catch {
+    return false;
+  }
+}
+
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
     Object.defineProperty(target, key, {
@@ -40,24 +76,50 @@ function safeAssign(target, key, value) {
   }
   target[key] = value;
 }
+const SHADOWED_KEYS = new Set(Object.getOwnPropertyNames(Object.prototype));
 function isShadowedKey(key) {
-  return key in Object.prototype;
+  return SHADOWED_KEYS.has(key);
 }
 function safeOwnRead(target, key) {
   if (isShadowedKey(key)) {
     const desc = Object.getOwnPropertyDescriptor(target, key);
     if (desc === void 0) return void 0;
-    return "value" in desc ? desc.value : target[key];
+    return "value" in desc ? desc.value : readConsumerProp(target, key);
   }
-  return target[key];
+  return readConsumerProp(target, key);
 }
 function safeOwnHas(target, key) {
-  return Object.prototype.hasOwnProperty.call(target, key);
+  try {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  } catch {
+    return false;
+  }
+}
+function spreadConsumerRecord(src) {
+  try {
+    return { ...src };
+  } catch {
+    const out = {};
+    for (const key of Object.keys(src)) {
+      safeAssign(out, key, readConsumerProp(src, key));
+    }
+    return out;
+  }
+}
+function copyConsumerArray(src) {
+  try {
+    return src.slice();
+  } catch {
+    const out = new Array(src.length);
+    for (let i = 0; i < src.length; i++) out[i] = readConsumerIndex(src, i);
+    return out;
+  }
 }
 
 function isDescendable(value) {
   if (value === null || typeof value !== "object") return false;
   if (Array.isArray(value)) return true;
+  if (value instanceof Map) return mapSegmentKeys(value) !== null;
   const proto = Object.getPrototypeOf(value);
   return proto === null || proto === Object.prototype;
 }
@@ -83,6 +145,16 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
     return;
   }
   if (oldIsDescendable && newIsDescendable) {
+    const oldIsMap = oldValue instanceof Map;
+    const newIsMap = newValue instanceof Map;
+    if (oldIsMap && newIsMap) {
+      diffMapsLockstep(oldValue, newValue, prefix, visit);
+      return;
+    }
+    if (oldIsMap !== newIsMap) {
+      visit({ kind: "changed", path: prefix, oldValue, newValue });
+      return;
+    }
     const oldIsArray = Array.isArray(oldValue);
     const newIsArray = Array.isArray(newValue);
     if (oldIsArray && newIsArray) {
@@ -122,46 +194,79 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
 function walkNewDescendable(newValue, prefix, visit) {
   if (Array.isArray(newValue)) {
     for (let i = 0; i < newValue.length; i++) {
-      diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
+      diffAndApply(void 0, readConsumerIndex(newValue, i), appendSegment(prefix, i), visit);
+    }
+  } else if (newValue instanceof Map) {
+    for (const [key, entry] of newValue) {
+      diffAndApply(void 0, entry, appendSegment(prefix, key), visit);
     }
   } else {
     const rec = newValue;
-    for (const k of Object.keys(rec)) {
-      diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
+    for (const k of consumerKeys(rec)) {
+      diffAndApply(void 0, readConsumerProp(rec, k), appendSegment(prefix, k), visit);
     }
   }
 }
 function walkOldDescendable(oldValue, prefix, visit) {
   if (Array.isArray(oldValue)) {
     for (let i = 0; i < oldValue.length; i++) {
-      diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
+      diffAndApply(readConsumerIndex(oldValue, i), void 0, appendSegment(prefix, i), visit);
+    }
+  } else if (oldValue instanceof Map) {
+    for (const [key, entry] of oldValue) {
+      diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
     }
   } else {
     const rec = oldValue;
-    for (const k of Object.keys(rec)) {
-      diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
+    for (const k of consumerKeys(rec)) {
+      diffAndApply(readConsumerProp(rec, k), void 0, appendSegment(prefix, k), visit);
     }
   }
 }
+function diffMapsLockstep(oldMap, newMap, prefix, visit) {
+  for (const [key, entry] of newMap) {
+    diffAndApply(oldMap.get(key), entry, appendSegment(prefix, key), visit);
+  }
+  for (const [key, entry] of oldMap) {
+    if (newMap.has(key)) continue;
+    diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
+  }
+}
 function diffArraysLockstep(oldArr, newArr, prefix, visit) {
   const max = Math.max(oldArr.length, newArr.length);
   for (let i = 0; i < max; i++) {
-    diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
+    diffAndApply(
+      readConsumerIndex(oldArr, i),
+      readConsumerIndex(newArr, i),
+      appendSegment(prefix, i),
+      visit
+    );
   }
 }
 function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
   const seen = /* @__PURE__ */ new Set();
-  for (const k of Object.keys(oldRec)) {
+  for (const k of consumerKeys(oldRec)) {
     seen.add(k);
-    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
   }
-  for (const k of Object.keys(newRec)) {
+  for (const k of consumerKeys(newRec)) {
     if (seen.has(k)) continue;
-    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
   }
 }
 function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
   if (!isDescendable(target) || !isDescendable(source)) return false;
+  if (target instanceof Map || source instanceof Map) return false;
   const targetIsArray = Array.isArray(target);
   const sourceIsArray = Array.isArray(source);
   if (targetIsArray !== sourceIsArray) return false;
@@ -230,6 +335,11 @@ function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
 }
 function structuralSnapshot(value) {
   if (!isDescendable(value)) return value;
+  if (value instanceof Map) {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of value) out2.set(k, structuralSnapshot(v));
+    return out2;
+  }
   if (Array.isArray(value)) {
     const out2 = new Array(value.length);
     for (let i = 0; i < value.length; i++) {
@@ -245,4 +355,4 @@ function structuralSnapshot(value) {
   return out;
 }
 
-export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, safeOwnHas as c, diffAndApply as d, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as e, applyChangedKeys as f, DEFAULT_MAX_RECURSION_DEPTH as g, ANONYMOUS_WIZARD_KEY_PREFIX as h, isShadowedKey as i, normalizeNumericOption as n, pickDefined as p, structuralSnapshot as s };
+export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, callConsumerSchemaFn as c, safeOwnHas as d, consumerHas as e, spreadConsumerRecord as f, copyConsumerArray as g, consumerKeys as h, isShadowedKey as i, readConsumerProp as j, diffAndApply as k, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as l, consumerSymbolKeys as m, normalizeNumericOption as n, applyChangedKeys as o, pickDefined as p, DEFAULT_MAX_RECURSION_DEPTH as q, readConsumerIndex as r, structuralSnapshot as s, ANONYMOUS_WIZARD_KEY_PREFIX as t };