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

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

@@ -1,55 +0,0 @@
-import { Ref } from 'vue';
-import { AppFieldApi, AppFieldComponent, AppFormState } from './AppForm';
-/** The per-field read slice an engine hands back — both adapters' internal field states satisfy it. */
-export interface FieldSlice {
-    readonly value: unknown;
-    readonly errors: readonly string[];
-    readonly isDirty: boolean;
-    readonly isTouched: boolean;
-}
-/** The per-field write seam an engine hands in. */
-export interface FieldOps {
-    readonly getState: (path: string) => FieldSlice;
-    readonly setValue: (path: string, value: unknown) => void;
-    readonly blur: (path: string) => void;
-}
-/**
- * Builds one path's field API — every member a live getter, so a read inside a template /
- * `computed` subscribes to exactly that field. `value` is writable, which is what makes
- * `v-model="field.value"` bind a control with no handler.
- *
- * EVERY READ GOES THROUGH ONE `computed`, and that is what makes the subscription per-FIELD rather
- * than per-form. An engine commits by replacing one state object, so a raw getter would wake every
- * reader in the form on any commit — the "form-wide re-render" the contract exists to avoid. A
- * `computed` only notifies when its value changes, and `ops.getState` hands back the SAME slice
- * object while nothing about the field moved (both engines cache per-path identity), so a control
- * re-renders on its own edits and sits still through everyone else's. It is the bail-out React got
- * from `useSyncExternalStore`'s selector cache, in one line.
- *
- * Adapters memoize this per path: the object identity is then stable across commits, so a slot
- * payload does not churn.
- */
-export declare function createFieldApi(path: string, ops: FieldOps): AppFieldApi<unknown>;
-/**
- * Builds the `form.state` view — live getters, each backed by its OWN `computed`, so a reader of
- * `state.isSubmitting` wakes when that flag flips and stays asleep through every unrelated commit.
- * `values` is one computed too: it re-emits when the values object is replaced (any field write),
- * which is the granularity a whole-values read can have — narrow further with a `computed` of your
- * own, or with `form.useFormState`.
- */
-export declare function createFormStateView<TValues extends object>(getFormState: () => AppFormState<TValues>): AppFormState<TValues>;
-/**
- * Builds `form.useFormState` — a selected slice as a `Ref`. Without `isEqual` it is a plain
- * `computed`. With one, the previous slice is HELD when the comparison says nothing changed:
- * `computed` only ever compares with `Object.is`, so a composite selector (`() => ({a, b})`)
- * would otherwise hand every downstream effect a fresh object on every store commit.
- */
-export declare function createUseFormState<TValues extends object>(getFormState: () => AppFormState<TValues>): <TSlice>(selector: (state: AppFormState<TValues>) => TSlice, isEqual?: (a: TSlice, b: TSlice) => boolean) => Readonly<Ref<TSlice>>;
-/**
- * Builds the `form.Field` component from an adapter's per-field accessor.
- * `getFieldApi(path)` returns a live-getter API object for that path — the adapter memoizes it
- * per path, so a slot payload keeps its identity across commits. `isFormDisabled` (optional)
- * reads the whole-form `isDisabled` option per render and ORs it into every field's
- * control-disabled flag — the lowest-leverage read-only / role-locked path.
- */
-export declare function createFieldComponent<TValues extends object>(getFieldApi: (path: string) => AppFieldApi<unknown>, isFormDisabled?: () => boolean): AppFieldComponent<TValues>;

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

@@ -1,47 +0,0 @@
-/** A parsed path segment — a property name or an array index. */
-export type PathKey = string | number;
-/** An array mutation at a path — the vocabulary `AppArrayApi` compiles down to. */
-export type ArrayOperation = {
-    readonly kind: 'push';
-    readonly value: unknown;
-} | {
-    readonly kind: 'insert';
-    readonly index: number;
-    readonly value: unknown;
-} | {
-    readonly kind: 'remove';
-    readonly index: number;
-} | {
-    readonly kind: 'swap';
-    readonly indexA: number;
-    readonly indexB: number;
-} | {
-    readonly kind: 'move';
-    readonly fromIndex: number;
-    readonly toIndex: number;
-};
-/** Parses `'rules[0].destination'` into `['rules', 0, 'destination']`. Tolerant of empty segments; never throws. */
-export declare function parsePath(path: string): readonly PathKey[];
-/** Formats parsed segments back into the canonical string form (`['rules', 0] → 'rules[0]'`). */
-export declare function formatPath(segments: readonly PathKey[]): string;
-/** Reads the value at a path; `undefined` when any hop is missing or non-object. */
-export declare function getPath(target: unknown, path: string): unknown;
-/**
- * Checks structural presence of a path — used to decide whether a mapped server
- * error path "matches a field". Array hops require the index to be in range.
- */
-export declare function hasPath(target: unknown, path: string): boolean;
-/** Sets the value at a path immutably — clones only the spine, keeps untouched branches by reference. */
-export declare function setPath<T>(target: T, path: string, value: unknown): T;
-/** Applies an array operation to a row array in place (callers pass a fresh copy). Indices are assumed in range. */
-export declare function mutateRows(rows: unknown[], operation: ArrayOperation): void;
-/**
- * Remaps a single row-scoped path key (`rules[1].destination`) through an array
- * operation at `arrayPath`. Returns the key unchanged when it does not sit under
- * a row of that array, or `null` when its row was removed.
- */
-export declare function remapPathKey(key: string, arrayPath: string, operation: ArrayOperation): string | null;
-/** Remaps every row-scoped key of an error map through an array operation; removed-row entries drop. */
-export declare function remapPathMap(map: Readonly<Record<string, readonly string[]>>, arrayPath: string, operation: ArrayOperation): Readonly<Record<string, readonly string[]>>;
-/** Remaps every row-scoped member of a touched set through an array operation; removed-row entries drop. */
-export declare function remapPathSet(set: ReadonlySet<string>, arrayPath: string, operation: ArrayOperation): ReadonlySet<string>;

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

@@ -1,29 +0,0 @@
-import { ResolveValidationMessage, ValidationMessageCatalogue } from '../foundation/validation';
-import { StandardSchemaV1 } from './StandardSchema';
-/** Normalizes a spec issue path (`PropertyKey | { key }` segments) to the canonical string form. */
-export declare function issuePathToString(path: StandardSchemaV1.Issue['path']): string;
-/** Folds failure issues into `path → messages`; a success result yields `{}`. */
-export declare function resultToFieldErrors(result: StandardSchemaV1.Result<unknown>): Record<string, string[]>;
-/**
- * Validates `values` against a Standard Schema. Sync schemas resolve synchronously
- * (no promise tick between a change and its errors); async schemas return a promise —
- * the engine's `isValidating` covers them.
- *
- * `resolveMessage` renders a house validator's issues through the form's message catalogue; it has no
- * effect on a third-party spec schema, whose codes the spec already erased.
- */
-export declare function runStandardSchema<TValues extends object>(schema: StandardSchemaV1<TValues>, values: TValues, resolveMessage?: ResolveValidationMessage): Record<string, string[]> | Promise<Record<string, string[]>>;
-/** The options an adapter reads a message resolver from — the `messages` / `labels` cluster alone. */
-interface MessageOptions {
-    readonly messages?: ValidationMessageCatalogue;
-    readonly labels?: Readonly<Record<string, string>>;
-}
-/**
- * Memoizes the form's message resolver against the identity of its `messages` / `labels` options —
- * an adapter calls this on every validation run and every submit failure, and `createMessageResolver`
- * merges a table over the defaults each time it is called. Shared by both in-repo adapters; an
- * adapter author wanting the catalogue wires this once and passes the result to `runStandardSchema` and
- * `resolveSubmitFailure`.
- */
-export declare function createOptionsMessageResolver(getOptions: () => MessageOptions): () => ResolveValidationMessage;
-export {};

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

@@ -1,33 +0,0 @@
-import { ApiError } from '../foundation/http';
-import { FieldIssue, ResolveValidationMessage } from '../foundation/validation';
-/** One mapped failure: a bare message, or the wide form carrying its rule code and operands. */
-export type SubmitFieldEntry = string | FieldIssue;
-/** What a `mapSubmitError` returns — server path → its failures. */
-export type SubmitErrorMap = Record<string, readonly SubmitFieldEntry[]>;
-/** Rewrites a server error path onto a form path — camelCase per property segment (`Rules[0].Destination` → `rules[0].destination`). */
-export declare function defaultMapFieldPath(serverPath: string): string;
-/**
- * Coerces any thrown value into the SDK `ApiError` — passes through an `ApiError`, wraps
- * everything else as status `0` (mirrors `/query`'s coercion). `fallbackMessage` is the
- * message for a throw that carries none of its own (not an `ApiError`, `Error`, or string) —
- * overridable for i18n; defaults to the English `'Unknown error'`.
- */
-export declare function toApiError(error: unknown, fallbackMessage?: string): ApiError;
-/** The outcome of resolving a thrown submit error: per-field server errors + the form-level remainder. */
-export interface SubmitFailureResolution {
-    /** Mapped messages whose form path matched a field — apply as the server-error overlay. */
-    readonly fieldErrors: Record<string, string[]>;
-    /** The coerced failure when it was not fully represented on fields (no or partial path matches); `null` when every mapped path landed. */
-    readonly submitError: ApiError | null;
-}
-/**
- * Resolves a thrown submit error: `mapSubmitError` → `mapFieldPath` per entry →
- * partition by `isKnownField`. Matches become field errors; if nothing matched — or
- * some messages could not be placed — the coerced error also lands in `submitError`
- * so no server message silently disappears.
- *
- * `resolveMessage` renders each failure through the form's message catalogue
- * (`createMessageResolver`); omitted, every failure renders the message the server sent. Resolution
- * runs AFTER the path rewrite, so a catalogue entry sees the form path its label is keyed by.
- */
-export declare function resolveSubmitFailure(error: unknown, mapSubmitError: (error: unknown) => SubmitErrorMap, mapFieldPath: (serverPath: string) => string, isKnownField: (path: string) => boolean, fallbackMessage?: string, resolveMessage?: ResolveValidationMessage): SubmitFailureResolution;

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

@@ -1,87 +0,0 @@
-import { PublicProps, Ref, VNode } from 'vue';
-import { AppArrayApi, AppFieldApi, AppFieldProps, AppFormState } from './AppForm';
-/** The slice of the `AppForm` contract the helper consumes — every engine's `AppForm` satisfies it. */
-export interface FieldArrayForm {
-    /** Field wrapper — rendered per cell at the row's element path (`${path}[${index}].${name}`). */
-    readonly Field: FieldArrayGlueField;
-    /** Array ops at a path — the helper's ops delegate here (never reimplemented). */
-    readonly array: (path: string) => AppArrayApi;
-    /** Selector-subscribed form state — the helper subscribes to the array's length only. */
-    readonly useFormState: <TSlice>(selector: (state: AppFormState<unknown>) => TSlice, isEqual?: (a: TSlice, b: TSlice) => boolean) => Readonly<Ref<TSlice>>;
-}
-/**
- * The loose (engine-free `AppFieldComponent`) props shape a `form.Field` accepts at a dynamic
- * path — DERIVED from the contract's own props at `TPath = string`, never a second copy of them.
- * A hand-written twin drifts silently and the failure lands on the consumer, as
- * `useFieldArray(form, path)` no longer accepting an `AppForm` at all.
- */
-export type FieldArrayGlueFieldProps = AppFieldProps<string>;
-/**
- * `form.Field` seen loosely — a dynamic path, an untyped cell payload. The slot signature is
- * deliberately `never`-parametered so that an `AppFieldComponent<TValues>` is assignable here for
- * ANY `TValues`, which is what lets one helper serve both adapters; the row cell's real payload
- * type is restored below, on {@link FieldArrayFieldProps}.
- */
-export interface FieldArrayGlueField {
-    new (props: FieldArrayGlueFieldProps): {
-        $props: FieldArrayGlueFieldProps & PublicProps;
-        $slots: {
-            default?: (...args: never[]) => VNode[];
-        };
-    };
-}
-/** One rendered row — a stable `key` for `v-for` (survives reorder) plus its live array index. */
-export interface FieldArrayRow {
-    readonly key: string;
-    readonly index: number;
-}
-/** Props for the typed row-field accessor — binds `${path}[${index}].${name}`, `f.value` typed as `TItem[name]`. */
-export interface FieldArrayFieldProps<TItem extends object, TName extends keyof TItem & string> {
-    /** The row's current array index (from `row.index`). */
-    readonly index: number;
-    /** The element field key — one level deep into `TItem`. */
-    readonly name: TName;
-    readonly isDisabled?: boolean;
-    readonly isRequired?: boolean;
-    readonly isReadOnly?: boolean;
-}
-/** The typed row-field accessor — one level deep (`keyof TItem`), no recursion, no vendor deep-path types. */
-export interface FieldArrayField<TItem extends object> {
-    new <TName extends keyof TItem & string>(props: FieldArrayFieldProps<TItem, TName>): {
-        $props: FieldArrayFieldProps<TItem, TName> & PublicProps;
-        /** `field.value` / `field.setValue` are typed as `TItem[name]` — no cast, and `v-model="f.value"` binds. */
-        $slots: {
-            default?: (field: AppFieldApi<TItem[TName]>) => VNode[];
-        };
-    };
-}
-/** What `useFieldArray` returns — reactive rows + stable keys, a typed row-field accessor, and element-typed ops. */
-export interface FieldArray<TItem extends object> {
-    /** The current rows — `{ key, index }`; render with `:key="row.key"` so a cell keeps identity through reorder. */
-    readonly rows: readonly FieldArrayRow[];
-    /** The current row count. */
-    readonly length: number;
-    /** The typed row-field accessor — `<array.Field :index="row.index" name="destination">`. */
-    readonly Field: FieldArrayField<TItem>;
-    /** Appends a row (typed to the element — a mistyped push is a compile error). Delegates to `form.array`. */
-    readonly push: (value: TItem) => void;
-    /** Inserts a row at `index`. Delegates to `form.array`. */
-    readonly insert: (index: number, value: TItem) => void;
-    /** Removes the row at `index`. Delegates to `form.array`. */
-    readonly remove: (index: number) => void;
-    /** Swaps two rows. Delegates to `form.array`. */
-    readonly swap: (indexA: number, indexB: number) => void;
-    /** Moves a row. Delegates to `form.array`. */
-    readonly move: (fromIndex: number, toIndex: number) => void;
-}
-/**
- * Row-render helper for the array at `path`. `TItem` is the row element type; row fields bind
- * one level deep (`keyof TItem`), typed, cast-free. Reuses `form.array(path)` for the ops
- * (row + error/touched reindexing stays in the adapter) and subscribes to the array LENGTH
- * only, so a row container re-renders on structural changes but not on per-row field edits —
- * each `array.Field` owns its own value subscription. Works identically on `house` + `tanstack`.
- *
- * `rows` / `length` are live getters, so `v-for="row in array.rows"` reads the current rows on
- * every render; destructuring the returned object takes a snapshot of both.
- */
-export declare function useFieldArray<TItem extends object>(form: FieldArrayForm, path: string): FieldArray<TItem>;

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

@@ -1,33 +0,0 @@
-import { ShallowRef } from 'vue';
-import { AppFormOptions, AppFormState } from '../AppForm';
-import { ArrayOperation } from '../Paths';
-/** The per-field slice the `Field` glue reads — identity-stable while its members are unchanged. */
-export interface HouseFieldState {
-    readonly value: unknown;
-    readonly errors: readonly string[];
-    readonly isDirty: boolean;
-    readonly isTouched: boolean;
-}
-/** The native house form instance — what `form.engine` exposes on the house adapter. */
-export interface HouseFormEngine<TValues extends object> {
-    /**
-     * The raw store. Reading `state.value` inside a `computed` / render / `watchEffect` subscribes
-     * to it — the reactive seam that replaces React's `subscribe` + `useSyncExternalStore` pair.
-     */
-    readonly state: Readonly<ShallowRef<unknown>>;
-    readonly getFormState: () => AppFormState<TValues>;
-    readonly getFieldState: (path: string) => HouseFieldState;
-    readonly setValue: (path: string, value: unknown) => void;
-    readonly blurField: (path: string) => void;
-    readonly applyArrayOperation: (path: string, operation: ArrayOperation) => void;
-    readonly reset: (next?: TValues) => void;
-    readonly setFieldErrors: (errors: Record<string, string[]>) => void;
-    readonly clearSubmitError: () => void;
-    readonly submit: () => Promise<boolean>;
-    /** Validates without submitting — populates errors, marks touched, resolves client validity. */
-    readonly validate: () => Promise<boolean>;
-    /** Releases the pending auto-submit timer (`submitOn: 'change'`) on scope teardown. */
-    readonly dispose: () => void;
-}
-/** Creates the house form store. `getOptions` reads the latest options (`AppFormOptionsSource`). */
-export declare function createHouseFormEngine<TValues extends object>(getOptions: () => AppFormOptions<TValues>): HouseFormEngine<TValues>;

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

@@ -1,16 +0,0 @@
-import { AppForm, AppFormOptionsSource } from '../AppForm';
-import { HouseFormEngine } from './HouseFormCore';
-/**
- * The house adapter's `useAppForm` — the facade contract over the zero-dependency
- * micro-store. 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 HouseFormEngine}
- * (the 90/10 escape hatch — typed here, `unknown` on the shared contract).
- *
- * Pass a getter / ref when an option must stay live (see `AppFormOptionsSource`); a plain object
- * is read once, which is what `defaultValues` + a closure `onSubmit` want.
- *
- * Call it in `setup()`: the pending `submitOn: 'change'` timer is released on scope teardown,
- * which is the whole of React's unmount effect here.
- */
-export declare function useAppForm<TValues extends object>(options: AppFormOptionsSource<TValues>): AppForm<TValues, HouseFormEngine<TValues>>;

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

@@ -1,315 +0,0 @@
-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