void-plugin-hono-jsx 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/plugins/runtime-paths.js

@@ -1,7 +1,14 @@
 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)) },
-};
+// Source fixtures use TSX; npm consumers use the precompiled environment entries.
+// Keep this adaptation in TypeScript so both emitted maps describe the actual code.
+const compiled = new URL(import.meta.url).pathname.endsWith('.js');
+export const pagesRuntimePath = fileURLToPath(new URL(compiled ? '../server/pages.js' : '../runtime/pages.tsx', import.meta.url));
+export const clientRuntimePath = fileURLToPath(new URL(compiled ? '../browser/client.js' : '../runtime/client.tsx', import.meta.url));
+export const publicRuntimeModules = compiled ? {
+    'void-plugin-hono-jsx/pages': { server: pagesRuntimePath, 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)),
+    },
+} : {};
+//# sourceMappingURL=runtime-paths.js.map

package/dist/plugins/runtime-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-paths.js","sourceRoot":"","sources":["../../src/plugins/runtime-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,kFAAkF;AAClF,oFAAoF;AACpF,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACnE,MAAM,CAAC,MAAM,gBAAgB,GAAG,aAAa,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,sBAAsB,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAClI,MAAM,CAAC,MAAM,iBAAiB,GAAG,aAAa,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,uBAAuB,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AACtI,MAAM,CAAC,MAAM,oBAAoB,GAAuD,QAAQ,CAAC,CAAC,CAAC;IACjG,4BAA4B,EAAE,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,CAAC,IAAI,GAAG,CAAC,qBAAqB,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE;IAClI,2BAA2B,EAAE;QAC3B,MAAM,EAAE,aAAa,CAAC,IAAI,GAAG,CAAC,mBAAmB,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;QACpE,MAAM,EAAE,aAAa,CAAC,IAAI,GAAG,CAAC,oBAAoB,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;KACtE;CACF,CAAC,CAAC,CAAC,EAAE,CAAC","sourcesContent":["import { fileURLToPath } from 'node:url';\n\n// Source fixtures use TSX; npm consumers use the precompiled environment entries.\n// Keep this adaptation in TypeScript so both emitted maps describe the actual code.\nconst compiled = new URL(import.meta.url).pathname.endsWith('.js');\nexport const pagesRuntimePath = fileURLToPath(new URL(compiled ? '../server/pages.js' : '../runtime/pages.tsx', import.meta.url));\nexport const clientRuntimePath = fileURLToPath(new URL(compiled ? '../browser/client.js' : '../runtime/client.tsx', import.meta.url));\nexport const publicRuntimeModules: Record<string, { server: string; client: string }> = compiled ? {\n  'void-plugin-hono-jsx/pages': { server: pagesRuntimePath, client: fileURLToPath(new URL('../browser/pages.js', import.meta.url)) },\n  'void-plugin-hono-jsx/form': {\n    server: fileURLToPath(new URL('../server/form.js', import.meta.url)),\n    client: fileURLToPath(new URL('../browser/form.js', import.meta.url)),\n  },\n} : {};\n"]}

package/dist/server/form.d.ts

@@ -14,3 +14,4 @@ export declare function useForm<T extends Record<string, unknown>>(initialData:
     patch: (url: string) => Promise<void>;
     delete: (url: string) => Promise<void>;
 };
+//# sourceMappingURL=form.d.ts.map

package/dist/server/form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.d.ts","sourceRoot":"","sources":["../../src/runtime/form.ts"],"names":[],"mappings":"AACA,OAAO,EAA+C,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AASjG,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;;;;;;;qBAmBzC,UAAU,OAAO,MAAM;;;gBAoCvC,MAAM;eACP,MAAM;iBACJ,MAAM;kBACL,MAAM;EAEvB"}

package/dist/server/form.js

@@ -78,3 +78,4 @@ export function useForm(initialData) {
         delete: (url) => submit('delete', url),
     };
 }
+//# sourceMappingURL=form.js.map

package/dist/server/form.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.js","mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,UAAU;AACvD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAoC,MAAM,mBAAmB;AAChG,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,4BAAa;AAEjE,SAAS,WAAW,CAAC,KAAsB;IACzC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI;IACvB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,MAAM,KAAK,QAAQ,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI;QAAE,OAAO,EAAE;IAC1I,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAA6B,EAAE,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC;AACnI;AAEA,MAAM,UAAU,OAAO,CAAoC,WAAc;IACvE,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,4FAA4F,CAAC;IAC7I,MAAM,MAAM,GAAG,SAAS,EAAE;IAC1B,MAAM,aAAa,GAAG,SAAS,EAAE;IACjC,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC;IAChD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC;IACnD,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC;IAC7C,MAAM,CAAC,aAAa,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC;IACtD,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAe,IAAI,CAAC;IACtD,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC;IAC5B,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC;IAE5B,MAAM,OAAO,GAAsB,CAAC,IAAI,EAAE,EAAE;QAC1C,UAAU,CAAC,IAAI,CAAC;QAChB,aAAa,CAAC,KAAK,CAAC;QACpB,SAAS,CAAC,EAAE,CAAC;QACb,QAAQ,CAAC,IAAI,CAAC;IAChB,CAAC;IAED,KAAK,UAAU,MAAM,CAAC,MAAkB,EAAE,GAAW;QACnD,IAAI,MAAM,CAAC,OAAO;YAAE;QACpB,MAAM,CAAC,OAAO,GAAG,IAAI;QACrB,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,OAAO;QAC/B,UAAU,CAAC,IAAI,CAAC;QAChB,aAAa,CAAC,KAAK,CAAC;QACpB,QAAQ,CAAC,IAAI,CAAC;QACd,SAAS,CAAC,EAAE,CAAC;QACb,IAAI;YACF,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC;YAC5G,IAAI,EAAE,KAAK,UAAU,CAAC,OAAO;gBAAE;YAC/B,IAAI,MAAM,CAAC,EAAE;gBAAE,aAAa,CAAC,IAAI,CAAC;iBAC7B;gBAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC;gBAAE,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAAE;QACvE;QAAE,OAAO,OAAO,EAAE;YAChB,IAAI,EAAE,KAAK,UAAU,CAAC,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE;gBACvD,QAAQ,CAAC,OAAO,YAAY,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;YAC3E;QACF;gBAAU;YACR,IAAI,EAAE,KAAK,UAAU,CAAC,OAAO,EAAE;gBAAE,MAAM,CAAC,OAAO,GAAG,KAAK;gBAAE,UAAU,CAAC,KAAK,CAAC;YAAE;QAC9E;IACF;IAEA,SAAS,MAAM;QACb,IAAI,CAAC,MAAM,CAAC,OAAO;YAAE;QACrB,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,OAAO;QAC/B,MAAM,CAAC,OAAO,GAAG,KAAK;QACtB,UAAU,CAAC,KAAK,CAAC;QACjB,aAAa,CAAC,KAAK,CAAC;QACpB,KAAK,MAAM,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,OAAgB,EAAE,EAAE;YAC/C,IAAI,EAAE,KAAK,UAAU,CAAC,OAAO;gBAAE,QAAQ,CAAC,OAAO,YAAY,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QAC1G,CAAC,CAAC;IACJ;IAEA,OAAO;QACL,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;QACpE,KAAK,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACjC,IAAI,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QAC1C,GAAG,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC;QACxC,KAAK,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC;QAC5C,MAAM,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC;KAC/C;AACH","names":[],"ignoreList":[],"sources":["../../src/runtime/form.ts"],"sourcesContent":["import { useContext, useRef, useState } from 'hono/jsx';\nimport { isAbortError, submitAction, VoidActionError, type FormMethod } from 'void/pages-client';\nimport { RouterContext, useErrors, useRouter } from './pages.tsx';\n\nfunction fieldErrors(error: VoidActionError): Record<string, string> {\n  const body = error.body;\n  if (typeof body !== 'object' || body === null || !('errors' in body) || typeof body.errors !== 'object' || body.errors === null) return {};\n  return Object.fromEntries(Object.entries(body.errors).filter((entry): entry is [string, string] => typeof entry[1] === 'string'));\n}\n\nexport function useForm<T extends Record<string, unknown>>(initialData: T) {\n  if (!useContext(RouterContext)) throw new Error('Hono Pages: useForm requires the full Pages renderer; island form helpers are unsupported.');\n  const router = useRouter();\n  const initialErrors = useErrors();\n  const [data, updateData] = useState(initialData);\n  const [errors, setErrors] = useState(initialErrors);\n  const [pending, setPending] = useState(false);\n  const [wasSuccessful, setSuccessful] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n  const active = useRef(false);\n  const generation = useRef(0);\n\n  const setData: typeof updateData = (next) => {\n    updateData(next);\n    setSuccessful(false);\n    setErrors({});\n    setError(null);\n  };\n\n  async function submit(method: FormMethod, url: string) {\n    if (active.current) return;\n    active.current = true;\n    const id = ++generation.current;\n    setPending(true);\n    setSuccessful(false);\n    setError(null);\n    setErrors({});\n    try {\n      const result = await submitAction(router, url, { method: method.toUpperCase(), data, preserveScroll: true });\n      if (id !== generation.current) return;\n      if (result.ok) setSuccessful(true);\n      else { setError(result.error); setErrors(fieldErrors(result.error)); }\n    } catch (failure) {\n      if (id === generation.current && !isAbortError(failure)) {\n        setError(failure instanceof Error ? failure : new Error(String(failure)));\n      }\n    } finally {\n      if (id === generation.current) { active.current = false; setPending(false); }\n    }\n  }\n\n  function cancel() {\n    if (!active.current) return;\n    const id = ++generation.current;\n    active.current = false;\n    setPending(false);\n    setSuccessful(false);\n    void router.refresh().catch((failure: unknown) => {\n      if (id === generation.current) setError(failure instanceof Error ? failure : new Error(String(failure)));\n    });\n  }\n\n  return {\n    data, setData, errors, pending, wasSuccessful, error, submit, cancel,\n    reset() { setData(initialData); },\n    post: (url: string) => submit('post', url),\n    put: (url: string) => submit('put', url),\n    patch: (url: string) => submit('patch', url),\n    delete: (url: string) => submit('delete', url),\n  };\n}\n"]}

package/dist/server/pages.d.ts

@@ -15,3 +15,4 @@ type LinkProps = Omit<JSX.IntrinsicElements['a'], 'href' | 'onClick'> & {
     onClick?: (event: MouseEvent) => void;
 };
 export declare function Link({ href, reloadDocument, replace, onClick, ...attributes }: LinkProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+//# sourceMappingURL=pages.d.ts.map

package/dist/server/pages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages.d.ts","sourceRoot":"","sources":["../../src/runtime/pages.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,YAAY,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,MAAM,CAAC;AAEtD,eAAO,MAAM,aAAa,+CAAyC,CAAC;AACpE,eAAO,MAAM,WAAW,+CAAyC,CAAC;AAQlE,wBAAgB,SAAS,4BAA+B;AACxD,wBAAgB,SAAS,2BAA+B;AACxD,wBAAgB,SAAS,2BAAqC;AAE9D,wBAAgB,SAAS,IAAI,UAAU,CAItC;AAED,KAAK,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,wBAAgB,IAAI,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,UAAU,EAAE,EAAE,SAAS,kDAaxF"}

package/dist/server/pages.js

@@ -34,3 +34,4 @@ export function Link({ href, reloadDocument, replace, onClick, ...attributes })
             });
         } });
 }
+//# sourceMappingURL=pages.js.map

package/dist/server/pages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages.js","sourceRoot":"","sources":["../../src/runtime/pages.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAY,MAAM,UAAU,CAAC;AAK/D,MAAM,CAAC,MAAM,aAAa,GAAG,aAAa,CAAoB,IAAI,CAAC,CAAC;AACpE,MAAM,CAAC,MAAM,WAAW,GAAG,aAAa,CAAoB,IAAI,CAAC,CAAC;AAElE,SAAS,OAAO;IACd,MAAM,IAAI,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC;IACrC,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IAC9E,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,SAAS,KAAK,OAAO,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AACxD,MAAM,UAAU,SAAS,KAAK,OAAO,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AACxD,MAAM,UAAU,SAAS,KAAK,OAAO,OAAO,EAAE,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC;AAE9D,MAAM,UAAU,SAAS;IACvB,MAAM,MAAM,GAAG,UAAU,CAAC,aAAa,CAAC,CAAC;IACzC,IAAI,CAAC,MAAM;QAAE,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IAChF,OAAO,MAAM,CAAC;AAChB,CAAC;AASD,MAAM,UAAU,IAAI,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,UAAU,EAAa;IACvF,MAAM,MAAM,GAAG,SAAS,EAAE,CAAC;IAC3B,OAAO,eAAO,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,KAAiB,EAAE,EAAE;YACnE,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;YACjB,IAAI,KAAK,CAAC,gBAAgB,IAAI,cAAc,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,MAAM;gBAAE,OAAO;YAC/I,IAAI,UAAU,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,MAAM,KAAK,OAAO,CAAC,IAAI,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC;gBAAE,OAAO;YAC3J,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAChD,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,OAAO;YACjG,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;gBAC3D,MAAM,CAAC,aAAa,CAAC,IAAI,WAAW,CAAC,6BAA6B,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;YAC1F,CAAC,CAAC,CAAC;QACL,CAAC,GAAI,CAAC;AACR,CAAC","sourcesContent":["import { createContext, useContext, type JSX } from 'hono/jsx';\nimport type { VoidRouter } from 'void/pages-client';\nimport type { PageObject } from 'void/pages-protocol';\nexport type { DeferredState as Deferred } from 'void';\n\nexport const RouterContext = createContext<VoidRouter | null>(null);\nexport const PageContext = createContext<PageObject | null>(null);\n\nfunction usePage() {\n  const page = useContext(PageContext);\n  if (!page) throw new Error('Hono Pages: page data requires a page provider.');\n  return page;\n}\n\nexport function useShared() { return usePage().shared; }\nexport function useParams() { return usePage().params; }\nexport function useErrors() { return usePage().errors ?? {}; }\n\nexport function useRouter(): VoidRouter {\n  const router = useContext(RouterContext);\n  if (!router) throw new Error('Hono Pages: useRouter requires a page provider.');\n  return router;\n}\n\ntype LinkProps = Omit<JSX.IntrinsicElements['a'], 'href' | 'onClick'> & {\n  href: string;\n  reloadDocument?: boolean;\n  replace?: boolean;\n  onClick?: (event: MouseEvent) => void;\n};\n\nexport function Link({ href, reloadDocument, replace, onClick, ...attributes }: LinkProps) {\n  const router = useRouter();\n  return <a {...attributes} href={href} onClick={(event: MouseEvent) => {\n    onClick?.(event);\n    if (event.defaultPrevented || reloadDocument || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;\n    if (attributes.download !== undefined || (attributes.target && attributes.target !== '_self') || attributes.rel?.split(/\\s+/).includes('external')) return;\n    const url = new URL(href, window.location.href);\n    if (url.origin !== window.location.origin || !['http:', 'https:'].includes(url.protocol)) return;\n    event.preventDefault();\n    void router.visit(url, { replace }).catch((error: unknown) => {\n      window.dispatchEvent(new CustomEvent('hono-pages:navigation-error', { detail: error }));\n    });\n  }} />;\n}\n"]}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "void-plugin-hono-jsx",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.3",
   "private": false,
-  "description": "Experimental Hono JSX Pages adapter for Void 0.26.1",
+  "description": "Experimental Hono JSX Pages adapter for Void",
   "type": "module",
   "license": "MIT",
   "engines": {
@@ -10,6 +10,7 @@
   },
   "files": [
     "dist",
+    "src",
     "README.md",
     "THIRD_PARTY_NOTICES.md",
     "LICENSE",
@@ -30,9 +31,9 @@
     }
   },
   "peerDependencies": {
-    "hono": "4.13.13",
-    "void": "0.26.1",
-    "vite": "8.3.3"
+    "hono": ">=4.13.13 <5.0.0",
+    "void": ">=0.26.1 <0.28.0",
+    "vite": ">=8.0.16 <9.0.0"
   },
   "repository": {
     "type": "git",

package/src/plugins/compatibility.ts

@@ -0,0 +1,64 @@
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { version as helperViteVersion } from 'vite';
+
+export const supportedFrameworkRanges = {
+  void: '>=0.26.1 <0.28.0',
+  hono: '>=4.13.13 <5.0.0',
+  vite: '>=8.0.16 <9.0.0',
+};
+export const supportedViteRange = supportedFrameworkRanges.vite;
+
+// Only stable releases are admitted. Void is pre-1.0, so its next minor
+// requires explicit validation; Hono and Vite use their current major lines.
+export function supportsFramework(name: keyof typeof supportedFrameworkRanges, version: unknown): boolean {
+  if (typeof version !== 'string') return false;
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(version);
+  if (!match) return false;
+  const [major, minor, patch] = match.slice(1).map(Number);
+  if (![major, minor, patch].every(Number.isSafeInteger)) return false;
+  if (name === 'void') return major === 0 && ((minor === 26 && patch >= 1) || minor === 27);
+  if (name === 'hono') return major === 4 && (minor > 13 || (minor === 13 && patch >= 13));
+  return major === 8 && (minor > 0 || patch >= 16);
+}
+export const supportsVite = (version: unknown): boolean => supportsFramework('vite', version);
+
+type PackageInfo = { version: string; path: string };
+function packageInfo(name: string, require: NodeRequire): PackageInfo {
+  let directory = dirname(require.resolve(name));
+  while (true) {
+    const path = join(directory, 'package.json');
+    if (existsSync(path)) {
+      const metadata: unknown = JSON.parse(readFileSync(path, 'utf8'));
+      if (typeof metadata === 'object' && metadata !== null && 'name' in metadata && (metadata.name === name || (name === 'vite' && metadata.name === '@voidzero-dev/vite-plus-core'))) {
+        if (!('version' in metadata) || typeof metadata.version !== 'string') throw new Error(`Hono Pages: ${name} package version is missing (${path}).`);
+        return { version: metadata.version, path };
+      }
+    }
+    const parent = dirname(directory);
+    if (parent === directory) throw new Error(`Hono Pages: cannot locate ${name} package metadata from ${require.resolve(name)}.`);
+    directory = parent;
+  }
+}
+function describe(name: string, require: NodeRequire): string {
+  try { const info = packageInfo(name, require); return `${info.path} (metadata ${info.version})`; }
+  catch { return `not resolved from ${require.resolve.paths(name)?.join(', ') ?? 'this context'}`; }
+}
+
+export function assertSupportedFrameworks({ root, viteVersion }: { root: string; viteVersion: unknown }) {
+  const adapter = createRequire(import.meta.url);
+  const project = createRequire(join(root, 'package.json'));
+  const diagnostic = () => `Running Vite from hook context: ${typeof viteVersion === 'string' ? viteVersion : 'unavailable'}. Adapter helper Vite: ${helperViteVersion}; package.json: ${describe('vite', adapter)}. Project Vite package.json: ${describe('vite', project)}. Package paths are diagnostics, not the running Vite identity.`;
+  if (!supportsVite(viteVersion)) {
+    throw new Error(`Hono Pages: running Vite ${typeof viteVersion === 'string' ? viteVersion : 'unavailable'} is unsupported; expected ${supportedViteRange}. ${diagnostic()} Update the CLI/launcher that executes Vite. For bundled launchers such as vp, installing project vite alone does not update the running Vite. For standard Vite, install vite@^8.3.4 and run vite directly.`);
+  }
+  if (!supportsVite(helperViteVersion)) {
+    throw new Error(`Hono Pages: adapter helper Vite ${helperViteVersion} is unsupported; expected ${supportedViteRange}. ${diagnostic()} Inspect the adapter's resolved peer copy; install vite@^8.3.4 and refresh the adapter's peer resolution/lockfile if a stale copy remains.`);
+  }
+  for (const name of ['void', 'hono'] as const) {
+    const expected = supportedFrameworkRanges[name];
+    const info = packageInfo(name, adapter);
+    if (!supportsFramework(name, info.version)) throw new Error(`Hono Pages: ${name} ${info.version} is unsupported; install ${name}@"${expected}". Resolved package.json: ${info.path}. Project package.json: ${describe(name, project)}. ${diagnostic()}`);
+  }
+}

package/src/plugins/hono-islands.ts

@@ -0,0 +1,105 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { normalizePath, parseSync, type Plugin } from 'vite';
+import { scanPages, resolvePagesDir, type PageScanResult } 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(): Plugin {
+  const root = process.cwd();
+  const pagesDir = resolvePagesDir(root);
+  const islands = new Map<string, string>();
+  const pageFiles = new Set<string>();
+  let scan: PageScanResult | undefined;
+
+  function islandImports(code: string, filename: string) {
+    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: string, filename: string) {
+    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/src/plugins/hono-jsx.ts

@@ -0,0 +1,20 @@
+import { transformWithOxc, type Plugin } from 'vite';
+
+/** JSX factories differ by Vite environment; hooks can be shared via hono/jsx. */
+export function honoJsx(): Plugin {
+  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/src/plugins/hono-pages.ts

@@ -0,0 +1,143 @@
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { normalizePath } from 'vite';
+import { pagesRuntimePath, clientRuntimePath, publicRuntimeModules } from './runtime-paths.ts';
+import { generateComponentManifest, resolvePagesDir, resolveStaticPageDataBuildOptions, scanPages, type PageScanResult } from 'void/pages';
+import type { Plugin } from 'vite';
+import { honoJsx } from './hono-jsx.ts';
+import { honoIslands } from './hono-islands.ts';
+import { assertSupportedFrameworks } from './compatibility.ts';
+
+const rendererId = 'virtual:void-pages-renderer';
+const clientId = 'virtual:void-pages-client';
+
+/** Experimental Pages contract verified against Void 0.26.1 and 0.27.0. */
+export function voidHonoPages(): Plugin[] {
+  const root = process.cwd();
+  const pagesDir = resolvePagesDir(root);
+  const staticData = resolveStaticPageDataBuildOptions(root);
+  let scan: PageScanResult | undefined;
+
+  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(config) {
+      assertSupportedFrameworks({ root: resolve(config.root ?? root), viteVersion: this?.meta?.viteVersion });
+      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: string) => {
+        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<(typeof modules)[number]>();
+      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: string[] = [];
+        manifest = manifest.replace(/\(\) => import\(("(?:[^"\\]|\\.)*")\)/g, (_, path: string) => {
+          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/src/plugins/runtime-paths.ts

@@ -0,0 +1,14 @@
+import { fileURLToPath } from 'node:url';
+
+// Source fixtures use TSX; npm consumers use the precompiled environment entries.
+// Keep this adaptation in TypeScript so both emitted maps describe the actual code.
+const compiled = new URL(import.meta.url).pathname.endsWith('.js');
+export const pagesRuntimePath = fileURLToPath(new URL(compiled ? '../server/pages.js' : '../runtime/pages.tsx', import.meta.url));
+export const clientRuntimePath = fileURLToPath(new URL(compiled ? '../browser/client.js' : '../runtime/client.tsx', import.meta.url));
+export const publicRuntimeModules: Record<string, { server: string; client: string }> = compiled ? {
+  'void-plugin-hono-jsx/pages': { server: pagesRuntimePath, 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/src/runtime/client.tsx

@@ -0,0 +1,83 @@
+import { render } from 'hono/jsx/dom';
+import { jsx } from 'hono/jsx/dom/jsx-runtime';
+import { useLayoutEffect, useState } from 'hono/jsx';
+import { createVoidRouter, type VoidRouterConfig } from 'void/pages-client';
+import { parseCacheFor } from 'void/pages-prefetch';
+import { PageContext, RouterContext } from './pages.tsx';
+import { createDocumentHead } from './document-head.ts';
+import { createDeferred, resolveDeferred, rejectDeferred, isLoading, bufferInitialDeferred } from './deferred.ts';
+
+type Manifest = Pick<VoidRouterConfig, 'components' | 'layoutTree' | 'routeMeta' | 'matchRoute' | 'staticPageData' | 'staticPageDataFastPath'>;
+
+function pageComponent(component: unknown) {
+  if (typeof component !== 'function') throw new Error('Hono Pages: a page must export a component function.');
+  return component;
+}
+
+export async function startHonoPages(manifest: Manifest) {
+  const root = document.getElementById('app');
+  if (!root) throw new Error('Hono Pages: app root is missing.');
+  type Frame = { page: Awaited<ReturnType<typeof createVoidRouter>>['initialPageData']; component: unknown; layouts: unknown[]; revision: number };
+  let update: ((frame: Frame) => void) | undefined;
+  let revision = 0;
+  let applyDocumentHead: ReturnType<typeof createDocumentHead> | undefined;
+  let renderedProps: Record<string, unknown> | undefined;
+  let updateDeferred: ((props: Record<string, unknown>) => void) | undefined;
+  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<void>((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<Frame>({ 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 <RouterContext.Provider value={navigation.router}>
+      <PageContext.Provider value={frame.page}>
+        {failed && <p role="alert">The page could not be loaded. Please try again.</p>}
+        {content}
+      </PageContext.Provider>
+    </RouterContext.Provider>;
+  }
+
+  render(<App />, root);
+  navigation.start();
+  navigation.commitInitialRender();
+  root.dataset.navigation = 'idle';
+  root.dataset.honoPages = 'mounted';
+}

package/src/runtime/deferred.ts

@@ -0,0 +1,34 @@
+import type { DeferredState } from 'void';
+
+export function createDeferred(): DeferredState<never> {
+  return { loading: true, value: null, error: null };
+}
+export function resolveDeferred(_ref: unknown, value: unknown): DeferredState<unknown> {
+  return { loading: false, value, error: null };
+}
+export function rejectDeferred(_ref: unknown, message: string): DeferredState<never> {
+  return { loading: false, value: null, error: new Error(message) };
+}
+export function isLoading(ref: unknown): boolean {
+  return typeof ref === 'object' && ref !== null && 'loading' in ref && ref.loading === true;
+}
+
+// Void installs its HTML callbacks before awaiting component imports. Keep early
+// messages in its existing queue until the initial deferred registry is ready.
+declare global {
+  interface Window {
+    __resolveDeferred?: (group: string, data: unknown) => void;
+    __rejectDeferred?: (group: string, error: string) => void;
+    __deferredQueue?: Array<[string, unknown] | [string, 0, string]>;
+  }
+}
+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/src/runtime/document-head.ts

@@ -0,0 +1,44 @@
+import { renderHeadToString } from 'void/pages-head';
+import type { HeadDescriptor } from 'void';
+
+function scriptSignature(script: HTMLScriptElement) {
+  return JSON.stringify([Array.from(script.attributes, ({ name, value }) => [name, value]).sort(), script.textContent]);
+}
+
+function scriptElements(head: HeadDescriptor | undefined) {
+  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: HeadDescriptor | undefined) {
+  let htmlKeys = Object.keys(initial?.htmlAttrs ?? {});
+  let bodyKeys = Object.keys(initial?.bodyAttrs ?? {});
+  let scripts: HTMLScriptElement[] = [];
+  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: HTMLElement, previous: string[], next: Record<string, string> = {}) {
+    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: HeadDescriptor | undefined) => {
+    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();
+  };
+}