diff --git a/packages/react/src/runtime/use-form.ts b/packages/react/src/runtime/use-form.ts
index 92d118d7e..d9e79b607 100644
--- a/packages/react/src/runtime/use-form.ts
+++ b/packages/react/src/runtime/use-form.ts
@@ -17,30 +17,21 @@ import {
   parseFormResetArgs,
   submitAction,
   type FormResetOptions,
+  type FormState,
 } from 'void/pages-client';
 import type { ActionUrl, ResolveActionBody, ActionFormOptions } from 'void/routes';
 import { RouterContext } from './context.ts';
 
 type SubmitPayload = FormData | { method: string };
-type UntypedForm = {
-  data: Record<string, unknown>;
-  setData(field: string, value: unknown): void;
-  errors: Record<string, string>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  post(formData: FormData): void;
-  put(formData: FormData): void;
-  patch(formData: FormData): void;
-  delete(formData: FormData): void;
-  reset(options: FormResetOptions, ...fields: ReadonlyArray<string>): void;
-  reset(...fields: ReadonlyArray<string>): void;
-  setError(field: string, message: string): void;
-  clearErrors(...fields: ReadonlyArray<string>): void;
-  clearError(): void;
-};
+// Submit methods are native form actions that take FormData.
+type FormReturn<TData> = FormState<TData, 'setters'> &
+  Readonly<{
+    setData: <K extends keyof TData & string>(field: K, value: TData[K]) => void;
+    post(formData: FormData): void;
+    put(formData: FormData): void;
+    patch(formData: FormData): void;
+    delete(formData: FormData): void;
+  }>;
 
 type FormOptions = {
   params?: Record<string, string>;
@@ -54,37 +45,13 @@ export function useForm<U extends ActionUrl & string>(
   url: U,
   defaults: ResolveActionBody<U>,
   options?: ActionFormOptions<U> & Pick<FormOptions, 'onSuccess' | 'onError'>,
-): {
-  data: ResolveActionBody<U>;
-  setData: <K extends keyof ResolveActionBody<U> & string>(
-    field: K,
-    value: ResolveActionBody<U>[K],
-  ) => void;
-  errors: Partial<Record<keyof ResolveActionBody<U> & string, string>>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  post(formData: FormData): void;
-  put(formData: FormData): void;
-  patch(formData: FormData): void;
-  delete(formData: FormData): void;
-  reset(
-    options: FormResetOptions,
-    ...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>
-  ): void;
-  reset(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
-  setError(field: keyof ResolveActionBody<U> & string, message: string): void;
-  clearErrors(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
-  clearError(): void;
-};
+): FormReturn<ResolveActionBody<U>>;
 
 export function useForm(
   url: string,
   defaults: Record<string, unknown>,
   options?: FormOptions,
-): UntypedForm {
+): FormReturn<Record<string, unknown>> {
   const router = useContext(RouterContext);
   const [data, setDataState] = useState<Record<string, unknown>>(() => cloneFormValue(defaults));
   const [defaultsState, setDefaultsState] = useState<Record<string, unknown>>(() =>
diff --git a/packages/react/src/runtime/use-island-form.ts b/packages/react/src/runtime/use-island-form.ts
index a1505ed07..bc8d8cd9b 100644
--- a/packages/react/src/runtime/use-island-form.ts
+++ b/packages/react/src/runtime/use-island-form.ts
@@ -1,23 +1,13 @@
 import { useState, useRef, useCallback, useMemo } from 'react';
-import { isEqualFormValue, submitIslandAction, type VoidActionError } from 'void/pages-client';
+import {
+  isEqualFormValue,
+  submitIslandAction,
+  type IslandFormState,
+  type VoidActionError,
+} from 'void/pages-client';
 
-export type IslandFormReturn<T extends Record<string, unknown>> = Readonly<{
-  data: T;
-  setData: <K extends keyof T & string>(field: K, value: T[K]) => void;
-  errors: Record<string, string>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  reset: (...fields: ReadonlyArray<keyof T & string>) => void;
-  clearErrors: (...fields: ReadonlyArray<string>) => void;
-  clearError: () => void;
-  post: (url: string) => Promise<void>;
-  put: (url: string) => Promise<void>;
-  patch: (url: string) => Promise<void>;
-  delete: (url: string) => Promise<void>;
-}>;
+export type IslandFormReturn<T extends Record<string, unknown>> = IslandFormState<T, 'setters'> &
+  Readonly<{ setData: <K extends keyof T & string>(field: K, value: T[K]) => void }>;
 
 /**
  * Form hook for island pages. Uses fetch + page reload instead of the
diff --git a/packages/react/test/unit/form-errors.typecheck.ts b/packages/react/test/unit/form-errors.typecheck.ts
index 0ae7c609b..5111d80b2 100644
--- a/packages/react/test/unit/form-errors.typecheck.ts
+++ b/packages/react/test/unit/form-errors.typecheck.ts
@@ -1,3 +1,4 @@
+import type { FormModel } from 'void/pages-client';
 import { useForm } from '../../src/runtime/use-form.ts';
 
 declare module 'void/routes' {
@@ -13,4 +14,28 @@ export function checkFieldErrors(): void {
   form.setError('missing', 'Invalid field');
   // @ts-expect-error Error messages must be strings.
   form.setError('email', 123);
+  // @ts-expect-error Form state is read-only; update fields with `setData`.
+  form.data = { email: '' };
+  // @ts-expect-error Form state is read-only.
+  form.errors = {};
+  // @ts-expect-error Form state is read-only.
+  form.error = null;
+  // @ts-expect-error Form state is read-only.
+  form.pending = true;
+  // @ts-expect-error Form state is read-only.
+  form.hasChanges = true;
+  // @ts-expect-error Form state is read-only.
+  form.wasSuccessful = true;
+  // @ts-expect-error Form state is read-only.
+  form.recentlySuccessful = true;
+  // @ts-expect-error Errors change through setError and clearErrors.
+  form.errors.email = 'Invalid';
+  // @ts-expect-error Fields change through setData.
+  form.data.email = '';
+  // @ts-expect-error Form methods are read-only.
+  form.clearError = () => {};
+  // @ts-expect-error Submit methods are form actions that take FormData.
+  form.post();
+  const model: FormModel<[FormData]> = form;
+  void model;
 }
diff --git a/packages/react/test/unit/island-form.typecheck.ts b/packages/react/test/unit/island-form.typecheck.ts
new file mode 100644
index 000000000..14a4cdf48
--- /dev/null
+++ b/packages/react/test/unit/island-form.typecheck.ts
@@ -0,0 +1,37 @@
+import { useIslandForm } from '../../src/runtime/use-island-form.ts';
+
+export function checkIslandForm(): void {
+  const form = useIslandForm({ title: '', count: 0 });
+  const title: string = form.data.title;
+  const count: number = form.data.count;
+  void title;
+  void count;
+  form.reset('title');
+  // @ts-expect-error Reset fields must exist in the defaults.
+  form.reset('missing');
+  // @ts-expect-error Island form state is read-only.
+  form.pending = true;
+  // @ts-expect-error Island form state is read-only.
+  form.data = { title: '', count: 0 };
+  // @ts-expect-error Island form state is read-only.
+  form.errors = {};
+  // @ts-expect-error Form methods are read-only.
+  form.clearError = () => {};
+  // Island errors are keyed by whatever names the action returns.
+  const nestedError: string | undefined = form.errors['items.0.name'];
+  void nestedError;
+  const titleError: string | undefined = form.errors.title;
+  void titleError;
+  // @ts-expect-error A field may have no error.
+  void form.errors.title.length;
+  // @ts-expect-error Island errors are read-only.
+  form.errors.title = 'Invalid';
+  // @ts-expect-error Fields change through setData.
+  form.data.title = '';
+  void form.post('/notes');
+  form.setData('title', 'Hello');
+  // @ts-expect-error Field values keep their default types.
+  form.setData('count', '1');
+  // @ts-expect-error Only Vue and Svelte islands expose submit().
+  void form.submit('/notes', 'PATCH');
+}
diff --git a/packages/solid/src/runtime/use-form.ts b/packages/solid/src/runtime/use-form.ts
index 1f8f15840..38e649520 100644
--- a/packages/solid/src/runtime/use-form.ts
+++ b/packages/solid/src/runtime/use-form.ts
@@ -10,70 +10,33 @@ import {
   parseFormResetArgs,
   submitAction,
   type FormResetOptions,
-  type VisitOptions,
+  type FormState,
+  type FormSubmitOptions,
 } from 'void/pages-client';
 import type { ActionUrl, ResolveActionBody, ActionFormOptions } from 'void/routes';
 import { RouterContext, ErrorsContext } from './context.ts';
 
-type FormSubmitOptions = Omit<VisitOptions, 'method' | 'data'> & {
-  data?: Record<string, unknown>;
-};
-type UntypedForm = {
-  data: Record<string, unknown>;
-  setData(field: string, value: unknown): void;
-  errors: Record<string, string>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  post(opts?: FormSubmitOptions): Promise<void>;
-  put(opts?: FormSubmitOptions): Promise<void>;
-  patch(opts?: FormSubmitOptions): Promise<void>;
-  delete(opts?: FormSubmitOptions): Promise<void>;
-  reset(options: FormResetOptions, ...fields: ReadonlyArray<string>): void;
-  reset(...fields: ReadonlyArray<string>): void;
-  setError(field: string, message: string): void;
-  clearErrors(...fields: ReadonlyArray<string>): void;
-  clearError(): void;
-};
+type FormReturn<TData> = FormState<TData, 'setters'> &
+  Readonly<{
+    setData: <K extends keyof TData & string>(field: K, value: TData[K]) => void;
+    post(opts?: FormSubmitOptions): Promise<void>;
+    put(opts?: FormSubmitOptions): Promise<void>;
+    patch(opts?: FormSubmitOptions): Promise<void>;
+    delete(opts?: FormSubmitOptions): Promise<void>;
+  }>;
 
 // Typed overload — full inference from PageActionMap (requires codegen)
 export function useForm<U extends ActionUrl & string>(
   url: U,
   defaults: ResolveActionBody<U>,
   options?: ActionFormOptions<U>,
-): {
-  data: ResolveActionBody<U>;
-  setData: <K extends keyof ResolveActionBody<U> & string>(
-    field: K,
-    value: ResolveActionBody<U>[K],
-  ) => void;
-  errors: Partial<Record<keyof ResolveActionBody<U> & string, string>>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  post(opts?: FormSubmitOptions): Promise<void>;
-  put(opts?: FormSubmitOptions): Promise<void>;
-  patch(opts?: FormSubmitOptions): Promise<void>;
-  delete(opts?: FormSubmitOptions): Promise<void>;
-  reset(
-    options: FormResetOptions,
-    ...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>
-  ): void;
-  reset(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
-  setError(field: keyof ResolveActionBody<U> & string, message: string): void;
-  clearErrors(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
-  clearError(): void;
-};
+): FormReturn<ResolveActionBody<U>>;
 
 export function useForm(
   url: string,
   defaults: Record<string, unknown>,
   options?: { params?: Record<string, string>; resetOnSuccess?: boolean },
-): UntypedForm {
+): FormReturn<Record<string, unknown>> {
   const router = useContext(RouterContext);
   // ErrorsContext provides the errors signal accessor — a reactive function
   // that returns the current global errors object. This allows useForm to
diff --git a/packages/solid/src/runtime/use-island-form.ts b/packages/solid/src/runtime/use-island-form.ts
index 7aa7cd59a..e0af9e309 100644
--- a/packages/solid/src/runtime/use-island-form.ts
+++ b/packages/solid/src/runtime/use-island-form.ts
@@ -1,24 +1,14 @@
 import { createSignal, createMemo } from 'solid-js';
 import { createStore, reconcile } from 'solid-js/store';
-import { isEqualFormValue, submitIslandAction, type VoidActionError } from 'void/pages-client';
+import {
+  isEqualFormValue,
+  submitIslandAction,
+  type IslandFormState,
+  type VoidActionError,
+} from 'void/pages-client';
 
-export type IslandFormReturn<T extends Record<string, unknown>> = Readonly<{
-  data: T;
-  setData: <K extends keyof T & string>(field: K, value: T[K]) => void;
-  errors: Record<string, string>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  reset: (...fields: ReadonlyArray<keyof T & string>) => void;
-  clearErrors: (...fields: ReadonlyArray<string>) => void;
-  clearError: () => void;
-  post: (url: string) => Promise<void>;
-  put: (url: string) => Promise<void>;
-  patch: (url: string) => Promise<void>;
-  delete: (url: string) => Promise<void>;
-}>;
+export type IslandFormReturn<T extends Record<string, unknown>> = IslandFormState<T, 'setters'> &
+  Readonly<{ setData: <K extends keyof T & string>(field: K, value: T[K]) => void }>;
 
 /**
  * Form composable for island pages. Uses fetch + page reload instead of the
diff --git a/packages/solid/test/unit/form-errors.typecheck.ts b/packages/solid/test/unit/form-errors.typecheck.ts
index 394f03fab..5849df88e 100644
--- a/packages/solid/test/unit/form-errors.typecheck.ts
+++ b/packages/solid/test/unit/form-errors.typecheck.ts
@@ -1,3 +1,4 @@
+import type { FormModel } from 'void/pages-client';
 import { useForm } from '../../src/runtime/use-form.ts';
 
 declare module 'void/routes' {
@@ -13,6 +14,30 @@ export function checkFieldErrors(): void {
   form.setError('missing', 'Invalid field');
   // @ts-expect-error Error messages must be strings.
   form.setError('email', 123);
+  // @ts-expect-error Form state is read-only; update fields with `setData`.
+  form.data = { email: '' };
+  // @ts-expect-error Form state is read-only.
+  form.errors = {};
+  // @ts-expect-error Form state is read-only.
+  form.error = null;
+  // @ts-expect-error Form state is read-only.
+  form.pending = true;
+  // @ts-expect-error Form state is read-only.
+  form.hasChanges = true;
+  // @ts-expect-error Form state is read-only.
+  form.wasSuccessful = true;
+  // @ts-expect-error Form state is read-only.
+  form.recentlySuccessful = true;
+  // @ts-expect-error Errors change through setError and clearErrors.
+  form.errors.email = 'Invalid';
+  // @ts-expect-error Fields change through setData.
+  form.data.email = '';
+  // @ts-expect-error Form methods are read-only.
+  form.clearError = () => {};
+  // @ts-expect-error The submit method sets the HTTP method.
+  void form.post({ method: 'GET' });
+  const model: FormModel = form;
+  void model;
   // @ts-expect-error Submission callbacks are specific to the React adapter.
   useForm('/__form-errors/solid', { email: '' }, { onSuccess: () => {} });
   // @ts-expect-error Submission callbacks are specific to the React adapter.
diff --git a/packages/solid/test/unit/island-form.typecheck.ts b/packages/solid/test/unit/island-form.typecheck.ts
new file mode 100644
index 000000000..14a4cdf48
--- /dev/null
+++ b/packages/solid/test/unit/island-form.typecheck.ts
@@ -0,0 +1,37 @@
+import { useIslandForm } from '../../src/runtime/use-island-form.ts';
+
+export function checkIslandForm(): void {
+  const form = useIslandForm({ title: '', count: 0 });
+  const title: string = form.data.title;
+  const count: number = form.data.count;
+  void title;
+  void count;
+  form.reset('title');
+  // @ts-expect-error Reset fields must exist in the defaults.
+  form.reset('missing');
+  // @ts-expect-error Island form state is read-only.
+  form.pending = true;
+  // @ts-expect-error Island form state is read-only.
+  form.data = { title: '', count: 0 };
+  // @ts-expect-error Island form state is read-only.
+  form.errors = {};
+  // @ts-expect-error Form methods are read-only.
+  form.clearError = () => {};
+  // Island errors are keyed by whatever names the action returns.
+  const nestedError: string | undefined = form.errors['items.0.name'];
+  void nestedError;
+  const titleError: string | undefined = form.errors.title;
+  void titleError;
+  // @ts-expect-error A field may have no error.
+  void form.errors.title.length;
+  // @ts-expect-error Island errors are read-only.
+  form.errors.title = 'Invalid';
+  // @ts-expect-error Fields change through setData.
+  form.data.title = '';
+  void form.post('/notes');
+  form.setData('title', 'Hello');
+  // @ts-expect-error Field values keep their default types.
+  form.setData('count', '1');
+  // @ts-expect-error Only Vue and Svelte islands expose submit().
+  void form.submit('/notes', 'PATCH');
+}
diff --git a/packages/svelte/src/runtime/use-form.svelte.ts b/packages/svelte/src/runtime/use-form.svelte.ts
index e832455ea..a968b2c32 100644
--- a/packages/svelte/src/runtime/use-form.svelte.ts
+++ b/packages/svelte/src/runtime/use-form.svelte.ts
@@ -9,65 +9,32 @@ import {
   parseFormResetArgs,
   submitAction,
   type FormResetOptions,
-  type VisitOptions,
+  type FormState,
+  type FormSubmitOptions,
   type VoidRouter,
 } from 'void/pages-client';
 import type { ActionUrl, ResolveActionBody, ActionFormOptions } from 'void/routes';
 
-type FormSubmitOptions = Omit<VisitOptions, 'method' | 'data'> & {
-  data?: Record<string, unknown>;
-};
-type UntypedForm = {
-  readonly data: Record<string, unknown>;
-  readonly errors: Record<string, string>;
-  readonly error: VoidActionError | null;
-  readonly pending: boolean;
-  readonly hasChanges: boolean;
-  readonly wasSuccessful: boolean;
-  readonly recentlySuccessful: boolean;
-  post(opts?: FormSubmitOptions): Promise<void>;
-  put(opts?: FormSubmitOptions): Promise<void>;
-  patch(opts?: FormSubmitOptions): Promise<void>;
-  delete(opts?: FormSubmitOptions): Promise<void>;
-  reset(options: FormResetOptions, ...fields: ReadonlyArray<string>): void;
-  reset(...fields: ReadonlyArray<string>): void;
-  setError(field: string, message: string): void;
-  clearErrors(...fields: ReadonlyArray<string>): void;
-  clearError(): void;
-};
+type FormReturn<TData> = FormState<TData, 'in-place'> &
+  Readonly<{
+    post(opts?: FormSubmitOptions): Promise<void>;
+    put(opts?: FormSubmitOptions): Promise<void>;
+    patch(opts?: FormSubmitOptions): Promise<void>;
+    delete(opts?: FormSubmitOptions): Promise<void>;
+  }>;
 
 // Typed overload — full inference from PageActionMap (requires codegen)
 export function useForm<U extends ActionUrl & string>(
   url: U,
   defaults: ResolveActionBody<U>,
   options?: ActionFormOptions<U>,
-): {
-  readonly data: ResolveActionBody<U>;
-  readonly errors: Partial<Record<keyof ResolveActionBody<U> & string, string>>;
-  readonly error: VoidActionError | null;
-  readonly pending: boolean;
-  readonly hasChanges: boolean;
-  readonly wasSuccessful: boolean;
-  readonly recentlySuccessful: boolean;
-  post(opts?: FormSubmitOptions): Promise<void>;
-  put(opts?: FormSubmitOptions): Promise<void>;
-  patch(opts?: FormSubmitOptions): Promise<void>;
-  delete(opts?: FormSubmitOptions): Promise<void>;
-  reset(
-    options: FormResetOptions,
-    ...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>
-  ): void;
-  reset(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
-  setError(field: keyof ResolveActionBody<U> & string, message: string): void;
-  clearErrors(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
-  clearError(): void;
-};
+): FormReturn<ResolveActionBody<U>>;
 
 export function useForm(
   url: string,
   defaults: Record<string, unknown>,
   options?: { params?: Record<string, string>; resetOnSuccess?: boolean },
-): UntypedForm {
+): FormReturn<Record<string, unknown>> {
   const router = getContext<VoidRouter>('__void_router');
 
   const initialDefaults = cloneFormValue(defaults);
diff --git a/packages/svelte/src/runtime/use-island-form.svelte.ts b/packages/svelte/src/runtime/use-island-form.svelte.ts
index 446f2d786..47078196f 100644
--- a/packages/svelte/src/runtime/use-island-form.svelte.ts
+++ b/packages/svelte/src/runtime/use-island-form.svelte.ts
@@ -1,29 +1,19 @@
-import { isEqualFormValue, submitIslandAction, type VoidActionError } from 'void/pages-client';
+import {
+  isEqualFormValue,
+  submitIslandAction,
+  type IslandFormState,
+  type VoidActionError,
+} from 'void/pages-client';
 
-type UntypedIslandForm = {
-  readonly data: Record<string, unknown>;
-  readonly errors: Record<string, string>;
-  readonly error: VoidActionError | null;
-  readonly pending: boolean;
-  readonly hasChanges: boolean;
-  readonly wasSuccessful: boolean;
-  readonly recentlySuccessful: boolean;
-  submit(url: string, method: string): Promise<void>;
-  post(url: string): Promise<void>;
-  put(url: string): Promise<void>;
-  patch(url: string): Promise<void>;
-  delete(url: string): Promise<void>;
-  reset(...fields: ReadonlyArray<string>): void;
-  clearErrors(...fields: ReadonlyArray<string>): void;
-  clearError(): void;
-};
+export type IslandFormReturn<T extends Record<string, unknown>> = IslandFormState<T, 'in-place'> &
+  Readonly<{ submit(url: string, method: string): Promise<void> }>;
 
 /**
  * Form composable for island pages. Uses fetch + page reload instead of the
  * Void Router (which is not available in island mode).
  */
-export function useIslandForm(defaults: Record<string, unknown>): UntypedIslandForm {
-  let data: Record<string, unknown> = $state({ ...defaults });
+export function useIslandForm<T extends Record<string, unknown>>(defaults: T): IslandFormReturn<T> {
+  let data: T = $state({ ...defaults });
   let errors: Record<string, string> = $state({});
   let error: VoidActionError | null = $state(null);
   let pending = $state(false);
@@ -37,7 +27,7 @@ export function useIslandForm(defaults: Record<string, unknown>): UntypedIslandF
     Object.keys(defaults_).some((key) => !isEqualFormValue(data[key], defaults_[key])),
   );
 
-  function reset(...fields: ReadonlyArray<string>) {
+  function reset(...fields: ReadonlyArray<keyof T & string>) {
     if (fields.length === 0) {
       data = { ...defaults_ };
     } else {
diff --git a/packages/svelte/test/unit/form-errors.typecheck.ts b/packages/svelte/test/unit/form-errors.typecheck.ts
index 600fbb9d4..024ba82b0 100644
--- a/packages/svelte/test/unit/form-errors.typecheck.ts
+++ b/packages/svelte/test/unit/form-errors.typecheck.ts
@@ -1,3 +1,4 @@
+import type { FormModel } from 'void/pages-client';
 import { useForm } from '../../src/runtime/use-form.svelte.ts';
 
 declare module 'void/routes' {
@@ -13,6 +14,30 @@ export function checkFieldErrors(): void {
   form.setError('missing', 'Invalid field');
   // @ts-expect-error Error messages must be strings.
   form.setError('email', 123);
+  form.data.email = '';
+  // @ts-expect-error Form state is read-only; edit fields through `data`.
+  form.data = { email: '' };
+  // @ts-expect-error Form state is read-only.
+  form.errors = {};
+  // @ts-expect-error Form state is read-only.
+  form.error = null;
+  // @ts-expect-error Form state is read-only.
+  form.pending = true;
+  // @ts-expect-error Form state is read-only.
+  form.hasChanges = true;
+  // @ts-expect-error Form state is read-only.
+  form.wasSuccessful = true;
+  // @ts-expect-error Form state is read-only.
+  form.recentlySuccessful = true;
+  form.errors.email = 'Invalid';
+  // @ts-expect-error Svelte edits `data` in place, so there is no setData.
+  form.setData('email', '');
+  // @ts-expect-error Form methods are read-only.
+  form.clearError = () => {};
+  // @ts-expect-error The submit method sets the HTTP method.
+  void form.post({ method: 'GET' });
+  const model: FormModel = form;
+  void model;
   // @ts-expect-error Submission callbacks are specific to the React adapter.
   useForm('/__form-errors/svelte', { email: '' }, { onSuccess: () => {} });
   // @ts-expect-error Submission callbacks are specific to the React adapter.
diff --git a/packages/svelte/test/unit/island-form.typecheck.ts b/packages/svelte/test/unit/island-form.typecheck.ts
new file mode 100644
index 000000000..f12cbf5d2
--- /dev/null
+++ b/packages/svelte/test/unit/island-form.typecheck.ts
@@ -0,0 +1,33 @@
+import { useIslandForm } from '../../src/runtime/use-island-form.svelte.ts';
+
+export function checkIslandForm(): void {
+  const form = useIslandForm({ title: '', count: 0 });
+  const title: string = form.data.title;
+  const count: number = form.data.count;
+  void title;
+  void count;
+  form.reset('title');
+  // @ts-expect-error Reset fields must exist in the defaults.
+  form.reset('missing');
+  // @ts-expect-error Island form state is read-only.
+  form.pending = true;
+  // @ts-expect-error Island form state is read-only.
+  form.data = { title: '', count: 0 };
+  // @ts-expect-error Island form state is read-only.
+  form.errors = {};
+  // @ts-expect-error Form methods are read-only.
+  form.clearError = () => {};
+  // Island errors are keyed by whatever names the action returns.
+  const nestedError: string | undefined = form.errors['items.0.name'];
+  void nestedError;
+  const titleError: string | undefined = form.errors.title;
+  void titleError;
+  // @ts-expect-error A field may have no error.
+  void form.errors.title.length;
+  form.errors.title = 'Invalid';
+  void form.post('/notes');
+  form.data.title = 'Hello';
+  void form.submit('/notes', 'PATCH');
+  // @ts-expect-error Svelte edits `data` in place, so there is no setData.
+  form.setData('title', 'Hello');
+}
diff --git a/packages/void/src/pages/client.ts b/packages/void/src/pages/client.ts
index 77311f53e..285cf80df 100644
--- a/packages/void/src/pages/client.ts
+++ b/packages/void/src/pages/client.ts
@@ -609,4 +609,7 @@ export {
   scheduleFormRetry,
   type FormModel,
   type FormMethod,
+  type FormState,
+  type FormSubmitOptions,
+  type IslandFormState,
 } from './form-presentation.ts';
diff --git a/packages/void/src/pages/form-presentation.ts b/packages/void/src/pages/form-presentation.ts
index 881f66994..03e5e895c 100644
--- a/packages/void/src/pages/form-presentation.ts
+++ b/packages/void/src/pages/form-presentation.ts
@@ -1,12 +1,64 @@
 import type { VoidActionError } from './action-result.ts';
+import type { FormResetOptions } from './form-reset.ts';
+import type { VisitOptions } from './navigation-engine.ts';
 
 export type FormMethod = 'post' | 'put' | 'patch' | 'delete';
-export type FormModel<Args extends Array<unknown> = []> = {
-  readonly pending: boolean;
-  readonly error: VoidActionError | null;
+export type FormModel<Args extends Array<unknown> = []> = Pick<FormStatus, 'pending' | 'error'> & {
   readonly errors: Readonly<Record<string, string | undefined>>;
 } & { [K in FormMethod]: (...args: Args) => void | Promise<void> };
 
+/** Router options a `useForm()` submission accepts in adapters whose submit methods take options. */
+export type FormSubmitOptions = Omit<VisitOptions, 'method' | 'data'> & {
+  data?: Record<string, unknown>;
+};
+/** Submission state that `useForm()` and `useIslandForm()` report in every adapter. */
+export type FormStatus = {
+  readonly error: VoidActionError | null;
+  readonly pending: boolean;
+  readonly hasChanges: boolean;
+  readonly wasSuccessful: boolean;
+  readonly recentlySuccessful: boolean;
+};
+/** Field-keyed validation messages; a field without an error is absent. */
+export type FormErrors<TData> = Partial<Record<keyof TData & string, string>>;
+/**
+ * How an adapter's apps change `data` and `errors`, following its framework's idiom.
+ * `'in-place'`: apps edit them directly (Vue, Svelte).
+ * `'setters'`: they are read-only and change through adapter setters such as `setData` (React, Solid).
+ */
+type FormEditing = 'in-place' | 'setters';
+type FormFields<TData, TErrors, TEditing extends FormEditing> = [TEditing] extends ['setters']
+  ? { readonly data: Readonly<TData>; readonly errors: Readonly<TErrors> }
+  : { readonly data: TData; readonly errors: TErrors };
+/**
+ * The `useForm()` contract every adapter shares. Field names are typed from the action body.
+ * Adapters add their submit methods.
+ */
+export type FormState<TData, TEditing extends FormEditing> = FormStatus &
+  FormFields<TData, FormErrors<TData>, TEditing> &
+  Readonly<{
+    reset(options: FormResetOptions, ...fields: ReadonlyArray<keyof TData & string>): void;
+    reset(...fields: ReadonlyArray<keyof TData & string>): void;
+    setError(field: keyof TData & string, message: string): void;
+    clearErrors(...fields: ReadonlyArray<keyof TData & string>): void;
+    clearError(): void;
+  }>;
+/**
+ * The `useIslandForm()` contract every adapter shares. Errors are keyed by whatever names the
+ * action returns, not only the default fields. Submit methods take the action URL.
+ */
+export type IslandFormState<TData, TEditing extends FormEditing> = FormStatus &
+  FormFields<TData, Partial<Record<string, string>>, TEditing> &
+  Readonly<{
+    reset(...fields: ReadonlyArray<keyof TData & string>): void;
+    clearErrors(...fields: ReadonlyArray<string>): void;
+    clearError(): void;
+    post(url: string): Promise<void>;
+    put(url: string): Promise<void>;
+    patch(url: string): Promise<void>;
+    delete(url: string): Promise<void>;
+  }>;
+
 export function formErrorMessage(form: Pick<FormModel, 'error' | 'errors'>): string | null {
   return form.error?.message ?? (Object.values(form.errors).filter(Boolean).join('. ') || null);
 }
diff --git a/packages/vue/src/runtime/use-form.ts b/packages/vue/src/runtime/use-form.ts
index 643101ea7..25be0b9f5 100644
--- a/packages/vue/src/runtime/use-form.ts
+++ b/packages/vue/src/runtime/use-form.ts
@@ -8,65 +8,32 @@ import {
   parseFormResetArgs,
   submitAction,
   type FormResetOptions,
-  type VisitOptions,
+  type FormState,
+  type FormSubmitOptions,
   type VoidRouter,
 } from 'void/pages-client';
 import type { ActionUrl, ResolveActionBody, ActionFormOptions } from 'void/routes';
 import { computed, reactive, ref, shallowRef, inject, watch } from 'vue';
 
-type FormSubmitOptions = Omit<VisitOptions, 'method' | 'data'> & {
-  data?: Record<string, unknown>;
-};
-type UntypedForm = {
-  data: Record<string, unknown>;
-  errors: Record<string, string>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  post(opts?: FormSubmitOptions): Promise<void>;
-  put(opts?: FormSubmitOptions): Promise<void>;
-  patch(opts?: FormSubmitOptions): Promise<void>;
-  delete(opts?: FormSubmitOptions): Promise<void>;
-  reset(options: FormResetOptions, ...fields: ReadonlyArray<string>): void;
-  reset(...fields: ReadonlyArray<string>): void;
-  setError(field: string, message: string): void;
-  clearErrors(...fields: ReadonlyArray<string>): void;
-  clearError(): void;
-};
+type FormReturn<TData> = FormState<TData, 'in-place'> &
+  Readonly<{
+    post(opts?: FormSubmitOptions): Promise<void>;
+    put(opts?: FormSubmitOptions): Promise<void>;
+    patch(opts?: FormSubmitOptions): Promise<void>;
+    delete(opts?: FormSubmitOptions): Promise<void>;
+  }>;
 
 export function useForm<U extends ActionUrl & string>(
   url: U,
   defaults: ResolveActionBody<U>,
   options?: ActionFormOptions<U>,
-): {
-  data: ResolveActionBody<U>;
-  errors: Partial<Record<keyof ResolveActionBody<U> & string, string>>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  post(opts?: FormSubmitOptions): Promise<void>;
-  put(opts?: FormSubmitOptions): Promise<void>;
-  patch(opts?: FormSubmitOptions): Promise<void>;
-  delete(opts?: FormSubmitOptions): Promise<void>;
-  reset(
-    options: FormResetOptions,
-    ...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>
-  ): void;
-  reset(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
-  setError(field: keyof ResolveActionBody<U> & string, message: string): void;
-  clearErrors(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
-  clearError(): void;
-};
+): FormReturn<ResolveActionBody<U>>;
 
 export function useForm(
   url: string,
   defaults: Record<string, unknown>,
   options?: { params?: Record<string, string>; resetOnSuccess?: boolean },
-): UntypedForm {
+): FormReturn<Record<string, unknown>> {
   const initialDefaults = cloneFormValue(defaults);
   const router = inject<VoidRouter | null>('__void_router', null);
   const data = reactive(cloneFormValue(initialDefaults)) as Record<string, unknown>;
diff --git a/packages/vue/src/runtime/use-island-form.ts b/packages/vue/src/runtime/use-island-form.ts
index 2238a6cb5..e083b22c1 100644
--- a/packages/vue/src/runtime/use-island-form.ts
+++ b/packages/vue/src/runtime/use-island-form.ts
@@ -1,30 +1,25 @@
-import { isEqualFormValue, submitIslandAction, type VoidActionError } from 'void/pages-client';
+import {
+  isEqualFormValue,
+  submitIslandAction,
+  type IslandFormState,
+  type VoidActionError,
+} from 'void/pages-client';
 import { reactive, ref, watch } from 'vue';
 
-export type IslandFormReturn<T extends Record<string, unknown>> = Readonly<{
-  data: T;
-  errors: Record<string, string>;
-  error: VoidActionError | null;
-  pending: boolean;
-  hasChanges: boolean;
-  wasSuccessful: boolean;
-  recentlySuccessful: boolean;
-  submit(url: string, method: string): Promise<void>;
-  post(url: string): Promise<void>;
-  put(url: string): Promise<void>;
-  patch(url: string): Promise<void>;
-  delete(url: string): Promise<void>;
-  reset(...fields: ReadonlyArray<keyof T & string>): void;
-  clearErrors(...fields: ReadonlyArray<string>): void;
-  clearError(): void;
-}>;
+export type IslandFormReturn<T extends Record<string, unknown>> = IslandFormState<T, 'in-place'> &
+  Readonly<{ submit(url: string, method: string): Promise<void> }>;
 
 /**
  * Form composable for island pages. Uses fetch + page reload instead of the
  * Void Router (which is not available in island mode).
  */
-export function useIslandForm<T extends Record<string, unknown>>(defaults: T): IslandFormReturn<T> {
-  const data = reactive({ ...defaults }) as T;
+export function useIslandForm<T extends Record<string, unknown>>(defaults: T): IslandFormReturn<T>;
+
+// Untyped implementation, so the returned object is checked against the island contract.
+export function useIslandForm(
+  defaults: Record<string, unknown>,
+): IslandFormReturn<Record<string, unknown>> {
+  const data = reactive({ ...defaults }) as Record<string, unknown>;
   const errors = reactive<Record<string, string>>({});
   const error = ref<VoidActionError | null>(null);
   const pending = ref(false);
@@ -45,7 +40,7 @@ export function useIslandForm<T extends Record<string, unknown>>(defaults: T): I
     { deep: true },
   );
 
-  function reset(...fields: ReadonlyArray<keyof T & string>) {
+  function reset(...fields: ReadonlyArray<string>) {
     if (fields.length === 0) {
       Object.assign(data, { ...defaults_ });
     } else {
@@ -123,5 +118,5 @@ export function useIslandForm<T extends Record<string, unknown>>(defaults: T): I
     put: (url: string) => submit(url, 'PUT'),
     patch: (url: string) => submit(url, 'PATCH'),
     delete: (url: string) => submit(url, 'DELETE'),
-  }) as IslandFormReturn<T>;
+  });
 }
diff --git a/packages/vue/test/unit/form-errors.typecheck.ts b/packages/vue/test/unit/form-errors.typecheck.ts
index 8b2a3980e..ab336a67f 100644
--- a/packages/vue/test/unit/form-errors.typecheck.ts
+++ b/packages/vue/test/unit/form-errors.typecheck.ts
@@ -1,3 +1,4 @@
+import type { FormModel } from 'void/pages-client';
 import { useForm } from '../../src/runtime/use-form.ts';
 
 declare module 'void/routes' {
@@ -13,4 +14,28 @@ export function checkFieldErrors(): void {
   form.setError('missing', 'Invalid field');
   // @ts-expect-error Error messages must be strings.
   form.setError('email', 123);
+  form.data.email = '';
+  // @ts-expect-error Form state is read-only; edit fields through `data`.
+  form.data = { email: '' };
+  // @ts-expect-error Form state is read-only.
+  form.errors = {};
+  // @ts-expect-error Form state is read-only.
+  form.error = null;
+  // @ts-expect-error Form state is read-only.
+  form.pending = true;
+  // @ts-expect-error Form state is read-only.
+  form.hasChanges = true;
+  // @ts-expect-error Form state is read-only.
+  form.wasSuccessful = true;
+  // @ts-expect-error Form state is read-only.
+  form.recentlySuccessful = true;
+  form.errors.email = 'Invalid';
+  // @ts-expect-error Vue edits `data` in place, so there is no setData.
+  form.setData('email', '');
+  // @ts-expect-error Form methods are read-only.
+  form.clearError = () => {};
+  // @ts-expect-error The submit method sets the HTTP method.
+  void form.post({ method: 'GET' });
+  const model: FormModel = form;
+  void model;
 }
diff --git a/packages/vue/test/unit/island-form.typecheck.ts b/packages/vue/test/unit/island-form.typecheck.ts
new file mode 100644
index 000000000..daffd401a
--- /dev/null
+++ b/packages/vue/test/unit/island-form.typecheck.ts
@@ -0,0 +1,33 @@
+import { useIslandForm } from '../../src/runtime/use-island-form.ts';
+
+export function checkIslandForm(): void {
+  const form = useIslandForm({ title: '', count: 0 });
+  const title: string = form.data.title;
+  const count: number = form.data.count;
+  void title;
+  void count;
+  form.reset('title');
+  // @ts-expect-error Reset fields must exist in the defaults.
+  form.reset('missing');
+  // @ts-expect-error Island form state is read-only.
+  form.pending = true;
+  // @ts-expect-error Island form state is read-only.
+  form.data = { title: '', count: 0 };
+  // @ts-expect-error Island form state is read-only.
+  form.errors = {};
+  // @ts-expect-error Form methods are read-only.
+  form.clearError = () => {};
+  // Island errors are keyed by whatever names the action returns.
+  const nestedError: string | undefined = form.errors['items.0.name'];
+  void nestedError;
+  const titleError: string | undefined = form.errors.title;
+  void titleError;
+  // @ts-expect-error A field may have no error.
+  void form.errors.title.length;
+  form.errors.title = 'Invalid';
+  void form.post('/notes');
+  form.data.title = 'Hello';
+  void form.submit('/notes', 'PATCH');
+  // @ts-expect-error Vue edits `data` in place, so there is no setData.
+  form.setData('title', 'Hello');
+}