@holo-js/forms 0.3.15 → 0.3.17

package/dist/{contracts-BOhBkI9c.d.ts → contracts-CJ9Aq8pS.d.ts}

@@ -1,5 +1,4 @@
-import { ValidationSchema, SchemaInputShape, ValidationErrorBag, InferSchemaData, FormLikeValidationInput } from '@holo-js/validation';
-import { FormSchema } from './schema.js';
+import { ValidationSchema, SchemaInputShape, ValidationErrorBag, InferValidationSchemaData, InferSchemaData, FormLikeValidationInput } from '@holo-js/validation';
 
 type FormFailureErrors = Readonly<Partial<Record<string, readonly string[]>>>;
 interface FormFailureOptions {
@@ -17,6 +16,7 @@ declare const sensitiveInputInternals: {
     DEFAULT_DONT_FLASH_FIELDS: readonly string[];
 };
 
+type InferFormData<TSchema extends ValidationSchema> = InferValidationSchemaData<TSchema>;
 interface FormFailurePayload<TData> {
     readonly ok: false;
     readonly status: number;
@@ -109,15 +109,15 @@ interface FormSubmissionFailure<TData> {
     fail(options: FormFailureOptions): FormFailurePayload<TData>;
 }
 type FormSubmissionResult<TData> = FormSubmissionSuccess<TData> | FormSubmissionFailure<TData>;
-declare function serializeSubmissionState<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>, schemaDefinition?: FormSchema): SerializedFormSubmission<TData>;
-declare function createSubmission<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>, failureStatus?: number, schemaDefinition?: FormSchema, failureMetadata?: FormFailureMetadata): FormSubmissionResult<TData>;
-declare function createSuccessfulSubmission<TShape extends SchemaInputShape>(schemaDefinition: FormSchema<TShape>, data: InferSchemaData<TShape>): FormSubmissionSuccess<InferSchemaData<TShape>>;
-declare function createFailedSubmission<TShape extends SchemaInputShape>(schemaDefinition: FormSchema<TShape>, values: Partial<InferSchemaData<TShape>>, flattenedErrors: Record<string, readonly string[]>, status?: number, failureMetadata?: FormFailureMetadata): FormSubmissionFailure<InferSchemaData<TShape>>;
+declare function serializeSubmissionState<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>, schemaDefinition?: ValidationSchema): SerializedFormSubmission<TData>;
+declare function createSubmission<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>, failureStatus?: number, schemaDefinition?: ValidationSchema, failureMetadata?: FormFailureMetadata): FormSubmissionResult<TData>;
+declare function createSuccessfulSubmission<TShape extends SchemaInputShape>(schemaDefinition: ValidationSchema<TShape>, data: InferSchemaData<TShape>): FormSubmissionSuccess<InferSchemaData<TShape>>;
+declare function createFailedSubmission<TShape extends SchemaInputShape>(schemaDefinition: ValidationSchema<TShape>, values: Partial<InferSchemaData<TShape>>, flattenedErrors: Record<string, readonly string[]>, status?: number, failureMetadata?: FormFailureMetadata): FormSubmissionFailure<InferSchemaData<TShape>>;
 declare function isRequestLikeHeaders(value: unknown): value is RequestLikeHeaders;
 declare function normalizeRequestHeaders(input: unknown): Headers;
 declare function normalizeRequestLikeInput(input: FormLikeValidationInput | FormRequestLikeInput | null | undefined): Request | undefined;
-declare function safeParse<TShape extends SchemaInputShape>(input: FormLikeValidationInput | FormRequestLikeInput, schemaDefinition: FormSchema<TShape>, options?: FormSecurityOptions): Promise<FormSubmissionResult<InferSchemaData<TShape>>>;
-declare function validate<TShape extends SchemaInputShape>(input: FormLikeValidationInput | FormRequestLikeInput, schemaDefinition: FormSchema<TShape>, options?: FormSecurityOptions): Promise<InferSchemaData<TShape>>;
+declare function safeParse<TShape extends SchemaInputShape>(input: FormLikeValidationInput | FormRequestLikeInput, schemaDefinition: ValidationSchema<TShape>, options?: FormSecurityOptions): Promise<FormSubmissionResult<InferSchemaData<TShape>>>;
+declare function validate<TShape extends SchemaInputShape>(input: FormLikeValidationInput | FormRequestLikeInput, schemaDefinition: ValidationSchema<TShape>, options?: FormSecurityOptions): Promise<InferSchemaData<TShape>>;
 declare const formsInternals: {
     createSubmission: typeof createSubmission;
     isRequestLikeHeaders: typeof isRequestLikeHeaders;
@@ -129,4 +129,4 @@ declare const formsInternals: {
     serializeSubmissionState: typeof serializeSubmissionState;
 };
 
-export { type FormFailureErrors as F, type SerializedFormSubmission as S, type FormFailureInput as a, type FormFailureOptions as b, type FormFailurePayload as c, type FormRequestLikeInput as d, type FormSecurityOptions as e, type FormSubmissionFailure as f, type FormSubmissionResult as g, type FormSubmissionSuccess as h, type FormSuccessPayload as i, createFailedSubmission as j, createSuccessfulSubmission as k, formsInternals as l, sanitizeFlashedInput as m, sensitiveInputInternals as n, safeParse as s, validate as v };
+export { type FormFailureErrors as F, type InferFormData as I, type SerializedFormSubmission as S, type FormFailureInput as a, type FormFailureOptions as b, type FormFailurePayload as c, type FormRequestLikeInput as d, type FormSecurityOptions as e, type FormSubmissionFailure as f, type FormSubmissionResult as g, type FormSubmissionSuccess as h, type FormSuccessPayload as i, createFailedSubmission as j, createSuccessfulSubmission as k, formsInternals as l, sanitizeFlashedInput as m, sensitiveInputInternals as n, safeParse as s, validate as v };

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-export { F as FormFailureErrors, a as FormFailureInput, b as FormFailureOptions, c as FormFailurePayload, d as FormRequestLikeInput, e as FormSecurityOptions, f as FormSubmissionFailure, g as FormSubmissionResult, h as FormSubmissionSuccess, i as FormSuccessPayload, S as SerializedFormSubmission, j as createFailedSubmission, k as createSuccessfulSubmission, l as formsInternals, s as safeParse, m as sanitizeFlashedInput, n as sensitiveInputInternals, v as validate } from './contracts-BOhBkI9c.js';
-export { FormSchema, InferFormData, isFormSchema, schema } from './schema.js';
-export { DEFAULT_VALIDATION_BAG, ErrorTree, ErrorTreeNode, FieldDefinition, FieldRule, InferSchemaData, SerializedValidationException, StandardSchemaV1, StandardSchemaV1Issue, StandardSchemaV1Props, StandardSchemaV1Result, ValidationErrorBag, ValidationException, ValidationExceptionOptions, ValidationFailure, ValidationResult, ValidationSchema, ValidationSuccess, WebFileLike, createErrorBag, defineSchema, field, isValidationException, parse } from '@holo-js/validation';
+export { F as FormFailureErrors, a as FormFailureInput, b as FormFailureOptions, c as FormFailurePayload, d as FormRequestLikeInput, e as FormSecurityOptions, f as FormSubmissionFailure, g as FormSubmissionResult, h as FormSubmissionSuccess, i as FormSuccessPayload, I as InferFormData, S as SerializedFormSubmission, j as createFailedSubmission, k as createSuccessfulSubmission, l as formsInternals, s as safeParse, m as sanitizeFlashedInput, n as sensitiveInputInternals, v as validate } from './contracts-CJ9Aq8pS.js';
+import '@holo-js/validation';
 
 declare class FormContractError extends Error {
     constructor(message: string);

package/dist/index.mjs

@@ -1,14 +1,3 @@
-import {
-  DEFAULT_VALIDATION_BAG,
-  ValidationException,
-  createErrorBag,
-  defineSchema,
-  field,
-  isFormSchema,
-  isValidationException,
-  parse,
-  schema
-} from "./chunk-GPWXGHZE.mjs";
 import {
   normalizeFailureErrors,
   normalizeFailureInput,
@@ -22,8 +11,8 @@ import {
 
 // src/contracts.ts
 import {
-  ValidationException as ValidationException2,
-  createErrorBag as createErrorBag2,
+  ValidationException,
+  createErrorBag,
   safeParse as safeParseInput,
   validationInternals
 } from "@holo-js/validation";
@@ -89,7 +78,7 @@ function createSuccessfulSubmission(schemaDefinition, data) {
   return createSubmission(
     true,
     data,
-    createErrorBag2(),
+    createErrorBag(),
     422,
     schemaDefinition
   );
@@ -100,7 +89,7 @@ function createFailedSubmission(schemaDefinition, values, flattenedErrors, statu
   return createSubmission(
     false,
     values,
-    createErrorBag2(flattenedErrors),
+    createErrorBag(flattenedErrors),
     normalizedStatus,
     schemaDefinition,
     failureMetadata
@@ -479,7 +468,7 @@ async function validate(input, schemaDefinition, options = {}) {
   }
   const failure = result.fail();
   const exception = validationInternals.setValidationExceptionValues(
-    ValidationException2.withMessages(result.errors.flatten(), {
+    ValidationException.withMessages(result.errors.flatten(), {
       bag: options.bag
     }),
     result.values
@@ -502,21 +491,12 @@ var formsInternals = {
   serializeSubmissionState
 };
 export {
-  DEFAULT_VALIDATION_BAG,
   FormContractError,
-  ValidationException,
-  createErrorBag,
   createFailedSubmission,
   createSuccessfulSubmission,
-  defineSchema,
-  field,
   formsInternals,
-  isFormSchema,
-  isValidationException,
-  parse,
   safeParse,
   sanitizeFlashedInput,
-  schema,
   sensitiveInputInternals,
   validate
 };

package/dist/internal/client.d.ts

@@ -1,6 +1,5 @@
-import { S as SerializedFormSubmission, c as FormFailurePayload, i as FormSuccessPayload, g as FormSubmissionResult } from '../contracts-BOhBkI9c.js';
-import { ValidationErrorBag, WebFileLike, SchemaInputShape, FieldBuilderInput, InferFieldOutput } from '@holo-js/validation';
-import { FormSchema, InferFormData } from '../schema.js';
+import { S as SerializedFormSubmission, c as FormFailurePayload, i as FormSuccessPayload, g as FormSubmissionResult, I as InferFormData } from '../contracts-CJ9Aq8pS.js';
+import { ValidationErrorBag, WebFileLike, ValidationSchema, SchemaInputShape, FieldBuilderInput, InferFieldOutput } from '@holo-js/validation';
 
 declare function collectFormDirtyPaths(current: unknown, initial: unknown, prefix?: string): readonly string[];
 declare class FormClientState<TValues, TSuccess = unknown> {
@@ -8,21 +7,35 @@ declare class FormClientState<TValues, TSuccess = unknown> {
     values: TValues;
     initialValues: TValues;
     flattenedErrors: Record<string, readonly string[]>;
-    touched: Set<string>;
-    dirty: Set<string>;
+    readonly touched: Set<string>;
     lastSubmission?: SerializedFormSubmission<TValues> | FormFailurePayload<TValues> | FormSuccessPayload<TSuccess>;
     readonly listeners: Set<() => void>;
-    validationSequence: number;
     constructor(values: TValues, initialState?: SerializedFormSubmission<TValues> | FormFailurePayload<TValues>);
     get submitting(): boolean;
     get errors(): ValidationErrorBag<TValues>;
     get dirtyPaths(): readonly string[];
-    replace(values: TValues, initialValues: TValues, errors: Record<string, readonly string[]>, touched: ReadonlySet<string>): void;
+    notify(): void;
+    invalidateEffects(): void;
+    beginValidation(): number;
+    isLatestValidation(sequence: number): boolean;
+    beginSubmissionEffects(): number;
+    ownsSubmissionEffects(sequence: number): boolean;
+    touch(path: string): void;
+    edit(path: string, value: unknown): void;
+    isDirty(path: string): boolean;
+    applyValidation(sequence: number, errors: Record<string, readonly string[]>, values?: Partial<TValues>): void;
+    applyFieldValidation(sequence: number, path: string, errors: Record<string, readonly string[]>): void;
+    applyServer(values: TValues, errors: Record<string, readonly string[]>, submission: FormClientState<TValues, TSuccess>['lastSubmission']): void;
+    reset(values?: Partial<TValues>): void;
     startSubmission(signal?: AbortSignal): () => void;
 }
 
 type PrimitiveLike = string | number | boolean | bigint | symbol | null | undefined | Date | Blob | WebFileLike;
 type ValidateOnMode = 'submit' | 'blur' | 'change';
+type FormRequestCredentials = 'omit' | 'same-origin' | 'include';
+interface ClientCsrfOptions {
+    readonly endpoint: string;
+}
 interface ClientSubmitContext<TData> {
     readonly action?: string;
     readonly method: string;
@@ -41,6 +54,8 @@ type BrowserFormElement = {
 interface UseFormOptions<TData, TSuccess = unknown> {
     readonly action?: string;
     readonly method?: string;
+    readonly credentials?: FormRequestCredentials;
+    readonly csrf?: ClientCsrfOptions;
     readonly validateOn?: ValidateOnMode;
     readonly initialValues?: Partial<TData>;
     readonly initialState?: SerializedFormSubmission<TData> | FormFailurePayload<TData> | null;
@@ -63,7 +78,7 @@ type FormFieldTree<TData> = [TData] extends [readonly unknown[]] ? FormFieldStat
 type FormFieldTreeFromShape<TShape extends SchemaInputShape> = {
     readonly [K in Extract<keyof TShape, string>]: TShape[K] extends FieldBuilderInput ? FormFieldState<InferFieldOutput<TShape[K]>> : TShape[K] extends SchemaInputShape ? FormFieldTreeFromShape<TShape[K]> : never;
 };
-type InferFormFieldTree<TSchema extends FormSchema> = TSchema extends FormSchema<infer TShape> ? FormFieldTreeFromShape<TShape> : never;
+type InferFormFieldTree<TSchema extends ValidationSchema> = TSchema extends ValidationSchema<infer TShape> ? FormFieldTreeFromShape<TShape> : never;
 interface UseFormResult<TData, TSuccess = unknown, TFields = FormFieldTree<TData>> {
     readonly fields: TFields;
     readonly values: TData;
@@ -83,6 +98,6 @@ declare function runWithBrowserFormElement<TData, TSuccess>(formClient: Pick<Use
 /**
  * @internal Shared headless form runtime for framework adapters.
  */
-declare function createFormClient<TSchema extends FormSchema, TSuccess = unknown>(schemaDefinition: TSchema, options?: UseFormOptions<InferFormData<TSchema>, TSuccess>): UseFormResult<InferFormData<TSchema>, TSuccess, InferFormFieldTree<TSchema>>;
+declare function createFormClient<TSchema extends ValidationSchema, TSuccess = unknown>(schemaDefinition: TSchema, options?: UseFormOptions<InferFormData<TSchema>, TSuccess>): UseFormResult<InferFormData<TSchema>, TSuccess, InferFormFieldTree<TSchema>>;
 
-export { type ClientSubmitContext, type ClientSubmitResult, FormClientState, type FormFieldState, type FormFieldTree, type InferFormFieldTree, type UseFormOptions, type UseFormResult, type ValidateOnMode, collectFormDirtyPaths, createFormClient, markClientSubmitControlFlowError, runWithBrowserFormElement };
+export { type ClientCsrfOptions, type ClientSubmitContext, type ClientSubmitResult, FormClientState, type FormFieldState, type FormFieldTree, type FormRequestCredentials, type InferFormFieldTree, type UseFormOptions, type UseFormResult, type ValidateOnMode, collectFormDirtyPaths, createFormClient, markClientSubmitControlFlowError, runWithBrowserFormElement };

package/dist/internal/client.mjs

@@ -275,10 +275,10 @@ var FormClientState = class {
   initialValues;
   flattenedErrors;
   touched = /* @__PURE__ */ new Set();
-  dirty = /* @__PURE__ */ new Set();
   lastSubmission;
   listeners = /* @__PURE__ */ new Set();
-  validationSequence = 0;
+  #validationSequence = 0;
+  #submissionSequence = 0;
   #submissions = /* @__PURE__ */ new Set();
   constructor(values, initialState) {
     this.values = cloneFormValue(values);
@@ -295,12 +295,68 @@ var FormClientState = class {
   get dirtyPaths() {
     return collectFormDirtyPaths(this.values, this.initialValues);
   }
-  replace(values, initialValues, errors, touched) {
+  notify() {
+    for (const listener of this.listeners) listener();
+  }
+  invalidateEffects() {
+    this.#validationSequence += 1;
+    this.#submissionSequence += 1;
+  }
+  beginValidation() {
+    return ++this.#validationSequence;
+  }
+  isLatestValidation(sequence) {
+    return sequence === this.#validationSequence;
+  }
+  beginSubmissionEffects() {
+    this.#validationSequence += 1;
+    return ++this.#submissionSequence;
+  }
+  ownsSubmissionEffects(sequence) {
+    return sequence === this.#submissionSequence;
+  }
+  touch(path) {
+    this.touched.add(path);
+  }
+  edit(path, value) {
+    this.invalidateEffects();
+    setFormValueAtPath(this.values, path, value);
+    this.touch(path);
+  }
+  isDirty(path) {
+    return !areFormValuesEqual(getFormValueAtPath(this.values, path), getFormValueAtPath(this.initialValues, path));
+  }
+  applyValidation(sequence, errors, values) {
+    if (!this.isLatestValidation(sequence)) return;
+    if (values) this.values = mergeFormValues(this.values, values);
+    this.flattenedErrors = errors;
+    this.notify();
+  }
+  applyFieldValidation(sequence, path, errors) {
+    if (!this.isLatestValidation(sequence)) return;
+    const prefix = `${path}.`;
+    const merged = Object.fromEntries(Object.entries(this.flattenedErrors).filter(([key]) => key !== path && !key.startsWith(prefix)));
+    for (const [key, messages] of Object.entries(errors)) {
+      if (key === path || key.startsWith(prefix)) merged[key] = messages;
+    }
+    this.applyValidation(sequence, merged);
+  }
+  applyServer(values, errors, submission) {
+    this.#validationSequence += 1;
     this.values = values;
-    this.initialValues = initialValues;
     this.flattenedErrors = errors;
-    this.touched = new Set(touched);
-    this.dirty = new Set(this.dirtyPaths);
+    this.lastSubmission = submission;
+    this.notify();
+  }
+  reset(values) {
+    const next = mergeFormValues(this.initialValues, values);
+    this.invalidateEffects();
+    this.values = cloneFormValue(next);
+    this.initialValues = cloneFormValue(next);
+    this.flattenedErrors = {};
+    this.touched.clear();
+    this.lastSubmission = void 0;
+    this.notify();
   }
   startSubmission(signal) {
     const id = /* @__PURE__ */ Symbol();
@@ -446,36 +502,12 @@ async function runWithBrowserFormElement(formClient, form) {
   }
   return await formClient.submit();
 }
-function notifyListeners(state) {
-  for (const listener of state.listeners) {
-    listener();
-  }
-}
-function nextValidationSequence(state) {
-  state.validationSequence += 1;
-  return state.validationSequence;
-}
-function isLatestValidation(state, sequence) {
-  return sequence === state.validationSequence;
-}
 function collectErrorsForPath(flattenedErrors, path) {
   const direct = flattenedErrors[path] ?? [];
   const prefix = `${path}.`;
   const nested = Object.entries(flattenedErrors).filter(([key]) => key.startsWith(prefix)).flatMap(([, messages]) => messages);
   return direct.length > 0 || nested.length > 0 ? [...direct, ...nested] : [];
 }
-function replaceErrorsForPath(flattenedErrors, path, nextErrors) {
-  const prefix = `${path}.`;
-  const merged = Object.fromEntries(
-    Object.entries(flattenedErrors).filter(([key]) => key !== path && !key.startsWith(prefix))
-  );
-  for (const [key, messages] of Object.entries(nextErrors)) {
-    if (key === path || key.startsWith(prefix)) {
-      merged[key] = messages;
-    }
-  }
-  return merged;
-}
 function buildFieldsTree(state, schemaDefinition, source, validateOn, prefix = "") {
   if (isFormLeafValue(source)) {
     const path = prefix;
@@ -493,56 +525,41 @@ function buildFieldsTree(state, schemaDefinition, source, validateOn, prefix = "
         return state.touched.has(path);
       },
       get dirty() {
-        return state.dirty.has(path);
+        return state.isDirty(path);
       },
       async set(value) {
-        setFormValueAtPath(state.values, path, value);
-        state.touched.add(path);
-        if (!areFormValuesEqual(getFormValueAtPath(state.initialValues, path), value)) {
-          state.dirty.add(path);
-        } else {
-          state.dirty.delete(path);
-        }
+        state.edit(path, value);
         if (validateOn === "change") {
-          const sequence = nextValidationSequence(state);
+          const sequence = state.beginValidation();
           const submission = await validateClientValues(
             cloneFormValue(state.values),
             schemaDefinition
           );
-          if (isLatestValidation(state, sequence)) {
-            state.flattenedErrors = submission.errors.flatten();
-          }
+          state.applyValidation(sequence, submission.errors.flatten());
+          return;
         }
-        notifyListeners(state);
+        state.notify();
       },
       async onInput(value) {
         await this.set(value);
       },
       async onBlur() {
-        state.touched.add(path);
+        state.touch(path);
         if (validateOn === "blur") {
-          const sequence = nextValidationSequence(state);
+          const sequence = state.beginValidation();
           const submission = await validateClientValues(
             cloneFormValue(state.values),
             schemaDefinition
           );
-          if (isLatestValidation(state, sequence)) {
-            state.flattenedErrors = replaceErrorsForPath(
-              state.flattenedErrors,
-              path,
-              submission.errors.flatten()
-            );
-          }
+          state.applyFieldValidation(sequence, path, submission.errors.flatten());
+          return;
         }
-        notifyListeners(state);
+        state.notify();
       },
       async validate() {
-        const sequence = nextValidationSequence(state);
+        const sequence = state.beginValidation();
         const submission = await validateClientValues(cloneFormValue(state.values), schemaDefinition);
-        if (isLatestValidation(state, sequence)) {
-          state.flattenedErrors = submission.errors.flatten();
-          notifyListeners(state);
-        }
+        state.applyValidation(sequence, submission.errors.flatten());
         return state.flattenedErrors[path] ?? [];
       }
     });
@@ -601,7 +618,7 @@ function normalizeSubmissionLike(schemaDefinition, values, result) {
       valid: false,
       values: result.values,
       errors: result.errors,
-      ...result.status === 429 && "retryAfter" in result ? { retryAfter: result.retryAfter } : {},
+      ...result.status === 429 && "retryAfterSeconds" in result ? { retryAfterSeconds: result.retryAfterSeconds } : {},
       ...result.status === 429 && "retryAt" in result ? { retryAt: result.retryAt } : {}
     };
   }
@@ -659,7 +676,7 @@ async function normalizeFetchResponse(response, fallbackValues) {
     return createTransportFailure(fallbackValues, response.status);
   }
 }
-async function defaultSubmitter(context) {
+async function defaultSubmitter(context, options) {
   if (typeof fetch !== "function" || !context.action) {
     return {
       ok: true,
@@ -668,9 +685,11 @@ async function defaultSubmitter(context) {
     };
   }
   const method = context.method.toUpperCase();
+  const credentials = options.credentials ? { credentials: options.credentials } : {};
   if (method === "GET" || method === "HEAD") {
     const response2 = await fetch(appendQueryString(context.action, context.formData), {
-      method
+      method,
+      ...credentials
     });
     if (method === "HEAD" || response2.status === 204 || response2.status === 205) {
       return {
@@ -681,8 +700,24 @@ async function defaultSubmitter(context) {
     }
     return await normalizeFetchResponse(response2, context.values);
   }
+  const headers = new Headers();
+  if (options.csrf) {
+    const csrfResponse = await fetch(options.csrf.endpoint, {
+      ...credentials
+    });
+    if (!csrfResponse.ok) {
+      return createTransportFailure(context.values, csrfResponse.status);
+    }
+    const csrfPayload = await csrfResponse.json();
+    if (!csrfPayload || typeof csrfPayload !== "object" || !("token" in csrfPayload) || typeof csrfPayload.token !== "string" || !csrfPayload.token) {
+      return createTransportFailure(context.values);
+    }
+    headers.set("X-CSRF-TOKEN", csrfPayload.token);
+  }
   const response = await fetch(context.action, {
     method,
+    ...credentials,
+    ...options.csrf ? { headers } : {},
     body: context.formData
   });
   return await normalizeFetchResponse(response, context.values);
@@ -710,28 +745,21 @@ function createFormClient(schemaDefinition, options = {}) {
     return await runValidationForInput(cloneFormValue(state.values));
   }
   async function runValidationForInput(input) {
-    const sequence = nextValidationSequence(state);
+    const sequence = state.beginValidation();
     const submission = await validateClientValues(input, schemaDefinition);
-    if (isLatestValidation(state, sequence)) {
-      state.values = mergeFormValues(
-        state.values,
-        submission.valid ? submission.data : submission.values
-      );
-      state.flattenedErrors = submission.errors.flatten();
-      notifyListeners(state);
-    }
+    state.applyValidation(sequence, submission.errors.flatten(), submission.valid ? submission.data : submission.values);
     return submission;
   }
-  function applyServerState(result) {
+  function applyServerState(result, submissionSequence) {
     const normalized = normalizeSubmissionLike(
       schemaDefinition,
       state.values,
       result
     );
+    const applies = submissionSequence === void 0 || state.ownsSubmissionEffects(submissionSequence);
+    if (submissionSequence === void 0) state.invalidateEffects();
     if ("ok" in normalized && normalized.ok === true) {
-      state.lastSubmission = normalized;
-      state.flattenedErrors = {};
-      notifyListeners(state);
+      if (applies) state.applyServer(state.values, {}, normalized);
       return normalized;
     }
     if ("ok" in normalized && normalized.ok === false) {
@@ -739,26 +767,27 @@ function createFormClient(schemaDefinition, options = {}) {
         ...normalized,
         values: sanitizeFlashedInput(normalized.values, schemaDefinition)
       };
-      state.values = mergeFormValues(state.values, sanitized.values);
-      clearSensitiveInputValues(state.values, schemaDefinition);
-      state.flattenedErrors = sanitized.errors;
-      state.lastSubmission = sanitized;
-      notifyListeners(state);
+      if (applies) {
+        const values = mergeFormValues(state.values, sanitized.values);
+        clearSensitiveInputValues(values, schemaDefinition);
+        state.applyServer(values, sanitized.errors, sanitized);
+      }
       return sanitized;
     }
     const normalizedSubmission = normalized;
-    state.values = mergeFormValues(state.values, normalizedSubmission.values);
-    clearSensitiveInputValues(state.values, schemaDefinition);
-    state.flattenedErrors = normalizedSubmission.errors.flatten();
-    state.lastSubmission = normalizedSubmission.valid ? void 0 : normalizedSubmission.fail();
-    notifyListeners(state);
+    if (applies) {
+      const values = mergeFormValues(state.values, normalizedSubmission.values);
+      clearSensitiveInputValues(values, schemaDefinition);
+      state.applyServer(values, normalizedSubmission.errors.flatten(), normalizedSubmission.valid ? void 0 : normalizedSubmission.fail());
+    }
     return normalizedSubmission;
   }
   async function submit(browserForm) {
+    const submissionSequence = state.beginSubmissionEffects();
     const finishSubmission = state.startSubmission();
-    notifyListeners(state);
+    state.notify();
     try {
-      const submitter = options.submitter ?? defaultSubmitter;
+      const submitter = options.submitter ?? ((context) => defaultSubmitter(context, options));
       const liveForm = browserForm ?? getActiveElementBrowserForm();
       const method = options.method ?? liveForm?.method ?? "POST";
       const action = options.action ?? liveForm?.action;
@@ -787,17 +816,18 @@ function createFormClient(schemaDefinition, options = {}) {
           throw error;
         }
         return applyServerState(
-          validationExceptionToFailure(error, state.values) ?? createTransportFailure(state.values)
+          validationExceptionToFailure(error, localSubmission.data) ?? createTransportFailure(localSubmission.data),
+          submissionSequence
         );
       }
       return applyServerState(response ?? {
         ok: true,
         status: 204,
         data: void 0
-      });
+      }, submissionSequence);
     } finally {
       finishSubmission();
-      notifyListeners(state);
+      state.notify();
     }
   }
   return Object.freeze({
@@ -837,28 +867,15 @@ function createFormClient(schemaDefinition, options = {}) {
       return submit(form);
     },
     reset(values) {
-      const next = mergeFormValues(state.initialValues, values);
-      state.values = cloneFormValue(next);
-      state.initialValues = cloneFormValue(next);
-      state.flattenedErrors = {};
-      state.touched.clear();
-      state.dirty.clear();
-      state.lastSubmission = void 0;
-      notifyListeners(state);
+      state.reset(values);
     },
     async setValue(path, value) {
-      setFormValueAtPath(state.values, path, value);
-      state.touched.add(path);
-      if (!areFormValuesEqual(getFormValueAtPath(state.initialValues, path), value)) {
-        state.dirty.add(path);
-      } else {
-        state.dirty.delete(path);
-      }
+      state.edit(path, value);
       if (validateOn === "change" && fieldPaths.includes(path)) {
         await runValidation();
         return;
       }
-      notifyListeners(state);
+      state.notify();
     },
     applyServerState(result) {
       return applyServerState(result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/forms",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "description": "Holo-JS Framework - forms-first validation and submission contracts",
   "type": "module",
   "license": "MIT",
@@ -10,11 +10,6 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
-    "./schema": {
-      "types": "./dist/schema.d.ts",
-      "import": "./dist/schema.mjs",
-      "default": "./dist/schema.mjs"
-    },
     "./internal/client": {
       "types": "./dist/internal/client.d.ts",
       "import": "./dist/internal/client.mjs",
@@ -33,10 +28,10 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/validation": "^0.3.15"
+    "@holo-js/validation": "^0.3.17"
   },
   "peerDependencies": {
-    "@holo-js/security": "^0.3.15"
+    "@holo-js/security": "^0.3.17"
   },
   "peerDependenciesMeta": {
     "@holo-js/security": {
@@ -50,6 +45,6 @@
     "vitest": "^4.1.5"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": "^22.12.0 || ^24.0.0 || ^26.0.0"
   }
 }

package/dist/chunk-GPWXGHZE.mjs

@@ -1,40 +0,0 @@
-// src/schema.ts
-import {
-  defineSchema,
-  isValidationSchema
-} from "@holo-js/validation";
-import {
-  createErrorBag,
-  DEFAULT_VALIDATION_BAG,
-  defineSchema as defineSchema2,
-  field,
-  isValidationException,
-  parse,
-  safeParse,
-  ValidationException,
-  validationInternals
-} from "@holo-js/validation";
-function schema(shapeOrSchema) {
-  const base = isValidationSchema(shapeOrSchema) ? shapeOrSchema : defineSchema(shapeOrSchema);
-  return Object.freeze({
-    ...base,
-    mode: "form"
-  });
-}
-function isFormSchema(value) {
-  return isValidationSchema(value) && value.mode === "form";
-}
-
-export {
-  schema,
-  isFormSchema,
-  createErrorBag,
-  DEFAULT_VALIDATION_BAG,
-  defineSchema2 as defineSchema,
-  field,
-  isValidationException,
-  parse,
-  safeParse,
-  ValidationException,
-  validationInternals
-};

package/dist/schema.d.ts

@@ -1,13 +0,0 @@
-import { SchemaInputShape, ValidationSchema, InferSchemaData } from '@holo-js/validation';
-export { DEFAULT_VALIDATION_BAG, ErrorTree, ErrorTreeNode, FieldDefinition, FieldRule, InferSchemaData, SerializedValidationException, StandardSchemaV1, StandardSchemaV1Issue, StandardSchemaV1Props, StandardSchemaV1Result, ValidationErrorBag, ValidationException, ValidationExceptionOptions, ValidationFailure, ValidationResult, ValidationSchema, ValidationSuccess, WebFileLike, createErrorBag, defineSchema, field, isValidationException, parse, safeParse, validationInternals } from '@holo-js/validation';
-
-interface FormSchema<TShape extends SchemaInputShape = SchemaInputShape> extends ValidationSchema<TShape> {
-    readonly mode: 'form';
-    readonly fields: ValidationSchema<TShape>['fields'];
-    readonly $values?: Partial<InferSchemaData<TShape>>;
-}
-type InferFormData<TSchema extends FormSchema> = TSchema extends FormSchema<infer TShape> ? InferSchemaData<TShape> : never;
-declare function schema<TShape extends SchemaInputShape>(shapeOrSchema: TShape | ValidationSchema<TShape>): FormSchema<TShape>;
-declare function isFormSchema(value: unknown): value is FormSchema;
-
-export { type FormSchema, type InferFormData, isFormSchema, schema };

package/dist/schema.mjs

@@ -1,26 +0,0 @@
-import {
-  DEFAULT_VALIDATION_BAG,
-  ValidationException,
-  createErrorBag,
-  defineSchema,
-  field,
-  isFormSchema,
-  isValidationException,
-  parse,
-  safeParse,
-  schema,
-  validationInternals
-} from "./chunk-GPWXGHZE.mjs";
-export {
-  DEFAULT_VALIDATION_BAG,
-  ValidationException,
-  createErrorBag,
-  defineSchema,
-  field,
-  isFormSchema,
-  isValidationException,
-  parse,
-  safeParse,
-  schema,
-  validationInternals
-};