void 1.5.0 → 1.6.0

package/dist/{mime-DKkO7ZtA.mjs → mime-CtP6-qAF.mjs}

@@ -1,5 +1,124 @@
 import { n as bytesToBase64 } from "./base64-ikl9yBy3.mjs";
 import { validate } from "email-validator";
+// src/runtime/email/threading.ts
+/**
+* Header-value checks shared by the MIME builder and the reply path, and the
+* best-effort cleaning of `In-Reply-To` / `References` ids. Thread ids usually
+* come from remote mail, so an id that cannot be sent is left out instead of
+* failing the message. No imports, so both `mime.ts` and `inbound.ts` can use it.
+*/
+/**
+* Index of the first C0 control other than HTAB, or DEL; -1 when there is
+* none. HTAB is folding whitespace (RFC 5322 §3.2.2).
+*/
+function indexOfControl(value) {
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 32 && c !== 9 || c === 127) return i;
+	}
+	return -1;
+}
+/**
+* `value` without leading or trailing SP and HTAB, the only whitespace a
+* `Headers` value is trimmed of. `String#trim` would also strip U+00A0.
+*/
+function trimFws(value) {
+	let start = 0;
+	let end = value.length;
+	while (start < end && (value.charCodeAt(start) === 32 || value.charCodeAt(start) === 9)) start++;
+	while (end > start && (value.charCodeAt(end - 1) === 32 || value.charCodeAt(end - 1) === 9)) end--;
+	return value.slice(start, end);
+}
+/**
+* Whether `Name: value` fits RFC 5322's 998-octet line once folded. It
+* follows `foldHeader`: a fold point is SP or HTAB outside a quoted string,
+* so the widest run between fold points decides.
+*/
+function fitsHeaderLine(name, value) {
+	if (!value) return false;
+	const budget = 998 - (name.length + 2);
+	let run = 0;
+	let inQuotes = false;
+	let escape = false;
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (escape) escape = false;
+		else if (c === 92 && inQuotes) escape = true;
+		else if (c === 34) inQuotes = !inQuotes;
+		else if ((c === 32 || c === 9) && !inQuotes) {
+			run = 0;
+			continue;
+		}
+		if (c < 128) run += 1;
+		else if (c < 2048) run += 2;
+		else if (c >= 55296 && c <= 56319 && i + 1 < value.length && (value.charCodeAt(i + 1) & 64512) === 56320) {
+			run += 4;
+			i++;
+		} else run += 3;
+		if (run > budget) return false;
+	}
+	return true;
+}
+/**
+* Longest `References` value, in UTF-16 code units. 8 KiB keeps any real
+* thread whole; past it the newest ids are kept, since mail clients thread on
+* any id they recognise and the parent is `In-Reply-To`.
+*/
+const MAX_REFERENCES_CHARS = 8192;
+/**
+* The newest whole ids of `chain` that fit `budget` code units, without the
+* ids that hold a control character.
+*/
+function newestIds(chain, budget) {
+	if (chain.length > budget) {
+		let cut = chain.length - budget;
+		while (cut < chain.length) {
+			const c = chain.charCodeAt(cut);
+			if (c === 32 || c === 9) break;
+			cut++;
+		}
+		chain = chain.slice(cut);
+	}
+	return dropControlIds(chain);
+}
+/** `chain` without the ids that hold a control character, joined by single spaces. */
+function dropControlIds(chain) {
+	if (indexOfControl(chain) === -1) return chain;
+	const kept = [];
+	let start = -1;
+	let tainted = false;
+	for (let i = 0; i <= chain.length; i++) {
+		const c = i < chain.length ? chain.charCodeAt(i) : 32;
+		if (c === 32 || c === 9) {
+			if (start >= 0 && !tainted) kept.push(chain.slice(start, i));
+			start = -1;
+			tainted = false;
+		} else {
+			if (start < 0) start = i;
+			if (c < 32 || c === 127) tainted = true;
+		}
+	}
+	return kept.join(" ");
+}
+/** `id` when it fits one `name:` line and holds no control character, else `''`. */
+function threadingId(name, id) {
+	return fitsHeaderLine(name, id) && indexOfControl(id) === -1 ? id : "";
+}
+/** `References` cut to its newest whole ids, or `''` when an id cannot fit a line. */
+function threadingReferences(chain) {
+	const kept = newestIds(chain, MAX_REFERENCES_CHARS).trim();
+	return fitsHeaderLine("References", kept) ? kept : "";
+}
+/**
+* A reply's `References`, or `''`: the inbound chain plus the parent's id,
+* trimmed to its newest whole ids, or the parent's id alone when an id
+* cannot fit a line. `messageId` was already checked with `threadingId`.
+*/
+function replyReferences(originalReferences, messageId) {
+	const parent = messageId ? ` ${messageId}` : "";
+	const chain = `${newestIds(originalReferences, MAX_REFERENCES_CHARS - parent.length)}${parent}`.trim();
+	return fitsHeaderLine("References", chain) ? chain : messageId;
+}
 // src/runtime/email/mime.ts
 /**
 * Minimal RFC 5322 / 2047 / 2045 MIME builder for the void/email runtime.
@@ -29,17 +148,6 @@ function rejectCRLF(field, value) {
 	}
 }
 /**
-* Index of the first C0 control other than HTAB, or DEL; -1 when there is
-* none. HTAB is folding whitespace (RFC 5322 §3.2.2).
-*/
-function indexOfControl(value) {
-	for (let i = 0; i < value.length; i++) {
-		const c = value.charCodeAt(i);
-		if (c < 32 && c !== 9 || c === 127) return i;
-	}
-	return -1;
-}
-/**
 * Refuse a control in a value rendered verbatim into a header (an
 * attachment's filename, media type and Content-ID). Names the code point,
 * never the value.
@@ -350,8 +458,7 @@ async function normalizeEmail(opts) {
 		if (attachmentBytes > MAX_ATTACHMENT_BYTES_TOTAL) throw attachmentsTooLargeError(attachmentBytes);
 		attachments.push(normalized);
 	}
-	if (opts.threading?.inReplyTo) rejectCRLF("threading.inReplyTo", opts.threading.inReplyTo);
-	if (opts.threading?.references) rejectCRLF("threading.references", opts.threading.references);
+	const threading = normalizeThreading(opts.threading);
 	return {
 		from,
 		to,
@@ -363,7 +470,28 @@ async function normalizeEmail(opts) {
 		html: opts.html,
 		headers: opts.headers ? { ...opts.headers } : {},
 		attachments,
-		threading: opts.threading
+		threading
+	};
+}
+/**
+* `threading` from `sendEmail`, `createEmail` or `replyEmail`. A value that is
+* not a string is a caller error. Thread ids often come from remote mail, so a
+* bad id never fails the email: an `inReplyTo` with a control character or
+* too long for one line is left out, and a `references` chain that cannot be
+* sent falls back to `inReplyTo`.
+*/
+function normalizeThreading(threading) {
+	if (threading === void 0) return;
+	if (typeof threading !== "object" || threading === null || Array.isArray(threading)) throw new MimeError("MIME_ERROR", "threading: must be an object.");
+	const { inReplyTo = "", references = "" } = threading;
+	if (typeof inReplyTo !== "string") throw new MimeError("MIME_ERROR", "threading.inReplyTo: must be a string.");
+	if (typeof references !== "string") throw new MimeError("MIME_ERROR", "threading.references: must be a string.");
+	const parent = threadingId("In-Reply-To", trimFws(inReplyTo));
+	const chain = threadingReferences(references) || parent;
+	if (!parent && !chain) return;
+	return {
+		...parent ? { inReplyTo: parent } : {},
+		...chain ? { references: chain } : {}
 	};
 }
 /**
@@ -873,4 +1001,4 @@ function buildMime(email) {
 		messageId
 	};
 }
-export { newId as a, validateAddressParts as c, indexOfControl as i, MimeError as n, normalizeEmail as o, buildMime as r, parseAddress as s, MAX_MESSAGE_BYTES as t };
+export { normalizeEmail as a, fitsHeaderLine as c, newId as i, replyReferences as l, MimeError as n, parseAddress as o, buildMime as r, validateAddressParts as s, MAX_MESSAGE_BYTES as t, threadingId as u };

package/dist/nitro.mjs

@@ -1,7 +1,7 @@
 import { a as join, n as dirname } from "./dist-DMYe8CZJ.mjs";
-import { l as getDatabaseDialect, p as readConfig } from "./config-DkA9jYF2.mjs";
-import { c as voidDbBundlerPlugin } from "./dispatch-CiJ1Xrba.mjs";
-import { n as bundleWorkerSqlDriver } from "./wrapper-iejSJDwL.mjs";
+import { l as getDatabaseDialect, p as readConfig } from "./config-BITKQ3O6.mjs";
+import { c as voidDbBundlerPlugin } from "./dispatch-BNLB5_Gm.mjs";
+import { n as bundleWorkerSqlDriver } from "./wrapper-C9SUxoj7.mjs";
 import { normalizePath } from "vite";
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path/win32";

package/dist/{node-BfAt2rz8.mjs → node-CZ6lGNLn.mjs}

@@ -1,6 +1,6 @@
 import { n as dirname } from "./dist-DMYe8CZJ.mjs";
 import { a as projectAuthConfigImporter, i as loadVoidAuthConfig, r as findVoidAuthConfig } from "./config-WlvEcL82.mjs";
-import { p as readConfig } from "./config-DkA9jYF2.mjs";
+import { p as readConfig } from "./config-BITKQ3O6.mjs";
 import { r as getMiniflareDatabasePath } from "./runner-5MCSimKx.mjs";
 import { s as loadLocalEnv } from "./env-CuzZZyjB.mjs";
 import { a as pgMigrationRunner, i as mysqlMigrationRunner, n as applyPgAuthMigrations, r as applySqliteAuthMigrations, t as applyMySqlAuthMigrations } from "./auth-migrations-DDeifS3v.mjs";

package/dist/{operator-cmd-CnAvSqJ5.mjs → operator-cmd-BUqsdk2K.mjs}

@@ -1,5 +1,6 @@
-import { h as sanitizeTerminalText, m as printSuccess } from "./output-BCdLioKP.mjs";
+import { h as sanitizeTerminalText, i as dim, m as printSuccess } from "./output-BCdLioKP.mjs";
 import { n as OperatorClient, r as OperatorClientError } from "./operator-client-BIY4-N_6.mjs";
+import { t as MINIMAL_RUNTIME_LOGS_NOTE } from "./platform-runtime-logs-CdJGnk3f.mjs";
 import { a as resolveOperatorOrigin, i as removeOperatorToken, n as readOperatorApiTokenStdin, o as saveOperatorToken, r as readOperatorToken, t as exchangeOperatorSession } from "./operator-auth-CfDcmzpo.mjs";
 import { createHash } from "node:crypto";
 import { setTimeout } from "node:timers/promises";
@@ -81,11 +82,16 @@ function outputMutation(result, args) {
 	if (args.json || result.ok === false || result.partial === true || result.complete === false || result.error || result.operationStatus && result.operationStatus !== "completed" || configuration?.status && configuration.status !== "ready" && configuration.status !== "disabled" || project?.state === "reconciling" || project?.state === "error" || project?.last_error) return;
 	printSuccess(`Platform ${args.group} ${args.action} completed.`);
 }
-function outputLogs(result, json) {
+function outputLogs(result, json, state = {}) {
 	if (json) {
 		output(result, true);
 		return;
 	}
+	const minimal = result.runtimeLogs === "minimal";
+	if (minimal && !state.runtimeLogsNoted) {
+		state.runtimeLogsNoted = true;
+		console.log(dim(MINIMAL_RUNTIME_LOGS_NOTE));
+	}
 	if (Array.isArray(result.lines)) {
 		for (const entry of result.lines) if (entry && typeof entry === "object") {
 			const line = entry;
@@ -100,15 +106,26 @@ function outputLogs(result, json) {
 				continue;
 			}
 			const row = entry;
-			console.log(`${printable(row.timestamp ?? row.ts)} ${printable(row.method)} ${printable(row.url)} ${printable(row.status ?? row.statusCode ?? row.outcome)}`);
+			const parts = [
+				printable(row.timestamp ?? row.ts),
+				printable(row.method),
+				printable(row.url),
+				printable(row.status ?? row.statusCode ?? row.outcome)
+			];
+			console.log((minimal ? parts.filter((part) => part !== "") : parts).join(" "));
 			if (Array.isArray(row.logs)) for (const log of row.logs) if (log && typeof log === "object") {
 				const record = log;
-				console.log(`  ${record.level ? `[${printable(record.level)}] ` : ""}${printable(record.message ?? log)}`);
+				const level = record.level ? `[${printable(record.level)}] ` : "";
+				if (minimal && Array.isArray(record.message) && record.message.length === 0) console.log(`  ${level.trimEnd()}`);
+				else console.log(`  ${level}${printable(record.message ?? log)}`);
 			} else console.log(`  ${printable(log)}`);
 			if (Array.isArray(row.exceptions)) for (const exception of row.exceptions) if (exception && typeof exception === "object") {
 				const record = exception;
-				const name = record.name ? `${printable(record.name)}: ` : "";
-				console.log(`  ${name}${printable(record.message ?? exception)}`);
+				if (minimal && record.message === "" && record.name) console.log(`  ${printable(record.name)}`);
+				else {
+					const name = record.name ? `${printable(record.name)}: ` : "";
+					console.log(`  ${name}${printable(record.message ?? exception)}`);
+				}
 			} else console.log(`  ${printable(exception)}`);
 		}
 		if (result.nextCursor) console.log(`Next cursor: ${printable(result.nextCursor)}`);
@@ -163,8 +180,8 @@ async function runAuth(origin, args) {
 	if (args.action === "login" || args.action === "token" && args.tokenStdin) {
 		if (!args.tokenStdin && !process.stdin.isTTY) throw new OperatorClientError("Browser login requires an interactive terminal. Use --token-stdin to exchange an API session.", "interactive_login_required");
 		const apiToken = args.tokenStdin ? await readOperatorApiTokenStdin() : await (async () => {
-			const { discoverPlatform } = await import("./platform-cmd-WnOmdLzR.mjs");
-			const { selectPlatformLoginMethod } = await import("./login-C0MiQrYs.mjs");
+			const { discoverPlatform } = await import("./platform-cmd-DpCHawGF.mjs");
+			const { selectPlatformLoginMethod } = await import("./login-BpbYeu-n.mjs");
 			const { runPlatformLogin } = await import("./auth-CL-p_rqV.mjs");
 			return runPlatformLogin(origin, (await selectPlatformLoginMethod(await discoverPlatform(origin), args.provider)).id, (url) => process.stderr.write(`Sign in at ${url}\n`));
 		})();
@@ -230,6 +247,7 @@ async function followOperatorLogs(client, args, signal, pollIntervalMs = 2e3) {
 	let previousRuntimeRows = /* @__PURE__ */ new Map();
 	let currentRuntimeRows = /* @__PURE__ */ new Map();
 	let currentRuntimeRowCount = 0;
+	const outputState = {};
 	try {
 		while (!combined.aborted) {
 			const result = await client.request(args.path, {
@@ -252,7 +270,7 @@ async function followOperatorLogs(client, args, signal, pollIntervalMs = 2e3) {
 					data
 				};
 			}
-			outputLogs(visibleResult, args.json);
+			outputLogs(visibleResult, args.json, outputState);
 			if (args.group === "build") {
 				if (typeof result.lastSeq !== "number" || !Number.isSafeInteger(result.lastSeq) || result.lastSeq < Number(query.since ?? 0)) throw new OperatorClientError("Build log response has an invalid cursor.", "invalid_response");
 				const previousSeq = Number(query.since ?? 0);
@@ -344,7 +362,7 @@ async function migrateDeploymentAssets(client, origin, args) {
 }
 async function runOperatorCommand(args) {
 	if (!args.action) {
-		const { printHelpPage } = await import("./help-BcZDUcTw.mjs");
+		const { printHelpPage } = await import("./help-Ba8Dq5-r.mjs");
 		printHelpPage(["platform", args.group]);
 		return;
 	}

package/dist/operator-cmd-wBYyp8iQ.mjs

@@ -0,0 +1 @@
+export { a as runOperatorCommand } from "./operator-cmd-BUqsdk2K.mjs";

package/dist/pages/client.d.mts

@@ -1,8 +1,8 @@
-import { l as toUrlString, s as interpolateRouteParams } from "../route-url-BGOiyKNz.mjs";
-import { t as PageObject } from "../protocol-xdrl-In0.mjs";
-import { n as CacheForInput, r as CacheForResult } from "../prefetch-CG0K6JPd.mjs";
+import { f as toUrlString, u as interpolateRouteParams } from "../route-url-C_YIH_zO.mjs";
+import { t as PageObject } from "../protocol-CkwjASep.mjs";
+import { a as LinkPrefetchValue, i as LinkPrefetchStrategy, n as CacheForInput, r as CacheForResult } from "../prefetch-NdNeubbH.mjs";
 import { UsageLimitData } from "@void/edge";
-import { ActionUrl, ResolveActionBody, ResolveActionParams, RouteUrlInput } from "void/routes";
+import { ActionUrl, Href, ResolveActionBody, ResolveActionParams, RouteUrlInput } from "void/routes";
 type ActionErrorHandlingScope = "callSite" | "boundary";
 type ActionResult<T = PageObject | undefined> = {
   ok: true;
@@ -17,8 +17,9 @@ export declare class VoidActionError extends Error {
   readonly status: number;
   readonly statusText: string;
   readonly url: string;
-  constructor({ body, status, statusText, url }: {
+  constructor({ body, message, status, statusText, url }: {
     body: unknown;
+    message?: string;
     status: number;
     statusText: string;
     url: string;
@@ -38,6 +39,8 @@ type VisitOptions = {
   preserveState?: boolean;
   replace?: boolean;
   viewTransition?: boolean;
+  /** React navigation completion: page data readiness or UI commit (default). */
+  resolveOn?: "data" | "commit";
   /** @internal Used by React Actions to avoid waiting for a commit blocked by the action itself. */
   _resolveOnShell?: boolean;
   /** @internal Used by popstate handler to pass saved scroll position */
@@ -75,6 +78,8 @@ type PageNavigationEngineConfig = {
   viewTransitions: boolean;
   prefetchHoverDelay: number;
   prefetchDefaultCacheFor: CacheForResult;
+  /** How Links without a `prefetch` prop prefetch. Defaults to `false`. */
+  prefetchDefaultStrategy?: LinkPrefetchValue;
   /** Reuse successful GET page shells on later visits, refreshing stale shells in the background. */
   cacheVisitedPageData?: boolean;
 };
@@ -99,6 +104,7 @@ type PageNavigationResource = {
 };
 type PageNavigationEngine = {
   _hoverDelay: number;
+  _prefetchDefaultStrategy: LinkPrefetchValue;
   initialPageData: PageData;
   initialComponent: unknown;
   initialLayouts: Array<unknown>;
@@ -116,8 +122,82 @@ export declare function hasFiles(data: unknown): boolean;
 export declare function objectToFormData(source: Record<string, unknown>, form?: FormData, parentKey?: string): FormData;
 export declare function createPageNavigationEngine(config: PageNavigationEngineConfig): Promise<PageNavigationEngine>;
 export declare function getValidationErrors(body: unknown): Record<string, string> | null;
-export declare function mergeDataIntoHref(href: string, data?: Record<string, unknown>): string;
+export declare function mergeDataIntoHref(href: Href, data?: Record<string, unknown>): Href;
 export declare function isModifiedEvent(e: Pick<MouseEvent, "currentTarget" | "ctrlKey" | "metaKey" | "shiftKey" | "altKey" | "button">): boolean;
+type LinkNavigateEvent = {
+  preventDefault(): void;
+};
+type LinkActiveMatch = "exact" | "prefix";
+/** Present only when the link matches the current URL. */
+type LinkActiveAttributes = {
+  "aria-current"?: "page";
+  "data-void-active"?: "";
+};
+/** Present only while a visit to the link's destination is loading. */
+type LinkPendingAttributes = {
+  "data-void-pending"?: "";
+};
+/** Props every adapter's Link accepts. Adapters add element attributes and children. */
+type BaseLinkProps = {
+  href: Href;
+  method?: NavigationMethod | Lowercase<NavigationMethod>;
+  data?: Record<string, unknown>;
+  preserveScroll?: boolean;
+  preserveState?: boolean;
+  replace?: boolean;
+  reloadDocument?: boolean;
+  viewTransition?: boolean;
+  /** If omitted, the Link uses the app's `prefetch.defaultStrategy`. */
+  prefetch?: LinkPrefetchValue;
+  cacheFor?: CacheForInput;
+  activeMatch?: LinkActiveMatch;
+  onNavigate?: (event: LinkNavigateEvent) => void;
+};
+type ResolvedLink = {
+  method: NavigationMethod;
+  isGet: boolean;
+  /** The destination, with GET data merged into its query. */
+  href: Href;
+};
+type LinkClickEvent = Pick<MouseEvent, "currentTarget" | "ctrlKey" | "metaKey" | "shiftKey" | "altKey" | "button" | "defaultPrevented" | "preventDefault">;
+type LinkClickProps = Pick<BaseLinkProps, "data" | "preserveScroll" | "preserveState" | "replace" | "reloadDocument" | "viewTransition" | "onNavigate">;
+/** Normalizes the method and destination, rejecting options that only GET links support. */
+export declare function resolveLink(props: Pick<BaseLinkProps, "href" | "method" | "data" | "prefetch" | "reloadDocument">): ResolvedLink;
+/**
+ * The events that prefetch a Link. A Link without a `prefetch` prop uses the app's
+ * `defaultStrategy`, but only when it is a GET link, the only kind that can prefetch.
+ */
+export declare function linkPrefetchStrategies(props: Pick<BaseLinkProps, "prefetch" | "reloadDocument">, link: Pick<ResolvedLink, "isGet">, defaultStrategy?: LinkPrefetchValue): ReadonlyArray<LinkPrefetchStrategy>;
+/**
+ * Marks a GET link to the current page. Pathnames compare the way the server
+ * matches pages: case-sensitive, trailing slash significant, decoded like Hono's
+ * getPath. The query and hash are ignored. `prefix` also matches nested pages by
+ * whole segment, except for `/`, but only an exact match is `aria-current`.
+ * Spread the result before the user's attributes so theirs win.
+ */
+export declare function linkActiveAttributes(router: VoidRouter | null | undefined, link: ResolvedLink, match?: LinkActiveMatch): LinkActiveAttributes;
+/**
+ * Marks a link while a visit to its destination is loading: the visit uses the link's
+ * method and goes to its path, query and hash. Unlike active links, the query counts,
+ * so `?page=2` isn't pending during a visit to `?page=3`. Every link to the destination
+ * is marked, not only the one that was clicked.
+ * Spread the result before the user's attributes so theirs win.
+ */
+export declare function linkPendingAttributes(router: VoidRouter | null | undefined, navigation: NavigationState | null | undefined, link: ResolvedLink): LinkPendingAttributes;
+/** Link's automatic prefetch. `router.prefetch()` called directly is not limited by the connection. */
+export declare function prefetchLink(router: VoidRouter | null | undefined, href: Href, cacheFor: CacheForInput | undefined): void;
+/**
+ * Runs a client-side visit for a plain same-origin click. Modified clicks, downloads,
+ * cross-origin destinations and `reloadDocument` links are left to the browser.
+ * Call it after the user's own click handler so its `preventDefault()` is respected.
+ */
+export declare function handleLinkClick(event: LinkClickEvent, router: VoidRouter | null | undefined, link: ResolvedLink, props: LinkClickProps): void;
+/**
+ * Calls `onVisible` once, after `element` has stayed in the viewport for
+ * `LINK_VISIBLE_PREFETCH_DELAY` ms. Leaving the viewport cancels the wait and entering
+ * again restarts it. Returns a cleanup that also cancels a pending wait.
+ */
+export declare function observeLinkVisible(element: Element, onVisible: () => void): () => void;
 type IslandActionResult = {
   kind: "redirect";
   url: string;
@@ -142,11 +222,60 @@ export declare function parseFormResetArgs(args: ReadonlyArray<string | FormRese
   fields: ReadonlyArray<string>;
 };
 type FormMethod = "post" | "put" | "patch" | "delete";
-type FormModel<Args extends Array<unknown> = []> = {
-  readonly pending: boolean;
-  readonly error: VoidActionError | null;
+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. */
+type FormSubmitOptions = Omit<VisitOptions, "method" | "data"> & {
+  data?: Record<string, unknown>;
+};
+/** Submission state that `useForm()` and `useIslandForm()` report in every adapter. */
+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. */
+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.
+ */
+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.
+ */
+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 declare function formErrorMessage(form: Pick<FormModel, "error" | "errors">): string | null;
 export declare function formRetryMessage(error: VoidActionError | null): string | null;
 export declare function formSubmissionBlocked(form: Pick<FormModel, "pending" | "error">, now?: number): boolean;
@@ -161,6 +290,8 @@ export type NavigationState = {
 };
 export type VoidRouter = {
   _hoverDelay: number;
+  /** How Links without a `prefetch` prop prefetch. Absent during SSR. */
+  _prefetchDefaultStrategy?: LinkPrefetchValue;
   readonly url: URL;
   readonly path: string;
   readonly query: URLSearchParams;
@@ -183,7 +314,7 @@ export type VoidRouterConfig = Omit<PageNavigationEngineConfig, "adapter"> & {
 };
 export declare function idleNavigationState(): NavigationState;
 export declare function createRouterFacade(router: VoidRouter, getCurrentUrl: () => string, getCurrentParams?: () => Record<string, string>): VoidRouter;
-export declare function createSsrRouter(url?: string, params?: Record<string, string>): VoidRouter;
+export declare function createSsrRouter(url?: string, params?: Record<string, string>, requestUrl?: string): VoidRouter;
 export declare const ssrProxy: VoidRouter;
 /** Refetch the current page in place: same history entry, URL hash, state and scroll. */
 export declare function refreshPage(router: Pick<VoidRouter, "visit">, options?: VisitOptions): Promise<unknown>;
@@ -193,6 +324,7 @@ type HasParams<U extends string> = [ResolveActionParams<U>] extends [never] ? fa
 type ActionOptions<U extends string> = {
   data?: ResolveActionBody<U>;
   method?: ActionMethod;
+  preserveScroll?: boolean;
 } & (HasParams<U> extends true ? {
   params: ResolveActionParams<U>;
 } : {
@@ -214,4 +346,4 @@ export declare function createVoidRouter(config: VoidRouterConfig): Promise<{
 }>;
 export declare function scheduleHydration(el: Element, loader: () => Promise<unknown>, props: Record<string, unknown>, strategy: string, hydrateFn: (el: Element, mod: unknown, props: Record<string, unknown>) => void | Promise<void>): void;
 export declare function initIslands(islands: Record<string, () => Promise<unknown>>, hydrateFn: (el: Element, mod: unknown, props: Record<string, unknown>, frontmatter: Record<string, unknown>) => void | Promise<void>): void;
-export { type ActionErrorHandlingScope, type ActionResult, type FormMethod, type FormModel, type FormResetOptions, type IslandActionResult, type PageNavigationEngine, type PageNavigationResource, type PageNavigationResult, type PrefetchOptions, type VisitOptions, interpolateRouteParams, toUrlString };
+export { type ActionErrorHandlingScope, type ActionResult, type BaseLinkProps, type FormMethod, type FormModel, type FormResetOptions, type FormState, type FormSubmitOptions, type IslandActionResult, type IslandFormState, type LinkActiveAttributes, type LinkActiveMatch, type LinkNavigateEvent, type LinkPendingAttributes, type LinkPrefetchStrategy, type LinkPrefetchValue, type PageNavigationEngine, type PageNavigationResource, type PageNavigationResult, type PrefetchOptions, type ResolvedLink, type VisitOptions, interpolateRouteParams, toUrlString };