@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/formsEngine/adapters/tanstack/index.js

@@ -0,0 +1,516 @@
+import { shallowRef, onMounted, toValue, onScopeDispose } from "vue";
+import { useForm, revalidateLogic } from "@tanstack/vue-form";
+import { a as fieldIssues } from "../../../chunks/FieldErrors-DIHjOm5W.js";
+import { A as AppErrorFactory } from "../../../chunks/AppErrorFactory-DCdNbVfv.js";
+import { s as snapshotFormValues, u as untilFormAbort, i as includesValidationPath, d as deepEqual, a as submitWithFocus, v as validateFormScope } from "../../../chunks/DeepEqual-xCcUOAA8.js";
+import { q as remapPathSet, u as remapPathMap, b as createFormStateView, a as createFieldComponent, n as parseStandardSchema, v as formParseFailure, d as createOptionsMessageResolver, g as getPath, c as createFieldApi, e as createUseFormState, t as toSubmitError, r as resolveSubmitFailure, j as hasPath, f as defaultMapFieldPath } from "../../../chunks/SubmitErrors-1_5oKOb1.js";
+const EmptyMap = Object.freeze(/* @__PURE__ */ Object.create(null));
+function normalizeErrorMap(errors) {
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [path, messages] of Object.entries(errors)) normalized[path] = [...messages];
+  return normalized;
+}
+function createTanstackFormOverlay(initialBaseline) {
+  const store = shallowRef({
+    baseline: initialBaseline,
+    scopedErrors: null,
+    scopedFields: void 0,
+    isScopeValidating: false,
+    serverErrors: EmptyMap,
+    touched: /* @__PURE__ */ new Set(),
+    submitCount: 0,
+    isSubmitting: false,
+    submitError: null,
+    isSubmitSuccessful: null
+  });
+  function commit(next) {
+    store.value = next;
+  }
+  function patch(partial) {
+    commit({ ...store.value, ...partial });
+  }
+  return {
+    state: store,
+    getState: () => store.value,
+    markBlurred: (path) => {
+      if (store.value.touched.has(path)) return;
+      const touched = new Set(store.value.touched);
+      touched.add(path);
+      patch({ touched });
+    },
+    clearServerErrorsAt: (path) => {
+      if (!Object.prototype.hasOwnProperty.call(store.value.serverErrors, path)) return;
+      patch({
+        serverErrors: Object.fromEntries(Object.entries(store.value.serverErrors).filter(([key]) => key !== path))
+      });
+    },
+    remapForArrayOperation: (arrayPath, operation) => {
+      patch({
+        serverErrors: remapPathMap(store.value.serverErrors, arrayPath, operation),
+        touched: remapPathSet(store.value.touched, arrayPath, operation)
+      });
+    },
+    beginSubmitAttempt: () => {
+      patch({
+        submitCount: store.value.submitCount + 1,
+        serverErrors: EmptyMap,
+        submitError: null,
+        isSubmitSuccessful: null
+      });
+    },
+    touchAll: () => {
+      if (store.value.submitCount === 0) patch({ submitCount: 1 });
+    },
+    setSubmitting: (isSubmitting) => {
+      if (store.value.isSubmitting !== isSubmitting) patch({ isSubmitting });
+    },
+    setSubmitSuccessful: (value) => {
+      if (store.value.isSubmitSuccessful !== value) patch({ isSubmitSuccessful: value });
+    },
+    applySubmitFailure: (resolution) => {
+      patch({
+        serverErrors: normalizeErrorMap(resolution.fieldErrors),
+        submitError: resolution.submitError
+      });
+    },
+    replaceServerErrors: (errors) => {
+      patch({ serverErrors: normalizeErrorMap(errors) });
+    },
+    clearSubmitError: () => {
+      if (store.value.submitError !== null) patch({ submitError: null });
+    },
+    setScope: (scopedErrors, scopedFields) => patch({ scopedErrors, scopedFields }),
+    setScopeValidating: (isScopeValidating) => patch({ isScopeValidating }),
+    setBaseline: (baseline) => patch({ baseline }),
+    reset: (baseline) => {
+      commit({
+        baseline,
+        scopedErrors: null,
+        scopedFields: void 0,
+        isScopeValidating: false,
+        serverErrors: EmptyMap,
+        touched: /* @__PURE__ */ new Set(),
+        submitCount: 0,
+        isSubmitting: false,
+        submitError: null,
+        isSubmitSuccessful: null
+      });
+    }
+  };
+}
+const EmptyMessages = Object.freeze([]);
+function toEngineValidationError(errors) {
+  const paths = Object.keys(errors);
+  if (paths.length === 0) return void 0;
+  const fields = /* @__PURE__ */ Object.create(null);
+  let form;
+  for (const path of paths) {
+    if (path === "") form = errors[path];
+    else fields[path] = errors[path] ?? [];
+  }
+  return form ? { form, fields } : { fields };
+}
+function toMessages(errors) {
+  if (!errors || errors.length === 0) return EmptyMessages;
+  const messages = [];
+  const visit = (error) => {
+    if (error === null || error === void 0) return;
+    if (typeof error === "string") {
+      messages.push(error);
+      return;
+    }
+    if (Array.isArray(error)) {
+      for (const entry of error) visit(entry);
+      return;
+    }
+    if (typeof error === "object" && typeof error.message === "string") {
+      messages.push(error.message);
+    }
+  };
+  for (const error of errors) visit(error);
+  return messages.length > 0 ? messages : EmptyMessages;
+}
+function sameMessages(a, b) {
+  return a === b || a.length === b.length && a.every((message, index) => message === b[index]);
+}
+function fieldStatesEqual(a, b) {
+  return Object.is(a.value, b.value) && a.isDirty === b.isDirty && a.isTouched === b.isTouched && sameMessages(a.errors, b.errors);
+}
+function bridgeStore(engine) {
+  const snapshot = shallowRef(engine.store.state);
+  const subscription = engine.store.subscribe((next) => {
+    snapshot.value = next;
+  });
+  onScopeDispose(() => subscription.unsubscribe(), true);
+  return snapshot;
+}
+function createCombinedReader(snapshot, overlay) {
+  let generation = null;
+  let formState = null;
+  let fieldCache = /* @__PURE__ */ new Map();
+  let previousFieldCache = /* @__PURE__ */ new Map();
+  function currentGeneration() {
+    const tan = snapshot.value;
+    const ov = overlay.state.value;
+    if (generation && generation.tan === tan && generation.ov === ov) return generation;
+    generation = { tan, ov };
+    formState = null;
+    previousFieldCache = fieldCache;
+    fieldCache = /* @__PURE__ */ new Map();
+    return generation;
+  }
+  return {
+    getFormState: () => {
+      const { tan, ov } = currentGeneration();
+      formState ??= {
+        values: tan.values,
+        isDirty: !deepEqual(tan.values, ov.baseline),
+        // Client validity is engine-native; the server-error overlay holds it false too.
+        isValid: (ov.scopedErrors === null ? tan.isValid : Object.keys(ov.scopedErrors).length === 0 && Object.entries(tan.fieldMeta).every(
+          ([path, meta]) => includesValidationPath(path, ov.scopedFields) || !meta?.errors.length
+        )) && Object.keys(ov.serverErrors).length === 0,
+        isSubmitting: ov.isSubmitting,
+        // Whole-schema validation is a FORM-level validator — TanStack's derived
+        // `isValidating` counts field-level validators only, so merge both flags.
+        isValidating: tan.isFormValidating || tan.isValidating || ov.isScopeValidating,
+        submitError: ov.submitError,
+        isSubmitSuccessful: ov.isSubmitSuccessful
+      };
+      return formState;
+    },
+    getFieldState: (path) => {
+      const { tan, ov } = currentGeneration();
+      const cached = fieldCache.get(path);
+      if (cached) return cached;
+      const value = getPath(tan.values, path);
+      const clientMessages = ov.scopedErrors !== null && includesValidationPath(path, ov.scopedFields) ? ov.scopedErrors[path] ?? EmptyMessages : toMessages(tan.fieldMeta[path]?.errors);
+      const serverMessages = ov.serverErrors[path] ?? EmptyMessages;
+      const computed = {
+        value,
+        // Client + server messages merged, client first (contract JSDoc).
+        errors: serverMessages.length === 0 ? clientMessages : clientMessages.length === 0 ? serverMessages : [...clientMessages, ...serverMessages],
+        isDirty: !deepEqual(value, getPath(ov.baseline, path)),
+        // A submit attempt counts as touching everything — error-display gating works post-attempt.
+        isTouched: [...ov.touched].some((selected) => includesValidationPath(path, [selected])) || ov.submitCount > 0
+      };
+      const previous = previousFieldCache.get(path);
+      const stable = previous && fieldStatesEqual(previous, computed) ? previous : computed;
+      fieldCache.set(path, stable);
+      return stable;
+    }
+  };
+}
+function createAdapterPrelude(getOptions) {
+  const initialOptions = getOptions();
+  const initialValues = snapshotFormValues(initialOptions.defaultValues);
+  const overlay = createTanstackFormOverlay(snapshotFormValues(initialValues));
+  const messageResolver = createOptionsMessageResolver(getOptions);
+  let cached = null;
+  const parseValues = (values, fresh = false) => {
+    const schema = getOptions().schema;
+    const resolver = messageResolver();
+    if (!fresh && cached !== null && deepEqual(cached.values, values) && cached.schema === schema && cached.resolver === resolver)
+      return cached.result;
+    const snapshot = snapshotFormValues(values);
+    const result = Promise.resolve().then(
+      () => schema ? parseStandardSchema(schema, snapshot, resolver) : { ok: true, value: snapshot }
+    ).catch(
+      () => formParseFailure({ "": [getOptions().fallbackErrorMessage ?? "Validation failed"] })
+    );
+    cached = { values: snapshotFormValues(values), schema, resolver, result };
+    return result;
+  };
+  const tanstackOptions = {
+    defaultValues: initialValues,
+    onSubmit: async ({ value }) => {
+      overlay.setSubmitting(true);
+      try {
+        const parsed = await parseValues(value, true);
+        if (!parsed.ok) return;
+        const result = await getOptions().onSubmit(parsed.value, { signal: new AbortController().signal });
+        overlay.setSubmitSuccessful(result.ok);
+      } finally {
+        overlay.setSubmitting(false);
+      }
+    }
+  };
+  const validateWithSchema = async ({ value, signal }) => {
+    overlay.setScope(null);
+    const result = await untilFormAbort(parseValues(value), signal, null);
+    if (!result) return void 0;
+    return toEngineValidationError(result.ok ? {} : result.failure.fieldErrors);
+  };
+  tanstackOptions.validators = { onDynamicAsync: validateWithSchema };
+  tanstackOptions.validationLogic = (props) => revalidateLogic({
+    mode: overlay.getState().submitCount > 0 || overlay.getState().touched.size > 0 ? "change" : initialOptions.validateOn ?? "submit",
+    modeAfterSubmission: "change"
+  })(props);
+  return { getOptions, overlay, tanstackOptions, messageResolver, parseValues };
+}
+function buildAppForm(engine, prelude) {
+  const { getOptions, overlay, tanstackOptions, messageResolver, parseValues } = prelude;
+  let lifecycleEpoch = 0;
+  let validationEpoch = 0;
+  let focusEpoch = 0;
+  let requestController = new AbortController();
+  let disposed = false;
+  let trailingSubmit = false;
+  let submittingValues = null;
+  const reader = createCombinedReader(bridgeStore(engine), overlay);
+  function applySubmitFailure(error, submittedValues = engine.store.state.values) {
+    const options = getOptions();
+    const values = engine.store.state.values;
+    overlay.applySubmitFailure(
+      resolveSubmitFailure(
+        error,
+        options.mapSubmitError ?? fieldIssues,
+        options.mapFieldPath ?? defaultMapFieldPath,
+        (path) => hasPath(submittedValues, path) && deepEqual(getPath(submittedValues, path), getPath(values, path)),
+        options.fallbackErrorMessage,
+        messageResolver()
+      )
+    );
+  }
+  async function performSubmit(values) {
+    if (disposed || getOptions().isDisabled) return false;
+    const epoch = lifecycleEpoch;
+    const signal = requestController.signal;
+    const isCurrent = () => !disposed && epoch === lifecycleEpoch;
+    validationEpoch += 1;
+    overlay.setScope(null);
+    overlay.beginSubmitAttempt();
+    const parsing = parseValues(values, true);
+    await engine.validate("submit");
+    const parsed = await parsing;
+    if (!isCurrent()) return false;
+    if (!parsed.ok) {
+      overlay.setSubmitSuccessful(false);
+      return false;
+    }
+    overlay.setSubmitting(true);
+    let successful = false;
+    try {
+      const result = await untilFormAbort(getOptions().onSubmit(parsed.value, { signal }), signal, {
+        ok: false,
+        failure: AppErrorFactory.cancelled()
+      });
+      successful = result.ok;
+      if (isCurrent() && result.ok) overlay.setBaseline(values);
+      else if (isCurrent() && !result.ok) applySubmitFailure(result.failure, values);
+    } catch (error) {
+      if (isCurrent()) applySubmitFailure(toSubmitError(error, getOptions().fallbackErrorMessage), values);
+    } finally {
+      if (isCurrent()) overlay.setSubmitting(false);
+      if (isCurrent()) overlay.setSubmitSuccessful(successful);
+    }
+    return successful && isCurrent();
+  }
+  let inFlight = null;
+  async function guardedSubmit() {
+    if (disposed) return false;
+    if (inFlight) {
+      if (!deepEqual(engine.store.state.values, submittingValues)) trailingSubmit = true;
+      return inFlight;
+    }
+    const run = async () => {
+      let successful = false;
+      do {
+        trailingSubmit = false;
+        submittingValues = snapshotFormValues(engine.store.state.values);
+        successful = await untilFormAbort(performSubmit(submittingValues), requestController.signal, false);
+      } while (!disposed && trailingSubmit && !deepEqual(engine.store.state.values, submittingValues) && !deepEqual(engine.store.state.values, overlay.getState().baseline));
+      return successful;
+    };
+    inFlight = run();
+    try {
+      return await inFlight;
+    } finally {
+      inFlight = null;
+      submittingValues = null;
+    }
+  }
+  async function validate(options) {
+    if (disposed) return false;
+    const epoch = ++validationEpoch;
+    const lifecycle = lifecycleEpoch;
+    if (options) {
+      for (const meta of Object.values(engine.state.validationMetaMap)) meta?.lastAbortController.abort();
+      const values2 = snapshotFormValues(engine.store.state.values);
+      for (const path of options.fields ?? Object.keys(values2)) overlay.markBlurred(path);
+      overlay.setScopeValidating(true);
+      const errors = await untilFormAbort(
+        validateFormScope(
+          values2,
+          options,
+          getOptions().schema,
+          messageResolver(),
+          getOptions().fallbackErrorMessage ?? "Validation failed"
+        ),
+        requestController.signal,
+        {}
+      );
+      if (disposed || epoch !== validationEpoch || lifecycle !== lifecycleEpoch) return false;
+      overlay.setScopeValidating(false);
+      if (!deepEqual(values2, engine.store.state.values)) return false;
+      const previous = overlay.getState();
+      const retained = Object.fromEntries(
+        Object.entries(previous.scopedErrors ?? {}).filter(([path]) => !includesValidationPath(path, options.fields))
+      );
+      const fields = options.fields && (previous.scopedErrors === null ? options.fields : previous.scopedFields && [...previous.scopedFields, ...options.fields]);
+      overlay.setScope({ ...retained, ...errors }, fields);
+      return Object.keys(errors).length === 0;
+    }
+    overlay.setScope(null);
+    overlay.touchAll();
+    const values = snapshotFormValues(engine.store.state.values);
+    const parsing = parseValues(values, true);
+    const result = await untilFormAbort(
+      Promise.all([engine.validate("submit"), parsing]),
+      requestController.signal,
+      null
+    );
+    return !disposed && lifecycle === lifecycleEpoch && epoch === validationEpoch && result !== null && result[1].ok;
+  }
+  let autoSubmitTimer = null;
+  const clearAutoSubmitTimer = () => {
+    if (autoSubmitTimer !== null) {
+      clearTimeout(autoSubmitTimer);
+      autoSubmitTimer = null;
+    }
+  };
+  const scheduleAutoSubmit = () => {
+    if ((getOptions().submitOn ?? "manual") !== "change") return;
+    clearAutoSubmitTimer();
+    const delay = getOptions().submitDebounceMs ?? 0;
+    autoSubmitTimer = setTimeout(() => {
+      autoSubmitTimer = null;
+      void guardedSubmit();
+    }, delay);
+  };
+  const autoSubmitOnBlur = () => {
+    if ((getOptions().submitOn ?? "manual") === "blur") void guardedSubmit();
+  };
+  const fieldApis = /* @__PURE__ */ new Map();
+  const fieldOps = {
+    getState: (path) => reader.getFieldState(path),
+    setValue: (path, value) => {
+      overlay.clearServerErrorsAt(path);
+      engine.setFieldValue(path, snapshotFormValues(value));
+      scheduleAutoSubmit();
+    },
+    blur: (path) => {
+      overlay.markBlurred(path);
+      void engine.validateField(path, "blur");
+      autoSubmitOnBlur();
+    }
+  };
+  const getFieldApi = (path) => {
+    const existing = fieldApis.get(path);
+    if (existing) return existing;
+    const api = createFieldApi(path, fieldOps);
+    fieldApis.set(path, api);
+    return api;
+  };
+  const arrayOperation = (path, operation) => {
+    const field = path;
+    switch (operation.kind) {
+      case "push":
+        engine.pushFieldValue(field, snapshotFormValues(operation.value));
+        break;
+      case "insert":
+        void engine.insertFieldValue(field, operation.index, snapshotFormValues(operation.value));
+        break;
+      case "remove":
+        void engine.removeFieldValue(field, operation.index);
+        break;
+      case "swap":
+        engine.swapFieldValues(field, operation.indexA, operation.indexB);
+        break;
+      case "move":
+        engine.moveFieldValues(field, operation.fromIndex, operation.toIndex);
+        break;
+    }
+    overlay.remapForArrayOperation(path, operation);
+    scheduleAutoSubmit();
+  };
+  function invalidateWork() {
+    lifecycleEpoch += 1;
+    validationEpoch += 1;
+    focusEpoch += 1;
+    requestController.abort();
+    requestController = new AbortController();
+    for (const meta of Object.values(engine.state.validationMetaMap)) meta?.lastAbortController.abort();
+    engine.baseStore.setState((previous) => ({ ...previous, isFormValidating: false }));
+    overlay.setSubmitting(false);
+    overlay.setScopeValidating(false);
+    trailingSubmit = false;
+    clearAutoSubmitTimer();
+  }
+  const state = createFormStateView(reader.getFormState);
+  const form = {
+    Field: createFieldComponent(getFieldApi, () => getOptions().isDisabled ?? false),
+    state,
+    // The same computed `state.values` reads — `form.values` is a shorthand, never a second source.
+    get values() {
+      return state.values;
+    },
+    useFormState: createUseFormState(reader.getFormState),
+    handleSubmit: async (event) => {
+      const epoch = ++focusEpoch;
+      return submitWithFocus(guardedSubmit, () => epoch === focusEpoch, event, getOptions().focusRoot?.());
+    },
+    validate,
+    cancelSubmit: () => {
+      invalidateWork();
+      overlay.applySubmitFailure({ fieldErrors: {}, submitError: AppErrorFactory.cancelled() });
+      overlay.setSubmitSuccessful(false);
+    },
+    invalidateSession: (next) => form.reset(next),
+    setValue: (path, value) => {
+      overlay.clearServerErrorsAt(path);
+      engine.setFieldValue(path, snapshotFormValues(value));
+      scheduleAutoSubmit();
+    },
+    array: (path) => ({
+      push: (value) => arrayOperation(path, { kind: "push", value }),
+      insert: (index, value) => arrayOperation(path, { kind: "insert", index, value }),
+      remove: (index) => arrayOperation(path, { kind: "remove", index }),
+      swap: (indexA, indexB) => arrayOperation(path, { kind: "swap", indexA, indexB }),
+      move: (fromIndex, toIndex) => arrayOperation(path, { kind: "move", fromIndex, toIndex })
+    }),
+    reset: (next) => {
+      invalidateWork();
+      const values = snapshotFormValues(next ?? overlay.getState().baseline);
+      tanstackOptions.defaultValues = values;
+      overlay.reset(snapshotFormValues(values));
+      engine.reset(values);
+      clearAutoSubmitTimer();
+    },
+    setFieldErrors: (errors) => overlay.replaceServerErrors(errors),
+    clearSubmitError: () => overlay.clearSubmitError(),
+    engine
+  };
+  return {
+    form,
+    dispose: () => {
+      invalidateWork();
+      disposed = true;
+    }
+  };
+}
+function useAppForm(options) {
+  const prelude = createAdapterPrelude(() => toValue(options));
+  const engine = useForm(prelude.tanstackOptions);
+  const built = buildAppForm(engine, prelude);
+  onMounted(() => {
+    if (toValue(options).validateOnMount) void engine.validate("submit");
+  });
+  onScopeDispose(built.dispose, true);
+  return built.form;
+}
+const tanstackFormEngine = { useAppForm };
+export {
+  tanstackFormEngine,
+  useAppForm
+};
+//# sourceMappingURL=index.js.map

package/dist/formsEngine/adapters/tanstack/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/formsEngine/adapters/tanstack/TanstackFormOverlay.ts","../../../../src/formsEngine/adapters/tanstack/UseAppForm.ts","../../../../src/formsEngine/adapters/tanstack/index.ts"],"sourcesContent":["import { shallowRef, type ShallowRef } from 'vue';\n\nimport type { AppError } from '../../../foundation/results';\n\nimport { remapPathMap, remapPathSet, type ArrayOperation } from '../../Paths';\nimport type { SubmitFailureResolution } from '../../SubmitErrors';\n\n/*\n * The adapter-owned overlay store — the contract state TanStack Form does not model\n * (docs/analysis/forms-engine.md §4/§5). TanStack has no client/server error merge, its\n * touched marks on change (contract: blur OR submit attempt), its dirty is sticky\n * per-field (contract: deep-compared against a resettable baseline), and its array\n * reindexing of field meta differs from the contract's remap rules. All four live here,\n * outside TanStack state, exactly like the house engine keeps them:\n *   - `serverErrors` — the server-error overlay, cleared per-path on the next change,\n *     replaced wholesale by `setFieldErrors`, remapped through array ops.\n *   - `baseline` — the dirty baseline `reset(next)` re-seeds.\n *   - `touched` — blur marks; `submitCount > 0` touches everything.\n *   - `isSubmitting` / `submitError` — the contract submit pipeline flags: `isSubmitting`\n *     wraps only the app's `onSubmit` call (not TanStack's validation window), and\n *     `submitError` holds the failure remainder no field could represent.\n *\n * The overlay is one immutable object in a `shallowRef`, so a read of `state.value` is the\n * subscription. TanStack's own store stays a `@tanstack/store` `Store` — the adapter bridges it\n * separately.\n */\n\ntype ErrorMap = Readonly<Record<string, ReadonlyArray<string>>>;\n\nconst EmptyMap: ErrorMap = Object.freeze(Object.create(null) as Record<string, ReadonlyArray<string>>);\n\n/** The adapter-owned slice merged with TanStack state into the contract's form/field state. */\nexport interface TanstackOverlayState<TValues extends object> {\n  /** The dirty baseline — `reset(next)` re-seeds it. */\n  readonly baseline: TValues;\n  readonly scopedErrors: ErrorMap | null;\n  readonly scopedFields: ReadonlyArray<string> | undefined;\n  readonly isScopeValidating: boolean;\n  /** The server-error overlay, keyed by form path (`rules[0].destination`). */\n  readonly serverErrors: ErrorMap;\n  readonly touched: ReadonlySet<string>;\n  readonly submitCount: number;\n  readonly isSubmitting: boolean;\n  readonly submitError: AppError | null;\n  /** The last completed submit's verdict — `null` until the first attempt completes and after `reset()`. */\n  readonly isSubmitSuccessful: boolean | null;\n}\n\n/** The overlay store the tanstack adapter combines with the TanStack form store. */\nexport interface TanstackFormOverlay<TValues extends object> {\n  /** The reactive seam; reading `state.value` subscribes. */\n  readonly state: Readonly<ShallowRef<TanstackOverlayState<TValues>>>;\n  readonly getState: () => TanstackOverlayState<TValues>;\n  /** Marks a field touched (wired onto the control's blur). */\n  readonly markBlurred: (path: string) => void;\n  /** Server messages clear on the next change to the field (contract JSDoc). */\n  readonly clearServerErrorsAt: (path: string) => void;\n  /** Row-scoped server errors + touched marks follow their rows through array ops. */\n  readonly remapForArrayOperation: (arrayPath: string, operation: ArrayOperation) => void;\n  /** A new attempt clears prior server errors, re-arms the verdict, and counts as touching every field. */\n  readonly beginSubmitAttempt: () => void;\n  /** Marks every field touched without clearing errors or the verdict — `validate()`'s display gate. */\n  readonly touchAll: () => void;\n  /** Brackets the app's `onSubmit` call — the contract's `isSubmitting` window. */\n  readonly setSubmitting: (isSubmitting: boolean) => void;\n  /** Settles the last completed submit's verdict (`handleSubmit` mirrors it into `isSubmitSuccessful`). */\n  readonly setSubmitSuccessful: (value: boolean | null) => void;\n  /** Lands a resolved submit failure: matches as the server overlay, remainder as `submitError`. */\n  readonly applySubmitFailure: (resolution: SubmitFailureResolution) => void;\n  /** Replaces the server-error overlay (`setFieldErrors`). */\n  readonly replaceServerErrors: (errors: Record<string, ReadonlyArray<string>>) => void;\n  /** Clears the form-level `submitError` without touching field errors (`clearSubmitError`). */\n  readonly clearSubmitError: () => void;\n  /** Clears everything and re-seeds the dirty baseline. */\n  readonly reset: (baseline: TValues) => void;\n  /** Advances the saved baseline without replacing newer editing values. */\n  readonly setScope: (errors: ErrorMap | null, fields?: ReadonlyArray<string>) => void;\n  readonly setScopeValidating: (value: boolean) => void;\n  readonly setBaseline: (baseline: TValues) => void;\n}\n\nfunction normalizeErrorMap(errors: Record<string, ReadonlyArray<string>>): ErrorMap {\n  const normalized: Record<string, ReadonlyArray<string>> = Object.create(null);\n  for (const [path, messages] of Object.entries(errors)) normalized[path] = [...messages];\n  return normalized;\n}\n\n/** Creates the adapter-owned overlay store seeded with the initial dirty baseline. */\nexport function createTanstackFormOverlay<TValues extends object>(\n  initialBaseline: TValues,\n): TanstackFormOverlay<TValues> {\n  const store = shallowRef<TanstackOverlayState<TValues>>({\n    baseline: initialBaseline,\n    scopedErrors: null,\n    scopedFields: undefined,\n    isScopeValidating: false,\n    serverErrors: EmptyMap,\n    touched: new Set<string>(),\n    submitCount: 0,\n    isSubmitting: false,\n    submitError: null,\n    isSubmitSuccessful: null,\n  });\n\n  function commit(next: TanstackOverlayState<TValues>): void {\n    store.value = next;\n  }\n\n  function patch(partial: Partial<TanstackOverlayState<TValues>>): void {\n    commit({ ...store.value, ...partial });\n  }\n\n  return {\n    state: store,\n    getState: () => store.value,\n    markBlurred: (path) => {\n      if (store.value.touched.has(path)) return;\n      const touched = new Set(store.value.touched);\n      touched.add(path);\n      patch({ touched });\n    },\n    clearServerErrorsAt: (path) => {\n      if (!Object.prototype.hasOwnProperty.call(store.value.serverErrors, path)) return;\n      patch({\n        serverErrors: Object.fromEntries(Object.entries(store.value.serverErrors).filter(([key]) => key !== path)),\n      });\n    },\n    remapForArrayOperation: (arrayPath, operation) => {\n      patch({\n        serverErrors: remapPathMap(store.value.serverErrors, arrayPath, operation),\n        touched: remapPathSet(store.value.touched, arrayPath, operation),\n      });\n    },\n    beginSubmitAttempt: () => {\n      patch({\n        submitCount: store.value.submitCount + 1,\n        serverErrors: EmptyMap,\n        submitError: null,\n        isSubmitSuccessful: null,\n      });\n    },\n    touchAll: () => {\n      if (store.value.submitCount === 0) patch({ submitCount: 1 });\n    },\n    setSubmitting: (isSubmitting) => {\n      if (store.value.isSubmitting !== isSubmitting) patch({ isSubmitting });\n    },\n    setSubmitSuccessful: (value) => {\n      if (store.value.isSubmitSuccessful !== value) patch({ isSubmitSuccessful: value });\n    },\n    applySubmitFailure: (resolution) => {\n      patch({\n        serverErrors: normalizeErrorMap(resolution.fieldErrors),\n        submitError: resolution.submitError,\n      });\n    },\n    replaceServerErrors: (errors) => {\n      patch({ serverErrors: normalizeErrorMap(errors) });\n    },\n    clearSubmitError: () => {\n      if (store.value.submitError !== null) patch({ submitError: null });\n    },\n    setScope: (scopedErrors, scopedFields) => patch({ scopedErrors, scopedFields }),\n    setScopeValidating: (isScopeValidating) => patch({ isScopeValidating }),\n    setBaseline: (baseline) => patch({ baseline }),\n    reset: (baseline) => {\n      commit({\n        baseline,\n        scopedErrors: null,\n        scopedFields: undefined,\n        isScopeValidating: false,\n        serverErrors: EmptyMap,\n        touched: new Set<string>(),\n        submitCount: 0,\n        isSubmitting: false,\n        submitError: null,\n        isSubmitSuccessful: null,\n      });\n    },\n  };\n}\n","import { onMounted, onScopeDispose, shallowRef, toValue, type ShallowRef } from 'vue';\n\nimport {\n  revalidateLogic,\n  useForm,\n  type DeepKeys,\n  type FormApi,\n  type FormAsyncValidateOrFn,\n  type FormOptions,\n  type FormValidateAsyncFn,\n  type VueFormApi,\n} from '@tanstack/vue-form';\n\nimport { fieldIssues } from '../../../foundation/http';\nimport { AppErrorFactory, type AppError } from '../../../foundation/results';\nimport type { ResolveValidationMessage } from '../../../foundation/validators';\n\nimport type {\n  AppFieldApi,\n  AppForm,\n  AppFormOptions,\n  AppFormOptionsSource,\n  AppFormState,\n  AppFormValidationOptions,\n} from '../../AppForm';\nimport { deepEqual } from '../../DeepEqual';\nimport { includesValidationPath, submitWithFocus, untilFormAbort, validateFormScope } from '../../FormOperations';\nimport { snapshotFormValues } from '../../FormSnapshot';\nimport { createFieldApi, createFieldComponent, createFormStateView, createUseFormState } from '../../FormGlue';\nimport { getPath, hasPath } from '../../Paths';\nimport {\n  createOptionsMessageResolver,\n  parseStandardSchema,\n  formParseFailure,\n  type FormParseResult,\n} from '../../SchemaValidation';\nimport { defaultMapFieldPath, resolveSubmitFailure, toSubmitError } from '../../SubmitErrors';\n\nimport { createTanstackFormOverlay, type TanstackFormOverlay, type TanstackOverlayState } from './TanstackFormOverlay';\n\n/*\n * The tanstack adapter — the facade contract over `@tanstack/vue-form` (optional peer).\n * TanStack owns values, validation scheduling, and the submit lifecycle; the overlay\n * (`TanstackFormOverlay`) owns everything the contract pins that TanStack models\n * differently — server-error merge/clearing, baseline-compared dirty, blur-or-submit\n * touched, contract array reindexing, `submitError` (see the overlay's module doc).\n *\n * Validation wiring: the whole-form Standard Schema runs as a TanStack form-level\n * `onDynamicAsync` validator under `revalidateLogic` — `validateOn` maps 1:1 onto its\n * pre-submission `mode` ('submit' default / 'blur' / 'change'), and `modeAfterSubmission:\n * 'change'` gives the pinned post-attempt change-revalidation. The validator returns\n * TanStack's global `{ form?, fields }` error shape, so client errors land in TanStack\n * field meta (created on demand — no TanStack `Field` mounts needed) and `state.isValid`\n * stays engine-native. Adapter notes (both mirror the contract's static options intent):\n *   - `validateOn` is creation-pinned; schema and message values are read per run.\n *     Schema presence may change through the options getter.\n *   - Escape-hatch writes (`engine.setFieldValue`) bypass the overlay — server-error\n *     clearing and touched semantics then follow TanStack, not the contract.\n *\n * HOW STATE IS READ. `@tanstack/vue-form` is `form-core` under a Vue host binding.\n *   - The returned instance is `FormApi & VueFormApi`.\n *   - TanStack's store is a `@tanstack/store` `Store`, invisible to Vue's tracker. It is bridged\n *     ONCE, here, into a `shallowRef` (`bridgeStore`); every contract read then flows through\n *     Vue reactivity. `form.useSelector` would do the same per slice, but it wraps its ref in\n *     `readonly()`, which would hand values back through a proxy and break the identity compares\n *     the reader and `deepEqual` rely on.\n *   - `useForm` applies its options ONCE (Vue's `setup` runs once), so the options object must\n *     stay stable: `reset()` keeps `tanstackOptions.defaultValues` in step with TanStack's own\n *     copy.\n */\n\n/** The native TanStack form instance the adapter builds — what `form.engine` exposes. */\nexport type TanstackFormEngine<TValues extends object> = FormApi<\n  TValues,\n  undefined, // onMount\n  undefined, // onChange\n  undefined, // onChangeAsync\n  undefined, // onBlur\n  undefined, // onBlurAsync\n  undefined, // onSubmit\n  undefined, // onSubmitAsync\n  undefined, // onDynamic\n  FormAsyncValidateOrFn<TValues>, // onDynamicAsync — the adapter's schema bridge\n  undefined, // onServer\n  never // submitMeta\n> &\n  VueFormApi<\n    TValues,\n    undefined,\n    undefined,\n    undefined,\n    undefined,\n    undefined,\n    undefined,\n    undefined,\n    undefined,\n    FormAsyncValidateOrFn<TValues>,\n    undefined,\n    never\n  >;\n\ntype TanstackFormOptions<TValues extends object> = FormOptions<\n  TValues,\n  undefined,\n  undefined,\n  undefined,\n  undefined,\n  undefined,\n  undefined,\n  undefined,\n  undefined,\n  FormAsyncValidateOrFn<TValues>,\n  undefined,\n  never\n>;\n\nconst EmptyMessages: ReadonlyArray<string> = Object.freeze([]);\n\n/**\n * Folds the shared schema-error map into TanStack's global form error shape:\n * root-path (`''`) issues become the form-level error, the rest per-field errors.\n */\nfunction toEngineValidationError(errors: Record<string, ReadonlyArray<string>>): unknown {\n  const paths = Object.keys(errors);\n  if (paths.length === 0) return undefined;\n  const fields: Record<string, ReadonlyArray<string>> = Object.create(null);\n  let form: ReadonlyArray<string> | undefined;\n  for (const path of paths) {\n    if (path === '') form = errors[path];\n    else fields[path] = errors[path] ?? [];\n  }\n  return form ? { form, fields } : { fields };\n}\n\n/**\n * Normalizes TanStack field-meta errors to plain messages. The adapter's own validator\n * yields `string[]`, but escape-hatch validators may add strings, nested arrays, or\n * Standard Schema issue objects — all are accepted.\n */\nfunction toMessages(errors: ReadonlyArray<unknown> | undefined): ReadonlyArray<string> {\n  if (!errors || errors.length === 0) return EmptyMessages;\n  const messages: string[] = [];\n  const visit = (error: unknown): void => {\n    if (error === null || error === undefined) return;\n    if (typeof error === 'string') {\n      messages.push(error);\n      return;\n    }\n    if (Array.isArray(error)) {\n      for (const entry of error) visit(entry);\n      return;\n    }\n    if (typeof error === 'object' && typeof (error as { message?: unknown }).message === 'string') {\n      messages.push((error as { message: string }).message);\n    }\n  };\n  for (const error of errors) visit(error);\n  return messages.length > 0 ? messages : EmptyMessages;\n}\n\n/** The per-field slice the `Field` glue reads — identity-stable while its members are unchanged. */\ninterface TanstackFieldState {\n  readonly value: unknown;\n  readonly errors: ReadonlyArray<string>;\n  readonly isDirty: boolean;\n  readonly isTouched: boolean;\n}\n\n/** The minimal structural view of TanStack form state the reader consumes (loose string paths). */\ninterface EngineStateView {\n  readonly values: unknown;\n  readonly isValid: boolean;\n  readonly isValidating: boolean;\n  readonly isFormValidating: boolean;\n  readonly fieldMeta: Partial<Record<string, { readonly errors: ReadonlyArray<unknown> }>>;\n}\n\nfunction sameMessages(a: ReadonlyArray<string>, b: ReadonlyArray<string>): boolean {\n  return a === b || (a.length === b.length && a.every((message, index) => message === b[index]));\n}\n\nfunction fieldStatesEqual(a: TanstackFieldState, b: TanstackFieldState): boolean {\n  return (\n    Object.is(a.value, b.value) &&\n    a.isDirty === b.isDirty &&\n    a.isTouched === b.isTouched &&\n    sameMessages(a.errors, b.errors)\n  );\n}\n\n/**\n * Mirrors the `@tanstack/store` store into a `shallowRef` — the ONE seam that puts TanStack\n * state inside Vue's tracker. Deliberately not `useSelector`/`useStore` from\n * `@tanstack/vue-store`: those wrap the ref in `readonly()`, which would hand every read back\n * through a deep proxy and defeat the `Object.is` identity compares the reader, `deepEqual`, and\n * TanStack's own writes all depend on.\n */\nfunction bridgeStore<TValues extends object>(engine: TanstackFormEngine<TValues>): ShallowRef<EngineStateView> {\n  const snapshot = shallowRef(engine.store.state as unknown as EngineStateView);\n  const subscription = engine.store.subscribe((next) => {\n    snapshot.value = next as unknown as EngineStateView;\n  });\n  onScopeDispose(() => subscription.unsubscribe(), true);\n  return snapshot;\n}\n\ninterface CombinedReader<TValues extends object> {\n  readonly getFormState: () => AppFormState<TValues>;\n  readonly getFieldState: (path: string) => TanstackFieldState;\n}\n\n/**\n * Derives the contract state from the (TanStack store state, overlay state) pair with\n * generation caching: snapshots are rebuilt only when either source commits, and per-path\n * field slices reuse the previous generation's identity when unchanged — so a read stays\n * referentially stable between commits. Both sources are `shallowRef`s, so every read below\n * is also the subscription.\n */\nfunction createCombinedReader<TValues extends object>(\n  snapshot: ShallowRef<EngineStateView>,\n  overlay: TanstackFormOverlay<TValues>,\n): CombinedReader<TValues> {\n  let generation: { tan: EngineStateView; ov: TanstackOverlayState<TValues> } | null = null;\n  let formState: AppFormState<TValues> | null = null;\n  let fieldCache = new Map<string, TanstackFieldState>();\n  let previousFieldCache = new Map<string, TanstackFieldState>();\n\n  function currentGeneration(): { tan: EngineStateView; ov: TanstackOverlayState<TValues> } {\n    const tan = snapshot.value;\n    const ov = overlay.state.value;\n    if (generation && generation.tan === tan && generation.ov === ov) return generation;\n    generation = { tan, ov };\n    formState = null;\n    previousFieldCache = fieldCache;\n    fieldCache = new Map();\n    return generation;\n  }\n\n  return {\n    getFormState: () => {\n      const { tan, ov } = currentGeneration();\n      formState ??= {\n        values: tan.values as TValues,\n        isDirty: !deepEqual(tan.values, ov.baseline),\n        // Client validity is engine-native; the server-error overlay holds it false too.\n        isValid:\n          (ov.scopedErrors === null\n            ? tan.isValid\n            : Object.keys(ov.scopedErrors).length === 0 &&\n              Object.entries(tan.fieldMeta).every(\n                ([path, meta]) => includesValidationPath(path, ov.scopedFields) || !meta?.errors.length,\n              )) && Object.keys(ov.serverErrors).length === 0,\n        isSubmitting: ov.isSubmitting,\n        // Whole-schema validation is a FORM-level validator — TanStack's derived\n        // `isValidating` counts field-level validators only, so merge both flags.\n        isValidating: tan.isFormValidating || tan.isValidating || ov.isScopeValidating,\n        submitError: ov.submitError,\n        isSubmitSuccessful: ov.isSubmitSuccessful,\n      };\n      return formState;\n    },\n    getFieldState: (path) => {\n      const { tan, ov } = currentGeneration();\n      const cached = fieldCache.get(path);\n      if (cached) return cached;\n      const value = getPath(tan.values, path);\n      const clientMessages =\n        ov.scopedErrors !== null && includesValidationPath(path, ov.scopedFields)\n          ? (ov.scopedErrors[path] ?? EmptyMessages)\n          : toMessages(tan.fieldMeta[path]?.errors);\n      const serverMessages = ov.serverErrors[path] ?? EmptyMessages;\n      const computed: TanstackFieldState = {\n        value,\n        // Client + server messages merged, client first (contract JSDoc).\n        errors:\n          serverMessages.length === 0\n            ? clientMessages\n            : clientMessages.length === 0\n              ? serverMessages\n              : [...clientMessages, ...serverMessages],\n        isDirty: !deepEqual(value, getPath(ov.baseline, path)),\n        // A submit attempt counts as touching everything — error-display gating works post-attempt.\n        isTouched: [...ov.touched].some((selected) => includesValidationPath(path, [selected])) || ov.submitCount > 0,\n      };\n      const previous = previousFieldCache.get(path);\n      const stable = previous && fieldStatesEqual(previous, computed) ? previous : computed;\n      fieldCache.set(path, stable);\n      return stable;\n    },\n  };\n}\n\ninterface AdapterPrelude<TValues extends object, TOutput> {\n  readonly getOptions: () => AppFormOptions<TValues, TOutput>;\n  readonly overlay: TanstackFormOverlay<TValues>;\n  readonly tanstackOptions: TanstackFormOptions<TValues>;\n  readonly parseValues: (values: TValues, fresh?: boolean) => Promise<FormParseResult<TOutput>>;\n  /** The form's message resolver, memoized against the `messages` / `labels` option identities. */\n  readonly messageResolver: () => ResolveValidationMessage;\n}\n\n/** Builds the overlay + the stable TanStack options (all callbacks read the latest options through `getOptions`). */\nfunction createAdapterPrelude<TValues extends object, TOutput>(\n  getOptions: () => AppFormOptions<TValues, TOutput>,\n): AdapterPrelude<TValues, TOutput> {\n  const initialOptions = getOptions();\n  const initialValues = snapshotFormValues(initialOptions.defaultValues);\n  const overlay = createTanstackFormOverlay<TValues>(snapshotFormValues(initialValues));\n  const messageResolver = createOptionsMessageResolver(getOptions);\n\n  let cached: {\n    values: TValues;\n    schema: AppFormOptions<TValues, TOutput>['schema'];\n    resolver: ResolveValidationMessage;\n    result: Promise<FormParseResult<TOutput>>;\n  } | null = null;\n  const parseValues = (values: TValues, fresh = false): Promise<FormParseResult<TOutput>> => {\n    const schema = getOptions().schema;\n    const resolver = messageResolver();\n    if (\n      !fresh &&\n      cached !== null &&\n      deepEqual(cached.values, values) &&\n      cached.schema === schema &&\n      cached.resolver === resolver\n    )\n      return cached.result;\n    const snapshot = snapshotFormValues(values);\n    const result = Promise.resolve()\n      .then(() =>\n        schema\n          ? parseStandardSchema(schema, snapshot, resolver)\n          : { ok: true as const, value: snapshot as unknown as TOutput },\n      )\n      .catch((): FormParseResult<TOutput> =>\n        formParseFailure({ '': [getOptions().fallbackErrorMessage ?? 'Validation failed'] }),\n      );\n    cached = { values: snapshotFormValues(values), schema, resolver, result };\n    return result;\n  };\n\n  const tanstackOptions: TanstackFormOptions<TValues> = {\n    defaultValues: initialValues,\n    onSubmit: async ({ value }) => {\n      // The contract's `isSubmitting` brackets ONLY the app submit call (house-identical),\n      // not TanStack's validation window. Failures propagate to the adapter's\n      // `handleSubmit` catch, so TanStack's own submit lifecycle stays truthful.\n      overlay.setSubmitting(true);\n      try {\n        const parsed = await parseValues(value, true);\n        if (!parsed.ok) return;\n        const result = await getOptions().onSubmit(parsed.value, { signal: new AbortController().signal });\n        // Reached only when validation passed AND the app submit resolved — the verdict's\n        // sole success signal (the invalid path never runs this; a throw skips it).\n        overlay.setSubmitSuccessful(result.ok);\n      } finally {\n        overlay.setSubmitting(false);\n      }\n    },\n  };\n\n  const validateWithSchema: FormValidateAsyncFn<TValues> = async ({ value, signal }) => {\n    overlay.setScope(null);\n    const result = await untilFormAbort(parseValues(value), signal, null);\n    if (!result) return undefined;\n    return toEngineValidationError(result.ok ? {} : result.failure.fieldErrors);\n  };\n  tanstackOptions.validators = { onDynamicAsync: validateWithSchema };\n  tanstackOptions.validationLogic = (props) =>\n    revalidateLogic({\n      mode:\n        overlay.getState().submitCount > 0 || overlay.getState().touched.size > 0\n          ? 'change'\n          : (initialOptions.validateOn ?? 'submit'),\n      modeAfterSubmission: 'change',\n    })(props);\n\n  return { getOptions, overlay, tanstackOptions, messageResolver, parseValues };\n}\n\n/** What `buildAppForm` returns — the contract surface plus the teardown the adapter's own timer needs. */\ninterface BuiltForm<TValues extends object> {\n  readonly form: AppForm<TValues, TanstackFormEngine<TValues>>;\n  /** Releases the pending `submitOn: 'change'` debounce timer on scope teardown. */\n  readonly dispose: () => void;\n}\n\n/** Builds the stable contract surface over the TanStack engine + overlay pair. */\nfunction buildAppForm<TValues extends object, TOutput>(\n  engine: TanstackFormEngine<TValues>,\n  prelude: AdapterPrelude<TValues, TOutput>,\n): BuiltForm<TValues> {\n  const { getOptions, overlay, tanstackOptions, messageResolver, parseValues } = prelude;\n  let lifecycleEpoch = 0;\n  let validationEpoch = 0;\n  let focusEpoch = 0;\n  let requestController = new AbortController();\n  let disposed = false;\n  let trailingSubmit = false;\n  let submittingValues: TValues | null = null;\n  const reader = createCombinedReader(bridgeStore(engine), overlay);\n\n  // ── Submit path shared by `handleSubmit` + auto-submit (validate → onSubmit → map failure) ─────\n  /** Resolves a thrown submit failure onto the overlay (matched paths → fields, remainder → banner). */\n  function applySubmitFailure(error: AppError, submittedValues = engine.store.state.values): void {\n    const options = getOptions();\n    const values = engine.store.state.values;\n    overlay.applySubmitFailure(\n      resolveSubmitFailure(\n        error,\n        options.mapSubmitError ?? fieldIssues,\n        options.mapFieldPath ?? defaultMapFieldPath,\n        (path) => hasPath(submittedValues, path) && deepEqual(getPath(submittedValues, path), getPath(values, path)),\n        options.fallbackErrorMessage,\n        messageResolver(),\n      ),\n    );\n  }\n\n  async function performSubmit(values: TValues): Promise<boolean> {\n    if (disposed || getOptions().isDisabled) return false;\n    const epoch = lifecycleEpoch;\n    const signal = requestController.signal;\n    const isCurrent = (): boolean => !disposed && epoch === lifecycleEpoch;\n    validationEpoch += 1;\n    overlay.setScope(null);\n    overlay.beginSubmitAttempt();\n    // The facade owns submission snapshots; TanStack still owns field validation and metadata.\n    // Its validator reuses this parse, so transforming/async schemas run once for this input.\n    const parsing = parseValues(values, true);\n    await engine.validate('submit');\n    const parsed = await parsing;\n    if (!isCurrent()) return false;\n    if (!parsed.ok) {\n      overlay.setSubmitSuccessful(false);\n      return false;\n    }\n    overlay.setSubmitting(true);\n    let successful = false;\n    try {\n      const result = await untilFormAbort(getOptions().onSubmit(parsed.value, { signal }), signal, {\n        ok: false,\n        failure: AppErrorFactory.cancelled(),\n      });\n      successful = result.ok;\n      if (isCurrent() && result.ok) overlay.setBaseline(values);\n      else if (isCurrent() && !result.ok) applySubmitFailure(result.failure, values);\n    } catch (error) {\n      if (isCurrent()) applySubmitFailure(toSubmitError(error, getOptions().fallbackErrorMessage), values);\n    } finally {\n      if (isCurrent()) overlay.setSubmitting(false);\n      if (isCurrent()) overlay.setSubmitSuccessful(successful);\n    }\n    return successful && isCurrent();\n  }\n\n  /** Serializes submissions and coalesces newer edits into one trailing snapshot. */\n  let inFlight: Promise<boolean> | null = null;\n  async function guardedSubmit(): Promise<boolean> {\n    if (disposed) return false;\n    if (inFlight) {\n      if (!deepEqual(engine.store.state.values, submittingValues)) trailingSubmit = true;\n      return inFlight;\n    }\n    const run = async (): Promise<boolean> => {\n      let successful = false;\n      do {\n        trailingSubmit = false;\n        submittingValues = snapshotFormValues(engine.store.state.values);\n        successful = await untilFormAbort(performSubmit(submittingValues), requestController.signal, false);\n      } while (\n        !disposed &&\n        trailingSubmit &&\n        !deepEqual(engine.store.state.values, submittingValues) &&\n        !deepEqual(engine.store.state.values, overlay.getState().baseline)\n      );\n      return successful;\n    };\n    inFlight = run();\n    try {\n      return await inFlight;\n    } finally {\n      inFlight = null;\n      submittingValues = null;\n    }\n  }\n\n  /** Validate without submitting — marks touched, runs the whole-form schema, resolves client validity. */\n  async function validate(options?: AppFormValidationOptions<TValues>): Promise<boolean> {\n    if (disposed) return false;\n    const epoch = ++validationEpoch;\n    const lifecycle = lifecycleEpoch;\n    if (options) {\n      for (const meta of Object.values(engine.state.validationMetaMap)) meta?.lastAbortController.abort();\n      const values = snapshotFormValues(engine.store.state.values);\n      for (const path of options.fields ?? Object.keys(values)) overlay.markBlurred(path);\n      overlay.setScopeValidating(true);\n      const errors = await untilFormAbort(\n        validateFormScope(\n          values,\n          options,\n          getOptions().schema,\n          messageResolver(),\n          getOptions().fallbackErrorMessage ?? 'Validation failed',\n        ),\n        requestController.signal,\n        {},\n      );\n      if (disposed || epoch !== validationEpoch || lifecycle !== lifecycleEpoch) return false;\n      overlay.setScopeValidating(false);\n      if (!deepEqual(values, engine.store.state.values)) return false;\n      const previous = overlay.getState();\n      const retained = Object.fromEntries(\n        Object.entries(previous.scopedErrors ?? {}).filter(([path]) => !includesValidationPath(path, options.fields)),\n      );\n      const fields =\n        options.fields &&\n        (previous.scopedErrors === null\n          ? options.fields\n          : previous.scopedFields && [...previous.scopedFields, ...options.fields]);\n      overlay.setScope({ ...retained, ...errors }, fields);\n      return Object.keys(errors).length === 0;\n    }\n    overlay.setScope(null);\n    overlay.touchAll();\n    const values = snapshotFormValues(engine.store.state.values);\n    const parsing = parseValues(values, true);\n    const result = await untilFormAbort(\n      Promise.all([engine.validate('submit'), parsing]),\n      requestController.signal,\n      null,\n    );\n    return !disposed && lifecycle === lifecycleEpoch && epoch === validationEpoch && result !== null && result[1].ok;\n  }\n\n  // ── Auto-submit (`submitOn`) — routes through the SAME `guardedSubmit` as manual submit ────────\n  let autoSubmitTimer: ReturnType<typeof setTimeout> | null = null;\n  const clearAutoSubmitTimer = (): void => {\n    if (autoSubmitTimer !== null) {\n      clearTimeout(autoSubmitTimer);\n      autoSubmitTimer = null;\n    }\n  };\n  const scheduleAutoSubmit = (): void => {\n    if ((getOptions().submitOn ?? 'manual') !== 'change') return;\n    clearAutoSubmitTimer();\n    const delay = getOptions().submitDebounceMs ?? 0;\n    autoSubmitTimer = setTimeout(() => {\n      autoSubmitTimer = null;\n      void guardedSubmit();\n    }, delay);\n  };\n  const autoSubmitOnBlur = (): void => {\n    if ((getOptions().submitOn ?? 'manual') === 'blur') void guardedSubmit();\n  };\n\n  // One API object per path — memoized, so the identity a slot payload sees is stable.\n  const fieldApis = new Map<string, AppFieldApi<unknown>>();\n  const fieldOps = {\n    getState: (path: string) => reader.getFieldState(path),\n    setValue: (path: string, value: unknown) => {\n      // Server messages clear on the next change to the field (contract JSDoc).\n      overlay.clearServerErrorsAt(path);\n      // Triggers TanStack 'change'-cause validation, gated by `revalidateLogic`.\n      engine.setFieldValue(path as DeepKeys<TValues>, snapshotFormValues(value) as never);\n      // `submitOn: 'change'` — a user-origin write schedules the debounced auto-submit.\n      scheduleAutoSubmit();\n    },\n    blur: (path: string) => {\n      overlay.markBlurred(path);\n      // 'blur'-cause validation — runs the schema only in `validateOn: 'blur'` mode.\n      void engine.validateField(path as DeepKeys<TValues>, 'blur');\n      // `submitOn: 'blur'` — save-on-blur.\n      autoSubmitOnBlur();\n    },\n  };\n  const getFieldApi = (path: string): AppFieldApi<unknown> => {\n    const existing = fieldApis.get(path);\n    if (existing) return existing;\n    const api = createFieldApi(path, fieldOps);\n    fieldApis.set(path, api);\n    return api;\n  };\n\n  const arrayOperation = (path: string, operation: Parameters<typeof overlay.remapForArrayOperation>[1]): void => {\n    // TanStack's array ops are constrained to its typed array paths (`DeepKeysOfType`); the\n    // contract's paths are loose strings, so the vendor's path algebra is opted out of with\n    // `never` rather than reimplemented here.\n    const field = path as never;\n    switch (operation.kind) {\n      case 'push':\n        engine.pushFieldValue(field, snapshotFormValues(operation.value) as never);\n        break;\n      case 'insert':\n        void engine.insertFieldValue(field, operation.index, snapshotFormValues(operation.value) as never);\n        break;\n      case 'remove':\n        void engine.removeFieldValue(field, operation.index);\n        break;\n      case 'swap':\n        engine.swapFieldValues(field, operation.indexA, operation.indexB);\n        break;\n      case 'move':\n        engine.moveFieldValues(field, operation.fromIndex, operation.toIndex);\n        break;\n    }\n    // Contract reindexing for the overlay: row-scoped server errors + touched marks\n    // follow their rows. TanStack shifts its OWN field meta by its rules; where they\n    // differ, the contract wins because errors/touched surface from the overlay and\n    // client errors are recomputed by the op's change-revalidation.\n    overlay.remapForArrayOperation(path, operation);\n    scheduleAutoSubmit();\n  };\n\n  function invalidateWork(): void {\n    lifecycleEpoch += 1;\n    validationEpoch += 1;\n    focusEpoch += 1;\n    requestController.abort();\n    requestController = new AbortController();\n    for (const meta of Object.values(engine.state.validationMetaMap)) meta?.lastAbortController.abort();\n    engine.baseStore.setState((previous) => ({ ...previous, isFormValidating: false }));\n    overlay.setSubmitting(false);\n    overlay.setScopeValidating(false);\n    trailingSubmit = false;\n    clearAutoSubmitTimer();\n  }\n\n  const state = createFormStateView<TValues>(reader.getFormState);\n\n  const form: AppForm<TValues, TanstackFormEngine<TValues>> = {\n    Field: createFieldComponent<TValues>(getFieldApi, () => getOptions().isDisabled ?? false),\n    state,\n    // The same computed `state.values` reads — `form.values` is a shorthand, never a second source.\n    get values() {\n      return state.values;\n    },\n    useFormState: createUseFormState<TValues>(reader.getFormState),\n    handleSubmit: async (event?: Event) => {\n      const epoch = ++focusEpoch;\n      return submitWithFocus(guardedSubmit, () => epoch === focusEpoch, event, getOptions().focusRoot?.());\n    },\n    validate,\n    cancelSubmit: () => {\n      invalidateWork();\n      overlay.applySubmitFailure({ fieldErrors: {}, submitError: AppErrorFactory.cancelled() });\n      overlay.setSubmitSuccessful(false);\n    },\n    invalidateSession: (next) => form.reset(next),\n    setValue: (path, value) => {\n      // Server messages clear on the next change to the field (contract JSDoc) — mirror the\n      // in-field `setValue`; TanStack's 'change'-cause validation runs under `revalidateLogic`.\n      overlay.clearServerErrorsAt(path);\n      engine.setFieldValue(path as DeepKeys<TValues>, snapshotFormValues(value) as never);\n      scheduleAutoSubmit();\n    },\n    array: (path: string) => ({\n      push: (value: unknown) => arrayOperation(path, { kind: 'push', value }),\n      insert: (index: number, value: unknown) => arrayOperation(path, { kind: 'insert', index, value }),\n      remove: (index: number) => arrayOperation(path, { kind: 'remove', index }),\n      swap: (indexA: number, indexB: number) => arrayOperation(path, { kind: 'swap', indexA, indexB }),\n      move: (fromIndex: number, toIndex: number) => arrayOperation(path, { kind: 'move', fromIndex, toIndex }),\n    }),\n    reset: (next?: TValues) => {\n      invalidateWork();\n      const values = snapshotFormValues(next ?? overlay.getState().baseline);\n      // Keep the options object TanStack was created with in sync: its own `reset(values)`\n      // rewrites `options.defaultValues`, and any later `update()` would otherwise clobber the\n      // re-seeded values back from the stale copy.\n      tanstackOptions.defaultValues = values;\n      overlay.reset(snapshotFormValues(values));\n      engine.reset(values);\n      clearAutoSubmitTimer(); // a reset/prefill never auto-submits — drop any pending trailing submit\n    },\n    setFieldErrors: (errors: Record<string, ReadonlyArray<string>>) => overlay.replaceServerErrors(errors),\n    clearSubmitError: () => overlay.clearSubmitError(),\n    engine,\n  };\n\n  return {\n    form,\n    dispose: () => {\n      invalidateWork();\n      disposed = true;\n    },\n  };\n}\n\n/**\n * The tanstack adapter's `useAppForm` — the facade contract over `@tanstack/vue-form`.\n * The returned form object is stable for the owning scope's lifetime and every state member on\n * it is a live getter, so `form.values.title` / `form.state.isSubmitting` read in a template ARE\n * the subscription; `form.engine` exposes the native {@link TanstackFormEngine} (the 90/10\n * escape hatch — typed here, `unknown` on the shared contract), including TanStack's typed\n * deep-path `Field`/`Subscribe` and per-field validator graph.\n *\n * Call it in `setup()`: `useForm` registers an `onMounted` of its own, and the store bridge +\n * the pending `submitOn: 'change'` timer release on scope teardown.\n */\nexport function useAppForm<TValues extends object, TOutput = TValues>(\n  options: AppFormOptionsSource<TValues, TOutput>,\n): AppForm<TValues, TanstackFormEngine<TValues>> {\n  const prelude = createAdapterPrelude<TValues, TOutput>(() => toValue(options));\n  const engine = useForm(prelude.tanstackOptions) as TanstackFormEngine<TValues>;\n  const built = buildAppForm<TValues, TOutput>(engine, prelude);\n\n  // Validate once on mount when flagged — seeds `isValid` / field errors WITHOUT marking touched\n  // (the mount pass shows validity without asserting the user interacted).\n  onMounted(() => {\n    if (toValue(options).validateOnMount) void engine.validate('submit');\n  });\n  onScopeDispose(built.dispose, true);\n\n  return built.form;\n}\n","// @wow-two-beta/ui-vue/forms-engine/tanstack — the DEFAULT engine adapter over\n// `@tanstack/vue-form` (optional peer; installed only by apps that pin this adapter).\n// Implements the full facade contract with TanStack owning values, validation scheduling\n// (`revalidateLogic` + a form-level Standard Schema bridge), and the submit lifecycle,\n// while the adapter-owned overlay keeps the contract semantics TanStack models\n// differently: client/server error merge with per-field clear-on-change, baseline-\n// compared dirty (`reset(next)` re-seeds), blur-or-submit touched, contract array\n// reindexing of row-scoped errors, and the `submitError` remainder.\n//\n// Past the contract, `form.engine` exposes the native TanStack instance — typed deep-path\n// `engine.Field`/`engine.Subscribe`, per-field validators, listeners — per the 90/10\n// escape-hatch rule (docs/analysis/forms-engine.md §4). Overlay-backed semantics apply\n// only through the contract surface; native writes follow TanStack's own rules.\n//\n// `@tanstack/vue-form` shares `form-core` with the React package, so every engine call the\n// React adapter made survives verbatim; what changed is the READ side — TanStack's store is\n// bridged once into a `shallowRef` so the contract's reactive surface is plain Vue.\n\nimport type { FormEngine } from '../../AppForm';\n\nimport { useAppForm } from './UseAppForm';\n\nexport { useAppForm };\nexport type { TanstackFormEngine } from './UseAppForm';\nexport type { TanstackFormOverlay, TanstackOverlayState } from './TanstackFormOverlay';\n\n/** The tanstack adapter as a `FormEngine` — compile-time proof it satisfies the module contract. */\nexport const tanstackFormEngine = { useAppForm } satisfies FormEngine;\n"],"names":["values"],"mappings":";;;;;;AA6BA,MAAM,WAAqB,OAAO,OAAO,uBAAO,OAAO,IAAI,CAA0C;AAoDrG,SAAS,kBAAkB,QAAyD;AAClF,QAAM,aAAoD,uBAAO,OAAO,IAAI;AAC5E,aAAW,CAAC,MAAM,QAAQ,KAAK,OAAO,QAAQ,MAAM,EAAG,YAAW,IAAI,IAAI,CAAC,GAAG,QAAQ;AACtF,SAAO;AACT;AAGO,SAAS,0BACd,iBAC8B;AAC9B,QAAM,QAAQ,WAA0C;AAAA,IACtD,UAAU;AAAA,IACV,cAAc;AAAA,IACd,cAAc;AAAA,IACd,mBAAmB;AAAA,IACnB,cAAc;AAAA,IACd,6BAAa,IAAA;AAAA,IACb,aAAa;AAAA,IACb,cAAc;AAAA,IACd,aAAa;AAAA,IACb,oBAAoB;AAAA,EAAA,CACrB;AAED,WAAS,OAAO,MAA2C;AACzD,UAAM,QAAQ;AAAA,EAChB;AAEA,WAAS,MAAM,SAAuD;AACpE,WAAO,EAAE,GAAG,MAAM,OAAO,GAAG,SAAS;AAAA,EACvC;AAEA,SAAO;AAAA,IACL,OAAO;AAAA,IACP,UAAU,MAAM,MAAM;AAAA,IACtB,aAAa,CAAC,SAAS;AACrB,UAAI,MAAM,MAAM,QAAQ,IAAI,IAAI,EAAG;AACnC,YAAM,UAAU,IAAI,IAAI,MAAM,MAAM,OAAO;AAC3C,cAAQ,IAAI,IAAI;AAChB,YAAM,EAAE,SAAS;AAAA,IACnB;AAAA,IACA,qBAAqB,CAAC,SAAS;AAC7B,UAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,MAAM,cAAc,IAAI,EAAG;AAC3E,YAAM;AAAA,QACJ,cAAc,OAAO,YAAY,OAAO,QAAQ,MAAM,MAAM,YAAY,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,QAAQ,IAAI,CAAC;AAAA,MAAA,CAC1G;AAAA,IACH;AAAA,IACA,wBAAwB,CAAC,WAAW,cAAc;AAChD,YAAM;AAAA,QACJ,cAAc,aAAa,MAAM,MAAM,cAAc,WAAW,SAAS;AAAA,QACzE,SAAS,aAAa,MAAM,MAAM,SAAS,WAAW,SAAS;AAAA,MAAA,CAChE;AAAA,IACH;AAAA,IACA,oBAAoB,MAAM;AACxB,YAAM;AAAA,QACJ,aAAa,MAAM,MAAM,cAAc;AAAA,QACvC,cAAc;AAAA,QACd,aAAa;AAAA,QACb,oBAAoB;AAAA,MAAA,CACrB;AAAA,IACH;AAAA,IACA,UAAU,MAAM;AACd,UAAI,MAAM,MAAM,gBAAgB,SAAS,EAAE,aAAa,GAAG;AAAA,IAC7D;AAAA,IACA,eAAe,CAAC,iBAAiB;AAC/B,UAAI,MAAM,MAAM,iBAAiB,aAAc,OAAM,EAAE,cAAc;AAAA,IACvE;AAAA,IACA,qBAAqB,CAAC,UAAU;AAC9B,UAAI,MAAM,MAAM,uBAAuB,aAAa,EAAE,oBAAoB,OAAO;AAAA,IACnF;AAAA,IACA,oBAAoB,CAAC,eAAe;AAClC,YAAM;AAAA,QACJ,cAAc,kBAAkB,WAAW,WAAW;AAAA,QACtD,aAAa,WAAW;AAAA,MAAA,CACzB;AAAA,IACH;AAAA,IACA,qBAAqB,CAAC,WAAW;AAC/B,YAAM,EAAE,cAAc,kBAAkB,MAAM,GAAG;AAAA,IACnD;AAAA,IACA,kBAAkB,MAAM;AACtB,UAAI,MAAM,MAAM,gBAAgB,YAAY,EAAE,aAAa,MAAM;AAAA,IACnE;AAAA,IACA,UAAU,CAAC,cAAc,iBAAiB,MAAM,EAAE,cAAc,cAAc;AAAA,IAC9E,oBAAoB,CAAC,sBAAsB,MAAM,EAAE,mBAAmB;AAAA,IACtE,aAAa,CAAC,aAAa,MAAM,EAAE,UAAU;AAAA,IAC7C,OAAO,CAAC,aAAa;AACnB,aAAO;AAAA,QACL;AAAA,QACA,cAAc;AAAA,QACd,cAAc;AAAA,QACd,mBAAmB;AAAA,QACnB,cAAc;AAAA,QACd,6BAAa,IAAA;AAAA,QACb,aAAa;AAAA,QACb,cAAc;AAAA,QACd,aAAa;AAAA,QACb,oBAAoB;AAAA,MAAA,CACrB;AAAA,IACH;AAAA,EAAA;AAEJ;AChEA,MAAM,gBAAuC,OAAO,OAAO,EAAE;AAM7D,SAAS,wBAAwB,QAAwD;AACvF,QAAM,QAAQ,OAAO,KAAK,MAAM;AAChC,MAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,QAAM,SAAgD,uBAAO,OAAO,IAAI;AACxE,MAAI;AACJ,aAAW,QAAQ,OAAO;AACxB,QAAI,SAAS,GAAI,QAAO,OAAO,IAAI;AAAA,gBACvB,IAAI,IAAI,OAAO,IAAI,KAAK,CAAA;AAAA,EACtC;AACA,SAAO,OAAO,EAAE,MAAM,OAAA,IAAW,EAAE,OAAA;AACrC;AAOA,SAAS,WAAW,QAAmE;AACrF,MAAI,CAAC,UAAU,OAAO,WAAW,EAAG,QAAO;AAC3C,QAAM,WAAqB,CAAA;AAC3B,QAAM,QAAQ,CAAC,UAAyB;AACtC,QAAI,UAAU,QAAQ,UAAU,OAAW;AAC3C,QAAI,OAAO,UAAU,UAAU;AAC7B,eAAS,KAAK,KAAK;AACnB;AAAA,IACF;AACA,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,iBAAW,SAAS,MAAO,OAAM,KAAK;AACtC;AAAA,IACF;AACA,QAAI,OAAO,UAAU,YAAY,OAAQ,MAAgC,YAAY,UAAU;AAC7F,eAAS,KAAM,MAA8B,OAAO;AAAA,IACtD;AAAA,EACF;AACA,aAAW,SAAS,OAAQ,OAAM,KAAK;AACvC,SAAO,SAAS,SAAS,IAAI,WAAW;AAC1C;AAmBA,SAAS,aAAa,GAA0B,GAAmC;AACjF,SAAO,MAAM,KAAM,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,CAAC,SAAS,UAAU,YAAY,EAAE,KAAK,CAAC;AAC9F;AAEA,SAAS,iBAAiB,GAAuB,GAAgC;AAC/E,SACE,OAAO,GAAG,EAAE,OAAO,EAAE,KAAK,KAC1B,EAAE,YAAY,EAAE,WAChB,EAAE,cAAc,EAAE,aAClB,aAAa,EAAE,QAAQ,EAAE,MAAM;AAEnC;AASA,SAAS,YAAoC,QAAkE;AAC7G,QAAM,WAAW,WAAW,OAAO,MAAM,KAAmC;AAC5E,QAAM,eAAe,OAAO,MAAM,UAAU,CAAC,SAAS;AACpD,aAAS,QAAQ;AAAA,EACnB,CAAC;AACD,iBAAe,MAAM,aAAa,YAAA,GAAe,IAAI;AACrD,SAAO;AACT;AAcA,SAAS,qBACP,UACA,SACyB;AACzB,MAAI,aAAiF;AACrF,MAAI,YAA0C;AAC9C,MAAI,iCAAiB,IAAA;AACrB,MAAI,yCAAyB,IAAA;AAE7B,WAAS,oBAAiF;AACxF,UAAM,MAAM,SAAS;AACrB,UAAM,KAAK,QAAQ,MAAM;AACzB,QAAI,cAAc,WAAW,QAAQ,OAAO,WAAW,OAAO,GAAI,QAAO;AACzE,iBAAa,EAAE,KAAK,GAAA;AACpB,gBAAY;AACZ,yBAAqB;AACrB,qCAAiB,IAAA;AACjB,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,cAAc,MAAM;AAClB,YAAM,EAAE,KAAK,GAAA,IAAO,kBAAA;AACpB,oBAAc;AAAA,QACZ,QAAQ,IAAI;AAAA,QACZ,SAAS,CAAC,UAAU,IAAI,QAAQ,GAAG,QAAQ;AAAA;AAAA,QAE3C,UACG,GAAG,iBAAiB,OACjB,IAAI,UACJ,OAAO,KAAK,GAAG,YAAY,EAAE,WAAW,KACxC,OAAO,QAAQ,IAAI,SAAS,EAAE;AAAA,UAC5B,CAAC,CAAC,MAAM,IAAI,MAAM,uBAAuB,MAAM,GAAG,YAAY,KAAK,CAAC,MAAM,OAAO;AAAA,QAAA,MAC7E,OAAO,KAAK,GAAG,YAAY,EAAE,WAAW;AAAA,QACpD,cAAc,GAAG;AAAA;AAAA;AAAA,QAGjB,cAAc,IAAI,oBAAoB,IAAI,gBAAgB,GAAG;AAAA,QAC7D,aAAa,GAAG;AAAA,QAChB,oBAAoB,GAAG;AAAA,MAAA;AAEzB,aAAO;AAAA,IACT;AAAA,IACA,eAAe,CAAC,SAAS;AACvB,YAAM,EAAE,KAAK,GAAA,IAAO,kBAAA;AACpB,YAAM,SAAS,WAAW,IAAI,IAAI;AAClC,UAAI,OAAQ,QAAO;AACnB,YAAM,QAAQ,QAAQ,IAAI,QAAQ,IAAI;AACtC,YAAM,iBACJ,GAAG,iBAAiB,QAAQ,uBAAuB,MAAM,GAAG,YAAY,IACnE,GAAG,aAAa,IAAI,KAAK,gBAC1B,WAAW,IAAI,UAAU,IAAI,GAAG,MAAM;AAC5C,YAAM,iBAAiB,GAAG,aAAa,IAAI,KAAK;AAChD,YAAM,WAA+B;AAAA,QACnC;AAAA;AAAA,QAEA,QACE,eAAe,WAAW,IACtB,iBACA,eAAe,WAAW,IACxB,iBACA,CAAC,GAAG,gBAAgB,GAAG,cAAc;AAAA,QAC7C,SAAS,CAAC,UAAU,OAAO,QAAQ,GAAG,UAAU,IAAI,CAAC;AAAA;AAAA,QAErD,WAAW,CAAC,GAAG,GAAG,OAAO,EAAE,KAAK,CAAC,aAAa,uBAAuB,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,GAAG,cAAc;AAAA,MAAA;AAE9G,YAAM,WAAW,mBAAmB,IAAI,IAAI;AAC5C,YAAM,SAAS,YAAY,iBAAiB,UAAU,QAAQ,IAAI,WAAW;AAC7E,iBAAW,IAAI,MAAM,MAAM;AAC3B,aAAO;AAAA,IACT;AAAA,EAAA;AAEJ;AAYA,SAAS,qBACP,YACkC;AAClC,QAAM,iBAAiB,WAAA;AACvB,QAAM,gBAAgB,mBAAmB,eAAe,aAAa;AACrE,QAAM,UAAU,0BAAmC,mBAAmB,aAAa,CAAC;AACpF,QAAM,kBAAkB,6BAA6B,UAAU;AAE/D,MAAI,SAKO;AACX,QAAM,cAAc,CAAC,QAAiB,QAAQ,UAA6C;AACzF,UAAM,SAAS,aAAa;AAC5B,UAAM,WAAW,gBAAA;AACjB,QACE,CAAC,SACD,WAAW,QACX,UAAU,OAAO,QAAQ,MAAM,KAC/B,OAAO,WAAW,UAClB,OAAO,aAAa;AAEpB,aAAO,OAAO;AAChB,UAAM,WAAW,mBAAmB,MAAM;AAC1C,UAAM,SAAS,QAAQ,QAAA,EACpB;AAAA,MAAK,MACJ,SACI,oBAAoB,QAAQ,UAAU,QAAQ,IAC9C,EAAE,IAAI,MAAe,OAAO,SAAA;AAAA,IAA+B,EAEhE;AAAA,MAAM,MACL,iBAAiB,EAAE,IAAI,CAAC,aAAa,wBAAwB,mBAAmB,EAAA,CAAG;AAAA,IAAA;AAEvF,aAAS,EAAE,QAAQ,mBAAmB,MAAM,GAAG,QAAQ,UAAU,OAAA;AACjE,WAAO;AAAA,EACT;AAEA,QAAM,kBAAgD;AAAA,IACpD,eAAe;AAAA,IACf,UAAU,OAAO,EAAE,YAAY;AAI7B,cAAQ,cAAc,IAAI;AAC1B,UAAI;AACF,cAAM,SAAS,MAAM,YAAY,OAAO,IAAI;AAC5C,YAAI,CAAC,OAAO,GAAI;AAChB,cAAM,SAAS,MAAM,WAAA,EAAa,SAAS,OAAO,OAAO,EAAE,QAAQ,IAAI,gBAAA,EAAkB,QAAQ;AAGjG,gBAAQ,oBAAoB,OAAO,EAAE;AAAA,MACvC,UAAA;AACE,gBAAQ,cAAc,KAAK;AAAA,MAC7B;AAAA,IACF;AAAA,EAAA;AAGF,QAAM,qBAAmD,OAAO,EAAE,OAAO,aAAa;AACpF,YAAQ,SAAS,IAAI;AACrB,UAAM,SAAS,MAAM,eAAe,YAAY,KAAK,GAAG,QAAQ,IAAI;AACpE,QAAI,CAAC,OAAQ,QAAO;AACpB,WAAO,wBAAwB,OAAO,KAAK,CAAA,IAAK,OAAO,QAAQ,WAAW;AAAA,EAC5E;AACA,kBAAgB,aAAa,EAAE,gBAAgB,mBAAA;AAC/C,kBAAgB,kBAAkB,CAAC,UACjC,gBAAgB;AAAA,IACd,MACE,QAAQ,SAAA,EAAW,cAAc,KAAK,QAAQ,SAAA,EAAW,QAAQ,OAAO,IACpE,WACC,eAAe,cAAc;AAAA,IACpC,qBAAqB;AAAA,EAAA,CACtB,EAAE,KAAK;AAEV,SAAO,EAAE,YAAY,SAAS,iBAAiB,iBAAiB,YAAA;AAClE;AAUA,SAAS,aACP,QACA,SACoB;AACpB,QAAM,EAAE,YAAY,SAAS,iBAAiB,iBAAiB,gBAAgB;AAC/E,MAAI,iBAAiB;AACrB,MAAI,kBAAkB;AACtB,MAAI,aAAa;AACjB,MAAI,oBAAoB,IAAI,gBAAA;AAC5B,MAAI,WAAW;AACf,MAAI,iBAAiB;AACrB,MAAI,mBAAmC;AACvC,QAAM,SAAS,qBAAqB,YAAY,MAAM,GAAG,OAAO;AAIhE,WAAS,mBAAmB,OAAiB,kBAAkB,OAAO,MAAM,MAAM,QAAc;AAC9F,UAAM,UAAU,WAAA;AAChB,UAAM,SAAS,OAAO,MAAM,MAAM;AAClC,YAAQ;AAAA,MACN;AAAA,QACE;AAAA,QACA,QAAQ,kBAAkB;AAAA,QAC1B,QAAQ,gBAAgB;AAAA,QACxB,CAAC,SAAS,QAAQ,iBAAiB,IAAI,KAAK,UAAU,QAAQ,iBAAiB,IAAI,GAAG,QAAQ,QAAQ,IAAI,CAAC;AAAA,QAC3G,QAAQ;AAAA,QACR,gBAAA;AAAA,MAAgB;AAAA,IAClB;AAAA,EAEJ;AAEA,iBAAe,cAAc,QAAmC;AAC9D,QAAI,YAAY,aAAa,WAAY,QAAO;AAChD,UAAM,QAAQ;AACd,UAAM,SAAS,kBAAkB;AACjC,UAAM,YAAY,MAAe,CAAC,YAAY,UAAU;AACxD,uBAAmB;AACnB,YAAQ,SAAS,IAAI;AACrB,YAAQ,mBAAA;AAGR,UAAM,UAAU,YAAY,QAAQ,IAAI;AACxC,UAAM,OAAO,SAAS,QAAQ;AAC9B,UAAM,SAAS,MAAM;AACrB,QAAI,CAAC,UAAA,EAAa,QAAO;AACzB,QAAI,CAAC,OAAO,IAAI;AACd,cAAQ,oBAAoB,KAAK;AACjC,aAAO;AAAA,IACT;AACA,YAAQ,cAAc,IAAI;AAC1B,QAAI,aAAa;AACjB,QAAI;AACF,YAAM,SAAS,MAAM,eAAe,aAAa,SAAS,OAAO,OAAO,EAAE,OAAA,CAAQ,GAAG,QAAQ;AAAA,QAC3F,IAAI;AAAA,QACJ,SAAS,gBAAgB,UAAA;AAAA,MAAU,CACpC;AACD,mBAAa,OAAO;AACpB,UAAI,eAAe,OAAO,GAAI,SAAQ,YAAY,MAAM;AAAA,eAC/C,UAAA,KAAe,CAAC,OAAO,GAAI,oBAAmB,OAAO,SAAS,MAAM;AAAA,IAC/E,SAAS,OAAO;AACd,UAAI,UAAA,EAAa,oBAAmB,cAAc,OAAO,WAAA,EAAa,oBAAoB,GAAG,MAAM;AAAA,IACrG,UAAA;AACE,UAAI,UAAA,EAAa,SAAQ,cAAc,KAAK;AAC5C,UAAI,UAAA,EAAa,SAAQ,oBAAoB,UAAU;AAAA,IACzD;AACA,WAAO,cAAc,UAAA;AAAA,EACvB;AAGA,MAAI,WAAoC;AACxC,iBAAe,gBAAkC;AAC/C,QAAI,SAAU,QAAO;AACrB,QAAI,UAAU;AACZ,UAAI,CAAC,UAAU,OAAO,MAAM,MAAM,QAAQ,gBAAgB,EAAG,kBAAiB;AAC9E,aAAO;AAAA,IACT;AACA,UAAM,MAAM,YAA8B;AACxC,UAAI,aAAa;AACjB,SAAG;AACD,yBAAiB;AACjB,2BAAmB,mBAAmB,OAAO,MAAM,MAAM,MAAM;AAC/D,qBAAa,MAAM,eAAe,cAAc,gBAAgB,GAAG,kBAAkB,QAAQ,KAAK;AAAA,MACpG,SACE,CAAC,YACD,kBACA,CAAC,UAAU,OAAO,MAAM,MAAM,QAAQ,gBAAgB,KACtD,CAAC,UAAU,OAAO,MAAM,MAAM,QAAQ,QAAQ,SAAA,EAAW,QAAQ;AAEnE,aAAO;AAAA,IACT;AACA,eAAW,IAAA;AACX,QAAI;AACF,aAAO,MAAM;AAAA,IACf,UAAA;AACE,iBAAW;AACX,yBAAmB;AAAA,IACrB;AAAA,EACF;AAGA,iBAAe,SAAS,SAA+D;AACrF,QAAI,SAAU,QAAO;AACrB,UAAM,QAAQ,EAAE;AAChB,UAAM,YAAY;AAClB,QAAI,SAAS;AACX,iBAAW,QAAQ,OAAO,OAAO,OAAO,MAAM,iBAAiB,EAAG,OAAM,oBAAoB,MAAA;AAC5F,YAAMA,UAAS,mBAAmB,OAAO,MAAM,MAAM,MAAM;AAC3D,iBAAW,QAAQ,QAAQ,UAAU,OAAO,KAAKA,OAAM,EAAG,SAAQ,YAAY,IAAI;AAClF,cAAQ,mBAAmB,IAAI;AAC/B,YAAM,SAAS,MAAM;AAAA,QACnB;AAAA,UACEA;AAAAA,UACA;AAAA,UACA,aAAa;AAAA,UACb,gBAAA;AAAA,UACA,WAAA,EAAa,wBAAwB;AAAA,QAAA;AAAA,QAEvC,kBAAkB;AAAA,QAClB,CAAA;AAAA,MAAC;AAEH,UAAI,YAAY,UAAU,mBAAmB,cAAc,eAAgB,QAAO;AAClF,cAAQ,mBAAmB,KAAK;AAChC,UAAI,CAAC,UAAUA,SAAQ,OAAO,MAAM,MAAM,MAAM,EAAG,QAAO;AAC1D,YAAM,WAAW,QAAQ,SAAA;AACzB,YAAM,WAAW,OAAO;AAAA,QACtB,OAAO,QAAQ,SAAS,gBAAgB,CAAA,CAAE,EAAE,OAAO,CAAC,CAAC,IAAI,MAAM,CAAC,uBAAuB,MAAM,QAAQ,MAAM,CAAC;AAAA,MAAA;AAE9G,YAAM,SACJ,QAAQ,WACP,SAAS,iBAAiB,OACvB,QAAQ,SACR,SAAS,gBAAgB,CAAC,GAAG,SAAS,cAAc,GAAG,QAAQ,MAAM;AAC3E,cAAQ,SAAS,EAAE,GAAG,UAAU,GAAG,OAAA,GAAU,MAAM;AACnD,aAAO,OAAO,KAAK,MAAM,EAAE,WAAW;AAAA,IACxC;AACA,YAAQ,SAAS,IAAI;AACrB,YAAQ,SAAA;AACR,UAAM,SAAS,mBAAmB,OAAO,MAAM,MAAM,MAAM;AAC3D,UAAM,UAAU,YAAY,QAAQ,IAAI;AACxC,UAAM,SAAS,MAAM;AAAA,MACnB,QAAQ,IAAI,CAAC,OAAO,SAAS,QAAQ,GAAG,OAAO,CAAC;AAAA,MAChD,kBAAkB;AAAA,MAClB;AAAA,IAAA;AAEF,WAAO,CAAC,YAAY,cAAc,kBAAkB,UAAU,mBAAmB,WAAW,QAAQ,OAAO,CAAC,EAAE;AAAA,EAChH;AAGA,MAAI,kBAAwD;AAC5D,QAAM,uBAAuB,MAAY;AACvC,QAAI,oBAAoB,MAAM;AAC5B,mBAAa,eAAe;AAC5B,wBAAkB;AAAA,IACpB;AAAA,EACF;AACA,QAAM,qBAAqB,MAAY;AACrC,SAAK,WAAA,EAAa,YAAY,cAAc,SAAU;AACtD,yBAAA;AACA,UAAM,QAAQ,aAAa,oBAAoB;AAC/C,sBAAkB,WAAW,MAAM;AACjC,wBAAkB;AAClB,WAAK,cAAA;AAAA,IACP,GAAG,KAAK;AAAA,EACV;AACA,QAAM,mBAAmB,MAAY;AACnC,SAAK,aAAa,YAAY,cAAc,aAAa,cAAA;AAAA,EAC3D;AAGA,QAAM,gCAAgB,IAAA;AACtB,QAAM,WAAW;AAAA,IACf,UAAU,CAAC,SAAiB,OAAO,cAAc,IAAI;AAAA,IACrD,UAAU,CAAC,MAAc,UAAmB;AAE1C,cAAQ,oBAAoB,IAAI;AAEhC,aAAO,cAAc,MAA2B,mBAAmB,KAAK,CAAU;AAElF,yBAAA;AAAA,IACF;AAAA,IACA,MAAM,CAAC,SAAiB;AACtB,cAAQ,YAAY,IAAI;AAExB,WAAK,OAAO,cAAc,MAA2B,MAAM;AAE3D,uBAAA;AAAA,IACF;AAAA,EAAA;AAEF,QAAM,cAAc,CAAC,SAAuC;AAC1D,UAAM,WAAW,UAAU,IAAI,IAAI;AACnC,QAAI,SAAU,QAAO;AACrB,UAAM,MAAM,eAAe,MAAM,QAAQ;AACzC,cAAU,IAAI,MAAM,GAAG;AACvB,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,CAAC,MAAc,cAA0E;AAI9G,UAAM,QAAQ;AACd,YAAQ,UAAU,MAAA;AAAA,MAChB,KAAK;AACH,eAAO,eAAe,OAAO,mBAAmB,UAAU,KAAK,CAAU;AACzE;AAAA,MACF,KAAK;AACH,aAAK,OAAO,iBAAiB,OAAO,UAAU,OAAO,mBAAmB,UAAU,KAAK,CAAU;AACjG;AAAA,MACF,KAAK;AACH,aAAK,OAAO,iBAAiB,OAAO,UAAU,KAAK;AACnD;AAAA,MACF,KAAK;AACH,eAAO,gBAAgB,OAAO,UAAU,QAAQ,UAAU,MAAM;AAChE;AAAA,MACF,KAAK;AACH,eAAO,gBAAgB,OAAO,UAAU,WAAW,UAAU,OAAO;AACpE;AAAA,IAAA;AAMJ,YAAQ,uBAAuB,MAAM,SAAS;AAC9C,uBAAA;AAAA,EACF;AAEA,WAAS,iBAAuB;AAC9B,sBAAkB;AAClB,uBAAmB;AACnB,kBAAc;AACd,sBAAkB,MAAA;AAClB,wBAAoB,IAAI,gBAAA;AACxB,eAAW,QAAQ,OAAO,OAAO,OAAO,MAAM,iBAAiB,EAAG,OAAM,oBAAoB,MAAA;AAC5F,WAAO,UAAU,SAAS,CAAC,cAAc,EAAE,GAAG,UAAU,kBAAkB,MAAA,EAAQ;AAClF,YAAQ,cAAc,KAAK;AAC3B,YAAQ,mBAAmB,KAAK;AAChC,qBAAiB;AACjB,yBAAA;AAAA,EACF;AAEA,QAAM,QAAQ,oBAA6B,OAAO,YAAY;AAE9D,QAAM,OAAsD;AAAA,IAC1D,OAAO,qBAA8B,aAAa,MAAM,WAAA,EAAa,cAAc,KAAK;AAAA,IACxF;AAAA;AAAA,IAEA,IAAI,SAAS;AACX,aAAO,MAAM;AAAA,IACf;AAAA,IACA,cAAc,mBAA4B,OAAO,YAAY;AAAA,IAC7D,cAAc,OAAO,UAAkB;AACrC,YAAM,QAAQ,EAAE;AAChB,aAAO,gBAAgB,eAAe,MAAM,UAAU,YAAY,OAAO,aAAa,aAAa;AAAA,IACrG;AAAA,IACA;AAAA,IACA,cAAc,MAAM;AAClB,qBAAA;AACA,cAAQ,mBAAmB,EAAE,aAAa,CAAA,GAAI,aAAa,gBAAgB,UAAA,GAAa;AACxF,cAAQ,oBAAoB,KAAK;AAAA,IACnC;AAAA,IACA,mBAAmB,CAAC,SAAS,KAAK,MAAM,IAAI;AAAA,IAC5C,UAAU,CAAC,MAAM,UAAU;AAGzB,cAAQ,oBAAoB,IAAI;AAChC,aAAO,cAAc,MAA2B,mBAAmB,KAAK,CAAU;AAClF,yBAAA;AAAA,IACF;AAAA,IACA,OAAO,CAAC,UAAkB;AAAA,MACxB,MAAM,CAAC,UAAmB,eAAe,MAAM,EAAE,MAAM,QAAQ,OAAO;AAAA,MACtE,QAAQ,CAAC,OAAe,UAAmB,eAAe,MAAM,EAAE,MAAM,UAAU,OAAO,OAAO;AAAA,MAChG,QAAQ,CAAC,UAAkB,eAAe,MAAM,EAAE,MAAM,UAAU,OAAO;AAAA,MACzE,MAAM,CAAC,QAAgB,WAAmB,eAAe,MAAM,EAAE,MAAM,QAAQ,QAAQ,QAAQ;AAAA,MAC/F,MAAM,CAAC,WAAmB,YAAoB,eAAe,MAAM,EAAE,MAAM,QAAQ,WAAW,QAAA,CAAS;AAAA,IAAA;AAAA,IAEzG,OAAO,CAAC,SAAmB;AACzB,qBAAA;AACA,YAAM,SAAS,mBAAmB,QAAQ,QAAQ,SAAA,EAAW,QAAQ;AAIrE,sBAAgB,gBAAgB;AAChC,cAAQ,MAAM,mBAAmB,MAAM,CAAC;AACxC,aAAO,MAAM,MAAM;AACnB,2BAAA;AAAA,IACF;AAAA,IACA,gBAAgB,CAAC,WAAkD,QAAQ,oBAAoB,MAAM;AAAA,IACrG,kBAAkB,MAAM,QAAQ,iBAAA;AAAA,IAChC;AAAA,EAAA;AAGF,SAAO;AAAA,IACL;AAAA,IACA,SAAS,MAAM;AACb,qBAAA;AACA,iBAAW;AAAA,IACb;AAAA,EAAA;AAEJ;AAaO,SAAS,WACd,SAC+C;AAC/C,QAAM,UAAU,qBAAuC,MAAM,QAAQ,OAAO,CAAC;AAC7E,QAAM,SAAS,QAAQ,QAAQ,eAAe;AAC9C,QAAM,QAAQ,aAA+B,QAAQ,OAAO;AAI5D,YAAU,MAAM;AACd,QAAI,QAAQ,OAAO,EAAE,gBAAiB,MAAK,OAAO,SAAS,QAAQ;AAAA,EACrE,CAAC;AACD,iBAAe,MAAM,SAAS,IAAI;AAElC,SAAO,MAAM;AACf;AC/qBO,MAAM,qBAAqB,EAAE,WAAA;"}

package/dist/formsEngine/index.d.ts

@@ -0,0 +1,10 @@
+export type { AppFormOptions, AppFormSubmitContext, AppFormValidationOptions, AppFormOptionsSource, AppFieldApi, AppFormState, AppFieldValue, AppFieldPath, AppFieldProps, AppFieldComponent, AppArrayApi, AppForm, FormEngine, } from './AppForm';
+export type { StandardSchemaV1 } from './StandardSchema';
+export { defaultMapFieldPath } from './SubmitErrors';
+export { focusFirstInvalid } from './FocusFirstInvalid';
+export { useFieldArray } from './UseFieldArray';
+export type { FieldArray, FieldArrayField, FieldArrayFieldProps, FieldArrayForm, FieldArrayGlueField, FieldArrayGlueFieldProps, FieldArrayRow, } from './UseFieldArray';
+export { createFieldComponent, createFieldApi, createFormStateView, createUseFormState, type FieldSlice, type FieldOps, } from './FormGlue';
+export { resolveSubmitFailure, toSubmitError, type SubmitFailureResolution, type SubmitErrorMap, type SubmitFieldEntry, } from './SubmitErrors';
+export { runStandardSchema, createOptionsMessageResolver, issuePathToString, resultToFieldErrors, } from './SchemaValidation';
+export { parsePath, formatPath, getPath, setPath, hasPath, type PathKey, type ArrayOperation } from './Paths';