attaform 0.28.0 → 0.30.0

package/dist/dev/shared/{attaform-dev.oYrkP9dj.mjs → attaform-dev.BK6Ge2qR.mjs}

@@ -1,36 +1,7 @@
-import { o as humanize, h as useAbstractForm } from './attaform-dev.WmuhD_CZ.mjs';
-import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.Dr2YzS5B.mjs';
-import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, b as buildFieldMetaPathMap, a as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform-dev.6qxD-Yqo.mjs';
-import { z } from 'zod';
-
-let warnedZodCodeMissing = false;
-function zodIssuesToValidationErrors(issues) {
-  return issues.map((issue) => {
-    let code;
-    if (typeof issue.code === "string" && issue.code.length > 0) {
-      code = `zod:${issue.code}`;
-    } else {
-      code = "zod:unknown";
-      if (!warnedZodCodeMissing) {
-        warnedZodCodeMissing = true;
-        console.warn(
-          "[attaform] zod-v4 adapter received an issue with no string `code`; stamping `'zod:unknown'`. This usually means a custom Zod plugin emitted an issue without the standard code field."
-        );
-      }
-    }
-    return {
-      message: issue.message,
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
-      path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
-      code
-    };
-  });
-}
-class UnsupportedSchemaError extends AttaformError {
-}
+import { j as humanize, c as useAbstractForm } from './attaform-dev.CQ2rJiAX.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform-dev.BQc5QV3Y.mjs';
+import { s as slimPrimitivesWalk, d as deriveDefaultWalk, m as mergeDeep, f as fixStructuralDefaults, w as walkPathSegments, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, e as getFieldMetaListForSchema, g as getFieldMetaForSchema } from './attaform-dev.BisFstxh.mjs';
+import { c as callConsumerSchemaFn } from './attaform-dev.BcYT6tFh.mjs';
 
 function readDef(schema) {
   if (schema === null || typeof schema !== "object") return void 0;
@@ -77,7 +48,9 @@ const IDENTITY_KINDS = /* @__PURE__ */ new Set([
   "file",
   "map",
   "symbol",
-  "function"
+  "function",
+  "nonoptional",
+  "success"
 ]);
 function kindOf(schema) {
   const def = readDef(schema);
@@ -110,6 +83,8 @@ function getRecordValueType(schema) {
   const def = readDef(schema);
   return def?.valueType;
 }
+const getMapKeyType = getRecordKeyType;
+const getMapValueType = getRecordValueType;
 function getTupleItems(schema) {
   const def = readDef(schema);
   return def?.items ?? [];
@@ -156,11 +131,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return getter();
-}
-function getLazyGetter(schema) {
-  const def = readDef(schema);
-  return typeof def?.getter === "function" ? def.getter : void 0;
+  return callConsumerSchemaFn(() => getter(), void 0, "lazy-getter");
 }
 function getIntersectionLeft(schema) {
   const def = readDef(schema);
@@ -174,11 +145,11 @@ function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  try {
-    return cv({ error: new Error("atta:default-values"), input: void 0 });
-  } catch {
-    return void 0;
-  }
+  return callConsumerSchemaFn(
+    () => cv({ error: new Error("atta:default-values"), input: void 0 }),
+    void 0,
+    "catch-factory"
+  );
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
@@ -186,7 +157,7 @@ function hasCatchValue(schema) {
 }
 function getDefaultValue(schema) {
   const def = readDef(schema);
-  return def?.defaultValue;
+  return callConsumerSchemaFn(() => def?.defaultValue, void 0, "default-factory");
 }
 function getNativeEnumValues(_schema) {
   return void 0;
@@ -197,11 +168,6 @@ function unwrapEffectsSource(_schema) {
 function unwrapBranded(_schema) {
   return void 0;
 }
-function hasChecks(schema) {
-  const def = readDef(schema);
-  const checks = def?.checks;
-  return Array.isArray(checks) && checks.length > 0;
-}
 function getChecks(schema) {
   const def = readDef(schema);
   const checks = def?.checks;
@@ -335,123 +301,6 @@ function isAsyncCheck(check) {
   return fn.constructor.name === "AsyncFunction";
 }
 
-const UNSUPPORTED = [
-  "promise",
-  "custom",
-  "template-literal",
-  "map",
-  "symbol",
-  "function"
-];
-function labelPath(path) {
-  return path.length === 0 ? "<root>" : path.join(".");
-}
-function assertSupportedKinds(schema, path = [], lazyGetters = []) {
-  const kind = kindOf(schema);
-  if (UNSUPPORTED.includes(kind)) {
-    throw new UnsupportedSchemaError(
-      `[attaform/zod] unsupported kind '${kind}' at '${labelPath(path)}'` 
-    );
-  }
-  switch (kind) {
-    case "object": {
-      const shape = getObjectShape(schema);
-      for (const [key, sub] of Object.entries(shape)) {
-        assertSupportedKinds(sub, [...path, key], lazyGetters);
-      }
-      return;
-    }
-    case "array":
-      assertSupportedKinds(getArrayElement(schema), [...path, "*"], lazyGetters);
-      return;
-    case "set":
-      assertSupportedKinds(getSetValueType(schema), [...path, "*"], lazyGetters);
-      return;
-    case "record":
-      assertSupportedKinds(getRecordValueType(schema), [...path, "*"], lazyGetters);
-      return;
-    case "tuple": {
-      const items = getTupleItems(schema);
-      items.forEach((item, i) => assertSupportedKinds(item, [...path, String(i)], lazyGetters));
-      return;
-    }
-    case "union": {
-      const options = getUnionOptions(schema);
-      options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-      return;
-    }
-    case "discriminated-union": {
-      const options = getDiscriminatedOptions(schema);
-      options.forEach((opt, i) => assertSupportedKinds(opt, [...path, `|${i}`], lazyGetters));
-      return;
-    }
-    case "optional":
-    case "nullable":
-    case "default":
-    case "readonly":
-    case "catch": {
-      const inner = unwrapInner(schema);
-      if (inner !== void 0) assertSupportedKinds(inner, path, lazyGetters);
-      return;
-    }
-    case "pipe": {
-      const inner = unwrapPipe(schema);
-      if (inner !== void 0) assertSupportedKinds(inner, path, lazyGetters);
-      return;
-    }
-    case "lazy": {
-      const getter = getLazyGetter(schema);
-      if (getter !== void 0 && lazyGetters.includes(getter)) return;
-      const inner = unwrapLazy(schema);
-      if (inner !== void 0) {
-        assertSupportedKinds(
-          inner,
-          path,
-          getter === void 0 ? lazyGetters : [...lazyGetters, getter]
-        );
-      }
-      return;
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      if (left !== void 0) assertSupportedKinds(left, [...path, "left"], lazyGetters);
-      if (right !== void 0) assertSupportedKinds(right, [...path, "right"], lazyGetters);
-      return;
-    }
-    // Leaves: nothing to descend into.
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "date":
-    case "enum":
-    case "literal":
-    case "null":
-    case "undefined":
-    case "nan":
-    case "any":
-    case "unknown":
-    case "void":
-    case "never":
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "file":
-    case "map":
-    case "symbol":
-    case "function":
-      return;
-    default: {
-      const _exhaustive = kind;
-      throw new Error(
-        `assertSupportedKinds: unhandled ZodKind '${_exhaustive}'` 
-      );
-    }
-  }
-}
-
 function unwrapToDiscriminatedUnion(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -478,6 +327,33 @@ function unwrapToDiscriminatedUnion(schema) {
   return void 0;
 }
 
+let warnedZodCodeMissing = false;
+function zodIssuesToValidationErrors(issues) {
+  return issues.map((issue) => {
+    let code;
+    if (typeof issue.code === "string" && issue.code.length > 0) {
+      code = `zod:${issue.code}`;
+    } else {
+      code = "zod:unknown";
+      if (!warnedZodCodeMissing) {
+        warnedZodCodeMissing = true;
+        console.warn(
+          "[attaform] zod-v4 adapter received an issue with no string `code`; stamping `'zod:unknown'`. This usually means a custom Zod plugin emitted an issue without the standard code field."
+        );
+      }
+    }
+    return {
+      message: issue.message,
+      // Adapter-side paths stay schema-relative — the validation
+      // pipeline in `create-form-store.ts` prepends the parent path
+      // to absolutise, then routes form-level (absolute path length 0)
+      // entries to the empty-string bucket at storage time.
+      path: issue.path.map((seg) => typeof seg === "number" ? seg : String(seg)),
+      code
+    };
+  });
+}
+
 const V4_INTROSPECTOR = {
   kindOf: (schema) => kindOf(schema),
   getObjectShape: (schema) => getObjectShape(schema),
@@ -497,8 +373,9 @@ const V4_INTROSPECTOR = {
     return getArrayElement(schema);
   },
   getSetValueType: (schema) => kindOf(schema) === "set" ? getSetValueType(schema) : void 0,
-  getRecordKeyType: (schema) => kindOf(schema) === "record" ? getRecordKeyType(schema) : void 0,
   getRecordValueType: (schema) => kindOf(schema) === "record" ? getRecordValueType(schema) : void 0,
+  getMapKeyType: (schema) => kindOf(schema) === "map" ? getMapKeyType(schema) : void 0,
+  getMapValueType: (schema) => kindOf(schema) === "map" ? getMapValueType(schema) : void 0,
   getUnionOptions,
   getIntersectionLeft,
   getIntersectionRight,
@@ -510,7 +387,6 @@ const V4_INTROSPECTOR = {
   unwrapPipeIn,
   unwrapPipeOut,
   unwrapLazy,
-  getLazyGetter,
   getDefaultValue,
   getCatchDefault,
   hasCatchValue
@@ -521,15 +397,12 @@ function slimPrimitivesOf(schema, maxRecursionDepth) {
 }
 
 function deriveDefault(schema, useDefault, maxRecursionDepth) {
-  return deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth, {
-    // v4 has an exhaustive switch against `SchemaIntrospector.kindOf`;
-    // unknown kinds genuinely shouldn't appear, so return undefined.
-    unsupportedKindFallback: () => void 0
-  });
+  return deriveDefaultWalk(schema, useDefault, V4_INTROSPECTOR, maxRecursionDepth);
 }
 function getDefaultValuesFromZodSchema(opts) {
   const { schema, useDefaultSchemaValues, constraints, maxRecursionDepth } = opts;
   const initial = deriveDefault(schema, useDefaultSchemaValues, maxRecursionDepth);
+  if (constraints === void 0) return { data: initial, success: true };
   const merged = mergeDeep(initial, constraints);
   return fixStructuralDefaults(
     schema,
@@ -561,137 +434,6 @@ function getNestedZodSchemasAtPath(schema, path, maxRecursionDepth) {
   );
 }
 
-function carrySyncChecks(rebuilt, original) {
-  if (!hasChecks(original)) return rebuilt;
-  const checks = getChecks(original).filter((c) => !isAsyncCheck(c));
-  if (checks.length === 0) return rebuilt;
-  return rebuilt.check(
-    ...checks
-  );
-}
-function stripAsyncChecks(schema) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  function recurse(s) {
-    if (seen.has(s)) return s;
-    seen.add(s);
-    const kind = kindOf(s);
-    switch (kind) {
-      case "string":
-        return hasChecks(s) ? carrySyncChecks(z.string(), s) : s;
-      case "number":
-        return hasChecks(s) ? carrySyncChecks(z.number(), s) : s;
-      case "bigint":
-        return hasChecks(s) ? carrySyncChecks(z.bigint(), s) : s;
-      case "array": {
-        const element = getArrayElement(s);
-        return carrySyncChecks(z.array(recurse(element)), s);
-      }
-      case "set": {
-        return carrySyncChecks(z.set(recurse(getSetValueType(s))), s);
-      }
-      case "tuple": {
-        const items = getTupleItems(s).map(recurse);
-        const rebuilt = z.tuple(
-          items
-        );
-        return carrySyncChecks(rebuilt, s);
-      }
-      case "object": {
-        const shape = getObjectShape(s);
-        const next = {};
-        for (const [k, v] of Object.entries(shape)) {
-          next[k] = recurse(v);
-        }
-        return carrySyncChecks(z.object(next), s);
-      }
-      case "record": {
-        const keyType = getRecordKeyType(s);
-        const valueType = recurse(getRecordValueType(s));
-        return carrySyncChecks(
-          z.record(keyType, valueType),
-          s
-        );
-      }
-      case "union": {
-        const options = getUnionOptions(s).map(recurse);
-        return carrySyncChecks(
-          z.union(options),
-          s
-        );
-      }
-      case "discriminated-union": {
-        const options = getDiscriminatedOptions(s).map((opt) => recurse(opt));
-        const discriminator = getDiscriminator(s);
-        if (discriminator === void 0) return s;
-        return z.discriminatedUnion(
-          discriminator,
-          options
-        );
-      }
-      case "optional": {
-        const inner = unwrapInner(s);
-        return inner === void 0 ? s : recurse(inner).optional();
-      }
-      case "nullable": {
-        const inner = unwrapInner(s);
-        return inner === void 0 ? s : recurse(inner).nullable();
-      }
-      case "default": {
-        const inner = unwrapInner(s);
-        if (inner === void 0) return s;
-        return recurse(inner).default(getDefaultValue(s));
-      }
-      case "readonly": {
-        const inner = unwrapInner(s);
-        return inner === void 0 ? s : recurse(inner).readonly();
-      }
-      case "lazy": {
-        const inner = unwrapLazy(s);
-        if (inner === void 0) return s;
-        const stripped = recurse(inner);
-        return z.lazy(() => stripped);
-      }
-      case "intersection": {
-        const left = getIntersectionLeft(s);
-        const right = getIntersectionRight(s);
-        if (left === void 0 || right === void 0) return s;
-        return z.intersection(recurse(left), recurse(right));
-      }
-      case "catch": {
-        const inner = unwrapInner(s);
-        if (inner === void 0) return s;
-        return recurse(inner).catch(getCatchDefault(s));
-      }
-      // Pipes pass through (see the docblock); the rest are leaves
-      // whose checks the strip walker deliberately leaves in place —
-      // an async check on one of these still poisons the sync parse
-      // and the callers' defensive catch owns that case.
-      case "pipe":
-      case "boolean":
-      case "date":
-      case "enum":
-      case "literal":
-      case "null":
-      case "undefined":
-      case "any":
-      case "unknown":
-      case "nan":
-      case "void":
-      case "never":
-      case "promise":
-      case "custom":
-      case "template-literal":
-      case "transform":
-      case "file":
-      case "map":
-      case "symbol":
-      case "function":
-        return s;
-    }
-  }
-  return recurse(schema);
-}
-
 function unwrapStructuralWrappers(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -704,6 +446,13 @@ function unwrapStructuralWrappers(schema) {
   }
   return current;
 }
+function assertKeyedRoot(rootSchema) {
+  const kind = kindOf(peelAllWrappers(rootSchema));
+  if (kind === "object" || kind === "record" || kind === "discriminated-union") return;
+  throw new AttaformError(
+    `[attaform/zod] useForm schema root must be a ZodObject, ZodRecord, or ZodDiscriminatedUnion (got '${kind}'). Wrap other shapes under a key.` 
+  );
+}
 function peelAllWrappers(schema) {
   let current = schema;
   for (let i = 0; i < 64; i++) {
@@ -777,22 +526,21 @@ function isLeafRequired(schema, depth = 0) {
 }
 function zodV4Adapter(rootSchema) {
   assertZodVersion(rootSchema);
-  assertSupportedKinds(rootSchema);
-  return (formKey, options) => createAbstractSchema(
+  assertKeyedRoot(rootSchema);
+  return (_formKey, options) => sharedV4Schemas(
     rootSchema,
-    V4_INTROSPECTOR,
-    buildV4Services(),
-    formKey,
-    options
+    options.maxRecursionDepth,
+    () => createAbstractSchema(
+      rootSchema,
+      V4_INTROSPECTOR,
+      buildV4Services(),
+      options
+    )
   );
 }
-async function lazyFingerprint(schema) {
-  const { fingerprintZodSchema } = await import('../chunks/fingerprint2.mjs');
-  return fingerprintZodSchema(schema);
-}
+const sharedV4Schemas = createSharedSchemaStore();
 function buildV4Services() {
   return {
-    fingerprint: (schema) => lazyFingerprint(schema),
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
     // v4 doesn't pre-strip for the slim-mode walk — its path walker
     // already peels every transparent wrapper inline, so the slim and
@@ -800,7 +548,7 @@ function buildV4Services() {
     getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth),
     slimPrimitivesOf: (schema, maxRecursionDepth) => slimPrimitivesOf(schema, maxRecursionDepth),
     deriveDefault: (schema, useDefault, maxRecursionDepth) => deriveDefault(schema, useDefault, maxRecursionDepth),
-    runStrictGetDefaults: (schema, config, fk, maxRecursionDepth) => runStrictGetDefaultsV4(schema, config, fk, maxRecursionDepth),
+    runGetDefaults: (schema, config, maxRecursionDepth) => runGetDefaultsV4(schema, config, maxRecursionDepth),
     unwrapStructuralWrappers: (schema) => unwrapStructuralWrappers(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllWrappers(schema),
@@ -815,47 +563,40 @@ function buildV4Services() {
       const result = await schema.safeParseAsync(data);
       return result.success ? { success: true, data: result.data } : { success: false, issues: result.error.issues };
     },
-    makeSubSchema: (schema, fk, maxRecursionDepth) => buildSubSchemaStubV4(schema, fk, maxRecursionDepth)
+    makeSubSchema: (schema, maxRecursionDepth) => buildSubSchemaStubV4(schema, maxRecursionDepth)
   };
 }
-function runStrictGetDefaultsV4(rootSchema, config, formKey, maxRecursionDepth) {
+function runGetDefaultsV4(rootSchema, config, maxRecursionDepth) {
   const { data } = getDefaultValuesFromZodSchema({
     schema: rootSchema,
     useDefaultSchemaValues: config.useDefaultSchemaValues,
     constraints: config.constraints,
     maxRecursionDepth
   });
-  if (config.strict === false) {
-    return { data, errors: void 0, success: true, formKey };
-  }
-  if (containsAsyncTransform(rootSchema)) {
-    return { data, errors: void 0, success: true, formKey };
+  if (containsAsyncTransform(rootSchema) || containsAsyncRefine(rootSchema)) {
+    return { data, errors: void 0, success: true };
   }
-  const parseTarget = containsAsyncRefine(rootSchema) ? stripAsyncChecks(rootSchema) : rootSchema;
   try {
-    const strictResult = parseTarget.safeParse(data);
-    if (strictResult.success) {
-      return { data, errors: void 0, success: true, formKey };
+    const parseResult = rootSchema.safeParse(data);
+    if (parseResult.success) {
+      return { data, errors: void 0, success: true };
     }
     return {
       data,
-      errors: zodIssuesToValidationErrors(strictResult.error.issues),
-      success: false,
-      formKey
+      errors: zodIssuesToValidationErrors(parseResult.error.issues),
+      success: false
     };
   } catch {
-    return { data, errors: void 0, success: true, formKey };
+    return { data, errors: void 0, success: true };
   }
 }
-function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
+function buildSubSchemaStubV4(schema, maxRecursionDepth) {
   return {
-    fingerprint: () => lazyFingerprint(schema),
     needsAsyncValidation: () => containsAsyncRefine(schema),
     getDefaultValues: () => ({
       data: deriveDefault(schema, true, maxRecursionDepth),
       errors: void 0,
-      success: true,
-      formKey
+      success: true
     }),
     getSchemasAtPath: () => [],
     validateAtPath: async (data) => {
@@ -864,15 +605,13 @@ function buildSubSchemaStubV4(schema, formKey, maxRecursionDepth) {
         return {
           data: result.data,
           errors: void 0,
-          success: true,
-          formKey
+          success: true
         };
       }
       return {
         data: void 0,
         errors: zodIssuesToValidationErrors(result.error.issues),
-        success: false,
-        formKey
+        success: false
       };
     }
   };
@@ -924,4 +663,4 @@ function useForm(configuration) {
   });
 }
 
-export { UnsupportedSchemaError as U, assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, getDiscriminator as f, getIntersectionLeft as g, getDiscriminatedOptions as h, getUnionOptions as i, getRecordKeyType as j, kindOf as k, getRecordValueType as l, getTupleItems as m, getSetValueType as n, getArrayElement as o, getObjectShape as p, getEnumValues as q, getLiteralValues as r, getChecks as s, getCatchDefault as t, useForm as u, getDefaultValue as v, zodV4Adapter as z };
+export { assertZodVersion as a, kindOf as k, useForm as u, zodV4Adapter as z };

package/dist/dev/shared/{attaform-dev.Dr2YzS5B.mjs → attaform-dev.BQc5QV3Y.mjs}

@@ -40,12 +40,6 @@ function normalizeErrorInputs(input, scope, defaultCode) {
   const items = Array.isArray(input) ? input : [input];
   return items.map((item) => normalizeErrorInput(item, scope, defaultCode));
 }
-function* cellEntriesFor(cells, side) {
-  for (const [key, cell] of cells) {
-    const list = cell[side];
-    if (list.length > 0) yield [key, list];
-  }
-}
 class RegistryNotInstalledError extends AttaformError {
   constructor() {
     super(
@@ -79,6 +73,16 @@ function groupErrorsByKey(entries) {
 }
 
 const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
+const SET_MEMBER_SEGMENT = "__atta:member";
+function mapSegmentKeys(value) {
+  const keys = [];
+  for (const key of value.keys()) {
+    if (typeof key === "string") keys.push(key);
+    else if (typeof key === "number" && Number.isInteger(key) && key >= 0) keys.push(key);
+    else return null;
+  }
+  return keys;
+}
 function normalizeSegment(raw) {
   if (typeof raw === "number") {
     if (!Number.isInteger(raw) || raw < 0) {
@@ -165,18 +169,6 @@ function pathKeyToDotted(key) {
   if (segments === null) return null;
   return segmentsToDotted(segments);
 }
-function coerceToPathKey(input) {
-  if (input.length > 0 && input.charCodeAt(0) === 91) {
-    try {
-      const parsed = JSON.parse(input);
-      if (Array.isArray(parsed) && parsed.every((s) => typeof s === "string" || typeof s === "number")) {
-        return input;
-      }
-    } catch {
-    }
-  }
-  return canonicalizePath(input).key;
-}
 const ROOT_PATH = Object.freeze([]);
 const ROOT_PATH_KEY = "[]";
 function isPathPrefix(prefix, path) {
@@ -194,4 +186,4 @@ function pathsEqual(a, b) {
   return true;
 }
 
-export { AttaformError as A, InvalidPathError as I, OutsideSetupError as O, ROOT_PATH as R, SubmitErrorHandlerError as S, InvalidUseFormConfigError as a, ROOT_PATH_KEY as b, RegistryNotInstalledError as c, ReservedFormKeyError as d, canonicalizePath as e, pathsEqual as f, pathKeyToDotted as g, cellEntriesFor as h, isPathPrefix as i, groupErrorsByKey as j, keyForSegments as k, normalizeErrorInputs as l, coerceToPathKey as m, normalizeErrorInput as n, parseDottedPath as p, segmentsForPathKey as s, toError as t };
+export { AttaformError as A, InvalidPathError as I, OutsideSetupError as O, ROOT_PATH as R, SubmitErrorHandlerError as S, InvalidUseFormConfigError as a, ROOT_PATH_KEY as b, RegistryNotInstalledError as c, ReservedFormKeyError as d, canonicalizePath as e, pathsEqual as f, pathKeyToDotted as g, SET_MEMBER_SEGMENT as h, isPathPrefix as i, groupErrorsByKey as j, keyForSegments as k, normalizeErrorInputs as l, mapSegmentKeys as m, normalizeErrorInput as n, parseDottedPath as p, segmentsForPathKey as s, toError as t };

package/dist/dev/shared/{attaform-dev.BR8u0YOZ.mjs → attaform-dev.BcNtyOmf.mjs}

@@ -1,7 +1,7 @@
-import { a as InvalidUseFormConfigError } from './attaform-dev.Dr2YzS5B.mjs';
-import { u as useForm$2 } from './attaform-dev.D2I8e_Mm.mjs';
-import { u as useForm$1 } from './attaform-dev.oYrkP9dj.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.6qxD-Yqo.mjs';
+import { a as InvalidUseFormConfigError } from './attaform-dev.BQc5QV3Y.mjs';
+import { u as useForm$2 } from './attaform-dev.DTrHonpc.mjs';
+import { u as useForm$1 } from './attaform-dev.BK6Ge2qR.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform-dev.BisFstxh.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;