void-plugin-hono-jsx 0.0.0-bootstrap.0 → 0.1.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.1.0-alpha.0 (release candidate; unpublished)
+
+- Accept the upstream esbuild development-server advisory GHSA-67mh-4wv8-2f99 as a documented limitation of the pinned alpha baseline, without dependency overrides. New unreviewed advisories and publisher-tooling findings remain blocked by the release gates.
+- Verify Void 0.26.1 production deferred errors remain generic while development preserves diagnostic messages.
+- Record the macOS development transport limitation after an undefined-action POST; the adapter does not repair this upstream edge case.
+
+Initial experimental Hono JSX Pages adapter for Void 0.26.1.
+
+- Server-rendered Pages, client-only pages, Void navigation and persistent layouts.
+- Loader/action forms, head metadata and single deferred loader props.
+- Load-policy islands, static output, development document reload and local ISR.
+- Exact framework peers: Hono 4.13.13, Void 0.26.1 and Vite 8.3.3; Node >=24.21.0.
+
+Browser mounting redraws server content. Managed edge deployment is unverified.
+See the package guide for unsupported modes and the pinned compatibility policy.
+This entry records the candidate scope; it does not claim an npm publication.

package/README.md

@@ -1,3 +1,142 @@
-# Registration-only staging candidate
+# Experimental Hono Pages adapter for Void
 
-This candidate establishes package ownership for Trusted Publisher setup. It contains no adapter code and must not be approved. The adapter release will be staged separately as 0.1.0-alpha.0 / next.
+This experimental package integrates Hono JSX with Void Pages. The package name is `void-plugin-hono-jsx`. The initial `0.1.0-alpha.0` candidate targets the `next` dist-tag. It is unpublished and distributed under the [MIT license](LICENSE). Publication remains a separate maintainer decision. It is not an official Void adapter.
+
+## Supported versions
+
+| Dependency | Verified version |
+| --- | --- |
+| Node.js | 24.21.0 or newer |
+| Void | 0.26.1 |
+| Hono | 4.13.13 |
+| Vite | 8.3.3 |
+
+Framework packages are exact peer dependencies. Other versions have not been validated; configuration fails with an install command when Void, Hono or Vite differs from this baseline.
+
+## Install the validation tarball
+
+In the repository, run `npm ci`, `npm run build:package`, then `npm pack ./packages/hono-pages`. Install the resulting tarball in your project alongside the supported peer versions:
+
+```sh
+npm install ./void-plugin-hono-jsx-0.1.0-alpha.0.tgz hono@4.13.13
+npm install --save-dev void@0.26.1 vite@8.3.3 typescript@7.0.2
+```
+
+## Configure
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import { voidPlugin } from 'void';
+import { voidHonoPages } from 'void-plugin-hono-jsx/plugin';
+
+export default defineConfig({ plugins: [voidPlugin(), voidHonoPages()] });
+```
+
+Configure project settings in `void.config.ts` using `defineConfig` from `void/config`. Run Vite from that project's root. `voidHonoPages()` includes the Hono JSX transform, so do not register a separate transform. Configure charset, viewport and favicon through Void's `head` settings.
+
+Use `jsx: "react-jsx"` and `jsxImportSource: "hono/jsx"` in TypeScript. The plugin chooses the server or DOM factory for application JSX; the plugin resolves package runtime exports using Vite's actual consumer environment. Cloudflare worker environments may enable the browser condition, so that condition alone cannot select the renderer.
+
+## Runtime exports
+
+```tsx
+import { Link, useRouter, useShared, useParams, useErrors } from 'void-plugin-hono-jsx/pages';
+import { useForm } from 'void-plugin-hono-jsx/form';
+```
+
+`Link` and `useRouter` use Void's shared navigation protocol. Ordinary GET visits reset page state; refresh preserves it. Root/nested/named layouts retain state while they remain in the active chain. Shared data, route params and field errors are available in SSR and browser components. `useForm` supports all mutation methods, named actions, validation, duplicate suppression and cancellation. Cancellation does not undo server writes.
+
+Head resolution and escaping follow Void. The adapter synchronizes document attributes and inert script metadata; navigation does not execute newly inserted scripts. Raw `script.innerHTML` is authored content. Serialize dynamic JSON-LD and escape `<` before assigning it.
+
+## Static output and prerendering
+
+Set `output: 'static'` in `void.config.ts`, then run `vite build`. Void collects known page routes and dynamic `getPrerenderPaths()` results and generates HTML plus `/_void/pages/*.json` under `dist/client`. The Hono adapter supplies its renderer and enables the shared router's static-data mode. It adds no route crawler.
+
+```ts
+// pages/users/[id].server.ts
+import { defineHandler } from 'void';
+export const prerender = true;
+export const getPrerenderPaths = () => [{ id: 'alice' }, { id: 'bob' }];
+export const loader = defineHandler((c) => ({ id: c.req.param('id') }));
+```
+
+Known routes auto-prerender in static output. `prerender = true` explicitly selects a route; `prerender = false` excludes it. Excluded routes and undeclared dynamic paths have no generated HTML or page-data file and require a server to work. Serve `dist/client` with clean URL mapping such as `/users/alice` to `users/alice.html`, including the generated assets and `/_void/pages` JSON files. Direct requests, reload and counters use the generated output; Pages links fetch the static JSON and keep the document.
+
+Actions and named actions require a server. The plugin rejects them during static discovery. Deferred props are unsupported in static output and produce an explicit renderer error. Void 0.26.1 reports failed prerender paths as warnings, continues the build, and omits that path's HTML; verify the expected file set before release. The consumer check exercises both diagnostics and rejects any unexpected prerender failures in the supported fixture.
+
+`fixtures/static` demonstrates loader-backed counters, declared dynamic paths and true/false overrides. `scripts/check-static-consumer.mjs`, called by `npm run check:consumer`, builds with Void's own collection and serves only generated files. ISR, CDN configuration and managed deployment are separate follow-up work.
+
+## Deferred loader props
+
+Return `defer(() => slowOperation())` from a Void loader. The public Hono `Deferred<T>` type is Void's `DeferredState<T>` discriminated union. Read its readonly `loading`, `error` and `value` fields:
+
+```tsx
+import type { Deferred } from 'void-plugin-hono-jsx/pages';
+function Result({ slow }: { slow: Deferred<string> }) {
+  if (slow.loading) return <p>Loading</p>;
+  if (slow.error) return <p role="alert">{slow.error.message}</p>;
+  return <p>{slow.value}</p>;
+}
+```
+
+The server renders immediate props and a loading state before the resolver completes. Deferred pages load the Pages entry asynchronously, so Hono can mount while the initial HTML stream is open. Initial HTML callbacks and SPA NDJSON responses use Void's existing protocol and deferred registry. During initial component imports, the adapter buffers early completions in Void's existing queue and drains them when the registry is ready.
+
+A resolved value or error updates the current page without resetting page-local state or surviving layouts. Updates from a pending page are ignored until that page commits. Void aborts and disposes old navigation resources; the adapter additionally accepts only updates belonging to the rendered props object.
+
+Void 0.26.1 forwards ordinary deferred resolver error messages in development; production streams use `Internal Server Error`. Deliberate HTTP exception messages may be forwarded in production. The adapter turns the received message into an `Error` and exposes it through `error`; server stack traces are not included. Author deliberate HTTP exception messages suitable for display to users. This follows the verified streaming error behavior of the pinned Void version.
+
+The verified contract covers single deferred props during GET document requests and SPA navigation. Grouped deferred props, deferred prefetching, mutation-driven deferred refresh and deferred island pages are excluded. The ordinary Pages action APIs remain documented under runtime exports.
+
+## Load-policy islands
+
+Use a `.island.tsx` or `.island.jsx` page for static server content and import an interactive component using Void's import attribute:
+
+```tsx
+import Counter from '../components/Counter' with { island: 'load' };
+export const layout = false;
+export default function Page() {
+  return <main><p>Static server content</p><Counter initialCount={9} message="Hello" /></main>;
+}
+```
+
+Place the counter outside the pages directory. It can use Hono hooks and event handlers normally. The adapter renders its initial HTML inside Void's `data-island`, `data-hydrate` and `data-props` markers, then uses `initIslands` to load and mount only interactive components. Props must be JSON-serializable values. Hono escapes the JSON attribute; parsed browser props match the server values. Mounting redraws the island contents. It does not reuse the server DOM.
+
+A static-only island page emits no client script or module preload tags. Static page modules stay outside the normal Pages browser manifest. A project containing only static island pages builds empty client entry modules with no framework code. Void's own automatic prerender policy still applies to eligible island pages. Full static output and explicit prerender configuration follow the static output contract below.
+
+Only the `load` policy, a single default relative TSX/JSX import, and attributes directly in the island page are supported. Other policies and malformed imports fail during discovery. Island layouts, nested attributed imports and island form helpers are unsupported. Direct imports of `void-plugin-hono-jsx/form` in an island page or component fail with a diagnostic; `useForm` also requires a full Pages provider at runtime. Use ordinary document links in static island pages. Pages navigation falls back to a document request for island routes. Static layouts remain server content and do not retain interactive state.
+
+## Experimental limitations
+
+The virtual renderer/client entries follow version-specific conventions observed in Void's official adapter rather than a documented third-party registration API. Browser mounting redraws the SSR page; DOM reuse is not guaranteed. Local ISR uses Void's native direct-worker KV/Cache API runtime; managed edge behavior remains unverified. Unsupported modes fail clearly. Package publication and repository visibility are separate maintainer decisions.
+
+## Known upstream dependency advisory
+
+The initial alpha accepts [GHSA-67mh-4wv8-2f99](https://github.com/advisories/GHSA-67mh-4wv8-2f99) as a known limitation on the pinned peer baseline. The reviewed audits on 2026-10-11 reported Moderate findings propagated across multiple package entries from this single esbuild advisory; package-entry counts can differ between audit reports. The affected esbuild 0.18.20 is installed through Void 0.26.1 → drizzle-kit 0.31.11 → @esbuild-kit/esm-loader 2.6.5 → @esbuild-kit/core-utils 3.3.2.
+
+The advisory concerns esbuild's own development server. The adapter uses Vite/Oxc for JSX and TypeScript for package compilation; the inspected upstream loader uses esbuild transforms. No esbuild serve invocation was found in the adapter or these loader modules, but other upstream commands and consumer configurations have not been exhaustively assessed. Avoid the affected esbuild serve feature. This is an accepted audit finding, not a claim of overall security or an audit-zero result.
+
+The package adds no overrides and does not force changes to Void's internal dependencies. Consumers install the framework peers and their dependencies even though this archive contains no dependency implementation. Follow compatible upstream fixes; a peer upgrade requires renewed validation. New unreviewed advisories continue to block release preparation policy.
+
+## Verification
+
+`npm run check:consumer` packs the package, audits its file list, copies a fixture into a temporary directory, installs locked peer dependencies and the tarball, and checks types, development rendering, production build, preview rendering and browser interaction. The consumer uses only the documented package exports and does not import repository source files.
+
+Repository: https://github.com/ts-76/void-plugin-hono-jsx
+
+### Development reload and compatibility
+
+Page and companion-loader edits reload the document and reset page/layout state. This is not state-preserving HMR. Added and removed page files update Void's route manifest without restarting the server. The adapter clears its discovery cache and uses Void's existing structural reload notifications; sending a second worker reload can mix SSR module instances during a request.
+
+In development, the SSR renderer eagerly imports server-rendered page and layout modules with their providers. This keeps in-flight requests within the same module generation during a reload. Server-side module initialization therefore happens when the renderer loads, including pages not yet visited. Browser-only page components are excluded from this server graph. Production keeps lazy component imports. The packed-consumer regression also sends parallel SSR requests during six simultaneous page/loader revisions and requires every response to succeed.
+
+The packed-consumer check edits a page, changes its loader value, adds and removes a route, checks counter interaction after reloading, and asserts that the server stays running. It also verifies actionable diagnostics for unverified Void, Hono and Vite versions. Development and production preview are exercised on the exact baseline above; no additional framework versions are claimed. The active CI workflow covers that baseline on Node 24.21.0. It also runs `npm run check:source` for navigation, persistent layouts, action forms and head metadata in development and production preview. Inspect the GitHub Actions result on the commit being reviewed.
+
+## Local ISR
+
+For server output, set `routing.revalidate` in `void.config.ts` and override a page with `export const revalidate` in its companion server module. The adapter uses Void's existing cache runtime. The packed-consumer check verifies fresh and stale HTML, background regeneration, page/global/zero policies, retained valid HTML after regeneration failure, safe props, asset references and browser interaction.
+
+The fixture binds local `ISR_CACHE` storage for Void production preview. Real deployments require Void's cache bindings; the fixture's placeholder ID and test control API are for local checks only. Managed edge, cross-data-center invalidation and production KV behavior remain unverified. ISR requires a worker/cache runtime; static output is served as generated files. See the repository `docs/isr.md` and [Void revalidation guide](https://void.cloud/guide/edge/revalidation).
+
+## Known local development limitation
+
+On the tested macOS Void/Miniflare development runtime, a POST to an undefined named action can reset the next request on a reused connection. Declared-action browser behavior is verified; this transport edge case remains unresolved upstream. Managed runtime behavior for the edge case is unverified. Review this limitation before adopting the initial alpha.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,55 @@
+# Third-party notices
+
+The renderer/client entry conventions and provider integration were adapted from the published `@void/react` 0.26.0 adapter and Void 0.26.0. Both distributions include the following MIT notice. Hono is a peer dependency; its notice is included for reference. The project is separately licensed under MIT; these notices preserve upstream copyright attribution.
+
+## Void and @void/react
+
+Source distributions: `void@0.26.0` and `@void/react@0.26.0`, published npm packages. The adapter imports framework APIs rather than bundling the framework.
+
+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.
+
+## Hono
+
+Source distribution: `hono@4.13.13`, published npm package. Hono is required as an exact peer dependency.
+
+MIT License
+
+Copyright (c) 2021 - present, Yusuke Wada and Hono contributors
+
+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/dist/browser/client.d.ts

@@ -0,0 +1,4 @@
+import { type VoidRouterConfig } from 'void/pages-client';
+type Manifest = Pick<VoidRouterConfig, 'components' | 'layoutTree' | 'routeMeta' | 'matchRoute' | 'staticPageData' | 'staticPageDataFastPath'>;
+export declare function startHonoPages(manifest: Manifest): Promise<void>;
+export {};

package/dist/browser/client.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/dom/jsx-runtime";
+import { render } from 'hono/jsx/dom';
+import { jsx } from 'hono/jsx/dom/jsx-runtime';
+import { useLayoutEffect, useState } from 'hono/jsx';
+import { createVoidRouter } from 'void/pages-client';
+import { parseCacheFor } from 'void/pages-prefetch';
+import { PageContext, RouterContext } from "void-plugin-hono-jsx/pages";
+import { createDocumentHead } from './document-head.js';
+import { createDeferred, resolveDeferred, rejectDeferred, isLoading, bufferInitialDeferred } from './deferred.js';
+function pageComponent(component) {
+    if (typeof component !== 'function')
+        throw new Error('Hono Pages: a page must export a component function.');
+    return component;
+}
+export async function startHonoPages(manifest) {
+    const root = document.getElementById('app');
+    if (!root)
+        throw new Error('Hono Pages: app root is missing.');
+    let update;
+    let revision = 0;
+    let applyDocumentHead;
+    let renderedProps;
+    let updateDeferred;
+    const initialization = createVoidRouter({
+        ...manifest,
+        adapter: {
+            createDeferred, resolveDeferred, rejectDeferred, isLoading,
+            onDeferredUpdate(props) {
+                if (props === renderedProps)
+                    updateDeferred?.({ ...props });
+            },
+            async applyUpdate(page, component, layouts, options) {
+                layouts.forEach(pageComponent);
+                pageComponent(component);
+                if (!update)
+                    throw new Error('Hono Pages: page rendering has not started.');
+                if (!options.preserveState)
+                    revision++;
+                renderedProps = page.props;
+                update({ page: { ...page, props: { ...page.props } }, component, layouts, revision });
+                await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+                applyDocumentHead?.(page.head);
+            },
+        },
+        viewTransitions: false,
+        prefetchHoverDelay: 75,
+        prefetchDefaultCacheFor: parseCacheFor('30s'),
+        cacheVisitedPageData: false,
+        onNavigationChange(state) { root.dataset.navigation = state.state; },
+    });
+    const releaseBuffer = bufferInitialDeferred();
+    const navigation = await initialization.finally(releaseBuffer);
+    renderedProps = navigation.initialPageData.props;
+    applyDocumentHead = createDocumentHead(navigation.initialPageData.head);
+    function App() {
+        const [frame, setFrame] = useState({ page: { ...navigation.initialPageData, props: { ...navigation.initialPageData.props } }, component: navigation.initialComponent, layouts: navigation.initialLayouts, revision });
+        const [failed, setFailed] = useState(false);
+        useLayoutEffect(() => {
+            updateDeferred = (props) => setFrame((frame) => ({ ...frame, page: { ...frame.page, props } }));
+            update = (next) => { setFailed(false); setFrame(next); };
+            const onError = () => setFailed(true);
+            window.addEventListener('hono-pages:navigation-error', onError);
+            return () => { update = undefined; updateDeferred = undefined; window.removeEventListener('hono-pages:navigation-error', onError); };
+        }, []);
+        let content = jsx(pageComponent(frame.component), frame.page.props, String(frame.revision));
+        const ids = manifest.layoutTree[frame.page.component] ?? [];
+        for (let index = frame.layouts.length - 1; index >= 0; index--) {
+            content = jsx(pageComponent(frame.layouts[index]), { children: content }, ids[index]);
+        }
+        return _jsx(RouterContext.Provider, { value: navigation.router, children: _jsxs(PageContext.Provider, { value: frame.page, children: [failed && _jsx("p", { role: "alert", children: "The page could not be loaded. Please try again." }), content] }) });
+    }
+    render(_jsx(App, {}), root);
+    navigation.start();
+    navigation.commitInitialRender();
+    root.dataset.navigation = 'idle';
+    root.dataset.honoPages = 'mounted';
+}

package/dist/browser/deferred.d.ts

@@ -0,0 +1,13 @@
+import type { DeferredState } from 'void';
+export declare function createDeferred(): DeferredState<never>;
+export declare function resolveDeferred(_ref: unknown, value: unknown): DeferredState<unknown>;
+export declare function rejectDeferred(_ref: unknown, message: string): DeferredState<never>;
+export declare function isLoading(ref: unknown): boolean;
+declare global {
+    interface Window {
+        __resolveDeferred?: (group: string, data: unknown) => void;
+        __rejectDeferred?: (group: string, error: string) => void;
+        __deferredQueue?: Array<[string, unknown] | [string, 0, string]>;
+    }
+}
+export declare function bufferInitialDeferred(): () => void;

package/dist/browser/deferred.js

@@ -0,0 +1,22 @@
+export function createDeferred() {
+    return { loading: true, value: null, error: null };
+}
+export function resolveDeferred(_ref, value) {
+    return { loading: false, value, error: null };
+}
+export function rejectDeferred(_ref, message) {
+    return { loading: false, value: null, error: new Error(message) };
+}
+export function isLoading(ref) {
+    return typeof ref === 'object' && ref !== null && 'loading' in ref && ref.loading === true;
+}
+export function bufferInitialDeferred() {
+    const resolve = window.__resolveDeferred;
+    const reject = window.__rejectDeferred;
+    window.__resolveDeferred = (group, data) => (window.__deferredQueue ??= []).push([group, data]);
+    window.__rejectDeferred = (group, error) => (window.__deferredQueue ??= []).push([group, 0, error]);
+    return () => {
+        window.__resolveDeferred = resolve;
+        window.__rejectDeferred = reject;
+    };
+}

package/dist/browser/document-head.d.ts

@@ -0,0 +1,3 @@
+import type { HeadDescriptor } from 'void';
+/** Complements Void's title/meta/link updates without executing navigation scripts. */
+export declare function createDocumentHead(initial: HeadDescriptor | undefined): (head: HeadDescriptor | undefined) => void;

package/dist/browser/document-head.js

@@ -0,0 +1,44 @@
+import { renderHeadToString } from 'void/pages-head';
+function scriptSignature(script) {
+    return JSON.stringify([Array.from(script.attributes, ({ name, value }) => [name, value]).sort(), script.textContent]);
+}
+function scriptElements(head) {
+    const template = document.createElement('template');
+    template.innerHTML = renderHeadToString({ script: head?.script });
+    return Array.from(template.content.querySelectorAll('script'));
+}
+/** Complements Void's title/meta/link updates without executing navigation scripts. */
+export function createDocumentHead(initial) {
+    let htmlKeys = Object.keys(initial?.htmlAttrs ?? {});
+    let bodyKeys = Object.keys(initial?.bodyAttrs ?? {});
+    let scripts = [];
+    const existing = Array.from(document.head.querySelectorAll('script'));
+    for (const desired of scriptElements(initial)) {
+        const index = existing.findIndex((script) => scriptSignature(script) === scriptSignature(desired));
+        if (index >= 0)
+            scripts.push(...existing.splice(index, 1));
+    }
+    function attributes(element, previous, next = {}) {
+        for (const key of previous)
+            if (!(key in next))
+                element.removeAttribute(key);
+        for (const [key, value] of Object.entries(next))
+            element.setAttribute(key, value);
+        return Object.keys(next);
+    }
+    return (head) => {
+        htmlKeys = attributes(document.documentElement, htmlKeys, head?.htmlAttrs);
+        bodyKeys = attributes(document.body, bodyKeys, head?.bodyAttrs);
+        const remaining = [...scripts];
+        scripts = scriptElements(head).map((desired) => {
+            const index = remaining.findIndex((script) => scriptSignature(script) === scriptSignature(desired));
+            if (index >= 0)
+                return remaining.splice(index, 1)[0];
+            // Template-parsed scripts remain inert when inserted. Head changes are metadata, not script execution.
+            document.head.appendChild(desired);
+            return desired;
+        });
+        for (const script of remaining)
+            script.remove();
+    };
+}

package/dist/browser/form.d.ts

@@ -0,0 +1,16 @@
+import { type FormMethod } from 'void/pages-client';
+export declare function useForm<T extends Record<string, unknown>>(initialData: T): {
+    data: T;
+    setData: (newState: T | ((currentState: T) => T)) => void;
+    errors: Record<string, string>;
+    pending: boolean;
+    wasSuccessful: boolean;
+    error: Error | null;
+    submit: (method: FormMethod, url: string) => Promise<void>;
+    cancel: () => void;
+    reset(): void;
+    post: (url: string) => Promise<void>;
+    put: (url: string) => Promise<void>;
+    patch: (url: string) => Promise<void>;
+    delete: (url: string) => Promise<void>;
+};

package/dist/browser/form.js

@@ -0,0 +1,80 @@
+import { useContext, useRef, useState } from 'hono/jsx';
+import { isAbortError, submitAction } from 'void/pages-client';
+import { RouterContext, useErrors, useRouter } from "void-plugin-hono-jsx/pages";
+function fieldErrors(error) {
+    const body = error.body;
+    if (typeof body !== 'object' || body === null || !('errors' in body) || typeof body.errors !== 'object' || body.errors === null)
+        return {};
+    return Object.fromEntries(Object.entries(body.errors).filter((entry) => typeof entry[1] === 'string'));
+}
+export function useForm(initialData) {
+    if (!useContext(RouterContext))
+        throw new Error('Hono Pages: useForm requires the full Pages renderer; island form helpers are unsupported.');
+    const router = useRouter();
+    const initialErrors = useErrors();
+    const [data, updateData] = useState(initialData);
+    const [errors, setErrors] = useState(initialErrors);
+    const [pending, setPending] = useState(false);
+    const [wasSuccessful, setSuccessful] = useState(false);
+    const [error, setError] = useState(null);
+    const active = useRef(false);
+    const generation = useRef(0);
+    const setData = (next) => {
+        updateData(next);
+        setSuccessful(false);
+        setErrors({});
+        setError(null);
+    };
+    async function submit(method, url) {
+        if (active.current)
+            return;
+        active.current = true;
+        const id = ++generation.current;
+        setPending(true);
+        setSuccessful(false);
+        setError(null);
+        setErrors({});
+        try {
+            const result = await submitAction(router, url, { method: method.toUpperCase(), data, preserveScroll: true });
+            if (id !== generation.current)
+                return;
+            if (result.ok)
+                setSuccessful(true);
+            else {
+                setError(result.error);
+                setErrors(fieldErrors(result.error));
+            }
+        }
+        catch (failure) {
+            if (id === generation.current && !isAbortError(failure)) {
+                setError(failure instanceof Error ? failure : new Error(String(failure)));
+            }
+        }
+        finally {
+            if (id === generation.current) {
+                active.current = false;
+                setPending(false);
+            }
+        }
+    }
+    function cancel() {
+        if (!active.current)
+            return;
+        const id = ++generation.current;
+        active.current = false;
+        setPending(false);
+        setSuccessful(false);
+        void router.refresh().catch((failure) => {
+            if (id === generation.current)
+                setError(failure instanceof Error ? failure : new Error(String(failure)));
+        });
+    }
+    return {
+        data, setData, errors, pending, wasSuccessful, error, submit, cancel,
+        reset() { setData(initialData); },
+        post: (url) => submit('post', url),
+        put: (url) => submit('put', url),
+        patch: (url) => submit('patch', url),
+        delete: (url) => submit('delete', url),
+    };
+}

package/dist/browser/pages.d.ts

@@ -0,0 +1,17 @@
+import { type JSX } from 'hono/jsx';
+import type { VoidRouter } from 'void/pages-client';
+import type { PageObject } from 'void/pages-protocol';
+export type { DeferredState as Deferred } from 'void';
+export declare const RouterContext: import("hono/jsx").Context<VoidRouter | null>;
+export declare const PageContext: import("hono/jsx").Context<PageObject | null>;
+export declare function useShared(): Record<string, unknown>;
+export declare function useParams(): Record<string, string>;
+export declare function useErrors(): Record<string, string>;
+export declare function useRouter(): VoidRouter;
+type LinkProps = Omit<JSX.IntrinsicElements['a'], 'href' | 'onClick'> & {
+    href: string;
+    reloadDocument?: boolean;
+    replace?: boolean;
+    onClick?: (event: MouseEvent) => void;
+};
+export declare function Link({ href, reloadDocument, replace, onClick, ...attributes }: LinkProps): import("hono/jsx/dom/jsx-dev-runtime").JSX.Element;

package/dist/browser/pages.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "hono/jsx/dom/jsx-runtime";
+import { createContext, useContext } from 'hono/jsx';
+export const RouterContext = createContext(null);
+export const PageContext = createContext(null);
+function usePage() {
+    const page = useContext(PageContext);
+    if (!page)
+        throw new Error('Hono Pages: page data requires a page provider.');
+    return page;
+}
+export function useShared() { return usePage().shared; }
+export function useParams() { return usePage().params; }
+export function useErrors() { return usePage().errors ?? {}; }
+export function useRouter() {
+    const router = useContext(RouterContext);
+    if (!router)
+        throw new Error('Hono Pages: useRouter requires a page provider.');
+    return router;
+}
+export function Link({ href, reloadDocument, replace, onClick, ...attributes }) {
+    const router = useRouter();
+    return _jsx("a", { ...attributes, href: href, onClick: (event) => {
+            onClick?.(event);
+            if (event.defaultPrevented || reloadDocument || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+                return;
+            if (attributes.download !== undefined || (attributes.target && attributes.target !== '_self') || attributes.rel?.split(/\s+/).includes('external'))
+                return;
+            const url = new URL(href, window.location.href);
+            if (url.origin !== window.location.origin || !['http:', 'https:'].includes(url.protocol))
+                return;
+            event.preventDefault();
+            void router.visit(url, { replace }).catch((error) => {
+                window.dispatchEvent(new CustomEvent('hono-pages:navigation-error', { detail: error }));
+            });
+        } });
+}

package/dist/plugins/compatibility.d.ts

@@ -0,0 +1 @@
+export declare function assertSupportedFrameworks(): void;

package/dist/plugins/compatibility.js

@@ -0,0 +1,29 @@
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const supported = { void: '0.26.1', hono: '4.13.13', vite: '8.3.3' };
+export function assertSupportedFrameworks() {
+    const require = createRequire(import.meta.url);
+    for (const [name, expected] of Object.entries(supported)) {
+        let directory = dirname(require.resolve(name));
+        let version;
+        while (true) {
+            const path = join(directory, 'package.json');
+            if (existsSync(path)) {
+                const metadata = JSON.parse(readFileSync(path, 'utf8'));
+                if (typeof metadata === 'object' && metadata !== null && 'name' in metadata && metadata.name === name) {
+                    if (!('version' in metadata) || typeof metadata.version !== 'string')
+                        throw new Error(`Hono Pages: ${name} package version is missing.`);
+                    version = metadata.version;
+                    break;
+                }
+            }
+            const parent = dirname(directory);
+            if (parent === directory)
+                throw new Error(`Hono Pages: cannot locate ${name} package metadata.`);
+            directory = parent;
+        }
+        if (version !== expected)
+            throw new Error(`Hono Pages: ${name} ${version} is unverified; install ${name}@${expected}. The adapter requires void@0.26.1, hono@4.13.13 and vite@8.3.3.`);
+    }
+}

package/dist/plugins/hono-islands.d.ts

@@ -0,0 +1,3 @@
+import { type Plugin } from 'vite';
+/** Narrow adapter for Void's load-on-page-load island convention. */
+export declare function honoIslands(): Plugin;

package/dist/plugins/hono-islands.js

@@ -0,0 +1,112 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { normalizePath, parseSync } from 'vite';
+import { scanPages, resolvePagesDir } from 'void/pages';
+import { findIslandImports, editIslandSource, resolveSpecifier, computePagesNeedingClientJS, ISLANDS_RENDERER_ID, ISLANDS_CLIENT_ENTRY_ID } from 'void/pages-islands-plugin';
+/** Narrow adapter for Void's load-on-page-load island convention. */
+export function honoIslands() {
+    const root = process.cwd();
+    const pagesDir = resolvePagesDir(root);
+    const islands = new Map();
+    const pageFiles = new Set();
+    let scan;
+    function islandImports(code, filename) {
+        const found = findIslandImports(code, filename);
+        const attributed = parseSync(filename, code).program.body.filter((node) => node.type === 'ImportDeclaration' && node.attributes?.some(({ key }) => ('name' in key && key.name === 'island') || ('value' in key && key.value === 'island')));
+        if (attributed.length !== found.length)
+            throw new Error(`Hono islands: use one default import with exactly one island: 'load' attribute in ${filename}.`);
+        return found;
+    }
+    function imports(code, filename) {
+        const found = islandImports(code, filename);
+        for (const entry of found) {
+            if (entry.hydrate !== 'load')
+                throw new Error(`Hono islands: unsupported policy '${entry.hydrate}' in ${filename}; use island: 'load'.`);
+            if (!entry.specifier.startsWith('.'))
+                throw new Error(`Hono islands: use a relative TSX/JSX component import in ${filename}.`);
+            const path = resolveSpecifier(entry.specifier, join(filename, '..'), ['.tsx', '.jsx']);
+            if (!path || !/\.[jt]sx$/.test(path))
+                throw new Error(`Hono islands: cannot resolve TSX/JSX component ${entry.specifier} in ${filename}.`);
+            const canonical = realpathSync(path);
+            const id = normalizePath(relative(root, canonical));
+            islands.set(id, canonical);
+        }
+        return found;
+    }
+    async function rescan() {
+        scan = await scanPages(root, { pagesDir });
+        islands.clear();
+        pageFiles.clear();
+        for (const page of scan.pages.filter((page) => page.island)) {
+            const filename = realpathSync(join(pagesDir, page.componentPath));
+            pageFiles.add(filename);
+            imports(readFileSync(filename, 'utf8'), filename);
+        }
+    }
+    return {
+        name: 'void-hono:islands',
+        enforce: 'pre',
+        buildStart: rescan,
+        async hotUpdate({ file }) {
+            if (normalizePath(file).startsWith(normalizePath(pagesDir) + '/'))
+                await rescan();
+        },
+        config() {
+            return { build: { rollupOptions: { input: { 'islands-client': ISLANDS_CLIENT_ENTRY_ID } } } };
+        },
+        resolveId(id) {
+            if (id === ISLANDS_RENDERER_ID || id === ISLANDS_CLIENT_ENTRY_ID)
+                return `\0${id}`;
+        },
+        transform(code, id) {
+            const filename = id.split('?')[0];
+            if (!/\.[jt]sx$/.test(filename) || filename.includes('/node_modules/'))
+                return;
+            const canonical = realpathSync(filename);
+            if ((pageFiles.has(canonical) || [...islands.values()].includes(canonical)) && parseSync(filename, code).program.body.some((node) => node.type === 'ImportDeclaration' && node.source.value === 'void-plugin-hono-jsx/form')) {
+                throw new Error('Hono islands: form helpers are unsupported; use a full Pages component.');
+            }
+            const found = islandImports(code, filename);
+            if (!found.length)
+                return;
+            if (!pageFiles.has(realpathSync(filename)))
+                throw new Error('Hono islands: attributed imports are supported only directly in .island.tsx/.island.jsx pages.');
+            imports(code, filename);
+            return editIslandSource(code, found.map((entry) => {
+                const path = resolveSpecifier(entry.specifier, join(filename, '..'), ['.tsx', '.jsx']);
+                if (!path)
+                    throw new Error(`Hono islands: missing component ${entry.specifier}.`);
+                const islandId = normalizePath(relative(root, realpathSync(path)));
+                const component = `__honoIslandComponent${entry.start}`;
+                return { start: entry.start, end: entry.end, text: `import ${component} from ${entry.specifierRaw};
+const ${entry.importName} = (props) => __honoIslandJsx('div', { 'data-island': ${JSON.stringify(islandId)}, 'data-hydrate': 'load', 'data-props': JSON.stringify(props), children: __honoIslandJsx(${component}, props) });` };
+            }), { prepend: "import { jsx as __honoIslandJsx } from 'hono/jsx/jsx-runtime';\n" });
+        },
+        load(id) {
+            if (id === `\0${ISLANDS_RENDERER_ID}`) {
+                if (!scan)
+                    throw new Error('Hono islands: page discovery has not completed.');
+                const interactive = [...computePagesNeedingClientJS(scan, pagesDir, null)];
+                return `import { renderPage } from 'virtual:void-pages-renderer';
+const interactive = new Set(${JSON.stringify(interactive)});
+export function renderIslandPage(page, assets) {
+  if (page.deferred?.length || page.deferredKeys) throw new Error('Hono islands: deferred props are unsupported.');
+  return renderPage(page, interactive.has(page.component) ? assets : { ...assets, preloads: '', body: '' });
+}`;
+            }
+            if (id === `\0${ISLANDS_CLIENT_ENTRY_ID}`) {
+                if (!islands.size)
+                    return 'export {};';
+                const loaders = [...islands].map(([name, path]) => `${JSON.stringify(name)}: () => import(${JSON.stringify(path)})`).join(',\n');
+                return `import { initIslands } from 'void/pages-client';
+import { jsx } from 'hono/jsx/dom/jsx-runtime';
+import { render } from 'hono/jsx/dom';
+initIslands({ ${loaders} }, (element, module, props) => {
+  if (typeof module.default !== 'function') throw new Error('Hono islands: a component must export a default function.');
+  render(jsx(module.default, props), element);
+  element.setAttribute('data-hono-island', 'mounted');
+});`;
+            }
+        },
+    };
+}

package/dist/plugins/hono-jsx.d.ts

@@ -0,0 +1,3 @@
+import { type Plugin } from 'vite';
+/** JSX factories differ by Vite environment; hooks can be shared via hono/jsx. */
+export declare function honoJsx(): Plugin;

package/dist/plugins/hono-jsx.js

@@ -0,0 +1,20 @@
+import { transformWithOxc } from 'vite';
+/** JSX factories differ by Vite environment; hooks can be shared via hono/jsx. */
+export function honoJsx() {
+    return {
+        name: 'poc:hono-jsx',
+        enforce: 'pre',
+        async transform(code, id) {
+            const filename = id.split('?')[0];
+            if (!/\.[jt]sx$/.test(filename) || filename.includes('/node_modules/'))
+                return;
+            return transformWithOxc(code, filename, {
+                jsx: {
+                    runtime: 'automatic',
+                    importSource: this.environment.config.consumer === 'client' ? 'hono/jsx/dom' : 'hono/jsx',
+                    development: this.environment.mode === 'dev',
+                },
+            });
+        },
+    };
+}

package/dist/plugins/hono-pages.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+/** Experimental Pages contract verified against Void 0.26.1. */
+export declare function voidHonoPages(): Plugin[];

package/dist/plugins/hono-pages.js

@@ -0,0 +1,148 @@
+import { realpathSync } from 'node:fs';
+import { normalizePath } from 'vite';
+import { pagesRuntimePath, clientRuntimePath, publicRuntimeModules } from './runtime-paths.js';
+import { generateComponentManifest, resolvePagesDir, resolveStaticPageDataBuildOptions, scanPages } from 'void/pages';
+import { honoJsx } from './hono-jsx.js';
+import { honoIslands } from './hono-islands.js';
+import { assertSupportedFrameworks } from './compatibility.js';
+const rendererId = 'virtual:void-pages-renderer';
+const clientId = 'virtual:void-pages-client';
+/** Experimental Pages contract verified against Void 0.26.1. */
+export function voidHonoPages() {
+    const root = process.cwd();
+    const pagesDir = resolvePagesDir(root);
+    const staticData = resolveStaticPageDataBuildOptions(root);
+    let scan;
+    async function rescan() {
+        scan = await scanPages(root, { pagesDir });
+        for (const layout of [...scan.layouts, ...scan.namedLayouts]) {
+            if (layout.island || !/\.[jt]sx$/.test(layout.filePath))
+                throw new Error('Hono Pages: only standard TSX/JSX layouts are supported.');
+        }
+        for (const page of scan.pages) {
+            if (!/\.[jt]sx$/.test(page.componentPath)) {
+                throw new Error(`Hono Pages: only standard TSX/JSX pages are supported: ${page.componentPath}.`);
+            }
+            if (staticData.enabled && page.methods.some((method) => method === 'action' || method === 'actions')) {
+                throw new Error(`Hono Pages: actions require a server and cannot be used with static output: ${page.componentPath}.`);
+            }
+        }
+        return scan;
+    }
+    return [honoIslands(), honoJsx(), {
+            name: 'void-hono:pages',
+            enforce: 'pre',
+            config() {
+                assertSupportedFrameworks();
+                return {
+                    resolve: { dedupe: ['hono'] },
+                    build: { manifest: true, rollupOptions: { input: { 'pages-client': clientId } } },
+                };
+            },
+            configEnvironment() {
+                const modules = Object.keys(publicRuntimeModules);
+                const packages = [...new Set(modules.map((id) => id.slice(0, id.lastIndexOf('/'))))];
+                return { optimizeDeps: { exclude: ['hono', ...modules] }, resolve: { noExternal: ['hono', ...packages] } };
+            },
+            async buildStart() {
+                await rescan();
+            },
+            configureServer(server) {
+                const clear = (file) => {
+                    if (normalizePath(file).startsWith(normalizePath(pagesDir) + '/'))
+                        scan = undefined;
+                };
+                server.watcher.on('add', clear);
+                server.watcher.on('unlink', clear);
+                server.httpServer?.once('close', () => { server.watcher.off('add', clear); server.watcher.off('unlink', clear); });
+            },
+            async hotUpdate({ file, type, modules, timestamp }) {
+                if (!normalizePath(file).startsWith(normalizePath(pagesDir) + '/'))
+                    return;
+                await rescan();
+                if (type !== 'update')
+                    return [];
+                const invalidated = new Set();
+                for (const module of modules)
+                    this.environment.moduleGraph.invalidateModule(module, invalidated, timestamp, true);
+                for (const id of [rendererId, clientId]) {
+                    const module = this.environment.moduleGraph.getModuleById(`\0${id}`);
+                    if (module)
+                        this.environment.moduleGraph.invalidateModule(module, invalidated, timestamp, true);
+                }
+                this.environment.hot.send({ type: 'full-reload' });
+                return [];
+            },
+            resolveId(id) {
+                if (id === rendererId || id === clientId)
+                    return `\0${id}`;
+                if (id === pagesRuntimePath || id === clientRuntimePath)
+                    return { id: realpathSync(id), external: false };
+                const runtime = publicRuntimeModules[id];
+                if (runtime)
+                    return { id: realpathSync(this.environment.config.consumer === 'client' ? runtime.client : runtime.server), external: false };
+            },
+            async load(id) {
+                if (id !== `\0${rendererId}` && id !== `\0${clientId}`)
+                    return;
+                const currentScan = scan ?? await rescan();
+                const serverSnapshot = id === `\0${rendererId}` && this.environment.mode === 'dev';
+                const manifestScan = id === `\0${clientId}`
+                    ? { ...currentScan, pages: currentScan.pages.filter((page) => !page.island) }
+                    : serverSnapshot ? { ...currentScan, pages: currentScan.pages.filter((page) => page.renderMode !== 'client') } : currentScan;
+                let manifest = generateComponentManifest(manifestScan, pagesDir);
+                if (serverSnapshot) {
+                    // A request can retain the old renderer while the worker module runner
+                    // reloads. Capture components with its providers instead of importing
+                    // a new generation into an in-flight render. Browser-only pages remain
+                    // absent from this server graph; production keeps lazy imports.
+                    const imports = [];
+                    manifest = manifest.replace(/\(\) => import\(("(?:[^"\\]|\\.)*")\)/g, (_, path) => {
+                        const name = `__honoPageSnapshot${imports.length}`;
+                        imports.push(`import * as ${name} from ${path};`);
+                        return `() => ${name}`;
+                    });
+                    manifest = imports.join('\n') + '\n' + manifest;
+                }
+                if (id === `\0${clientId}` && !currentScan.pages.some((page) => !page.island))
+                    return 'export {};';
+                if (id === `\0${rendererId}`) {
+                    return `
+import { jsx } from 'hono/jsx';
+import { createSsrRouter } from 'void/pages-client';
+import { PageContext, RouterContext } from ${JSON.stringify(pagesRuntimePath)};
+import { serializePageData } from 'void/pages-server';
+import { renderHeadToString, renderHtmlAttrs, renderBodyAttrs } from 'void/pages-head';
+${manifest}
+export async function renderPage(pageObj, assetTags) {
+  if (${JSON.stringify(staticData.enabled)} && pageObj.deferredKeys) throw new Error('Hono Pages: deferred props cannot be statically prerendered; remove defer().');
+  const load = components[pageObj.component];
+  if (!load) throw new Error('Hono Pages: unknown page component ' + pageObj.component);
+  const { default: Page } = await load();
+  if (typeof Page !== 'function') throw new Error('Hono Pages: a page must export a component function.');
+  let content = jsx(Page, pageObj.props);
+  const ids = layoutTree[pageObj.component] ?? [];
+  const layouts = await Promise.all(ids.map(async (id) => (await components[id]()).default));
+  for (const Layout of layouts.reverse()) {
+    if (typeof Layout !== 'function') throw new Error('Hono Pages: a layout must export a component function.');
+    content = jsx(Layout, { children: content });
+  }
+  const markup = await jsx(RouterContext.Provider, { value: createSsrRouter(pageObj.url, pageObj.params), children: jsx(PageContext.Provider, { value: pageObj, children: content }) }).toString();
+  const head = pageObj.head;
+  const body = pageObj.deferredKeys ? assetTags.body.replaceAll('<script type="module"', '<script async type="module"') : assetTags.body;
+  return '<!doctype html><html' + (head ? renderHtmlAttrs(head) : '') + '><head>'
+    + (head ? renderHeadToString(head) : '') + assetTags.css + assetTags.preloads
+    + '</head><body' + (head ? renderBodyAttrs(head) : '') + '>'
+    + '<script id="__VOID_PAGE_DATA__" type="application/json">' + serializePageData(pageObj) + '</script>'
+    + '<div id="app">' + markup + '</div>' + body + '</body></html>';
+}
+`;
+                }
+                return `
+import { startHonoPages } from ${JSON.stringify(clientRuntimePath)};
+${manifest}
+await startHonoPages({ components, layoutTree, routeMeta, matchRoute, staticPageData: ${JSON.stringify(staticData.enabled)}, staticPageDataFastPath: ${JSON.stringify(staticData.fastPath)} });
+`;
+            },
+        }];
+}

package/dist/plugins/runtime-paths.d.ts

@@ -0,0 +1,6 @@
+export declare const pagesRuntimePath: string;
+export declare const clientRuntimePath: string;
+export declare const publicRuntimeModules: Record<string, {
+    server: string;
+    client: string;
+}>;

package/dist/plugins/runtime-paths.js

@@ -0,0 +1,7 @@
+import { fileURLToPath } from 'node:url';
+export const pagesRuntimePath = fileURLToPath(new URL('../server/pages.js', import.meta.url));
+export const clientRuntimePath = fileURLToPath(new URL('../browser/client.js', import.meta.url));
+export const publicRuntimeModules = {
+  "void-plugin-hono-jsx/pages": { server: fileURLToPath(new URL('../server/pages.js', import.meta.url)), client: fileURLToPath(new URL('../browser/pages.js', import.meta.url)) },
+  "void-plugin-hono-jsx/form": { server: fileURLToPath(new URL('../server/form.js', import.meta.url)), client: fileURLToPath(new URL('../browser/form.js', import.meta.url)) },
+};

package/dist/server/form.d.ts

@@ -0,0 +1,16 @@
+import { type FormMethod } from 'void/pages-client';
+export declare function useForm<T extends Record<string, unknown>>(initialData: T): {
+    data: T;
+    setData: (newState: T | ((currentState: T) => T)) => void;
+    errors: Record<string, string>;
+    pending: boolean;
+    wasSuccessful: boolean;
+    error: Error | null;
+    submit: (method: FormMethod, url: string) => Promise<void>;
+    cancel: () => void;
+    reset(): void;
+    post: (url: string) => Promise<void>;
+    put: (url: string) => Promise<void>;
+    patch: (url: string) => Promise<void>;
+    delete: (url: string) => Promise<void>;
+};

package/dist/server/form.js

@@ -0,0 +1,80 @@
+import { useContext, useRef, useState } from 'hono/jsx';
+import { isAbortError, submitAction } from 'void/pages-client';
+import { RouterContext, useErrors, useRouter } from "void-plugin-hono-jsx/pages";
+function fieldErrors(error) {
+    const body = error.body;
+    if (typeof body !== 'object' || body === null || !('errors' in body) || typeof body.errors !== 'object' || body.errors === null)
+        return {};
+    return Object.fromEntries(Object.entries(body.errors).filter((entry) => typeof entry[1] === 'string'));
+}
+export function useForm(initialData) {
+    if (!useContext(RouterContext))
+        throw new Error('Hono Pages: useForm requires the full Pages renderer; island form helpers are unsupported.');
+    const router = useRouter();
+    const initialErrors = useErrors();
+    const [data, updateData] = useState(initialData);
+    const [errors, setErrors] = useState(initialErrors);
+    const [pending, setPending] = useState(false);
+    const [wasSuccessful, setSuccessful] = useState(false);
+    const [error, setError] = useState(null);
+    const active = useRef(false);
+    const generation = useRef(0);
+    const setData = (next) => {
+        updateData(next);
+        setSuccessful(false);
+        setErrors({});
+        setError(null);
+    };
+    async function submit(method, url) {
+        if (active.current)
+            return;
+        active.current = true;
+        const id = ++generation.current;
+        setPending(true);
+        setSuccessful(false);
+        setError(null);
+        setErrors({});
+        try {
+            const result = await submitAction(router, url, { method: method.toUpperCase(), data, preserveScroll: true });
+            if (id !== generation.current)
+                return;
+            if (result.ok)
+                setSuccessful(true);
+            else {
+                setError(result.error);
+                setErrors(fieldErrors(result.error));
+            }
+        }
+        catch (failure) {
+            if (id === generation.current && !isAbortError(failure)) {
+                setError(failure instanceof Error ? failure : new Error(String(failure)));
+            }
+        }
+        finally {
+            if (id === generation.current) {
+                active.current = false;
+                setPending(false);
+            }
+        }
+    }
+    function cancel() {
+        if (!active.current)
+            return;
+        const id = ++generation.current;
+        active.current = false;
+        setPending(false);
+        setSuccessful(false);
+        void router.refresh().catch((failure) => {
+            if (id === generation.current)
+                setError(failure instanceof Error ? failure : new Error(String(failure)));
+        });
+    }
+    return {
+        data, setData, errors, pending, wasSuccessful, error, submit, cancel,
+        reset() { setData(initialData); },
+        post: (url) => submit('post', url),
+        put: (url) => submit('put', url),
+        patch: (url) => submit('patch', url),
+        delete: (url) => submit('delete', url),
+    };
+}

package/dist/server/pages.d.ts

@@ -0,0 +1,17 @@
+import { type JSX } from 'hono/jsx';
+import type { VoidRouter } from 'void/pages-client';
+import type { PageObject } from 'void/pages-protocol';
+export type { DeferredState as Deferred } from 'void';
+export declare const RouterContext: import("hono/jsx").Context<VoidRouter | null>;
+export declare const PageContext: import("hono/jsx").Context<PageObject | null>;
+export declare function useShared(): Record<string, unknown>;
+export declare function useParams(): Record<string, string>;
+export declare function useErrors(): Record<string, string>;
+export declare function useRouter(): VoidRouter;
+type LinkProps = Omit<JSX.IntrinsicElements['a'], 'href' | 'onClick'> & {
+    href: string;
+    reloadDocument?: boolean;
+    replace?: boolean;
+    onClick?: (event: MouseEvent) => void;
+};
+export declare function Link({ href, reloadDocument, replace, onClick, ...attributes }: LinkProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;

package/dist/server/pages.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "hono/jsx/jsx-runtime";
+import { createContext, useContext } from 'hono/jsx';
+export const RouterContext = createContext(null);
+export const PageContext = createContext(null);
+function usePage() {
+    const page = useContext(PageContext);
+    if (!page)
+        throw new Error('Hono Pages: page data requires a page provider.');
+    return page;
+}
+export function useShared() { return usePage().shared; }
+export function useParams() { return usePage().params; }
+export function useErrors() { return usePage().errors ?? {}; }
+export function useRouter() {
+    const router = useContext(RouterContext);
+    if (!router)
+        throw new Error('Hono Pages: useRouter requires a page provider.');
+    return router;
+}
+export function Link({ href, reloadDocument, replace, onClick, ...attributes }) {
+    const router = useRouter();
+    return _jsx("a", { ...attributes, href: href, onClick: (event) => {
+            onClick?.(event);
+            if (event.defaultPrevented || reloadDocument || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+                return;
+            if (attributes.download !== undefined || (attributes.target && attributes.target !== '_self') || attributes.rel?.split(/\s+/).includes('external'))
+                return;
+            const url = new URL(href, window.location.href);
+            if (url.origin !== window.location.origin || !['http:', 'https:'].includes(url.protocol))
+                return;
+            event.preventDefault();
+            void router.visit(url, { replace }).catch((error) => {
+                window.dispatchEvent(new CustomEvent('hono-pages:navigation-error', { detail: error }));
+            });
+        } });
+}

package/package.json

@@ -1,20 +1,58 @@
 {
   "name": "void-plugin-hono-jsx",
-  "version": "0.0.0-bootstrap.0",
+  "version": "0.1.0-alpha.0",
   "private": false,
-  "description": "Registration-only staging candidate; not the adapter release",
+  "description": "Experimental Hono JSX Pages adapter for Void 0.26.1",
+  "type": "module",
   "license": "MIT",
+  "engines": {
+    "node": ">=24.21.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    "./plugin": {
+      "types": "./dist/plugins/hono-pages.d.ts",
+      "import": "./dist/plugins/hono-pages.js"
+    },
+    "./pages": {
+      "types": "./dist/server/pages.d.ts",
+      "default": "./dist/server/pages.js"
+    },
+    "./form": {
+      "types": "./dist/server/form.d.ts",
+      "default": "./dist/server/form.js"
+    }
+  },
+  "peerDependencies": {
+    "hono": "4.13.13",
+    "void": "0.26.1",
+    "vite": "8.3.3"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/ts-76/void-plugin-hono-jsx.git"
+    "url": "https://github.com/ts-76/void-plugin-hono-jsx.git",
+    "directory": "packages/hono-pages"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
     "access": "public",
-    "tag": "bootstrap"
+    "registry": "https://registry.npmjs.org/",
+    "tag": "next"
   },
-  "files": [
-    "README.md",
-    "LICENSE"
+  "bugs": {
+    "url": "https://github.com/ts-76/void-plugin-hono-jsx/issues"
+  },
+  "homepage": "https://github.com/ts-76/void-plugin-hono-jsx#readme",
+  "keywords": [
+    "void",
+    "hono",
+    "jsx",
+    "vite",
+    "ssr"
   ]
 }