formstand 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1418 @@
+'use strict';
+
+var vanilla = require('zustand/vanilla');
+var zod = require('zod');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var react$1 = require('zustand/react');
+var shallow = require('zustand/react/shallow');
+
+// src/core/createForm.ts
+
+// src/core/array.ts
+var removeAt = (i) => (n) => n === i ? null : n > i ? n - 1 : n;
+var insertAt = (i) => (n) => n >= i ? n + 1 : n;
+var moveFromTo = (from, to) => (n) => {
+  if (n === from) return to;
+  if (from < to && n > from && n <= to) return n - 1;
+  if (from > to && n >= to && n < from) return n + 1;
+  return n;
+};
+var swapIndices = (a, b) => (n) => n === a ? b : n === b ? a : n;
+var indexAndTail = (rest) => {
+  const dotIdx = rest.indexOf(".");
+  const idxStr = dotIdx === -1 ? rest : rest.slice(0, dotIdx);
+  const tail = dotIdx === -1 ? "" : rest.slice(dotIdx);
+  const idx = Number(idxStr);
+  if (!Number.isInteger(idx) || idx < 0 || String(idx) !== idxStr) return null;
+  return { index: idx, tail };
+};
+var reKeyByArrayPath = (map, basePath, mapper) => {
+  const prefix = basePath === "" ? "" : `${basePath}.`;
+  return Object.fromEntries(
+    Object.entries(map).flatMap(([key, value]) => {
+      if (key === basePath) return [[key, value]];
+      if (!key.startsWith(prefix)) return [[key, value]];
+      const parsed = indexAndTail(key.slice(prefix.length));
+      if (parsed === null) return [[key, value]];
+      const next = mapper(parsed.index);
+      if (next === null) return [];
+      return [[`${prefix}${next}${parsed.tail}`, value]];
+    })
+  );
+};
+
+// src/core/equality.ts
+var isPlainObject = (v) => {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+var valuesEqual = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => valuesEqual(v, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    return aKeys.length === bKeys.length && aKeys.every((k) => valuesEqual(a[k], b[k]));
+  }
+  return false;
+};
+var dirtyCache = /* @__PURE__ */ new WeakMap();
+var MAX_VERDICTS = 4;
+var isFieldDirty = (value, initialValue) => {
+  if (Object.is(value, initialValue)) return false;
+  if (typeof value !== "object" || value === null) {
+    return !valuesEqual(value, initialValue);
+  }
+  const cached = dirtyCache.get(value) ?? [];
+  const hit = cached.find((v) => Object.is(v.initial, initialValue));
+  if (hit !== void 0) return hit.dirty;
+  const dirty = !valuesEqual(value, initialValue);
+  dirtyCache.set(
+    value,
+    [{ initial: initialValue, dirty }, ...cached].slice(0, MAX_VERDICTS)
+  );
+  return dirty;
+};
+
+// src/core/path.ts
+var MAX_ARRAY_INDEX = 1e5;
+var isIndexSegment = (s) => {
+  const n = Number(s);
+  return Number.isInteger(n) && n >= 0 && String(n) === s;
+};
+var parsePath = (path) => path === "" ? [] : path.split(".").map((s) => isIndexSegment(s) ? Number(s) : s);
+var isPlainRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var readSegment = (obj, segment) => {
+  if (obj == null) return void 0;
+  if (Array.isArray(obj)) {
+    return typeof segment === "number" ? obj[segment] : void 0;
+  }
+  return isPlainRecord(obj) ? obj[String(segment)] : void 0;
+};
+var getAtPath = (obj, path) => parsePath(path).reduce(readSegment, obj);
+var slotAtPath = (obj, path) => {
+  const walked = parsePath(path).reduce(
+    (acc, segment) => {
+      const outOfBounds = typeof segment === "number" && (Array.isArray(acc.current) ? segment >= acc.current.length : !isPlainRecord(acc.current));
+      return !acc.ok || outOfBounds ? { ok: false, current: void 0 } : { ok: true, current: readSegment(acc.current, segment) };
+    },
+    { ok: true, current: obj }
+  );
+  return walked.ok ? { exists: true, value: walked.current } : { exists: false };
+};
+var writeIntoArray = (arr, index, rest, value) => {
+  const length = Math.max(arr.length, index + 1);
+  return Array.from(
+    { length },
+    (_, i) => i === index ? writeSegments(arr[i], rest, value) : arr[i]
+  );
+};
+var refusesHugeIndex = (index) => {
+  if (index > MAX_ARRAY_INDEX) {
+    console.warn(
+      `[formstand] refusing to write array index ${index} (max ${MAX_ARRAY_INDEX}); value left unchanged.`
+    );
+    return true;
+  }
+  return false;
+};
+var writeSegments = (obj, segments, value) => {
+  const [head, ...rest] = segments;
+  if (head === void 0) return value;
+  if (Array.isArray(obj)) {
+    if (typeof head !== "number") {
+      console.warn(
+        `[formstand] cannot write string key "${head}" into an array; value left unchanged.`
+      );
+      return obj;
+    }
+    if (refusesHugeIndex(head)) return obj;
+    return writeIntoArray(obj, head, rest, value);
+  }
+  if (isPlainRecord(obj)) {
+    const key = String(head);
+    return { ...obj, [key]: writeSegments(obj[key], rest, value) };
+  }
+  if (typeof head === "number") {
+    if (refusesHugeIndex(head)) return obj;
+    return writeIntoArray([], head, rest, value);
+  }
+  return { [head]: writeSegments(void 0, rest, value) };
+};
+var setAtPath = (obj, path, value) => writeSegments(obj, parsePath(path), value);
+var issuePathToFormPath = (path) => path.filter((segment) => typeof segment !== "symbol").join(".");
+var expandIssue = (issue, prefix) => {
+  const at = [...prefix, ...issue.path];
+  if (issue.code === "invalid_union") {
+    const nested = issue.errors.flatMap(
+      (branch) => branch.flatMap((sub) => expandIssue(sub, at))
+    );
+    if (nested.length > 0) return nested;
+  }
+  return [{ path: issuePathToFormPath(at), message: issue.message }];
+};
+var flattenIssues = (issues) => issues.flatMap((issue) => expandIssue(issue, [])).reduce((acc, { path, message }) => {
+  const existing = acc[path] ?? [];
+  return existing.includes(message) ? acc : { ...acc, [path]: [...existing, message] };
+}, {});
+var validateSync = (schema, values) => {
+  const result = schema.safeParse(values);
+  return result.success ? { kind: "valid", data: result.data } : { kind: "invalid", errors: flattenIssues(result.error.issues) };
+};
+var validateAsync = async (schema, values) => {
+  const result = await schema.safeParseAsync(values);
+  return result.success ? { kind: "valid", data: result.data } : { kind: "invalid", errors: flattenIssues(result.error.issues) };
+};
+var isAsyncRequiredError = (e) => e instanceof zod.z.core.$ZodAsyncError || e instanceof Error && /Encountered Promise during synchronous parse/i.test(e.message);
+var isPathOrChild = (key, path) => key === path || key.startsWith(`${path}.`);
+var prefixErrorKeys = (errors, path) => path === "" ? errors : Object.fromEntries(
+  Object.entries(errors).map(([k, v]) => [
+    k === "" ? path : `${path}.${k}`,
+    v
+  ])
+);
+var emptyValueForSchema = (schema) => {
+  const walk = (s, sawNullable) => {
+    if (s instanceof zod.z.ZodOptional) return void 0;
+    if (s instanceof zod.z.ZodNullable) {
+      return walk(s.unwrap(), true);
+    }
+    return sawNullable ? null : void 0;
+  };
+  return walk(schema, false);
+};
+var hasChecks = (s) => {
+  const checks = s.def.checks;
+  return checks !== void 0 && checks.length > 0;
+};
+var fieldSchemaAtPath = (schema, path) => parsePath(path).reduce((current, segment) => {
+  if (current === null || hasChecks(current)) return null;
+  if (current instanceof zod.z.ZodObject && typeof segment === "string") {
+    const shape = current.shape;
+    return shape[segment] ?? null;
+  }
+  if (current instanceof zod.z.ZodArray && typeof segment === "number") {
+    return current.element;
+  }
+  return null;
+}, schema);
+
+// src/core/createForm.ts
+var shallowFieldEqual = (a, b) => Object.is(a.value, b.value) && a.error === b.error && a.touched === b.touched && a.dirty === b.dirty && a.isValidating === b.isValidating;
+var emptyErrors = {};
+var emptyBools = {};
+var identityMapper = (n) => n;
+var omitKey = (map, key) => Object.fromEntries(Object.entries(map).filter(([k]) => k !== key));
+var inScopeOfAny = (key, paths) => paths.some((p) => isPathOrChild(key, p));
+var omitScope = (map, paths) => {
+  const entries = Object.entries(map);
+  const kept = entries.filter(([k]) => !inScopeOfAny(k, paths));
+  return kept.length === entries.length ? map : Object.fromEntries(kept);
+};
+var pickScope = (map, paths) => Object.fromEntries(
+  Object.entries(map).filter(([k]) => inScopeOfAny(k, paths))
+);
+var mergeScopedErrors = (prev, scoped, paths) => ({ ...omitScope(prev, paths), ...scoped });
+var releaseAncestorEntries = (map, path) => {
+  const entries = Object.entries(map);
+  const kept = entries.filter(([k]) => k !== "" && !isPathOrChild(path, k));
+  return kept.length === entries.length ? map : Object.fromEntries(kept);
+};
+var dirtyPathsOf = (values, initial, prefix) => {
+  if (valuesEqual(values, initial)) return [];
+  if (isPlainObject(values) && isPlainObject(initial)) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(values), ...Object.keys(initial)]);
+    return [...keys].flatMap(
+      (k) => dirtyPathsOf(
+        values[k],
+        initial[k],
+        prefix === "" ? k : `${prefix}.${k}`
+      )
+    );
+  }
+  return [prefix];
+};
+var FORM_SEQ_KEY = "__form__";
+var stringArraysEqual = (a, b) => a === b || a.length === b.length && a.every((v, i) => v === b[i]);
+var reuseErrorRefs = (next, prev) => {
+  if (next === prev) return prev;
+  const entries = Object.entries(next).map(([k, v]) => {
+    const old = prev[k];
+    return [
+      k,
+      old !== void 0 && stringArraysEqual(old, v) ? old : v
+    ];
+  });
+  const sameShape = entries.length === Object.keys(prev).length && entries.every(([k, v]) => prev[k] === v);
+  return sameShape ? prev : Object.fromEntries(entries);
+};
+var scopeSettledResult = (result, path, viaSubschema) => result.kind !== "invalid" ? emptyErrors : viaSubschema ? prefixErrorKeys(result.errors, path) : path === "" ? result.errors : pickScope(result.errors, [path]);
+var mergeErrorChannels = (schema, server) => {
+  const extra = Object.entries(server).filter(([k]) => schema[k] === void 0);
+  return extra.length === 0 ? schema : { ...schema, ...Object.fromEntries(extra) };
+};
+var errorChannels = (state, patch) => {
+  const schemaErrors = patch.schemaErrors ?? state.schemaErrors;
+  const serverErrors = patch.serverErrors ?? state.serverErrors;
+  if (schemaErrors === state.schemaErrors && serverErrors === state.serverErrors) {
+    return { errors: state.errors, schemaErrors, serverErrors };
+  }
+  return {
+    schemaErrors,
+    serverErrors,
+    errors: reuseErrorRefs(
+      mergeErrorChannels(schemaErrors, serverErrors),
+      state.errors
+    )
+  };
+};
+var releaseSpine = (server, path) => path === "" ? emptyErrors : releaseAncestorEntries(omitScope(server, [path]), path);
+var releaseChangedSlices = (server, prevValues, nextValues) => {
+  const entries = Object.entries(server);
+  const kept = entries.filter(
+    ([k]) => valuesEqual(getAtPath(prevValues, k), getAtPath(nextValues, k))
+  );
+  return kept.length === entries.length ? server : Object.fromEntries(kept);
+};
+var createForm = (schema, options) => {
+  const initialMode = options.mode ?? "onBlur";
+  const initialReValidateMode = options.reValidateMode ?? "onChange";
+  const initial = {
+    values: options.initialValues,
+    initialValues: options.initialValues,
+    errors: emptyErrors,
+    schemaErrors: emptyErrors,
+    serverErrors: emptyErrors,
+    touched: emptyBools,
+    isSubmitting: false,
+    submitCount: 0,
+    isValidating: emptyBools,
+    isValidatingForm: false,
+    mode: initialMode,
+    reValidateMode: initialReValidateMode
+  };
+  const store = vanilla.createStore(() => initial);
+  const commitFullPass = (state, next) => errorChannels(state, {
+    schemaErrors: reuseErrorRefs(next, state.schemaErrors)
+  });
+  const validate = () => {
+    try {
+      const result = validateSync(schema, store.getState().values);
+      store.setState((state) => ({
+        ...state,
+        ...commitFullPass(
+          state,
+          result.kind === "invalid" ? result.errors : emptyErrors
+        )
+      }));
+      return result;
+    } catch (e) {
+      if (isAsyncRequiredError(e)) {
+        return { kind: "pending", promise: validateAsyncOnForm() };
+      }
+      throw e;
+    }
+  };
+  const validateFields = (paths) => {
+    if (paths.length === 0) return true;
+    if (paths.some((p) => p === "")) {
+      const result = validate();
+      return result.kind === "pending" ? result.promise.then((r) => r.kind === "valid") : result.kind === "valid";
+    }
+    try {
+      const result = validateSync(schema, store.getState().values);
+      const fullErrors = result.kind === "invalid" ? result.errors : emptyErrors;
+      store.setState((state) => ({
+        ...state,
+        ...errorChannels(state, {
+          schemaErrors: reuseErrorRefs(
+            mergeScopedErrors(
+              state.schemaErrors,
+              pickScope(fullErrors, paths),
+              paths
+            ),
+            state.schemaErrors
+          ),
+          // A validation explicitly targeting these paths supersedes any
+          // server verdict on them.
+          serverErrors: omitScope(state.serverErrors, paths)
+        })
+      }));
+      return Object.keys(fullErrors).every((k) => !inScopeOfAny(k, paths));
+    } catch (e) {
+      if (isAsyncRequiredError(e)) return validateFieldsAsync(paths);
+      throw e;
+    }
+  };
+  const subschemaCache = /* @__PURE__ */ new Map();
+  const subschemaAt = (path) => {
+    const cached = subschemaCache.get(path);
+    if (cached !== void 0) return cached;
+    const sub = fieldSchemaAtPath(schema, path);
+    subschemaCache.set(path, sub);
+    return sub;
+  };
+  const fieldScopeFor = (path, values) => {
+    const sub = path === "" ? null : subschemaAt(path);
+    if (sub === null) {
+      return { kind: "parse", schema, value: values, viaSubschema: false };
+    }
+    const slot = slotAtPath(values, path);
+    return slot.exists ? { kind: "parse", schema: sub, value: slot.value, viaSubschema: true } : { kind: "skip" };
+  };
+  const scopedFieldErrors = (path) => {
+    const values = store.getState().values;
+    const scope = fieldScopeFor(path, values);
+    return scope.kind === "skip" ? emptyErrors : scopeSettledResult(
+      validateSync(scope.schema, scope.value),
+      path,
+      scope.viaSubschema
+    );
+  };
+  const scopedFieldErrorsAsync = async (path, values) => {
+    const scope = fieldScopeFor(path, values);
+    return scope.kind === "skip" ? emptyErrors : scopeSettledResult(
+      await validateAsync(scope.schema, scope.value),
+      path,
+      scope.viaSubschema
+    );
+  };
+  const fieldResult = (scoped) => {
+    const messages = Object.values(scoped).flat();
+    return messages.length === 0 ? { kind: "valid" } : { kind: "invalid", errors: messages };
+  };
+  const commitFieldErrors = (state, scoped, path) => path === "" ? commitFullPass(state, scoped) : errorChannels(state, {
+    schemaErrors: reuseErrorRefs(
+      mergeScopedErrors(state.schemaErrors, scoped, [path]),
+      state.schemaErrors
+    ),
+    serverErrors: omitScope(state.serverErrors, [path])
+  });
+  const validateField = (path) => {
+    try {
+      const scoped = scopedFieldErrors(path);
+      store.setState((state) => ({
+        ...state,
+        ...commitFieldErrors(state, scoped, path)
+      }));
+      return fieldResult(scoped);
+    } catch (e) {
+      if (isAsyncRequiredError(e)) {
+        return { kind: "pending", promise: validateFieldAsync(path) };
+      }
+      throw e;
+    }
+  };
+  const snapshotField = (state, path) => {
+    const value = getAtPath(state.values, path);
+    return {
+      value,
+      error: state.errors[path],
+      touched: state.touched[path] ?? false,
+      dirty: isFieldDirty(value, getAtPath(state.initialValues, path)),
+      isValidating: state.isValidating[path] ?? false
+    };
+  };
+  const sequences = /* @__PURE__ */ new Map();
+  const nextSeq = (key) => {
+    const next = (sequences.get(key) ?? 0) + 1;
+    sequences.set(key, next);
+    return next;
+  };
+  const validateAsyncOnForm = async () => {
+    const seq = nextSeq(FORM_SEQ_KEY);
+    const valuesAtStart = store.getState().values;
+    store.setState((state) => ({ ...state, isValidatingForm: true }));
+    const result = await validateAsync(schema, valuesAtStart);
+    const live = store.getState();
+    const stillOwns = sequences.get(FORM_SEQ_KEY) === seq;
+    if (!stillOwns || live.values !== valuesAtStart) {
+      if (stillOwns) {
+        store.setState((state) => ({ ...state, isValidatingForm: false }));
+      }
+      return result;
+    }
+    store.setState((state) => ({
+      ...state,
+      ...commitFullPass(
+        state,
+        result.kind === "invalid" ? result.errors : emptyErrors
+      ),
+      isValidatingForm: false
+    }));
+    return result;
+  };
+  const validateFieldsAsync = async (paths) => {
+    if (paths.length === 0) return true;
+    if (paths.some((p) => p === "")) {
+      const result2 = await validateAsyncOnForm();
+      return result2.kind === "valid";
+    }
+    const seqs = new Map(paths.map((p) => [p, nextSeq(p)]));
+    const valuesAtStart = store.getState().values;
+    store.setState((state) => ({
+      ...state,
+      isValidating: paths.reduce(
+        (acc, p) => ({ ...acc, [p]: true }),
+        { ...state.isValidating }
+      )
+    }));
+    const result = await validateAsync(schema, valuesAtStart);
+    const fullErrors = result.kind === "invalid" ? result.errors : emptyErrors;
+    const requestedValid = Object.keys(fullErrors).every(
+      (k) => !inScopeOfAny(k, paths)
+    );
+    const live = store.getState();
+    const stillCurrent = paths.filter((p) => sequences.get(p) === seqs.get(p));
+    if (live.values !== valuesAtStart) {
+      if (stillCurrent.length > 0) {
+        store.setState((state) => ({
+          ...state,
+          isValidating: stillCurrent.reduce(
+            (acc, p) => omitKey(acc, p),
+            state.isValidating
+          )
+        }));
+      }
+      return requestedValid;
+    }
+    store.setState((state) => ({
+      ...state,
+      ...errorChannels(state, {
+        schemaErrors: reuseErrorRefs(
+          mergeScopedErrors(
+            state.schemaErrors,
+            pickScope(fullErrors, stillCurrent),
+            stillCurrent
+          ),
+          state.schemaErrors
+        ),
+        serverErrors: omitScope(state.serverErrors, stillCurrent)
+      }),
+      isValidating: stillCurrent.reduce(
+        (acc, p) => omitKey(acc, p),
+        state.isValidating
+      )
+    }));
+    return requestedValid;
+  };
+  const validateFieldAsync = async (path) => {
+    const seq = nextSeq(path);
+    const valuesAtStart = store.getState().values;
+    store.setState((state) => ({
+      ...state,
+      isValidating: { ...state.isValidating, [path]: true }
+    }));
+    const scoped = await scopedFieldErrorsAsync(path, valuesAtStart);
+    const live = store.getState();
+    const stillOwns = sequences.get(path) === seq;
+    if (!stillOwns || live.values !== valuesAtStart) {
+      if (stillOwns) {
+        store.setState((state) => ({
+          ...state,
+          isValidating: omitKey(state.isValidating, path)
+        }));
+      }
+      return fieldResult(scoped);
+    }
+    store.setState((state) => ({
+      ...state,
+      ...commitFieldErrors(state, scoped, path),
+      isValidating: omitKey(state.isValidating, path)
+    }));
+    return fieldResult(scoped);
+  };
+  const applyArrayOp = (path, nextArray, mapper, indexInBounds) => {
+    const current = getAtPath(store.getState().values, path);
+    if (current !== void 0 && !Array.isArray(current)) {
+      console.warn(
+        `[formstand] array op on "${path}" but the value at that path is not an array (got ${typeof current}). Operation skipped.`
+      );
+      return;
+    }
+    const length = Array.isArray(current) ? current.length : 0;
+    if (indexInBounds !== void 0 && !indexInBounds(length)) {
+      console.warn(
+        `[formstand] array op on "${path}" with an out-of-range or non-integer index (length ${length}). Operation skipped.`
+      );
+      return;
+    }
+    store.setState((state) => {
+      const live = getAtPath(state.values, path);
+      const arr = Array.isArray(live) ? live : [];
+      return {
+        ...state,
+        values: setAtPath(state.values, path, nextArray(arr)),
+        ...errorChannels(state, {
+          schemaErrors: reKeyByArrayPath(state.schemaErrors, path, mapper),
+          // Server entries on rows follow their rows through the index
+          // mapping — a verdict on "items.1.name" is still vouched for after
+          // the op moves it to "items.0.name" (that row's value didn't
+          // change). Entries at the array itself or an ancestor release: the
+          // op changed that value.
+          serverErrors: releaseAncestorEntries(
+            reKeyByArrayPath(state.serverErrors, path, mapper),
+            path
+          )
+        }),
+        touched: reKeyByArrayPath(state.touched, path, mapper),
+        isValidating: reKeyByArrayPath(state.isValidating, path, mapper)
+      };
+    });
+  };
+  const inFlight = {
+    count: 0,
+    baseline: false
+  };
+  const submit = async (onValid, onInvalid, submitOptions) => {
+    if (inFlight.count > 0 && submitOptions?.force !== true) {
+      return { kind: "skipped" };
+    }
+    if (inFlight.count === 0) {
+      inFlight.baseline = store.getState().isSubmitting;
+    }
+    inFlight.count += 1;
+    store.setState((state) => ({
+      ...state,
+      isSubmitting: true,
+      submitCount: state.submitCount + 1
+    }));
+    try {
+      const result = await validateAsync(schema, store.getState().values);
+      if (result.kind === "invalid") {
+        store.setState((state) => {
+          const committed = commitFullPass(state, result.errors);
+          return {
+            ...state,
+            ...committed,
+            // Mark every errored field touched so touched-gated error UIs
+            // show something after the canonical first failed submit. The
+            // "" key (schema-level refine) has no field to touch.
+            touched: {
+              ...state.touched,
+              ...Object.fromEntries(
+                Object.keys(committed.errors).filter((k) => k !== "").map((k) => [k, true])
+              )
+            }
+          };
+        });
+        const merged = store.getState().errors;
+        onInvalid?.(merged);
+        return { kind: "invalid", errors: merged };
+      }
+      store.setState((state) => ({
+        ...state,
+        ...commitFullPass(state, emptyErrors)
+      }));
+      await onValid(result.data);
+      return { kind: "valid", data: result.data };
+    } finally {
+      inFlight.count -= 1;
+      if (inFlight.count === 0) {
+        const baseline = inFlight.baseline;
+        store.setState((state) => ({ ...state, isSubmitting: baseline }));
+      }
+    }
+  };
+  if (options.validateOnMount === true) {
+    validate();
+  }
+  return Object.freeze({
+    schema,
+    store,
+    getState: store.getState,
+    subscribe: store.subscribe,
+    getField: (path) => getAtPath(store.getState().values, path),
+    getFieldState: (path) => snapshotField(store.getState(), path),
+    watchField: (path, listener) => {
+      const ref = {
+        current: snapshotField(store.getState(), path)
+      };
+      return store.subscribe((state) => {
+        const next = snapshotField(state, path);
+        if (!shallowFieldEqual(ref.current, next)) {
+          ref.current = next;
+          listener(next);
+        }
+      });
+    },
+    watchValue: (path, listener) => {
+      const ref = {
+        current: getAtPath(store.getState().values, path)
+      };
+      return store.subscribe((state) => {
+        const next = getAtPath(state.values, path);
+        if (!Object.is(ref.current, next)) {
+          const prev = ref.current;
+          ref.current = next;
+          listener(
+            next,
+            prev
+          );
+        }
+      });
+    },
+    watchValues: (listener) => {
+      const ref = { current: store.getState().values };
+      return store.subscribe((state) => {
+        if (state.values !== ref.current) {
+          const prev = ref.current;
+          ref.current = state.values;
+          listener(state.values, prev);
+        }
+      });
+    },
+    setValue: (path, value) => store.setState((state) => ({
+      ...state,
+      values: setAtPath(state.values, path, value),
+      ...errorChannels(state, {
+        serverErrors: releaseSpine(state.serverErrors, path)
+      })
+    })),
+    setValues: (next) => store.setState((state) => ({
+      ...state,
+      values: next,
+      ...errorChannels(state, {
+        serverErrors: releaseChangedSlices(
+          state.serverErrors,
+          state.values,
+          next
+        )
+      })
+    })),
+    setTouched: (path, touched = true) => store.setState((state) => ({
+      ...state,
+      touched: { ...state.touched, [path]: touched }
+    })),
+    setSubmitting: (value) => store.setState((state) => ({ ...state, isSubmitting: value })),
+    setMode: (mode) => store.setState((state) => ({ ...state, mode })),
+    setReValidateMode: (reValidateMode) => store.setState((state) => ({ ...state, reValidateMode })),
+    setError: (path, errors) => {
+      const list = typeof errors === "string" ? [errors] : errors;
+      store.setState((state) => ({
+        ...state,
+        ...errorChannels(state, {
+          serverErrors: list.length === 0 ? omitKey(state.serverErrors, path) : { ...state.serverErrors, [path]: list }
+        })
+      }));
+    },
+    setErrors: (errors) => store.setState((state) => ({
+      ...state,
+      ...errorChannels(state, { serverErrors: errors })
+    })),
+    clearErrors: (path) => store.setState((state) => {
+      const scrub = (map) => path === void 0 ? emptyErrors : omitScope(map, [path]);
+      return {
+        ...state,
+        ...errorChannels(state, {
+          schemaErrors: scrub(state.schemaErrors),
+          serverErrors: scrub(state.serverErrors)
+        })
+      };
+    }),
+    updateState: (updater) => store.setState((state) => {
+      const patch = updater(state);
+      if (Object.keys(patch).length === 0) return state;
+      if (patch.errors !== void 0 && patch.errors !== state.errors) {
+        console.warn(
+          "[formstand] `errors` is derived from schemaErrors/serverErrors \u2014 patch those channels instead; the direct `errors` patch is ignored."
+        );
+      }
+      const next = { ...state, ...patch };
+      return {
+        ...next,
+        ...errorChannels(state, {
+          schemaErrors: next.schemaErrors,
+          serverErrors: next.serverErrors
+        })
+      };
+    }),
+    adoptValues: (values) => {
+      sequences.clear();
+      store.setState((state) => ({
+        ...state,
+        values,
+        initialValues: values,
+        ...errorChannels(state, {
+          schemaErrors: emptyErrors,
+          serverErrors: emptyErrors
+        })
+      }));
+    },
+    reset: (nextInitial, resetOptions) => {
+      sequences.clear();
+      store.setState((state) => {
+        const init = nextInitial === void 0 ? state.initialValues : isPlainObject(state.initialValues) && isPlainObject(nextInitial) ? {
+          ...state.initialValues,
+          ...nextInitial
+        } : nextInitial;
+        return {
+          ...state,
+          values: init,
+          initialValues: init,
+          ...resetOptions?.keepErrors === true ? {} : errorChannels(state, {
+            schemaErrors: emptyErrors,
+            serverErrors: emptyErrors
+          }),
+          touched: resetOptions?.keepTouched === true ? state.touched : emptyBools,
+          isSubmitting: false,
+          submitCount: resetOptions?.keepSubmitCount === true ? state.submitCount : 0,
+          isValidating: emptyBools,
+          isValidatingForm: false
+        };
+      });
+    },
+    resetField: (path) => store.setState((state) => ({
+      ...state,
+      values: setAtPath(
+        state.values,
+        path,
+        getAtPath(state.initialValues, path)
+      ),
+      // A runtime "" path scopes the whole form (the imperative surface is
+      // string-typed even though FieldPath excludes ""). Server entries
+      // follow the setValue release contract (releaseSpine).
+      ...errorChannels(state, {
+        schemaErrors: path === "" ? emptyErrors : omitScope(state.schemaErrors, [path]),
+        serverErrors: releaseSpine(state.serverErrors, path)
+      }),
+      touched: path === "" ? emptyBools : omitScope(state.touched, [path]),
+      isValidating: path === "" ? emptyBools : omitScope(state.isValidating, [path])
+    })),
+    validate,
+    validateField,
+    validateFields,
+    validateAsync: validateAsyncOnForm,
+    validateFieldAsync,
+    validateFieldsAsync,
+    submit,
+    arrayPush: (path, item) => applyArrayOp(path, (arr) => [...arr, item], identityMapper),
+    arrayRemove: (path, index) => applyArrayOp(
+      path,
+      (arr) => [...arr.slice(0, index), ...arr.slice(index + 1)],
+      removeAt(index),
+      (len) => Number.isInteger(index) && index >= 0 && index < len
+    ),
+    arrayInsert: (path, index, item) => applyArrayOp(
+      path,
+      (arr) => [...arr.slice(0, index), item, ...arr.slice(index)],
+      insertAt(index),
+      (len) => Number.isInteger(index) && index >= 0 && index <= len
+    ),
+    arrayMove: (path, from, to) => applyArrayOp(
+      path,
+      (arr) => {
+        const without = [...arr.slice(0, from), ...arr.slice(from + 1)];
+        return [...without.slice(0, to), arr[from], ...without.slice(to)];
+      },
+      moveFromTo(from, to),
+      (len) => Number.isInteger(from) && Number.isInteger(to) && from >= 0 && from < len && to >= 0 && to < len
+    ),
+    arraySwap: (path, a, b) => applyArrayOp(
+      path,
+      (arr) => arr.map((v, i) => i === a ? arr[b] : i === b ? arr[a] : v),
+      swapIndices(a, b),
+      (len) => Number.isInteger(a) && Number.isInteger(b) && a >= 0 && a < len && b >= 0 && b < len
+    ),
+    handleSubmit: (onValid, onInvalid, opts) => async (event) => {
+      event?.preventDefault();
+      return submit(onValid, onInvalid, opts);
+    },
+    diff: () => {
+      const state = store.getState();
+      return Object.fromEntries(
+        dirtyPathsOf(state.values, state.initialValues, "").map((path) => [
+          path,
+          getAtPath(state.values, path)
+        ])
+      );
+    },
+    dirtyFields: () => {
+      const state = store.getState();
+      return dirtyPathsOf(state.values, state.initialValues, "");
+    },
+    snapshot: () => store.getState(),
+    restore: (snap) => store.setState(() => {
+      const schemaErrors = snap.schemaErrors ?? emptyErrors;
+      const serverErrors = snap.serverErrors ?? emptyErrors;
+      return {
+        ...snap,
+        schemaErrors,
+        serverErrors,
+        errors: reuseErrorRefs(
+          mergeErrorChannels(schemaErrors, serverErrors),
+          snap.errors ?? emptyErrors
+        )
+      };
+    })
+  });
+};
+
+// src/core/mode.ts
+var shouldValidateOn = (trigger, mode, reValidateMode, submitAttempted, touched = false) => {
+  const effective = submitAttempted ? reValidateMode : mode;
+  switch (effective) {
+    case "onChange":
+      return trigger === "change";
+    case "onBlur":
+      return trigger === "blur";
+    case "onSubmit":
+      return false;
+    case "onTouched":
+      return trigger === "blur" || touched;
+    case "all":
+      return true;
+  }
+};
+var useForm = (schema, options) => {
+  const formRef = react.useRef(null);
+  if (formRef.current === null) {
+    formRef.current = createForm(schema, options);
+  }
+  const form = formRef.current;
+  const warnedRef = react.useRef(false);
+  react.useEffect(() => {
+    if (!warnedRef.current && form.schema !== schema) {
+      warnedRef.current = true;
+      console.warn(
+        "[formstand] useForm received a different schema reference after the first render; schema and options changes are ignored for the life of the component. If the schema is defined inline this is harmless (but consider hoisting it to module scope). For initial values that arrive later (e.g. from a fetch), call form.adoptValues(values) or form.reset(values) instead."
+      );
+    }
+  }, [form, schema]);
+  return form;
+};
+var createFormContext = () => {
+  const Context = react.createContext(null);
+  const Provider = ({ form, children }) => /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value: form, children });
+  const useFormContext = () => {
+    const ctx = react.useContext(Context);
+    if (ctx === null) {
+      throw new Error(
+        "useFormContext must be used inside the matching <Provider>"
+      );
+    }
+    return ctx;
+  };
+  return { Provider, useFormContext };
+};
+function useFormSelector(form, selector) {
+  return react$1.useStore(form.store, selector);
+}
+function useFormSelectorShallow(form, selector) {
+  return react$1.useStore(form.store, shallow.useShallow(selector));
+}
+var useFormState = useFormSelector;
+var useFormStateShallow = useFormSelectorShallow;
+var useFormError = (form) => react$1.useStore(
+  form.store,
+  shallow.useShallow((state) => state.errors[""])
+);
+var useIsDirty = (form) => react$1.useStore(
+  form.store,
+  (state) => isFieldDirty(state.values, state.initialValues)
+);
+var useIsValid = (form) => react$1.useStore(form.store, (state) => {
+  for (const k in state.errors) {
+    const errs = state.errors[k];
+    if (errs !== void 0 && errs.length > 0) return false;
+  }
+  return true;
+});
+var useIsSubmitting = (form) => react$1.useStore(form.store, (state) => state.isSubmitting);
+var useSubmitCount = (form) => react$1.useStore(form.store, (state) => state.submitCount);
+function useField(form, pathArg, options) {
+  const slice = react$1.useStore(
+    form.store,
+    shallow.useShallow((state) => {
+      const p = typeof pathArg === "function" ? pathArg(state) : pathArg;
+      const value = getAtPath(state.values, p);
+      const initialValue2 = getAtPath(state.initialValues, p);
+      return {
+        path: p,
+        value,
+        initialValue: initialValue2,
+        error: state.errors[p],
+        touched: state.touched[p] ?? false,
+        dirty: isFieldDirty(value, initialValue2),
+        isValidating: state.isValidating[p] ?? false
+      };
+    })
+  );
+  const path = slice.path;
+  const formSchema = form.schema;
+  const initialValue = slice.initialValue;
+  const emptyValue = react.useMemo(() => {
+    if (formSchema !== void 0) {
+      const sub = fieldSchemaAtPath(formSchema, path);
+      if (sub !== null) return emptyValueForSchema(sub);
+    }
+    return initialValue === null ? null : void 0;
+  }, [formSchema, path, initialValue]);
+  const debounceMs = options?.debounceMs;
+  const debounceTimerRef = react.useRef(null);
+  react.useEffect(() => {
+    return () => {
+      if (debounceTimerRef.current !== null) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = null;
+      }
+    };
+  }, [form, path, debounceMs]);
+  const triggerValidate = react.useCallback(() => {
+    if (debounceMs !== void 0 && debounceMs > 0) {
+      if (debounceTimerRef.current !== null) {
+        clearTimeout(debounceTimerRef.current);
+      }
+      debounceTimerRef.current = setTimeout(() => {
+        void form.validateFieldAsync(path);
+        debounceTimerRef.current = null;
+      }, debounceMs);
+      return;
+    }
+    try {
+      form.validateField(path);
+    } catch (e) {
+      if (isAsyncRequiredError(e)) {
+        void form.validateFieldAsync(path);
+        return;
+      }
+      throw e;
+    }
+  }, [form, path, debounceMs]);
+  const setValue = react.useCallback(
+    (value) => {
+      form.setValue(path, value);
+      const state = form.store.getState();
+      if (shouldValidateOn(
+        "change",
+        state.mode,
+        state.reValidateMode,
+        state.submitCount > 0,
+        state.touched[path] ?? false
+      )) {
+        triggerValidate();
+      }
+    },
+    [form, path, triggerValidate]
+  );
+  const setTouched = react.useCallback(
+    (touched) => form.setTouched(path, touched),
+    [form, path]
+  );
+  const setError = react.useCallback(
+    (errors) => form.setError(path, errors),
+    [form, path]
+  );
+  const clearError = react.useCallback(
+    () => form.clearErrors(path),
+    [form, path]
+  );
+  const validate = react.useCallback(() => form.validateField(path), [form, path]);
+  const validateAsync2 = react.useCallback(
+    () => form.validateFieldAsync(path),
+    [form, path]
+  );
+  const onBlur = react.useCallback(() => {
+    form.setTouched(path, true);
+    const state = form.store.getState();
+    if (shouldValidateOn(
+      "blur",
+      state.mode,
+      state.reValidateMode,
+      state.submitCount > 0,
+      true
+    )) {
+      triggerValidate();
+    }
+  }, [form, path, triggerValidate]);
+  return react.useMemo(
+    () => ({
+      path: slice.path,
+      value: slice.value,
+      initialValue: slice.initialValue,
+      emptyValue,
+      error: slice.error,
+      touched: slice.touched,
+      dirty: slice.dirty,
+      isValidating: slice.isValidating,
+      setValue,
+      setTouched,
+      setError,
+      clearError,
+      validate,
+      validateAsync: validateAsync2,
+      onBlur
+    }),
+    [slice, emptyValue, setValue, setTouched, setError, clearError, validate, validateAsync2, onBlur]
+  );
+}
+
+// src/react/inputProps.ts
+var ariaInvalid = (field) => field.error !== void 0 && field.error.length > 0 ? true : void 0;
+var numberToInputText = (value) => value === void 0 || value === null || Number.isNaN(value) ? "" : String(value);
+var parseNumberText = (text) => {
+  if (text.trim() === "") return { kind: "empty" };
+  const parsed = Number(text);
+  return Number.isFinite(parsed) ? { kind: "number", value: parsed } : { kind: "invalid" };
+};
+var textInputProps = (field) => ({
+  name: field.path,
+  value: field.value ?? "",
+  "aria-invalid": ariaInvalid(field),
+  onChange: (e) => {
+    const text = e.target.value;
+    field.setValue(
+      text === "" && field.emptyValue === null ? null : text
+    );
+  },
+  onBlur: field.onBlur
+});
+var numberInputProps = (field) => ({
+  type: "number",
+  name: field.path,
+  value: numberToInputText(field.value),
+  "aria-invalid": ariaInvalid(field),
+  onChange: (e) => {
+    const parsed = parseNumberText(e.target.value);
+    field.setValue(
+      parsed.kind === "number" ? parsed.value : field.emptyValue
+    );
+  },
+  onBlur: field.onBlur
+});
+var checkboxProps = (field) => ({
+  type: "checkbox",
+  name: field.path,
+  checked: field.value ?? false,
+  "aria-invalid": ariaInvalid(field),
+  onChange: (e) => field.setValue(e.target.checked),
+  onBlur: field.onBlur
+});
+var selectProps = (field) => ({
+  name: field.path,
+  value: field.value ?? "",
+  "aria-invalid": ariaInvalid(field),
+  onChange: (e) => {
+    const v = e.target.value;
+    field.setValue(
+      v === "" && field.emptyValue === null ? null : v
+    );
+  },
+  onBlur: field.onBlur
+});
+var hasError = (error) => error !== void 0 && error.length > 0;
+var ErrorText = ({
+  id,
+  error
+}) => hasError(error) ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "zf-error", id, role: "alert", children: error?.[0] }) : null;
+var TextField = ({
+  form,
+  path,
+  label,
+  placeholder,
+  type = "text",
+  autoComplete,
+  ref
+}) => {
+  const id = react.useId();
+  const errorId = `${id}-error`;
+  const field = useField(form, path);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "zf-field", children: [
+    label !== void 0 ? /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, className: "zf-label", children: label }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        id,
+        ref,
+        ...textInputProps(field),
+        type,
+        placeholder,
+        autoComplete,
+        "aria-describedby": hasError(field.error) ? errorId : void 0
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(ErrorText, { id: errorId, error: field.error })
+  ] });
+};
+var IDLE_EDIT = { raw: null, pushed: void 0 };
+var useNumberInput = (field) => {
+  const [edit, setEdit] = react.useState(IDLE_EDIT);
+  const externallyChanged = edit.raw !== null && !Object.is(field.value, edit.pushed);
+  if (externallyChanged) {
+    setEdit(IDLE_EDIT);
+  }
+  const raw = externallyChanged ? null : edit.raw;
+  return {
+    name: field.path,
+    value: raw ?? numberToInputText(field.value),
+    inputMode: "decimal",
+    "aria-invalid": hasError(field.error) ? true : void 0,
+    onChange: (e) => {
+      const text = e.target.value;
+      const parsed = parseNumberText(text);
+      switch (parsed.kind) {
+        case "empty": {
+          const empty = field.emptyValue;
+          setEdit({ raw: text, pushed: empty });
+          field.setValue(empty);
+          return;
+        }
+        case "number":
+          setEdit({ raw: text, pushed: parsed.value });
+          field.setValue(parsed.value);
+          return;
+        case "invalid":
+          setEdit({ raw: text, pushed: field.value });
+          return;
+      }
+    },
+    onBlur: () => {
+      setEdit(IDLE_EDIT);
+      field.onBlur();
+    }
+  };
+};
+var NumberField = ({
+  form,
+  path,
+  label,
+  placeholder,
+  ref
+}) => {
+  const id = react.useId();
+  const errorId = `${id}-error`;
+  const field = useField(form, path);
+  const binding = useNumberInput(field);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "zf-field", children: [
+    label !== void 0 ? /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, className: "zf-label", children: label }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        id,
+        ref,
+        type: "text",
+        ...binding,
+        placeholder,
+        "aria-describedby": hasError(field.error) ? errorId : void 0
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(ErrorText, { id: errorId, error: field.error })
+  ] });
+};
+var CheckboxField = ({ form, path, label, ref }) => {
+  const id = react.useId();
+  const errorId = `${id}-error`;
+  const field = useField(form, path);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "zf-field", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: id, className: "zf-label", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          id,
+          ref,
+          ...checkboxProps(field),
+          "aria-describedby": hasError(field.error) ? errorId : void 0
+        }
+      ),
+      " ",
+      label
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(ErrorText, { id: errorId, error: field.error })
+  ] });
+};
+var SelectField = ({
+  form,
+  path,
+  label,
+  options,
+  placeholder,
+  ref
+}) => {
+  const id = react.useId();
+  const errorId = `${id}-error`;
+  const field = useField(form, path);
+  const showEmptyOption = field.value === void 0 || field.value === null || placeholder !== void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "zf-field", children: [
+    label !== void 0 ? /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, className: "zf-label", children: label }) : null,
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "select",
+      {
+        id,
+        ref,
+        ...selectProps(field),
+        "aria-describedby": hasError(field.error) ? errorId : void 0,
+        children: [
+          showEmptyOption ? /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", disabled: true, children: placeholder ?? "" }) : null,
+          options.map((opt) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: opt.value, children: opt.label }, opt.value))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(ErrorText, { id: errorId, error: field.error })
+  ] });
+};
+
+// src/react/focusError.ts
+var focusFirstError = (errors, root) => {
+  const scope = root ?? document;
+  const erroredPaths = Object.keys(errors).filter(
+    (k) => k !== "" && (errors[k]?.length ?? 0) > 0
+  );
+  const hasRootError = (errors[""]?.length ?? 0) > 0;
+  const controls = [
+    ...scope.querySelectorAll(
+      "input[name], select[name], textarea[name]"
+    )
+  ].filter((el) => !el.matches(':disabled, [type="hidden"]'));
+  const fieldMatch = controls.find((el) => {
+    const name = el.getAttribute("name");
+    return name !== null && erroredPaths.some((k) => isPathOrChild(name, k));
+  });
+  const target = fieldMatch ?? (hasRootError ? controls[0] : void 0);
+  target?.focus();
+  return target !== void 0;
+};
+var EMPTY_ID_STATE = { items: [], ids: [], counter: 0 };
+var EMPTY_ITEMS = [];
+var reconcileIds = (prev, nextItems) => {
+  if (prev.items === nextItems) return prev;
+  if (prev.items.length === nextItems.length && prev.items.every((item, i) => Object.is(item, nextItems[i]))) {
+    return prev;
+  }
+  const buckets = prev.items.reduce((acc, item, i) => {
+    const bucket = acc.get(item);
+    if (bucket === void 0) {
+      acc.set(item, [i]);
+    } else {
+      bucket.push(i);
+    }
+    return acc;
+  }, /* @__PURE__ */ new Map());
+  const matchedIds = nextItems.map((item) => {
+    const prevIndex = buckets.get(item)?.shift();
+    return prevIndex === void 0 ? null : prev.ids[prevIndex] ?? null;
+  });
+  const leftover = [...buckets.values()].flat().sort((a, b) => a - b).map((i) => prev.ids[i]).filter((id) => id !== void 0);
+  const ordinals = matchedIds.reduce((acc, id) => {
+    const count = acc.length === 0 ? 0 : acc[acc.length - 1] ?? 0;
+    acc.push(id === null ? count + 1 : count);
+    return acc;
+  }, []);
+  const unmatched = ordinals.length === 0 ? 0 : ordinals[ordinals.length - 1] ?? 0;
+  const ids = matchedIds.map((id, i) => {
+    if (id !== null) return id;
+    const ordinal = ordinals[i] ?? 0;
+    return leftover[ordinal - 1] ?? `__zfa_${prev.counter + (ordinal - leftover.length)}`;
+  });
+  return {
+    items: nextItems,
+    ids,
+    counter: prev.counter + Math.max(0, unmatched - leftover.length)
+  };
+};
+var useFieldArray = (form, pathArg) => {
+  const path = react$1.useStore(
+    form.store,
+    (state) => typeof pathArg === "function" ? pathArg(state) : pathArg
+  );
+  const slice = react$1.useStore(
+    form.store,
+    shallow.useShallow((state) => {
+      const value = getAtPath(state.values, path);
+      return {
+        items: Array.isArray(value) ? value : EMPTY_ITEMS,
+        error: state.errors[path]
+      };
+    })
+  );
+  const items = slice.items;
+  const error = slice.error;
+  const [idEntry, setIdEntry] = react.useState({ form, path, state: EMPTY_ID_STATE });
+  const base = idEntry.form === form && idEntry.path === path ? idEntry.state : { ...EMPTY_ID_STATE, counter: idEntry.state.counter };
+  const nextIdState = reconcileIds(base, items);
+  if (idEntry.form !== form || idEntry.path !== path || idEntry.state !== nextIdState) {
+    setIdEntry({ form, path, state: nextIdState });
+  }
+  const ids = nextIdState.ids;
+  const push = react.useCallback(
+    (item) => form.arrayPush(path, item),
+    [form, path]
+  );
+  const remove = react.useCallback(
+    (index) => form.arrayRemove(path, index),
+    [form, path]
+  );
+  const insert = react.useCallback(
+    (index, item) => form.arrayInsert(path, index, item),
+    [form, path]
+  );
+  const move = react.useCallback(
+    (from, to) => form.arrayMove(path, from, to),
+    [form, path]
+  );
+  const swap = react.useCallback(
+    (a, b) => form.arraySwap(path, a, b),
+    [form, path]
+  );
+  const fields = react.useMemo(
+    () => items.map((value, index) => ({
+      id: ids[index] ?? `__zfa_fallback_${index}`,
+      value
+    })),
+    [items, ids]
+  );
+  return react.useMemo(
+    () => ({
+      fields,
+      items,
+      length: items.length,
+      error,
+      push,
+      remove,
+      insert,
+      move,
+      swap
+    }),
+    [fields, items, error, push, remove, insert, move, swap]
+  );
+};
+
+exports.CheckboxField = CheckboxField;
+exports.NumberField = NumberField;
+exports.SelectField = SelectField;
+exports.TextField = TextField;
+exports.checkboxProps = checkboxProps;
+exports.createForm = createForm;
+exports.createFormContext = createFormContext;
+exports.flattenIssues = flattenIssues;
+exports.focusFirstError = focusFirstError;
+exports.getAtPath = getAtPath;
+exports.isAsyncRequiredError = isAsyncRequiredError;
+exports.numberInputProps = numberInputProps;
+exports.parsePath = parsePath;
+exports.selectProps = selectProps;
+exports.setAtPath = setAtPath;
+exports.shouldValidateOn = shouldValidateOn;
+exports.textInputProps = textInputProps;
+exports.useField = useField;
+exports.useFieldArray = useFieldArray;
+exports.useForm = useForm;
+exports.useFormError = useFormError;
+exports.useFormSelector = useFormSelector;
+exports.useFormSelectorShallow = useFormSelectorShallow;
+exports.useFormState = useFormState;
+exports.useFormStateShallow = useFormStateShallow;
+exports.useIsDirty = useIsDirty;
+exports.useIsSubmitting = useIsSubmitting;
+exports.useIsValid = useIsValid;
+exports.useSubmitCount = useSubmitCount;
+exports.validateAsync = validateAsync;
+exports.validateSync = validateSync;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map