@void/solid 0.10.13 → 0.20.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present, Cloudflare, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -115,7 +115,8 @@ request.
 
 ## Tests
 
-- `test/unit/use-form.test.ts`
 - `test/integration/solid-pages-playground.test.ts`
 
 The Solid integration test covers both SSR output and browser-side navigation/forms.
+
+The [shared client](../../test/pages-client-contract.ts) and [island](../../test/pages-island-contract.ts) contracts run against this adapter in both dev and preview. Shared form equality is tested directly in [Void](../void/test/unit/form-value-equality.test.ts); tests do not copy the hook implementation.

package/dist/plugin.d.mts

@@ -1,16 +1,14 @@
 import solid from "vite-plugin-solid";
 import { Plugin } from "vite";
-
 //#region src/plugin.d.ts
 type PrefetchConfig = {
   hoverDelay?: number;
   cacheFor?: number | string | [string, string];
 };
-type VoidSolidOptions = Readonly<{
+export type VoidSolidOptions = Readonly<{
   solid?: Parameters<typeof solid>[0];
   viewTransitions?: boolean;
   prefetch?: PrefetchConfig;
 }>;
-declare function voidSolid(options?: VoidSolidOptions): Array<Plugin>;
-//#endregion
-export { VoidSolidOptions, voidSolid };
+export declare function voidSolid(options?: VoidSolidOptions): Array<Plugin>;
+//#endregion

package/dist/plugin.mjs

@@ -203,7 +203,7 @@ function islandsPlugin(pagesDir, options) {
 						});
 					}
 					const islandId = absPath ? normalizePath(relative(root, absPath)).replace(/\.[^.]+$/, "") : spec;
-					const wrapperUrl = "/@void-island-wrap/island_" + wrapperId++ + ".tsx";
+					const wrapperUrl = WRAPPER_PREFIX + "island_" + wrapperId++ + ".tsx";
 					wrapperMeta.set(wrapperUrl, {
 						src: absPath || spec,
 						islandId,
@@ -341,6 +341,7 @@ initIslands(islands, mountIsland);
 }
 //#endregion
 //#region src/plugin-pages.ts
+const RENDERER_ID = "virtual:void-pages-renderer";
 const CLIENT_ENTRY_ID = "virtual:void-pages-client";
 /** Check if the pages directory has any non-island page files (.tsx/.jsx without .island.). */
 function hasNonIslandPages(dir) {
@@ -374,7 +375,7 @@ function pagesPlugin(pagesDir, options) {
 		return pendingRescan;
 	};
 	const invalidatePageModules = (server) => {
-		for (const env of Object.values(server.environments)) for (const id of ["\0virtual:void-pages-renderer", "\0virtual:void-pages-client"]) {
+		for (const env of Object.values(server.environments)) for (const id of ["\0" + RENDERER_ID, "\0" + CLIENT_ENTRY_ID]) {
 			const mod = env.moduleGraph.getModuleById(id);
 			if (mod) env.moduleGraph.invalidateModule(mod);
 		}
@@ -395,11 +396,11 @@ function pagesPlugin(pagesDir, options) {
 			async handler(id) {
 				if (isDev && pendingRescan) await pendingRescan;
 				if (!pageScan && existsSync(pagesDir)) await runRescan();
-				if (id === "\0virtual:void-pages-renderer") {
+				if (id === "\0" + RENDERER_ID) {
 					if (!pageScan) return "export function renderPage() { throw new Error('No pages found'); }";
 					return generateRendererModule(pageScan, pagesDir);
 				}
-				if (id === "\0virtual:void-pages-client") {
+				if (id === "\0" + CLIENT_ENTRY_ID) {
 					if (!pageScan) return "";
 					return generateClientEntry(pageScan, pagesDir, options?.viewTransitions, options?.prefetch, resolveStaticPageDataBuildOptions(root, { publicDir: viteConfig?.publicDir }));
 				}

package/dist/runtime/context.d.mts

@@ -0,0 +1,9 @@
+import { Context } from "solid-js";
+import { NavigationState, VoidRouter } from "void/pages-client";
+//#region src/runtime/context.d.ts
+export declare const SharedContext: Context<Record<string, unknown> | null>;
+export declare const ErrorsContext: Context<Record<string, string> | (() => Record<string, string>) | null>;
+export declare const ParamsContext: Context<Record<string, string> | null>;
+export declare const RouterContext: Context<VoidRouter | null>;
+export declare const NavigationContext: Context<(() => NavigationState) | null>;
+//#endregion

package/dist/runtime/context.mjs

@@ -0,0 +1,9 @@
+import { createContext } from "solid-js";
+//#region src/runtime/context.ts
+const SharedContext = createContext(null);
+const ErrorsContext = createContext(null);
+const ParamsContext = createContext(null);
+const RouterContext = createContext(null);
+const NavigationContext = createContext(null);
+//#endregion
+export { ErrorsContext, NavigationContext, ParamsContext, RouterContext, SharedContext };

package/dist/runtime/index.d.mts

@@ -0,0 +1,103 @@
+import { ErrorsContext, NavigationContext, ParamsContext, RouterContext, SharedContext } from "./context.mjs";
+import { JSX } from "solid-js";
+import { ActionResult, NavigationState, VisitOptions, VoidActionError, VoidRouter } from "void/pages-client";
+import { CloudContextVariables, DeferredState as Deferred, InferProps } from "void";
+import { ActionFormOptions, ActionUrl, ResolveActionBody, ResolveActionParams } from "void/routes";
+//#region src/runtime/link.d.ts
+type PrefetchStrategy = "hover" | "click" | "mount" | "visible";
+type LinkMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type NavigateEvent = {
+  preventDefault(): void;
+};
+type CommonProps = {
+  href: string;
+  method?: LinkMethod | Lowercase<LinkMethod>;
+  data?: Record<string, unknown>;
+  preserveScroll?: boolean;
+  preserveState?: boolean;
+  replace?: boolean;
+  reloadDocument?: boolean;
+  viewTransition?: boolean;
+  prefetch?: boolean | PrefetchStrategy | ReadonlyArray<PrefetchStrategy>;
+  cacheFor?: number | string | [string, string];
+  onNavigate?: (event: NavigateEvent) => void;
+  children?: JSX.Element;
+};
+type LinkProps = CommonProps & Omit<JSX.AnchorHTMLAttributes<HTMLAnchorElement>, keyof CommonProps> & Omit<JSX.ButtonHTMLAttributes<HTMLButtonElement>, keyof CommonProps>;
+export declare function Link(props: LinkProps): JSX.Element;
+//#endregion
+//#region src/runtime/use-router.d.ts
+export declare function useRouter(): VoidRouter;
+//#endregion
+//#region src/runtime/use-params.d.ts
+export declare function useParams<T extends Record<string, string> = Record<string, string>>(): T;
+//#endregion
+//#region src/runtime/use-shared.d.ts
+export declare function useShared<T = CloudContextVariables["shared"]>(): T;
+//#endregion
+//#region src/runtime/use-form.d.ts
+type FormSubmitOptions = Omit<VisitOptions, "method" | "data"> & {
+  data?: Record<string, unknown>;
+};
+export declare 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(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
+  clearErrors(...fields: ReadonlyArray<keyof ResolveActionBody<U> & string>): void;
+  clearError(): void;
+};
+//#endregion
+//#region src/runtime/use-navigation.d.ts
+export declare function useNavigation(): NavigationState;
+//#endregion
+//#region src/runtime/use-island-form.d.ts
+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>;
+}>;
+/**
+ * Form composable for island pages. Uses fetch + page reload instead of the
+ * Void Router (which is not available in island mode).
+ */
+export declare function useIslandForm<T extends Record<string, unknown>>(defaults: T): IslandFormReturn<T>;
+//#endregion
+//#region src/runtime/action.d.ts
+type ActionMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+type HasParams<U extends string> = [ResolveActionParams<U>] extends [never] ? false : true;
+type ActionOptions<U extends string> = {
+  data?: ResolveActionBody<U>;
+  method?: ActionMethod;
+} & (HasParams<U> extends true ? {
+  params: ResolveActionParams<U>;
+} : {
+  params?: never;
+});
+/** Called during app initialization to store the router instance */
+export declare function setActionRouter(router: VoidRouter): void;
+/** Programmatic one-shot page action call with Inertia page update */
+export declare function action<U extends ActionUrl & string>(url: U, ...args: HasParams<U> extends true ? [options: ActionOptions<U>] : [options?: ActionOptions<U>]): Promise<ActionResult>;
+//#endregion
+export { type Deferred, ErrorsContext, type InferProps, type LinkProps, NavigationContext, ParamsContext, RouterContext, SharedContext };

package/dist/runtime/index.mjs

@@ -0,0 +1,527 @@
+import { ErrorsContext, NavigationContext, ParamsContext, RouterContext, SharedContext } from "./context.mjs";
+import { createMemo, createSignal, onCleanup, onMount, splitProps, useContext } from "solid-js";
+import { VoidActionError, categorizeActionError, idleNavigationState, isAbortError, isEqualFormValue, ssrProxy, submitAction } from "void/pages-client";
+import { createStore, reconcile } from "solid-js/store";
+//#region src/runtime/link.tsx
+function appendQueryValue(params, key, value) {
+	if (value === null || value === void 0) return false;
+	if (value instanceof Date) {
+		params.append(key, value.toISOString());
+		return true;
+	}
+	if (Array.isArray(value)) {
+		let appended = false;
+		for (const item of value) appended = appendQueryValue(params, key, item) || appended;
+		return appended;
+	}
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+		params.append(key, String(value));
+		return true;
+	}
+	throw new Error(`Link: GET data only supports primitive values and arrays. Remove nested data for '${key}'.`);
+}
+function mergeDataIntoHref(href, data) {
+	if (!data) return href;
+	const hashIndex = href.indexOf("#");
+	const beforeHash = hashIndex === -1 ? href : href.slice(0, hashIndex);
+	const hash = hashIndex === -1 ? "" : href.slice(hashIndex);
+	const searchIndex = beforeHash.indexOf("?");
+	const path = searchIndex === -1 ? beforeHash : beforeHash.slice(0, searchIndex);
+	const search = searchIndex === -1 ? "" : beforeHash.slice(searchIndex + 1);
+	const params = new URLSearchParams(search);
+	let appended = false;
+	for (const [key, value] of Object.entries(data)) appended = appendQueryValue(params, key, value) || appended;
+	if (!appended) return href;
+	const query = params.toString();
+	return `${path}${query ? `?${query}` : ""}${hash}`;
+}
+function hasPrefetch(prefetch) {
+	return prefetch !== false && prefetch !== void 0;
+}
+function isModifiedEvent(e) {
+	const target = e.currentTarget.getAttribute("target");
+	return target !== null && target !== "_self" || e.ctrlKey || e.metaKey || e.shiftKey || e.altKey || e.button !== 0;
+}
+function mergeStyle(style) {
+	if (typeof style === "string") return `touch-action: manipulation; ${style}`;
+	return {
+		touchAction: "manipulation",
+		...style
+	};
+}
+function callHandler(handler, event) {
+	if (Array.isArray(handler)) {
+		const [fn, data] = handler;
+		if (typeof fn === "function") fn(data, event);
+	} else if (typeof handler === "function") handler(event);
+}
+function Link(props) {
+	const [local, rest] = splitProps(props, [
+		"href",
+		"method",
+		"data",
+		"preserveScroll",
+		"preserveState",
+		"replace",
+		"reloadDocument",
+		"viewTransition",
+		"prefetch",
+		"cacheFor",
+		"onNavigate",
+		"children",
+		"style",
+		"onClick",
+		"onMouseEnter",
+		"onMouseLeave",
+		"onFocus",
+		"onMouseDown",
+		"onTouchStart"
+	]);
+	const router = useContext(RouterContext);
+	const linkState = createMemo(() => {
+		const method = (local.method || "GET").toUpperCase();
+		const isGet = method === "GET";
+		if (hasPrefetch(local.prefetch) && !isGet) throw new Error("Link: prefetch only supports GET links. Remove `prefetch` or use method=\"GET\".");
+		if (local.reloadDocument && !isGet) throw new Error("Link: reloadDocument only supports GET links.");
+		return {
+			href: isGet ? mergeDataIntoHref(local.href, local.data) : local.href,
+			isGet,
+			method
+		};
+	});
+	const normalizedMethod = () => linkState().method;
+	const isGet = () => linkState().isGet;
+	const hrefWithData = () => linkState().href;
+	const strategies = createMemo(() => {
+		if (local.prefetch === false || local.prefetch === void 0 || local.reloadDocument) return [];
+		if (local.prefetch === true) return ["hover"];
+		if (typeof local.prefetch === "string") return [local.prefetch];
+		return local.prefetch;
+	});
+	const resolvedStyle = createMemo(() => mergeStyle(local.style));
+	function doPrefetch() {
+		if (!router?.prefetch) return;
+		const current = window.location.pathname + window.location.search;
+		if (hrefWithData() === current) return;
+		const options = {};
+		if (local.cacheFor !== void 0) options.cacheFor = local.cacheFor;
+		if (normalizedMethod()) options.method = normalizedMethod();
+		router.prefetch(hrefWithData(), options);
+	}
+	function shouldHandleClick(event) {
+		if (local.reloadDocument || !router || event.defaultPrevented || isModifiedEvent(event)) return false;
+		if (event.currentTarget.hasAttribute("download")) return false;
+		if (new URL(hrefWithData(), window.location.origin).origin !== window.location.origin) return false;
+		return true;
+	}
+	function onClick(event) {
+		callHandler(local.onClick, event);
+		if (!shouldHandleClick(event)) return;
+		let navigatePrevented = false;
+		local.onNavigate?.({ preventDefault() {
+			navigatePrevented = true;
+		} });
+		if (navigatePrevented) {
+			event.preventDefault();
+			return;
+		}
+		event.preventDefault();
+		router?.visit(hrefWithData(), {
+			method: normalizedMethod(),
+			data: isGet() ? void 0 : local.data,
+			preserveScroll: local.preserveScroll,
+			preserveState: local.preserveState,
+			replace: local.replace,
+			viewTransition: local.viewTransition
+		});
+	}
+	let hoverTimer = null;
+	let observer = null;
+	let el;
+	function onMouseEnter(event) {
+		callHandler(local.onMouseEnter, event);
+		if (event.defaultPrevented) return;
+		if (hoverTimer) clearTimeout(hoverTimer);
+		hoverTimer = setTimeout(doPrefetch, router?._hoverDelay ?? 75);
+	}
+	function onMouseLeave(event) {
+		callHandler(local.onMouseLeave, event);
+		if (hoverTimer) {
+			clearTimeout(hoverTimer);
+			hoverTimer = null;
+		}
+	}
+	function onFocus(event) {
+		callHandler(local.onFocus, event);
+		if (!event.defaultPrevented) doPrefetch();
+	}
+	function onMouseDown(event) {
+		callHandler(local.onMouseDown, event);
+		if (!event.defaultPrevented) doPrefetch();
+	}
+	function onTouchStart(event) {
+		callHandler(local.onTouchStart, event);
+		if (!event.defaultPrevented) doPrefetch();
+	}
+	onMount(() => {
+		if (strategies().includes("mount")) doPrefetch();
+		if (strategies().includes("visible") && el) {
+			observer = new IntersectionObserver((entries) => {
+				if (entries.some((e) => e.isIntersecting)) {
+					doPrefetch();
+					observer?.disconnect();
+					observer = null;
+				}
+			}, { rootMargin: "0px" });
+			observer.observe(el);
+		}
+	});
+	onCleanup(() => {
+		if (hoverTimer) clearTimeout(hoverTimer);
+		if (observer) {
+			observer.disconnect();
+			observer = null;
+		}
+	});
+	const eventHandlers = createMemo(() => {
+		const handlers = {
+			onClick,
+			onFocus: local.onFocus,
+			onMouseDown: local.onMouseDown,
+			onMouseEnter: local.onMouseEnter,
+			onMouseLeave: local.onMouseLeave,
+			onTouchStart: local.onTouchStart
+		};
+		if (strategies().includes("hover")) {
+			handlers.onMouseEnter = onMouseEnter;
+			handlers.onMouseLeave = onMouseLeave;
+			handlers.onFocus = onFocus;
+			handlers.onTouchStart = onTouchStart;
+		}
+		if (strategies().includes("click")) {
+			handlers.onMouseDown = onMouseDown;
+			handlers.onTouchStart = onTouchStart;
+		}
+		return handlers;
+	});
+	return <>
+      {isGet() ? <a ref={(r) => {
+		el = r;
+	}} href={hrefWithData()} {...rest} style={resolvedStyle()} {...eventHandlers()}>
+          {local.children}
+        </a> : <button ref={(r) => {
+		el = r;
+	}} type="button" {...rest} style={resolvedStyle()} {...eventHandlers()}>
+          {local.children}
+        </button>}
+    </>;
+}
+//#endregion
+//#region src/runtime/use-router.ts
+function useRouter() {
+	return useContext(RouterContext) ?? ssrProxy;
+}
+//#endregion
+//#region src/runtime/use-params.ts
+function useParams() {
+	const params = useContext(ParamsContext);
+	if (params === null) throw new Error("useParams(): must be used inside a Void page.");
+	return params;
+}
+//#endregion
+//#region src/runtime/use-shared.ts
+function useShared() {
+	const shared = useContext(SharedContext);
+	if (shared === null) throw new Error("useShared(): must be used inside a pages component.");
+	return shared;
+}
+//#endregion
+//#region src/runtime/use-form.ts
+function getValidationErrors$1(error) {
+	const body = error.body;
+	if (body && typeof body === "object" && "errors" in body && body.errors && typeof body.errors === "object" && !Array.isArray(body.errors)) return body.errors;
+	return null;
+}
+function useForm(url, defaults, options) {
+	let resolvedUrl = url;
+	let actionQuery = "";
+	const qIdx = resolvedUrl.indexOf("?");
+	if (qIdx !== -1) {
+		actionQuery = resolvedUrl.slice(qIdx);
+		resolvedUrl = resolvedUrl.slice(0, qIdx);
+	}
+	if (options?.params) for (const [key, value] of Object.entries(options.params)) resolvedUrl = resolvedUrl.replace(`:${key}`, encodeURIComponent(value));
+	resolvedUrl = resolvedUrl + actionQuery;
+	const router = useContext(RouterContext);
+	const globalErrors = useContext(ErrorsContext);
+	const [data, setDataStore] = createStore({ ...defaults });
+	const [localErrors, setLocalErrors] = createSignal({});
+	const errors = createMemo(() => {
+		const local = localErrors();
+		if (Object.keys(local).length > 0) return local;
+		if (!globalErrors) return {};
+		if (typeof globalErrors === "function") return globalErrors();
+		return globalErrors;
+	});
+	const [pending, setPending] = createSignal(false);
+	const [error, setError] = createSignal(null);
+	const [wasSuccessful, setWasSuccessful] = createSignal(false);
+	const [recentlySuccessful, setRecentlySuccessful] = createSignal(false);
+	let defaults_ = { ...defaults };
+	let successTimeout = null;
+	const hasChanges = createMemo(() => {
+		return Object.keys(defaults_).some((key) => !isEqualFormValue(data[key], defaults_[key]));
+	});
+	function setData(field, value) {
+		setDataStore(field, value);
+	}
+	function reset(...fields) {
+		if (fields.length === 0) setDataStore(reconcile({ ...defaults_ }));
+		else for (const field of fields) setDataStore(field, defaults_[field]);
+	}
+	function clearErrors(...fields) {
+		if (fields.length === 0) setLocalErrors({});
+		else setLocalErrors((prev) => {
+			const next = { ...prev };
+			for (const field of fields) delete next[field];
+			return next;
+		});
+	}
+	function clearError() {
+		setError(null);
+	}
+	async function submit(method, opts = {}) {
+		setPending(true);
+		setWasSuccessful(false);
+		setRecentlySuccessful(false);
+		if (successTimeout) clearTimeout(successTimeout);
+		setLocalErrors({});
+		clearError();
+		try {
+			if (!router) throw new Error("useForm(): requires the Void Router.");
+			const result = await submitAction(router, resolvedUrl, {
+				method,
+				data: { ...data },
+				...opts
+			});
+			if (!result.ok) {
+				const validationErrors = getValidationErrors$1(result.error);
+				if (validationErrors) setLocalErrors(validationErrors);
+				else setError(result.error);
+				return;
+			}
+			setWasSuccessful(true);
+			setRecentlySuccessful(true);
+			defaults_ = { ...data };
+			successTimeout = setTimeout(() => {
+				setRecentlySuccessful(false);
+			}, 2e3);
+		} catch (submitError) {
+			if (isAbortError(submitError)) return;
+			throw submitError;
+		} finally {
+			setPending(false);
+		}
+	}
+	return {
+		get data() {
+			return data;
+		},
+		setData,
+		get errors() {
+			return errors();
+		},
+		get error() {
+			return error();
+		},
+		get pending() {
+			return pending();
+		},
+		get hasChanges() {
+			return hasChanges();
+		},
+		get wasSuccessful() {
+			return wasSuccessful();
+		},
+		get recentlySuccessful() {
+			return recentlySuccessful();
+		},
+		reset,
+		clearErrors,
+		clearError,
+		post: (opts) => submit("POST", opts),
+		put: (opts) => submit("PUT", opts),
+		patch: (opts) => submit("PATCH", opts),
+		delete: (opts) => submit("DELETE", opts)
+	};
+}
+//#endregion
+//#region src/runtime/use-navigation.ts
+function useNavigation() {
+	const navigation = useContext(NavigationContext);
+	if (!navigation) return idleNavigationState();
+	return {
+		get state() {
+			return navigation().state;
+		},
+		get location() {
+			return navigation().location;
+		},
+		get method() {
+			return navigation().method;
+		}
+	};
+}
+//#endregion
+//#region src/runtime/use-island-form.ts
+function getValidationErrors(body) {
+	if (body && typeof body === "object" && "errors" in body && body.errors && typeof body.errors === "object" && !Array.isArray(body.errors)) return body.errors;
+	return null;
+}
+async function readActionErrorBody(response) {
+	const contentType = response.headers.get("content-type") || "";
+	try {
+		if (contentType.includes("application/json")) return await response.json();
+		return await response.text() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Form composable for island pages. Uses fetch + page reload instead of the
+* Void Router (which is not available in island mode).
+*/
+function useIslandForm(defaults) {
+	const [data, setDataStore] = createStore({ ...defaults });
+	const [errors, setErrors] = createSignal({});
+	const [error, setError] = createSignal(null);
+	const [pending, setPending] = createSignal(false);
+	const [wasSuccessful, setWasSuccessful] = createSignal(false);
+	const [recentlySuccessful, setRecentlySuccessful] = createSignal(false);
+	let defaults_ = { ...defaults };
+	let successTimeout = null;
+	const hasChanges = createMemo(() => {
+		return Object.keys(defaults_).some((key) => !isEqualFormValue(data[key], defaults_[key]));
+	});
+	function setData(field, value) {
+		setDataStore(field, value);
+	}
+	function reset(...fields) {
+		if (fields.length === 0) setDataStore(reconcile({ ...defaults_ }));
+		else for (const field of fields) setDataStore(field, defaults_[field]);
+	}
+	function clearErrors(...fields) {
+		if (fields.length === 0) setErrors({});
+		else setErrors((prev) => {
+			const next = { ...prev };
+			for (const field of fields) delete next[field];
+			return next;
+		});
+	}
+	function clearError() {
+		setError(null);
+	}
+	async function submit(url, method) {
+		setPending(true);
+		setWasSuccessful(false);
+		setRecentlySuccessful(false);
+		if (successTimeout) clearTimeout(successTimeout);
+		setErrors({});
+		clearError();
+		try {
+			const response = await fetch(url, {
+				method,
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(data)
+			});
+			if (response.redirected) {
+				window.location.href = response.url;
+				return;
+			}
+			if (response.ok) {
+				setWasSuccessful(true);
+				setRecentlySuccessful(true);
+				defaults_ = { ...data };
+				successTimeout = setTimeout(() => setRecentlySuccessful(false), 2e3);
+				window.location.reload();
+			} else if (!response.ok) {
+				const body = await readActionErrorBody(response);
+				const actionError = new VoidActionError({
+					body,
+					status: response.status,
+					statusText: response.statusText,
+					url
+				});
+				const validationErrors = response.status === 422 ? getValidationErrors(body) : null;
+				if (validationErrors) {
+					setErrors(validationErrors);
+					return;
+				}
+				if (categorizeActionError(response.status) === "boundary") throw actionError;
+				setError(actionError);
+			}
+		} finally {
+			setPending(false);
+		}
+	}
+	return {
+		get data() {
+			return data;
+		},
+		setData,
+		get errors() {
+			return errors();
+		},
+		get error() {
+			return error();
+		},
+		get pending() {
+			return pending();
+		},
+		get hasChanges() {
+			return hasChanges();
+		},
+		get wasSuccessful() {
+			return wasSuccessful();
+		},
+		get recentlySuccessful() {
+			return recentlySuccessful();
+		},
+		reset,
+		clearErrors,
+		clearError,
+		post: (url) => submit(url, "POST"),
+		put: (url) => submit(url, "PUT"),
+		patch: (url) => submit(url, "PATCH"),
+		delete: (url) => submit(url, "DELETE")
+	};
+}
+//#endregion
+//#region src/runtime/action.ts
+let _router = null;
+/** Called during app initialization to store the router instance */
+function setActionRouter(router) {
+	_router = router;
+}
+/** Programmatic one-shot page action call with Inertia page update */
+async function action(url, ...args) {
+	if (!_router) throw new Error("action(): called before router initialization.");
+	const options = args[0];
+	const data = options?.data;
+	const method = options?.method || "POST";
+	let resolvedUrl = url;
+	let actionQuery = "";
+	const qIdx = resolvedUrl.indexOf("?");
+	if (qIdx !== -1) {
+		actionQuery = resolvedUrl.slice(qIdx);
+		resolvedUrl = resolvedUrl.slice(0, qIdx);
+	}
+	if (options?.params) for (const [key, value] of Object.entries(options.params)) resolvedUrl = resolvedUrl.replace(`:${key}`, encodeURIComponent(value));
+	resolvedUrl = resolvedUrl + actionQuery;
+	return submitAction(_router, resolvedUrl, {
+		method,
+		data
+	});
+}
+//#endregion
+export { ErrorsContext, Link, NavigationContext, ParamsContext, RouterContext, SharedContext, action, setActionRouter, useForm, useIslandForm, useNavigation, useParams, useRouter, useShared };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@void/solid",
-  "version": "0.10.13",
+  "version": "0.20.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -13,46 +13,36 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/runtime/index.ts",
+      "types": "./dist/runtime/index.d.mts",
       "default": "./src/runtime/index.ts"
     },
     "./plugin": {
       "types": "./dist/plugin.d.mts",
       "import": "./dist/plugin.mjs"
-    },
-    "./runtime": {
-      "types": "./src/runtime/index.ts",
-      "default": "./src/runtime/index.ts"
-    },
-    "./context": {
-      "default": "./src/runtime/context.ts"
-    },
-    "./prefetch": {
-      "default": "./src/runtime/prefetch.ts"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "vite-plugin-solid": "^2.11.12"
+    "vite-plugin-solid": "^2.11.14"
   },
   "devDependencies": {
-    "@types/node": "^26.1.0",
+    "@types/node": "^26.5.1",
     "pathslash": "^0.1.0",
-    "solid-js": "^1.9.14",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
-    "vite-plus": "^0.2.2",
-    "void": "0.10.13"
+    "solid-js": "^1.9.15",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.3.1",
+    "vite-plus": "0.3.1",
+    "void": "0.20.0"
   },
   "peerDependencies": {
     "solid-js": "^1.9.0",
     "vite": "^8.0.0",
-    "void": "0.10.13"
+    "void": "0.20.0"
   },
   "scripts": {
     "build": "vp pack",
     "dev": "vp pack --watch",
-    "typecheck": "tsgo --noEmit"
+    "typecheck": "tsc --noEmit --rootDir ../.."
   }
 }

package/src/runtime/prefetch.ts

@@ -1,2 +0,0 @@
-export { PrefetchCache, parseCacheFor } from 'void/pages-prefetch';
-export type { CacheForResult, CacheForInput, CacheEntry } from 'void/pages-prefetch';