@wow-two-beta/ui-vue 0.0.2

package/dist/forms-engine/house/index.d.ts

@@ -0,0 +1,7 @@
+import { useAppForm } from './UseAppForm';
+export { useAppForm };
+export type { HouseFormEngine, HouseFieldState } from './HouseFormCore';
+/** The house adapter as a `FormEngine` — compile-time proof it satisfies the module contract. */
+export declare const houseFormEngine: {
+    useAppForm: typeof useAppForm;
+};

package/dist/forms-engine/house/index.js

@@ -0,0 +1,315 @@
+import { shallowRef, onScopeDispose, toValue } from "vue";
+import { l as runStandardSchema, g as getPath, m as mutateRows, n as remapPathSet, o as remapPathMap, s as setPath, d as createOptionsMessageResolver, r as resolveSubmitFailure, i as hasPath, f as defaultMapFieldPath, b as createFormStateView, e as createUseFormState, a as createFieldComponent, c as createFieldApi } from "../../chunks/SubmitErrors-K8nmmj0P.js";
+import { f as fieldIssues } from "../../chunks/FieldErrors-2zjhia4U.js";
+import { d as deepEqual } from "../../chunks/DeepEqual-7lBKnkNS.js";
+const EMPTY_ERRORS = Object.freeze([]);
+const EMPTY_MAP = Object.freeze({});
+function mergeErrors(client, server) {
+  const clientKeys = Object.keys(client);
+  const serverKeys = Object.keys(server);
+  if (serverKeys.length === 0) return client;
+  if (clientKeys.length === 0) return server;
+  const merged = { ...client };
+  for (const key of serverKeys) {
+    const existing = merged[key];
+    merged[key] = existing ? [...existing, ...server[key] ?? []] : server[key] ?? EMPTY_ERRORS;
+  }
+  return merged;
+}
+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 normalizeErrorMap(errors) {
+  const normalized = {};
+  for (const [path, messages] of Object.entries(errors)) normalized[path] = [...messages];
+  return normalized;
+}
+function createHouseFormEngine(getOptions) {
+  const initialValues = getOptions().defaultValues;
+  const store = shallowRef({
+    values: initialValues,
+    baseline: initialValues,
+    clientErrors: EMPTY_MAP,
+    serverErrors: EMPTY_MAP,
+    errors: EMPTY_MAP,
+    touched: /* @__PURE__ */ new Set(),
+    submitCount: 0,
+    isSubmitting: false,
+    isValidating: false,
+    submitError: null,
+    isSubmitSuccessful: null
+  });
+  let generation = null;
+  let formState = null;
+  let fieldCache = /* @__PURE__ */ new Map();
+  let previousFieldCache = /* @__PURE__ */ new Map();
+  let validationEpoch = 0;
+  let autoSubmitTimer = null;
+  let inFlight = null;
+  const messageResolver = createOptionsMessageResolver(getOptions);
+  function currentState() {
+    const internal = store.value;
+    if (generation !== internal) {
+      generation = internal;
+      formState = null;
+      previousFieldCache = fieldCache;
+      fieldCache = /* @__PURE__ */ new Map();
+    }
+    return internal;
+  }
+  function peek() {
+    return store.value;
+  }
+  function buildFormState(internal) {
+    return {
+      values: internal.values,
+      isDirty: !deepEqual(internal.values, internal.baseline),
+      isValid: Object.keys(internal.errors).length === 0,
+      isSubmitting: internal.isSubmitting,
+      isValidating: internal.isValidating,
+      submitError: internal.submitError,
+      isSubmitSuccessful: internal.isSubmitSuccessful
+    };
+  }
+  function commit(next) {
+    store.value = next;
+  }
+  function patch(partial) {
+    const next = { ...peek(), ...partial };
+    const errorsChanged = partial.clientErrors !== void 0 || partial.serverErrors !== void 0;
+    commit(errorsChanged ? { ...next, errors: mergeErrors(next.clientErrors, next.serverErrors) } : next);
+  }
+  function currentOptions() {
+    return getOptions();
+  }
+  function shouldValidateOnChange() {
+    const validateOn = currentOptions().validateOn ?? "submit";
+    return validateOn === "change" || peek().submitCount > 0;
+  }
+  function clearAutoSubmitTimer() {
+    if (autoSubmitTimer !== null) {
+      clearTimeout(autoSubmitTimer);
+      autoSubmitTimer = null;
+    }
+  }
+  function scheduleAutoSubmit() {
+    if ((currentOptions().submitOn ?? "manual") !== "change") return;
+    clearAutoSubmitTimer();
+    const delay = currentOptions().submitDebounceMs ?? 0;
+    autoSubmitTimer = setTimeout(() => {
+      autoSubmitTimer = null;
+      void submit();
+    }, delay);
+  }
+  function runValidation() {
+    const epoch = ++validationEpoch;
+    const schema = currentOptions().schema;
+    if (!schema) {
+      if (Object.keys(peek().clientErrors).length > 0 || peek().isValidating) {
+        patch({ clientErrors: EMPTY_MAP, isValidating: false });
+      }
+      return {};
+    }
+    const outcome = runStandardSchema(schema, peek().values, messageResolver());
+    if (outcome instanceof Promise) {
+      if (!peek().isValidating) patch({ isValidating: true });
+      return outcome.then((errors) => {
+        if (epoch === validationEpoch) patch({ clientErrors: normalizeErrorMap(errors), isValidating: false });
+        return errors;
+      });
+    }
+    patch({ clientErrors: normalizeErrorMap(outcome), isValidating: false });
+    return outcome;
+  }
+  function getFieldState(path) {
+    const state = currentState();
+    const cached = fieldCache.get(path);
+    if (cached) return cached;
+    const value = getPath(state.values, path);
+    const computed = {
+      value,
+      errors: state.errors[path] ?? EMPTY_ERRORS,
+      isDirty: !deepEqual(value, getPath(state.baseline, path)),
+      // A submit attempt counts as touching everything — error-display gating works post-attempt.
+      isTouched: state.touched.has(path) || state.submitCount > 0
+    };
+    const previous = previousFieldCache.get(path);
+    const stable = previous && fieldStatesEqual(previous, computed) ? previous : computed;
+    fieldCache.set(path, stable);
+    return stable;
+  }
+  function setValue(path, value) {
+    const state = peek();
+    const serverErrors = Object.prototype.hasOwnProperty.call(state.serverErrors, path) ? Object.fromEntries(Object.entries(state.serverErrors).filter(([key]) => key !== path)) : state.serverErrors;
+    patch({ values: setPath(state.values, path, value), serverErrors });
+    if (shouldValidateOnChange()) void runValidation();
+    scheduleAutoSubmit();
+  }
+  function blurField(path) {
+    const state = peek();
+    if (!state.touched.has(path)) {
+      const touched = new Set(state.touched);
+      touched.add(path);
+      patch({ touched });
+    }
+    const options = currentOptions();
+    if ((options.validateOn ?? "submit") === "blur") void runValidation();
+    if ((options.submitOn ?? "manual") === "blur") void submit();
+  }
+  function applyArrayOperation(path, operation) {
+    const state = peek();
+    const current = getPath(state.values, path);
+    const rows = Array.isArray(current) ? [...current] : [];
+    mutateRows(rows, operation);
+    patch({
+      values: setPath(state.values, path, rows),
+      // Row-scoped errors + touched marks follow their rows (insert/remove/swap/move reindex).
+      clientErrors: remapPathMap(state.clientErrors, path, operation),
+      serverErrors: remapPathMap(state.serverErrors, path, operation),
+      touched: remapPathSet(state.touched, path, operation)
+    });
+    if (shouldValidateOnChange()) void runValidation();
+    scheduleAutoSubmit();
+  }
+  function reset(next) {
+    validationEpoch += 1;
+    clearAutoSubmitTimer();
+    const values = next ?? currentOptions().defaultValues;
+    commit({
+      values,
+      baseline: values,
+      clientErrors: EMPTY_MAP,
+      serverErrors: EMPTY_MAP,
+      errors: EMPTY_MAP,
+      touched: /* @__PURE__ */ new Set(),
+      submitCount: 0,
+      isSubmitting: peek().isSubmitting,
+      // an in-flight submit still owns its flag (its finally clears it)
+      isValidating: false,
+      submitError: null,
+      isSubmitSuccessful: null
+    });
+  }
+  function setFieldErrorsAction(errors) {
+    patch({ serverErrors: normalizeErrorMap(errors) });
+  }
+  function clearSubmitError() {
+    if (peek().submitError !== null) patch({ submitError: null });
+  }
+  async function performSubmit() {
+    if (currentOptions().isDisabled) return false;
+    patch({ submitCount: peek().submitCount + 1, serverErrors: EMPTY_MAP, submitError: null, isSubmitSuccessful: null });
+    const errors = await runValidation();
+    if (Object.keys(errors).length > 0 && !currentOptions().submitInvalid) {
+      patch({ isSubmitSuccessful: false });
+      return false;
+    }
+    const options = currentOptions();
+    patch({ isSubmitting: true });
+    let successful = false;
+    try {
+      await options.onSubmit(peek().values);
+      successful = true;
+    } catch (error) {
+      const resolution = resolveSubmitFailure(
+        error,
+        options.mapSubmitError ?? fieldIssues,
+        options.mapFieldPath ?? defaultMapFieldPath,
+        (path) => hasPath(peek().values, path),
+        options.fallbackErrorMessage,
+        messageResolver()
+      );
+      patch({ serverErrors: normalizeErrorMap(resolution.fieldErrors), submitError: resolution.submitError });
+    } finally {
+      patch({ isSubmitting: false, isSubmitSuccessful: successful });
+    }
+    return successful;
+  }
+  async function submit() {
+    if (inFlight) return inFlight;
+    const run = performSubmit();
+    inFlight = run;
+    try {
+      return await run;
+    } finally {
+      inFlight = null;
+    }
+  }
+  async function validate() {
+    if (peek().submitCount === 0) patch({ submitCount: 1 });
+    const errors = await runValidation();
+    return Object.keys(errors).length === 0;
+  }
+  if (currentOptions().validateOnMount) void runValidation();
+  return {
+    state: store,
+    getFormState: () => {
+      const internal = currentState();
+      formState ??= buildFormState(internal);
+      return formState;
+    },
+    getFieldState,
+    setValue,
+    blurField,
+    applyArrayOperation,
+    reset,
+    setFieldErrors: setFieldErrorsAction,
+    clearSubmitError,
+    submit,
+    validate,
+    dispose: clearAutoSubmitTimer
+  };
+}
+function useAppForm(options) {
+  const engine = createHouseFormEngine(() => toValue(options));
+  onScopeDispose(engine.dispose, true);
+  const fieldApis = /* @__PURE__ */ new Map();
+  const fieldOps = {
+    getState: (path) => engine.getFieldState(path),
+    setValue: (path, value) => engine.setValue(path, value),
+    blur: (path) => engine.blurField(path)
+  };
+  const getFieldApi = (path) => {
+    const existing = fieldApis.get(path);
+    if (existing) return existing;
+    const api = createFieldApi(path, fieldOps);
+    fieldApis.set(path, api);
+    return api;
+  };
+  const state = createFormStateView(engine.getFormState);
+  return {
+    Field: createFieldComponent(getFieldApi, () => toValue(options).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(engine.getFormState),
+    handleSubmit: (event) => {
+      event?.preventDefault();
+      return engine.submit();
+    },
+    validate: () => engine.validate(),
+    setValue: (path, value) => engine.setValue(path, value),
+    array: (path) => ({
+      push: (value) => engine.applyArrayOperation(path, { kind: "push", value }),
+      insert: (index, value) => engine.applyArrayOperation(path, { kind: "insert", index, value }),
+      remove: (index) => engine.applyArrayOperation(path, { kind: "remove", index }),
+      swap: (indexA, indexB) => engine.applyArrayOperation(path, { kind: "swap", indexA, indexB }),
+      move: (fromIndex, toIndex) => engine.applyArrayOperation(path, { kind: "move", fromIndex, toIndex })
+    }),
+    reset: (next) => engine.reset(next),
+    setFieldErrors: (errors) => engine.setFieldErrors(errors),
+    clearSubmitError: () => engine.clearSubmitError(),
+    engine
+  };
+}
+const houseFormEngine = { useAppForm };
+export {
+  houseFormEngine,
+  useAppForm
+};
+//# sourceMappingURL=index.js.map

package/dist/forms-engine/house/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/forms-engine/house/HouseFormCore.ts","../../../src/forms-engine/house/UseAppForm.ts","../../../src/forms-engine/house/index.ts"],"sourcesContent":["import { shallowRef, type ShallowRef } from 'vue';\n\nimport { fieldIssues, type ApiError } from '../../foundation/http';\n\nimport type { AppFormOptions, AppFormState } from '../AppForm';\nimport { deepEqual } from '../DeepEqual';\nimport {\n  getPath,\n  hasPath,\n  mutateRows,\n  remapPathMap,\n  remapPathSet,\n  setPath,\n  type ArrayOperation,\n} from '../Paths';\nimport { createOptionsMessageResolver, runStandardSchema } from '../SchemaValidation';\nimport { defaultMapFieldPath, resolveSubmitFailure } from '../SubmitErrors';\n\n/*\n * The house micro-store — one immutable state object in a `shallowRef`.\n * SCOPE CEILING (docs/analysis/forms-engine.md §7): flat + dot-path store, whole-schema\n * Standard Schema validation, arrays, dirty/touched, submit pipeline. NO typed deep\n * paths, NO per-field async/debounce validators, NO linked-field graphs — a form that\n * needs those uses the tanstack adapter. Grow this file only from product evidence;\n * everything else is the `form.engine` escape hatch.\n *\n * REACT'S EXTERNAL-STORE PLUMBING IS GONE. `listeners` + `subscribe` + `useSyncExternalStore`\n * existed to make a plain object notify React; here `commit` assigns a `shallowRef` and any\n * getter that reads it is tracked wherever it is read. Everything else survives: state stays\n * ONE frozen-by-convention object replaced whole, and the generation caching below still hands\n * out identity-stable per-path slices so a field re-renders only when its own slice changed.\n */\n\ntype ErrorMap = Readonly<Record<string, readonly string[]>>;\n\nconst EMPTY_ERRORS: readonly string[] = Object.freeze([]);\nconst EMPTY_MAP: ErrorMap = Object.freeze({});\n\n/** The per-field slice the `Field` glue reads — identity-stable while its members are unchanged. */\nexport interface HouseFieldState {\n  readonly value: unknown;\n  readonly errors: readonly string[];\n  readonly isDirty: boolean;\n  readonly isTouched: boolean;\n}\n\ninterface InternalState<TValues extends object> {\n  readonly values: TValues;\n  /** The dirty baseline — `reset(next)` re-seeds it. */\n  readonly baseline: TValues;\n  readonly clientErrors: ErrorMap;\n  readonly serverErrors: ErrorMap;\n  /** Merged per-path messages, client first — rebuilt whenever either source changes. */\n  readonly errors: ErrorMap;\n  readonly touched: ReadonlySet<string>;\n  readonly submitCount: number;\n  readonly isSubmitting: boolean;\n  readonly isValidating: boolean;\n  readonly submitError: ApiError | 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 native house form instance — what `form.engine` exposes on the house adapter. */\nexport interface HouseFormEngine<TValues extends object> {\n  /**\n   * The raw store. Reading `state.value` inside a `computed` / render / `watchEffect` subscribes\n   * to it — the reactive seam that replaces React's `subscribe` + `useSyncExternalStore` pair.\n   */\n  readonly state: Readonly<ShallowRef<unknown>>;\n  readonly getFormState: () => AppFormState<TValues>;\n  readonly getFieldState: (path: string) => HouseFieldState;\n  readonly setValue: (path: string, value: unknown) => void;\n  readonly blurField: (path: string) => void;\n  readonly applyArrayOperation: (path: string, operation: ArrayOperation) => void;\n  readonly reset: (next?: TValues) => void;\n  readonly setFieldErrors: (errors: Record<string, string[]>) => void;\n  readonly clearSubmitError: () => void;\n  readonly submit: () => Promise<boolean>;\n  /** Validates without submitting — populates errors, marks touched, resolves client validity. */\n  readonly validate: () => Promise<boolean>;\n  /** Releases the pending auto-submit timer (`submitOn: 'change'`) on scope teardown. */\n  readonly dispose: () => void;\n}\n\nfunction mergeErrors(client: ErrorMap, server: ErrorMap): ErrorMap {\n  const clientKeys = Object.keys(client);\n  const serverKeys = Object.keys(server);\n  if (serverKeys.length === 0) return client;\n  if (clientKeys.length === 0) return server;\n  const merged: Record<string, readonly string[]> = { ...client };\n  for (const key of serverKeys) {\n    const existing = merged[key];\n    merged[key] = existing ? [...existing, ...(server[key] ?? [])] : (server[key] ?? EMPTY_ERRORS);\n  }\n  return merged;\n}\n\nfunction sameMessages(a: readonly string[], b: readonly string[]): boolean {\n  return a === b || (a.length === b.length && a.every((message, index) => message === b[index]));\n}\n\nfunction fieldStatesEqual(a: HouseFieldState, b: HouseFieldState): 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\nfunction normalizeErrorMap(errors: Record<string, string[]>): ErrorMap {\n  const normalized: Record<string, readonly string[]> = {};\n  for (const [path, messages] of Object.entries(errors)) normalized[path] = [...messages];\n  return normalized;\n}\n\n/** Creates the house form store. `getOptions` reads the latest options (`AppFormOptionsSource`). */\nexport function createHouseFormEngine<TValues extends object>(\n  getOptions: () => AppFormOptions<TValues>,\n): HouseFormEngine<TValues> {\n  const initialValues = getOptions().defaultValues;\n\n  const store = shallowRef<InternalState<TValues>>({\n    values: initialValues,\n    baseline: initialValues,\n    clientErrors: EMPTY_MAP,\n    serverErrors: EMPTY_MAP,\n    errors: EMPTY_MAP,\n    touched: new Set<string>(),\n    submitCount: 0,\n    isSubmitting: false,\n    isValidating: false,\n    submitError: null,\n    isSubmitSuccessful: null,\n  });\n\n  /** The generation the caches below belong to — swapped lazily on the first read after a commit. */\n  let generation: InternalState<TValues> | null = null;\n  let formState: AppFormState<TValues> | null = null;\n  /** Per-path field slices for the CURRENT generation — rebuilt lazily, reusing the previous generation's identity when unchanged. */\n  let fieldCache = new Map<string, HouseFieldState>();\n  let previousFieldCache = new Map<string, HouseFieldState>();\n  /** Monotonic guard: only the newest validation run may apply its result (async schemas). */\n  let validationEpoch = 0;\n  /** The pending trailing-debounce auto-submit timer (`submitOn: 'change'`); cleared on reset / teardown. */\n  let autoSubmitTimer: ReturnType<typeof setTimeout> | null = null;\n  /** Single-flight latch: an in-flight submit coalesces re-entrant triggers (double-click / change-burst). */\n  let inFlight: Promise<boolean> | null = null;\n  /** The form's message resolver, memoized against the `messages` / `labels` option identities. */\n  const messageResolver = createOptionsMessageResolver(getOptions);\n\n  /**\n   * Reads the store — THE reactive dependency every getter below inherits — and rolls the cache\n   * generation when it has moved. React did this eagerly in `commit`; doing it on read keeps the\n   * commit path free of work no one may look at.\n   */\n  function currentState(): InternalState<TValues> {\n    const internal = store.value;\n    if (generation !== internal) {\n      generation = internal;\n      formState = null;\n      previousFieldCache = fieldCache;\n      fieldCache = new Map();\n    }\n    return internal;\n  }\n\n  /** The untracked read — for the imperative paths (submit, validation, actions), which must never subscribe. */\n  function peek(): InternalState<TValues> {\n    return store.value;\n  }\n\n  function buildFormState(internal: InternalState<TValues>): AppFormState<TValues> {\n    return {\n      values: internal.values,\n      isDirty: !deepEqual(internal.values, internal.baseline),\n      isValid: Object.keys(internal.errors).length === 0,\n      isSubmitting: internal.isSubmitting,\n      isValidating: internal.isValidating,\n      submitError: internal.submitError,\n      isSubmitSuccessful: internal.isSubmitSuccessful,\n    };\n  }\n\n  function commit(next: InternalState<TValues>): void {\n    store.value = next;\n  }\n\n  function patch(partial: Partial<InternalState<TValues>>): void {\n    const next = { ...peek(), ...partial };\n    const errorsChanged = partial.clientErrors !== undefined || partial.serverErrors !== undefined;\n    commit(errorsChanged ? { ...next, errors: mergeErrors(next.clientErrors, next.serverErrors) } : next);\n  }\n\n  function currentOptions(): AppFormOptions<TValues> {\n    return getOptions();\n  }\n\n  function shouldValidateOnChange(): boolean {\n    const validateOn = currentOptions().validateOn ?? 'submit';\n    // 'submit' (default) + 'blur' both re-validate on change after the first attempt,\n    // so errors clear as the user fixes them.\n    return validateOn === 'change' || peek().submitCount > 0;\n  }\n\n  function clearAutoSubmitTimer(): void {\n    if (autoSubmitTimer !== null) {\n      clearTimeout(autoSubmitTimer);\n      autoSubmitTimer = null;\n    }\n  }\n\n  /**\n   * Schedules a trailing-debounced auto-submit for `submitOn: 'change'` — a user-origin write\n   * calls this; a change burst coalesces onto one submit (the timer resets each write), and the\n   * single-flight guard drops any overlap. No-op for `'blur'` / `'manual'`. `reset()` cancels it.\n   */\n  function scheduleAutoSubmit(): void {\n    if ((currentOptions().submitOn ?? 'manual') !== 'change') return;\n    clearAutoSubmitTimer();\n    const delay = currentOptions().submitDebounceMs ?? 0;\n    autoSubmitTimer = setTimeout(() => {\n      autoSubmitTimer = null;\n      void submit();\n    }, delay);\n  }\n\n  /** Runs whole-schema validation; sync schemas apply synchronously, async ones flip `isValidating`. */\n  function runValidation(): Record<string, string[]> | Promise<Record<string, string[]>> {\n    const epoch = ++validationEpoch;\n    const schema = currentOptions().schema;\n    if (!schema) {\n      if (Object.keys(peek().clientErrors).length > 0 || peek().isValidating) {\n        patch({ clientErrors: EMPTY_MAP, isValidating: false });\n      }\n      return {};\n    }\n    const outcome = runStandardSchema(schema, peek().values, messageResolver());\n    if (outcome instanceof Promise) {\n      if (!peek().isValidating) patch({ isValidating: true });\n      return outcome.then((errors) => {\n        if (epoch === validationEpoch) patch({ clientErrors: normalizeErrorMap(errors), isValidating: false });\n        return errors;\n      });\n    }\n    patch({ clientErrors: normalizeErrorMap(outcome), isValidating: false });\n    return outcome;\n  }\n\n  function getFieldState(path: string): HouseFieldState {\n    const state = currentState();\n    const cached = fieldCache.get(path);\n    if (cached) return cached;\n    const value = getPath(state.values, path);\n    const computed: HouseFieldState = {\n      value,\n      errors: state.errors[path] ?? EMPTY_ERRORS,\n      isDirty: !deepEqual(value, getPath(state.baseline, path)),\n      // A submit attempt counts as touching everything — error-display gating works post-attempt.\n      isTouched: state.touched.has(path) || state.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  function setValue(path: string, value: unknown): void {\n    const state = peek();\n    // Server messages clear on the next change to the field (contract JSDoc).\n    const serverErrors = Object.prototype.hasOwnProperty.call(state.serverErrors, path)\n      ? Object.fromEntries(Object.entries(state.serverErrors).filter(([key]) => key !== path))\n      : state.serverErrors;\n    patch({ values: setPath(state.values, path, value), serverErrors });\n    if (shouldValidateOnChange()) void runValidation();\n    scheduleAutoSubmit();\n  }\n\n  function blurField(path: string): void {\n    const state = peek();\n    if (!state.touched.has(path)) {\n      const touched = new Set(state.touched);\n      touched.add(path);\n      patch({ touched });\n    }\n    const options = currentOptions();\n    if ((options.validateOn ?? 'submit') === 'blur') void runValidation();\n    if ((options.submitOn ?? 'manual') === 'blur') void submit();\n  }\n\n  function applyArrayOperation(path: string, operation: ArrayOperation): void {\n    const state = peek();\n    const current = getPath(state.values, path);\n    const rows: unknown[] = Array.isArray(current) ? [...(current as unknown[])] : [];\n    mutateRows(rows, operation);\n    patch({\n      values: setPath(state.values, path, rows),\n      // Row-scoped errors + touched marks follow their rows (insert/remove/swap/move reindex).\n      clientErrors: remapPathMap(state.clientErrors, path, operation),\n      serverErrors: remapPathMap(state.serverErrors, path, operation),\n      touched: remapPathSet(state.touched, path, operation),\n    });\n    if (shouldValidateOnChange()) void runValidation();\n    scheduleAutoSubmit();\n  }\n\n  function reset(next?: TValues): void {\n    validationEpoch += 1; // drop any in-flight validation result\n    clearAutoSubmitTimer(); // a reset/prefill never auto-submits — drop any pending trailing submit\n    const values = next ?? currentOptions().defaultValues;\n    commit({\n      values,\n      baseline: values,\n      clientErrors: EMPTY_MAP,\n      serverErrors: EMPTY_MAP,\n      errors: EMPTY_MAP,\n      touched: new Set<string>(),\n      submitCount: 0,\n      isSubmitting: peek().isSubmitting, // an in-flight submit still owns its flag (its finally clears it)\n      isValidating: false,\n      submitError: null,\n      isSubmitSuccessful: null,\n    });\n  }\n\n  function setFieldErrorsAction(errors: Record<string, string[]>): void {\n    patch({ serverErrors: normalizeErrorMap(errors) });\n  }\n\n  function clearSubmitError(): void {\n    if (peek().submitError !== null) patch({ submitError: null });\n  }\n\n  async function performSubmit(): Promise<boolean> {\n    // A whole-form disabled form is inert — no attempt, no onSubmit (read-only / role-locked / frozen).\n    if (currentOptions().isDisabled) return false;\n    // A new attempt clears the previous server errors + remainder and re-arms the verdict.\n    patch({ submitCount: peek().submitCount + 1, serverErrors: EMPTY_MAP, submitError: null, isSubmitSuccessful: null });\n    const errors = await runValidation();\n    // `submitInvalid` (default false) blocks onSubmit on client errors; `true` runs onSubmit anyway\n    // (the errors stay populated as advisory) — the backend becomes the source of truth.\n    if (Object.keys(errors).length > 0 && !currentOptions().submitInvalid) {\n      patch({ isSubmitSuccessful: false }); // invalid + block-on-errors — onSubmit never runs\n      return false;\n    }\n    const options = currentOptions();\n    patch({ isSubmitting: true });\n    let successful = false;\n    try {\n      await options.onSubmit(peek().values);\n      successful = true;\n    } catch (error) {\n      const resolution = resolveSubmitFailure(\n        error,\n        options.mapSubmitError ?? fieldIssues,\n        options.mapFieldPath ?? defaultMapFieldPath,\n        (path) => hasPath(peek().values, path),\n        options.fallbackErrorMessage,\n        messageResolver(),\n      );\n      patch({ serverErrors: normalizeErrorMap(resolution.fieldErrors), submitError: resolution.submitError });\n    } finally {\n      patch({ isSubmitting: false, isSubmitSuccessful: successful });\n    }\n    return successful;\n  }\n\n  /**\n   * Single-flight submit — while a run is in flight a re-entrant trigger (double-click / Enter-spam\n   * / a `submitOn: 'change'` burst) coalesces onto it instead of starting a second `onSubmit`.\n   */\n  async function submit(): Promise<boolean> {\n    if (inFlight) return inFlight;\n    const run = performSubmit();\n    inFlight = run;\n    try {\n      return await run;\n    } finally {\n      inFlight = null;\n    }\n  }\n\n  /**\n   * Validates without submitting — the validation half of `submit()`: marks every field touched\n   * (so errors display and subsequent changes re-validate), runs the whole-form schema, and resolves\n   * the client validity. `onSubmit` never runs; the server-error overlay is left untouched.\n   */\n  async function validate(): Promise<boolean> {\n    if (peek().submitCount === 0) patch({ submitCount: 1 });\n    const errors = await runValidation();\n    return Object.keys(errors).length === 0;\n  }\n\n  // Validate on mount when flagged — seed `isValid` / field errors before any interaction WITHOUT\n  // marking fields touched (submitCount stays 0), so an edit screen shows validity without asserting\n  // the user has interacted. Runs after every action above is defined.\n  if (currentOptions().validateOnMount) void runValidation();\n\n  return {\n    state: store,\n    getFormState: () => {\n      const internal = currentState();\n      formState ??= buildFormState(internal);\n      return formState;\n    },\n    getFieldState,\n    setValue,\n    blurField,\n    applyArrayOperation,\n    reset,\n    setFieldErrors: setFieldErrorsAction,\n    clearSubmitError,\n    submit,\n    validate,\n    dispose: clearAutoSubmitTimer,\n  };\n}\n","import { onScopeDispose, toValue } from 'vue';\n\nimport type { AppFieldApi, AppForm, AppFormOptionsSource } from '../AppForm';\nimport {\n  createFieldApi,\n  createFieldComponent,\n  createFormStateView,\n  createUseFormState,\n} from '../FormGlue';\n\nimport { createHouseFormEngine, type HouseFormEngine } from './HouseFormCore';\n\n/**\n * The house adapter's `useAppForm` — the facade contract over the zero-dependency\n * micro-store. The returned form object is stable for the owning scope's lifetime and every\n * state member on it is a live getter, so `form.values.title` / `form.state.isSubmitting` read\n * in a template ARE the subscription; `form.engine` exposes the native {@link HouseFormEngine}\n * (the 90/10 escape hatch — typed here, `unknown` on the shared contract).\n *\n * Pass a getter / ref when an option must stay live (see `AppFormOptionsSource`); a plain object\n * is read once, which is what `defaultValues` + a closure `onSubmit` want.\n *\n * Call it in `setup()`: the pending `submitOn: 'change'` timer is released on scope teardown,\n * which is the whole of React's unmount effect here.\n */\nexport function useAppForm<TValues extends object>(\n  options: AppFormOptionsSource<TValues>,\n): AppForm<TValues, HouseFormEngine<TValues>> {\n  const engine = createHouseFormEngine<TValues>(() => toValue(options));\n  onScopeDispose(engine.dispose, true);\n\n  // One API object per path, so a slot payload keeps its identity across commits (React got this\n  // from `useMemo` inside the per-field hook; here the map outlives every render).\n  const fieldApis = new Map<string, AppFieldApi<unknown>>();\n  const fieldOps = {\n    getState: (path: string) => engine.getFieldState(path),\n    setValue: (path: string, value: unknown) => engine.setValue(path, value),\n    blur: (path: string) => engine.blurField(path),\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 state = createFormStateView<TValues>(engine.getFormState);\n\n  return {\n    Field: createFieldComponent<TValues>(getFieldApi, () => toValue(options).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>(engine.getFormState),\n    handleSubmit: (event?: Event) => {\n      event?.preventDefault();\n      return engine.submit();\n    },\n    validate: () => engine.validate(),\n    setValue: (path, value) => engine.setValue(path, value),\n    array: (path: string) => ({\n      push: (value: unknown) => engine.applyArrayOperation(path, { kind: 'push', value }),\n      insert: (index: number, value: unknown) => engine.applyArrayOperation(path, { kind: 'insert', index, value }),\n      remove: (index: number) => engine.applyArrayOperation(path, { kind: 'remove', index }),\n      swap: (indexA: number, indexB: number) => engine.applyArrayOperation(path, { kind: 'swap', indexA, indexB }),\n      move: (fromIndex: number, toIndex: number) =>\n        engine.applyArrayOperation(path, { kind: 'move', fromIndex, toIndex }),\n    }),\n    reset: (next?: TValues) => engine.reset(next),\n    setFieldErrors: (errors: Record<string, string[]>) => engine.setFieldErrors(errors),\n    clearSubmitError: () => engine.clearSubmitError(),\n    engine,\n  };\n}\n","// @wow-two-beta/ui-vue/forms-engine/house — the zero-dependency house micro-engine.\n// The true vendor hedge behind the `/forms-engine` facade: a flat + dot-path store in a\n// `shallowRef`, whole-schema Standard Schema validation (sync or async, with `validateOn`\n// timing), push/insert/remove/swap/move array ops with row-scoped error and touched reindexing,\n// dirty/touched tracking against a resettable baseline, and the full submit pipeline\n// (`mapSubmitError` → `mapFieldPath` → field errors, remainder → `submitError`).\n//\n// SCOPE CEILING (docs/analysis/forms-engine.md §7 — enforced, not aspirational):\n//   - NO typed deep paths (loose string paths; top-level keys infer their value type)\n//   - NO per-field async / debounced validators (whole-schema only; async schemas ride `isValidating`)\n//   - NO linked-field graphs / listeners\n// A form that outgrows this ceiling switches its app's `src/form.ts` pin to the tanstack\n// adapter — the house engine must stay a micro-engine, never a third form library.\n\nimport type { FormEngine } from '../AppForm';\n\nimport { useAppForm } from './UseAppForm';\n\nexport { useAppForm };\nexport type { HouseFormEngine, HouseFieldState } from './HouseFormCore';\n\n/** The house adapter as a `FormEngine` — compile-time proof it satisfies the module contract. */\nexport const houseFormEngine = { useAppForm } satisfies FormEngine;\n"],"names":[],"mappings":"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"}

package/dist/forms-engine/index.d.ts

@@ -0,0 +1,10 @@
+export type { AppFormOptions, 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, toApiError, 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';

package/dist/forms-engine/index.js

@@ -0,0 +1,127 @@
+import { g as getPath } from "../chunks/SubmitErrors-K8nmmj0P.js";
+import { c, a, b, d, e, f, h, i, j, p, r, k, l, s, t } from "../chunks/SubmitErrors-K8nmmj0P.js";
+import { shallowRef, watch, computed, defineComponent, h as h2 } from "vue";
+function focusFirstInvalid(root) {
+  if (!root) return null;
+  for (const candidate of root.querySelectorAll('[aria-invalid="true"]')) {
+    if (candidate.matches(":disabled") || candidate.getAttribute("aria-disabled") === "true") continue;
+    if (candidate.tabIndex < 0) continue;
+    candidate.focus();
+    if (candidate.ownerDocument.activeElement === candidate) return candidate;
+  }
+  return null;
+}
+function makeKey(seq) {
+  const id = seq.current;
+  seq.current = id + 1;
+  return `far-${id}`;
+}
+function buildKeys(length, seq) {
+  const keys = [];
+  for (let index = 0; index < length; index += 1) keys.push(makeKey(seq));
+  return keys;
+}
+function reconcileKeys(current, length, seq) {
+  const keys = current.slice(0, length);
+  while (keys.length < length) keys.push(makeKey(seq));
+  return keys;
+}
+function swapKeys(keys, indexA, indexB) {
+  const valueA = keys[indexA];
+  const valueB = keys[indexB];
+  if (valueA === void 0 || valueB === void 0) return;
+  keys[indexA] = valueB;
+  keys[indexB] = valueA;
+}
+function moveKey(keys, fromIndex, toIndex) {
+  const [moved] = keys.splice(fromIndex, 1);
+  if (moved === void 0) return;
+  keys.splice(toIndex, 0, moved);
+}
+function useFieldArray(form, path) {
+  const ops = form.array(path);
+  const storeLength = form.useFormState((state) => {
+    const value = getPath(state.values, path);
+    return Array.isArray(value) ? value.length : 0;
+  });
+  const seq = { current: 0 };
+  const keysRef = shallowRef(buildKeys(storeLength.value, seq));
+  watch(
+    storeLength,
+    (length) => {
+      if (keysRef.value.length !== length) keysRef.value = reconcileKeys(keysRef.value, length, seq);
+    },
+    { flush: "sync" }
+  );
+  const rows = computed(
+    () => keysRef.value.map((key, index) => ({ key, index }))
+  );
+  const Field = defineComponent({
+    name: "FieldArrayField",
+    props: {
+      index: { type: Number, required: true },
+      name: { type: String, required: true },
+      // `default: undefined` per optional boolean — an undefaulted `Boolean` prop is cast to `false`.
+      isDisabled: { type: Boolean, default: void 0 },
+      isRequired: { type: Boolean, default: void 0 },
+      isReadOnly: { type: Boolean, default: void 0 }
+    },
+    setup(props, { slots }) {
+      const GlueField = form.Field;
+      return () => h2(
+        GlueField,
+        {
+          name: `${path}[${props.index}].${props.name}`,
+          isDisabled: props.isDisabled,
+          isRequired: props.isRequired,
+          isReadOnly: props.isReadOnly
+        },
+        {
+          // The one `unknown → element` cast — sound by construction (`${path}[${index}].${name}` is `TItem[name]`).
+          default: (field) => slots.default?.(field)
+        }
+      );
+    }
+  });
+  const apply = (mutateKeys, run) => {
+    const next = [...keysRef.value];
+    mutateKeys(next);
+    keysRef.value = next;
+    run();
+  };
+  return {
+    get rows() {
+      return rows.value;
+    },
+    get length() {
+      return rows.value.length;
+    },
+    Field,
+    push: (value) => apply((next) => next.push(makeKey(seq)), () => ops.push(value)),
+    insert: (index, value) => apply((next) => next.splice(index, 0, makeKey(seq)), () => ops.insert(index, value)),
+    remove: (index) => apply((next) => next.splice(index, 1), () => ops.remove(index)),
+    swap: (indexA, indexB) => apply((next) => swapKeys(next, indexA, indexB), () => ops.swap(indexA, indexB)),
+    move: (fromIndex, toIndex) => apply((next) => moveKey(next, fromIndex, toIndex), () => ops.move(fromIndex, toIndex))
+  };
+}
+export {
+  c as createFieldApi,
+  a as createFieldComponent,
+  b as createFormStateView,
+  d as createOptionsMessageResolver,
+  e as createUseFormState,
+  f as defaultMapFieldPath,
+  focusFirstInvalid,
+  h as formatPath,
+  getPath,
+  i as hasPath,
+  j as issuePathToString,
+  p as parsePath,
+  r as resolveSubmitFailure,
+  k as resultToFieldErrors,
+  l as runStandardSchema,
+  s as setPath,
+  t as toApiError,
+  useFieldArray
+};
+//# sourceMappingURL=index.js.map

package/dist/forms-engine/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/forms-engine/FocusFirstInvalid.ts","../../src/forms-engine/UseFieldArray.ts"],"sourcesContent":["/*\n * Focus-first-invalid — the submit-rejection a11y hop (docs/analysis/forms-vector-next.md F-2e).\n * Contract-neutral by construction: it reads the `aria-invalid=\"true\"` the FormControlContext\n * glue stamps on every wired control, so it behaves identically on every engine adapter\n * (house, tanstack) and for client AND server errors — anything that flips a field invalid.\n * DOM order = visual order, so \"first\" matches what the user sees.\n */\n\n/**\n * Focuses the first invalid, focusable control inside `root` and returns it (`null` when\n * nothing qualifies — the form is valid, or every invalid control is disabled/hidden).\n *\n * Call it after `handleSubmit` settles; capture the form element BEFORE awaiting — the DOM\n * nulls `event.currentTarget` once dispatch ends, so reading it after an `await` yields `null`:\n *\n * ```vue\n * <form @submit=\"(event) => {\n *   const root = event.currentTarget as ParentNode;\n *   void form.handleSubmit(event).then(() => focusFirstInvalid(root));\n * }\">\n * ```\n */\nexport function focusFirstInvalid(root: ParentNode | null | undefined): HTMLElement | null {\n  if (!root) return null;\n  for (const candidate of root.querySelectorAll<HTMLElement>('[aria-invalid=\"true\"]')) {\n    // Disabled controls (native or ARIA widget) never take focus — skip to the next invalid one.\n    if (candidate.matches(':disabled') || candidate.getAttribute('aria-disabled') === 'true') continue;\n    // Focusable = in the tab order: native controls default 0; ARIA widgets need an explicit tabindex.\n    if (candidate.tabIndex < 0) continue;\n    candidate.focus();\n    // `focus()` silently no-ops on undisplayed nodes — only a verified move counts.\n    if (candidate.ownerDocument.activeElement === candidate) return candidate;\n  }\n  return null;\n}\n","import {\n  computed,\n  defineComponent,\n  h,\n  shallowRef,\n  watch,\n  type Component,\n  type PublicProps,\n  type Ref,\n  type VNode,\n} from 'vue';\n\nimport type { AppArrayApi, AppFieldApi, AppFieldProps, AppFormState } from './AppForm';\nimport { getPath } from './Paths';\n\n/*\n * useFieldArray — the typed row-render helper over `form.array(path)`\n * (docs/analysis/forms-deferred-items.md item 2b · forms-vector-next.md §F-2g).\n *\n * ENGINE-FREE, ONE IMPLEMENTATION. It composes only the shared `AppForm` contract —\n * `form.array` (ops), `form.useFormState` (a reactive row count), `form.Field` (the per-cell\n * binding) — so it serves BOTH adapters (`house` + `tanstack`) with no per-engine code and no\n * conformance drift; the shared suite pins it once against each.\n *\n * WHY IT EXISTS. A deep path like `rules[0].destination` resolves to `unknown` on\n * `AppFieldValue` — the deliberate typed-values / untyped-paths contract line (recursive\n * `PathValue` is rejected: it re-implements vendor `DeepKeys`, blows up on our discriminated\n * unions, and leaks engine types into the engine-free contract — item 2, option a). So every\n * array-row cell casts `f.value` (smart-qr `RuleControls`: 3 casts/row). This helper is typed\n * by the ROW ELEMENT instead: one generic `TItem` + one `keyof TItem`, NO recursion, NO vendor\n * deep-path types. A cell binds with `f.value` typed as `TItem[name]`, and the single\n * `unknown → element` cast lives HERE, in the SDK, once — not per-row in every consumer.\n *\n * It also retires the F-2g strain \"a reorderable-array component must become form-aware\": the\n * component takes `form` + `path` once through this composable, gets stable row keys (focus +\n * local state follow the logical row through insert/remove/swap/move, not the index), and drives\n * row-scoped errors through `form.array`'s existing reindexing — never reimplemented here.\n *\n * REACT'S `useRef` + `useReducer(forceRender)` PAIR IS GONE. The key list is a `shallowRef` an\n * op REPLACES (never mutates in place), so a reorder that keeps the length — swap / move — still\n * publishes; that is the whole job `forceRender` was doing. Reconciling an externally-changed\n * length (`reset(data)`, a whole-array `setValue`) moved out of the render, where React had to\n * put it, into a sync-flush `watch` on the length: it lands in the same tick as the store commit,\n * so no read ever sees a stale key list, and nothing writes reactive state from inside a\n * `computed`.\n */\n\n/** The slice of the `AppForm` contract the helper consumes — every engine's `AppForm` satisfies it. */\nexport interface FieldArrayForm {\n  /** Field wrapper — rendered per cell at the row's element path (`${path}[${index}].${name}`). */\n  readonly Field: FieldArrayGlueField;\n  /** Array ops at a path — the helper's ops delegate here (never reimplemented). */\n  readonly array: (path: string) => AppArrayApi;\n  /** Selector-subscribed form state — the helper subscribes to the array's length only. */\n  readonly useFormState: <TSlice>(\n    selector: (state: AppFormState<unknown>) => TSlice,\n    isEqual?: (a: TSlice, b: TSlice) => boolean,\n  ) => Readonly<Ref<TSlice>>;\n}\n\n/**\n * The loose (engine-free `AppFieldComponent`) props shape a `form.Field` accepts at a dynamic\n * path — DERIVED from the contract's own props at `TPath = string`, never a second copy of them.\n * A hand-written twin drifts silently and the failure lands on the consumer, as\n * `useFieldArray(form, path)` no longer accepting an `AppForm` at all.\n */\nexport type FieldArrayGlueFieldProps = AppFieldProps<string>;\n\n/**\n * `form.Field` seen loosely — a dynamic path, an untyped cell payload. The slot signature is\n * deliberately `never`-parametered so that an `AppFieldComponent<TValues>` is assignable here for\n * ANY `TValues`, which is what lets one helper serve both adapters; the row cell's real payload\n * type is restored below, on {@link FieldArrayFieldProps}.\n */\nexport interface FieldArrayGlueField {\n  new (props: FieldArrayGlueFieldProps): {\n    $props: FieldArrayGlueFieldProps & PublicProps;\n    $slots: { default?: (...args: never[]) => VNode[] };\n  };\n}\n\n/** One rendered row — a stable `key` for `v-for` (survives reorder) plus its live array index. */\nexport interface FieldArrayRow {\n  readonly key: string;\n  readonly index: number;\n}\n\n/** Props for the typed row-field accessor — binds `${path}[${index}].${name}`, `f.value` typed as `TItem[name]`. */\nexport interface FieldArrayFieldProps<TItem extends object, TName extends keyof TItem & string> {\n  /** The row's current array index (from `row.index`). */\n  readonly index: number;\n  /** The element field key — one level deep into `TItem`. */\n  readonly name: TName;\n  readonly isDisabled?: boolean;\n  readonly isRequired?: boolean;\n  readonly isReadOnly?: boolean;\n}\n\n/** The typed row-field accessor — one level deep (`keyof TItem`), no recursion, no vendor deep-path types. */\nexport interface FieldArrayField<TItem extends object> {\n  new <TName extends keyof TItem & string>(props: FieldArrayFieldProps<TItem, TName>): {\n    $props: FieldArrayFieldProps<TItem, TName> & PublicProps;\n    /** `field.value` / `field.setValue` are typed as `TItem[name]` — no cast, and `v-model=\"f.value\"` binds. */\n    $slots: { default?: (field: AppFieldApi<TItem[TName]>) => VNode[] };\n  };\n}\n\n/** What `useFieldArray` returns — reactive rows + stable keys, a typed row-field accessor, and element-typed ops. */\nexport interface FieldArray<TItem extends object> {\n  /** The current rows — `{ key, index }`; render with `:key=\"row.key\"` so a cell keeps identity through reorder. */\n  readonly rows: readonly FieldArrayRow[];\n  /** The current row count. */\n  readonly length: number;\n  /** The typed row-field accessor — `<array.Field :index=\"row.index\" name=\"destination\">`. */\n  readonly Field: FieldArrayField<TItem>;\n  /** Appends a row (typed to the element — a mistyped push is a compile error). Delegates to `form.array`. */\n  readonly push: (value: TItem) => void;\n  /** Inserts a row at `index`. Delegates to `form.array`. */\n  readonly insert: (index: number, value: TItem) => void;\n  /** Removes the row at `index`. Delegates to `form.array`. */\n  readonly remove: (index: number) => void;\n  /** Swaps two rows. Delegates to `form.array`. */\n  readonly swap: (indexA: number, indexB: number) => void;\n  /** Moves a row. Delegates to `form.array`. */\n  readonly move: (fromIndex: number, toIndex: number) => void;\n}\n\n/** Monotonic per-instance row-key allocator — keys are never reused, so a removed row's key can't collide. */\nfunction makeKey(seq: { current: number }): string {\n  const id = seq.current;\n  seq.current = id + 1;\n  return `far-${id}`;\n}\n\n/** Builds `length` fresh keys (first read). */\nfunction buildKeys(length: number, seq: { current: number }): string[] {\n  const keys: string[] = [];\n  for (let index = 0; index < length; index += 1) keys.push(makeKey(seq));\n  return keys;\n}\n\n/** Reconciles a key list to `length` the ops didn't cause (external `reset(data)` / whole-array `setValue`): keep the prefix, grow with fresh keys, shrink by truncation. */\nfunction reconcileKeys(current: readonly string[], length: number, seq: { current: number }): string[] {\n  const keys = current.slice(0, length);\n  while (keys.length < length) keys.push(makeKey(seq));\n  return keys;\n}\n\n/** Swaps two key slots in place (indices assumed in range, mirroring `AppArrayApi`). */\nfunction swapKeys(keys: string[], indexA: number, indexB: number): void {\n  const valueA = keys[indexA];\n  const valueB = keys[indexB];\n  if (valueA === undefined || valueB === undefined) return;\n  keys[indexA] = valueB;\n  keys[indexB] = valueA;\n}\n\n/** Moves a key slot in place (indices assumed in range). */\nfunction moveKey(keys: string[], fromIndex: number, toIndex: number): void {\n  const [moved] = keys.splice(fromIndex, 1);\n  if (moved === undefined) return;\n  keys.splice(toIndex, 0, moved);\n}\n\n/**\n * Row-render helper for the array at `path`. `TItem` is the row element type; row fields bind\n * one level deep (`keyof TItem`), typed, cast-free. Reuses `form.array(path)` for the ops\n * (row + error/touched reindexing stays in the adapter) and subscribes to the array LENGTH\n * only, so a row container re-renders on structural changes but not on per-row field edits —\n * each `array.Field` owns its own value subscription. Works identically on `house` + `tanstack`.\n *\n * `rows` / `length` are live getters, so `v-for=\"row in array.rows\"` reads the current rows on\n * every render; destructuring the returned object takes a snapshot of both.\n */\nexport function useFieldArray<TItem extends object>(form: FieldArrayForm, path: string): FieldArray<TItem> {\n  const ops = form.array(path);\n\n  // Reactive row count. A length-only selector (`Object.is` on the number) means field edits —\n  // which change the array reference but not its length — don't re-render the container.\n  const storeLength = form.useFormState((state) => {\n    const value = getPath(state.values, path);\n    return Array.isArray(value) ? value.length : 0;\n  });\n\n  // Stable row keys the helper OWNS, moved in lockstep with the ops.\n  const seq = { current: 0 };\n  const keysRef = shallowRef<string[]>(buildKeys(storeLength.value, seq));\n\n  // A length change no op of ours caused — `reset(data)`, a whole-array `setValue`. `flush: 'sync'`\n  // so the keys reconcile in the same tick as the store commit and no read can see a stale list;\n  // after one of our own ops the lengths already agree, so this is a no-op there.\n  watch(\n    storeLength,\n    (length) => {\n      if (keysRef.value.length !== length) keysRef.value = reconcileKeys(keysRef.value, length, seq);\n    },\n    { flush: 'sync' },\n  );\n\n  const rows = computed<readonly FieldArrayRow[]>(() =>\n    keysRef.value.map((key, index) => ({ key, index })),\n  );\n\n  const Field = defineComponent({\n    name: 'FieldArrayField',\n    props: {\n      index: { type: Number, required: true },\n      name: { type: String, required: true },\n      // `default: undefined` per optional boolean — an undefaulted `Boolean` prop is cast to `false`.\n      isDisabled: { type: Boolean, default: undefined },\n      isRequired: { type: Boolean, default: undefined },\n      isReadOnly: { type: Boolean, default: undefined },\n    },\n    setup(props, { slots }) {\n      // The contract's `Field` is typed as a constructor for `TPath` inference; `h` wants the\n      // runtime component behind it. One cast, at the one seam that needs it.\n      const GlueField = form.Field as unknown as Component;\n      return () =>\n        h(\n          GlueField,\n          {\n            name: `${path}[${props.index}].${props.name}`,\n            isDisabled: props.isDisabled,\n            isRequired: props.isRequired,\n            isReadOnly: props.isReadOnly,\n          },\n          {\n            // The one `unknown → element` cast — sound by construction (`${path}[${index}].${name}` is `TItem[name]`).\n            default: (field: AppFieldApi<unknown>) => slots.default?.(field as AppFieldApi<TItem[keyof TItem & string]>),\n          },\n        );\n    },\n  }) as unknown as FieldArrayField<TItem>;\n\n  // Each op moves the keys the SAME way it moves the rows, publishes the new list, then delegates\n  // to `form.array` (the adapter reindexes row-scoped errors + touched). The list is REPLACED, not\n  // mutated, so swap/move — which keep the length — still publish.\n  const apply = (mutateKeys: (keys: string[]) => void, run: () => void): void => {\n    const next = [...keysRef.value];\n    mutateKeys(next);\n    keysRef.value = next;\n    run();\n  };\n\n  return {\n    get rows() {\n      return rows.value;\n    },\n    get length() {\n      return rows.value.length;\n    },\n    Field,\n    push: (value: TItem) => apply((next) => next.push(makeKey(seq)), () => ops.push(value)),\n    insert: (index: number, value: TItem) =>\n      apply((next) => next.splice(index, 0, makeKey(seq)), () => ops.insert(index, value)),\n    remove: (index: number) => apply((next) => next.splice(index, 1), () => ops.remove(index)),\n    swap: (indexA: number, indexB: number) =>\n      apply((next) => swapKeys(next, indexA, indexB), () => ops.swap(indexA, indexB)),\n    move: (fromIndex: number, toIndex: number) =>\n      apply((next) => moveKey(next, fromIndex, toIndex), () => ops.move(fromIndex, toIndex)),\n  };\n}\n"],"names":["h"],"mappings":"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"}

package/dist/forms-engine/tanstack/TanstackFormOverlay.d.ts

@@ -0,0 +1,49 @@
+import { ShallowRef } from 'vue';
+import { ApiError } from '../../foundation/http';
+import { ArrayOperation } from '../Paths';
+import { SubmitFailureResolution } from '../SubmitErrors';
+type ErrorMap = Readonly<Record<string, readonly string[]>>;
+/** The adapter-owned slice merged with TanStack state into the contract's form/field state. */
+export interface TanstackOverlayState<TValues extends object> {
+    /** The dirty baseline — `reset(next)` re-seeds it. */
+    readonly baseline: TValues;
+    /** The server-error overlay, keyed by form path (`rules[0].destination`). */
+    readonly serverErrors: ErrorMap;
+    readonly touched: ReadonlySet<string>;
+    readonly submitCount: number;
+    readonly isSubmitting: boolean;
+    readonly submitError: ApiError | null;
+    /** The last completed submit's verdict — `null` until the first attempt completes and after `reset()`. */
+    readonly isSubmitSuccessful: boolean | null;
+}
+/** The overlay store the tanstack adapter combines with the TanStack form store. */
+export interface TanstackFormOverlay<TValues extends object> {
+    /** The reactive seam — reading `state.value` subscribes, the way `subscribe` + `useSyncExternalStore` did in React. */
+    readonly state: Readonly<ShallowRef<TanstackOverlayState<TValues>>>;
+    readonly getState: () => TanstackOverlayState<TValues>;
+    /** Marks a field touched (wired onto the control's blur). */
+    readonly markBlurred: (path: string) => void;
+    /** Server messages clear on the next change to the field (contract JSDoc). */
+    readonly clearServerErrorsAt: (path: string) => void;
+    /** Row-scoped server errors + touched marks follow their rows through array ops. */
+    readonly remapForArrayOperation: (arrayPath: string, operation: ArrayOperation) => void;
+    /** A new attempt clears the previous server errors + submitError, re-arms the verdict, and counts as touching everything. */
+    readonly beginSubmitAttempt: () => void;
+    /** Marks every field touched (`submitCount > 0`) WITHOUT clearing errors or the verdict — `validate()`'s display gate. */
+    readonly touchAll: () => void;
+    /** Brackets the app's `onSubmit` call — the contract's `isSubmitting` window. */
+    readonly setSubmitting: (isSubmitting: boolean) => void;
+    /** Settles the last completed submit's verdict (`handleSubmit` mirrors it into `isSubmitSuccessful`). */
+    readonly setSubmitSuccessful: (value: boolean | null) => void;
+    /** Lands a resolved submit failure: matches as the server overlay, remainder as `submitError`. */
+    readonly applySubmitFailure: (resolution: SubmitFailureResolution) => void;
+    /** Replaces the server-error overlay (`setFieldErrors`). */
+    readonly replaceServerErrors: (errors: Record<string, string[]>) => void;
+    /** Clears the form-level `submitError` without touching field errors (`clearSubmitError`). */
+    readonly clearSubmitError: () => void;
+    /** Clears everything and re-seeds the dirty baseline. */
+    readonly reset: (baseline: TValues) => void;
+}
+/** Creates the adapter-owned overlay store seeded with the initial dirty baseline. */
+export declare function createTanstackFormOverlay<TValues extends object>(initialBaseline: TValues): TanstackFormOverlay<TValues>;
+export {};

package/dist/forms-engine/tanstack/UseAppForm.d.ts

@@ -0,0 +1,26 @@
+import { FormApi, FormAsyncValidateOrFn, VueFormApi } from '@tanstack/vue-form';
+import { AppForm, AppFormOptionsSource } from '../AppForm';
+/** The native TanStack form instance the adapter builds — what `form.engine` exposes. */
+export type TanstackFormEngine<TValues extends object> = FormApi<TValues, undefined, // onMount
+undefined, // onChange
+undefined, // onChangeAsync
+undefined, // onBlur
+undefined, // onBlurAsync
+undefined, // onSubmit
+undefined, // onSubmitAsync
+undefined, // onDynamic
+FormAsyncValidateOrFn<TValues>, // onDynamicAsync — the adapter's schema bridge
+undefined, // onServer
+never> & VueFormApi<TValues, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, FormAsyncValidateOrFn<TValues>, undefined, never>;
+/**
+ * The tanstack adapter's `useAppForm` — the facade contract over `@tanstack/vue-form`.
+ * The returned form object is stable for the owning scope's lifetime and every state member on
+ * it is a live getter, so `form.values.title` / `form.state.isSubmitting` read in a template ARE
+ * the subscription; `form.engine` exposes the native {@link TanstackFormEngine} (the 90/10
+ * escape hatch — typed here, `unknown` on the shared contract), including TanStack's typed
+ * deep-path `Field`/`Subscribe` and per-field validator graph.
+ *
+ * Call it in `setup()`: `useForm` registers an `onMounted` of its own, and the store bridge +
+ * the pending `submitOn: 'change'` timer release on scope teardown.
+ */
+export declare function useAppForm<TValues extends object>(options: AppFormOptionsSource<TValues>): AppForm<TValues, TanstackFormEngine<TValues>>;