@wular/pnext 0.0.3 → 0.0.6

package/src/client/entry.ts

@@ -1,41 +1,41 @@
-import path from 'node:path';
-import type { ClientReference } from './reference';
-import { ISLAND_STATIC_CHILDREN_ATTRIBUTE } from '../islands/static-children';
+import path from 'node:path'
+import type { ClientReference } from './reference'
+import { ISLAND_STATIC_CHILDREN_ATTRIBUTE } from '../render/static-children'
 import {
   ISLAND_BOUNDARY_ERROR_DIGEST_ATTRIBUTE,
   ISLAND_BOUNDARY_ERROR_ELEMENT,
   ISLAND_BOUNDARY_ERROR_MESSAGE_ATTRIBUTE,
-} from '../islands/boundary-error';
+} from '../render/boundary-error'
 
 interface ClientEntryOptions {
-  pageFile?: string;
-  clientReferences: ClientReference[];
-  nextCompat?: boolean;
+  pageFile?: string
+  clientReferences: ClientReference[]
+  nextCompat?: boolean
   /** See ClientRuntimeFacts.suspense; false drops the Suspense island wrapper (and preact/compat). */
-  suspense?: boolean;
+  suspense?: boolean
   /**
    * The app reaches a server action anywhere (build's action manifest, or a route whose scan
    * recorded the `actions`/`form` client-entry reason). The whole action client runtime - RPC wire,
    * form interception, prop revival, error overlay - is emitted only then.
    */
-  actions?: boolean;
+  actions?: boolean
   /** Route's nearest error.* file: rendered as the action-error overlay (compat). */
-  errorFile?: string;
+  errorFile?: string
   /** Route's nearest not-found.* file: rendered for client-side notFound(). */
-  notFoundFile?: string;
+  notFoundFile?: string
   /**
    * A `'use client'` module in the route graph throws notFound()/forbidden()/
    * unauthorized(). The boundary then has something to render (its built-in
    * 404) even with no not-found.* file, so it must ship for this route.
    */
-  controlFlow?: boolean;
+  controlFlow?: boolean
   /**
    * App-root global-error.* file (compat): passed to installClientErrors as the
    * globalErrorComponent so a user global-error mounts for client throws that
    * escape every route error boundary. Threaded by client/build.ts; consumed by
-   * routerImportSource + mountLifecycleSource (mount-section coder owns wiring).
+   * routerImportSource + mountLifecycleSource (the mount section owns the wiring).
    */
-  globalErrorFile?: string;
+  globalErrorFile?: string
   /**
    * The route's root layout is itself a `'use client'` component. Only then does the whole document
    * body need re-rendering through that layout at hydration (the client-shell path, which adopts each
@@ -43,29 +43,29 @@ interface ClientEntryOptions {
    * client references are ordinary nested/slot islands that mount into their own containers, and
    * building a shell would wrongly remount the body under one of those islands.
    */
-  clientRootLayout?: boolean;
+  clientRootLayout?: boolean
   /**
    * Some file in this route's closure can reach a soft navigation (a Link, a navigation hook, compat
    * parity). False means no click on this page can ever start one, so the entry ships no router.
    */
-  router?: boolean;
+  router?: boolean
   /**
    * Layout files outermost-first; the shell nests in this order because
    * `clientReferences` is path-hash sorted (see build.ts shellLayoutOrder).
    */
-  shellLayoutOrder?: string[];
+  shellLayoutOrder?: string[]
   /**
    * Dev split: the served URL a deferred dynamic reference loads from instead
    * of bundling its target into this entry (see buildClientDynamicChunk).
    */
-  deferredDynamicHref?: (reference: ClientReference) => string | undefined;
+  deferredDynamicHref?: (reference: ClientReference) => string | undefined
 }
 
 // The soft-navigation runtime is bundled into every entry from this source
 // file; esbuild resolves the absolute path, so entries share the module (and
 // its prefetch/navigation state) through the common chunk graph.
 function routerModulePath() {
-  return path.join(import.meta.dirname, '../api/router.ts');
+  return path.join(import.meta.dirname, './router/index.ts')
 }
 
 // Server-action client runtime lives in the compat layer (only ever imported
@@ -73,29 +73,29 @@ function routerModulePath() {
 // core but emits these as generated import strings, gated on nextCompat, so
 // core carries no static import of compat.
 function actionRouterModulePath() {
-  return path.join(import.meta.dirname, '../compat/actions/action-router.ts');
+  return path.join(import.meta.dirname, '../compat/actions/router.ts')
 }
 
 function actionClientModulePath() {
-  return path.join(import.meta.dirname, '../compat/actions/action-client.ts');
+  return path.join(import.meta.dirname, '../compat/actions/client.ts')
 }
 
 function navCompatModulePath() {
-  return path.join(import.meta.dirname, '../compat/client/nav-compat.ts');
+  return path.join(import.meta.dirname, '../compat/client/nav.ts')
 }
 
 function islandContextModulePath() {
-  return path.join(import.meta.dirname, '../render/island-context.ts');
+  return path.join(import.meta.dirname, '../render/island-context.ts')
 }
 
 // Wire-marker revival shared with the server encoder (utils/serialize.ts):
 // island props carrying a CYCLE travel as `$$pnext_ref` back-references.
 function staticSlotsModulePath() {
-  return path.join(import.meta.dirname, '../islands/static-slots.ts');
+  return path.join(import.meta.dirname, '../render/static-slots.ts')
 }
 
 function serializeModulePath() {
-  return path.join(import.meta.dirname, '../utils/serialize.ts');
+  return path.join(import.meta.dirname, '../utils/serialize.ts')
 }
 
 // Re-provide the per-island layout-segment snapshot (stamped by the renderer as
@@ -103,7 +103,7 @@ function serializeModulePath() {
 // useSelectedLayoutSegment(s) recomputes live from the layout depth. Emitted
 // only under next compat (the hooks are compat-only); a no-op wrapper otherwise.
 function layoutSegmentHelperSource(nextCompat?: boolean) {
-  if (!nextCompat) return '';
+  if (!nextCompat) return ''
   return `
 import { LayoutSegmentContext as __PNextLayoutSegmentContext, RouteParamsContext as __PNextRouteParamsContext } from ${JSON.stringify(islandContextModulePath())};
 function pnextIslandReadJson(root, attr) {
@@ -121,7 +121,7 @@ function pnextIslandVNode(h, Component, props, children, root) {
   if (params) vnode = h(__PNextRouteParamsContext.Provider, { value: params }, vnode);
   return vnode;
 }
-`;
+`
 }
 
 function islandVNodeExpr(
@@ -133,7 +133,7 @@ function islandVNodeExpr(
 ) {
   return nextCompat
     ? `pnextIslandVNode(h, ${componentExpr}, ${propsExpr}, ${childrenExpr}, ${rootExpr})`
-    : `h(${componentExpr}, ${propsExpr}, ${childrenExpr})`;
+    : `h(${componentExpr}, ${propsExpr}, ${childrenExpr})`
 }
 
 // Two mount passes can reach the same island root concurrently - mountRoute and the streamed-Suspense
@@ -159,7 +159,7 @@ async function mountIslandOnce(root, mountTree) {
     if (root.__pnextMounting === mounting) root.__pnextMounting = undefined;
   }
 }
-`;
+`
 }
 
 // Error seams, imported from their leaf modules rather than through a barrel:
@@ -167,19 +167,19 @@ async function mountIslandOnce(root, mountTree) {
 // barrel re-export would drag the boundary into first paint even for an entry
 // that never names it.
 function clientErrorsInstallPath() {
-  return path.join(import.meta.dirname, '../compat/client/errors/lazy.ts');
+  return path.join(import.meta.dirname, '../compat/client/errors/lazy.ts')
 }
 
 function clientErrorBoundaryPath() {
-  return path.join(import.meta.dirname, '../compat/client/errors/error-boundary.ts');
+  return path.join(import.meta.dirname, '../compat/client/errors/error-boundary.ts')
 }
 
 function softRefreshModulePath() {
-  return path.join(import.meta.dirname, '../compat/client/errors/soft-refresh.ts');
+  return path.join(import.meta.dirname, '../compat/client/errors/soft-refresh.ts')
 }
 
 function bareErrorBoundaryPath() {
-  return path.join(import.meta.dirname, '../compat/client/errors/bare-boundary.ts');
+  return path.join(import.meta.dirname, '../compat/client/errors/bare-boundary.ts')
 }
 
 // The full in-tree ClientErrorBoundary is emitted only for a route that has an
@@ -188,18 +188,18 @@ function bareErrorBoundaryPath() {
 // window last resort - but only the bare tier, which re-throws and preserves
 // primitive throws for global-error and carries none of the cluster.
 function boundaryImportSource(nextCompat?: boolean, boundary?: boolean, builtinNotFound?: boolean) {
-  if (!nextCompat) return '';
+  if (!nextCompat) return ''
   if (!boundary) {
-    return `import { BareErrorBoundary } from ${JSON.stringify(bareErrorBoundaryPath())};`;
+    return `import { BareErrorBoundary } from ${JSON.stringify(bareErrorBoundaryPath())};`
   }
   return `import { ClientErrorBoundary } from ${JSON.stringify(clientErrorBoundaryPath())};
 import { softRefreshRoute } from ${JSON.stringify(softRefreshModulePath())};${
     builtinNotFound ? `\n${builtInNotFoundSource()}` : ''
-  }`;
+  }`
 }
 
 function errorUiModulePath() {
-  return path.join(import.meta.dirname, '../compat/lifecycle/error-ui.ts');
+  return path.join(import.meta.dirname, '../compat/lifecycle/error-ui.ts')
 }
 
 // Next's default 404 body, for a client notFound() on a route with no not-found.* of its own.
@@ -209,7 +209,7 @@ function builtInNotFoundSource() {
   return `import { httpAccessFallbackUi as __pnextHttpAccessFallbackUi } from ${JSON.stringify(errorUiModulePath())};
 function __PNextBuiltInNotFound() {
   return __pnextHttpAccessFallbackUi(404, 'This page could not be found.');
-}`;
+}`
 }
 
 /**
@@ -227,13 +227,13 @@ type EntryCompatFacts = Pick<
   | 'notFoundFile'
   | 'controlFlow'
   | 'router'
->;
+>
 
 /** Whether this route has something for the in-tree boundary to render. */
 export function hasErrorBoundary(
   facts: Pick<ClientEntryOptions, 'errorFile' | 'notFoundFile' | 'controlFlow'>,
 ) {
-  return Boolean(facts.errorFile ?? facts.notFoundFile) || facts.controlFlow === true;
+  return Boolean(facts.errorFile ?? facts.notFoundFile) || facts.controlFlow === true
 }
 
 function routerImportSource({
@@ -249,20 +249,20 @@ function routerImportSource({
   // guard is the one thing still owed, and it is one window read (autoMountGuard).
   const base = router
     ? `import { installRouter, routerImportActive } from ${JSON.stringify(routerModulePath())};`
-    : '';
-  if (!nextCompat) return base;
+    : ''
+  if (!nextCompat) return base
   const imports = [
     `${base}
 import { installNavCompat } from ${JSON.stringify(navCompatModulePath())};
 import { installClientErrors } from ${JSON.stringify(clientErrorsInstallPath())};`,
-  ];
+  ]
   if (actions) {
     // Compat apps may use server actions whose client stub navigates redirects
     // through window.__PNEXT_ROUTER__; install that global from the entry.
     imports.push(
       `import { installActionRouter } from ${JSON.stringify(actionRouterModulePath())};
 import { isActionError } from ${JSON.stringify(actionClientModulePath())};`,
-    );
+    )
   }
   if (errorFile) {
     // Route error.js: rendered as an overlay when an action error goes uncaught
@@ -270,17 +270,17 @@ import { isActionError } from ${JSON.stringify(actionClientModulePath())};`,
     if (actions) {
       imports.push(
         `import { installActionErrorOverlay } from ${JSON.stringify(actionClientModulePath())};`,
-      );
+      )
     }
-    imports.push(`import __PNextRouteErrorComponent from ${JSON.stringify(errorFile)};`);
+    imports.push(`import __PNextRouteErrorComponent from ${JSON.stringify(errorFile)};`)
   }
   if (globalErrorFile) {
-    imports.push(`import __PNextGlobalErrorComponent from ${JSON.stringify(globalErrorFile)};`);
+    imports.push(`import __PNextGlobalErrorComponent from ${JSON.stringify(globalErrorFile)};`)
   }
   if (notFoundFile) {
-    imports.push(`import __PNextRouteNotFoundComponent from ${JSON.stringify(notFoundFile)};`);
+    imports.push(`import __PNextRouteNotFoundComponent from ${JSON.stringify(notFoundFile)};`)
   }
-  return imports.join('\n');
+  return imports.join('\n')
 }
 
 // Island props may carry serialized server-action references; the action runtime revives them into
@@ -289,7 +289,7 @@ import { isActionError } from ${JSON.stringify(actionClientModulePath())};`,
 // untouched when next compat is off - so core and react entries import the ref+binary reviver and the
 // error branch never ships.
 function propsParserSource(nextCompat?: boolean) {
-  const revive = nextCompat ? 'reviveSerializedErrorRefs' : 'reviveSerializedRefs';
+  const revive = nextCompat ? 'reviveSerializedErrorRefs' : 'reviveSerializedRefs'
   return `
 import { ${revive} as __pnextReviveSerializedRefs } from ${JSON.stringify(serializeModulePath())};
 import { hasIslandStaticSlots as __pnextHasIslandSlots, reviveIslandStaticSlots as __pnextReviveIslandSlots } from ${JSON.stringify(staticSlotsModulePath())};
@@ -332,7 +332,7 @@ function pnextFulfilled(value) {
   promise.value = value;
   return promise;
 }
-`;
+`
 }
 
 // Entries auto-mount only when loaded as the document's own module script.
@@ -443,14 +443,16 @@ function keepsMountedRoot(root, keep) {
   }
   return false;
 }
-`;
+`
 }
 
 // The per-route half of the lifecycle, closing over the route's own mount
 // state. mountRoute runs the steps the route actually has: an island scan, the
 // client-shell hydration, the client page.
 function routeLifecycleSource({ nextCompat, islands, page, shell }: ClientRuntimeFacts) {
-  const gate = nextCompat ? '  pnextGate(markRouteHydrated, pnextIslandMounts, pnextVisibleMount);\n' : '';
+  const gate = nextCompat
+    ? '  pnextGate(markRouteHydrated, pnextIslandMounts, pnextVisibleMount);\n'
+    : ''
   const mountBody = [
     islands
       ? `  if (islands.length > 0) {
@@ -467,7 +469,7 @@ function routeLifecycleSource({ nextCompat, islands, page, shell }: ClientRuntim
       : '',
   ]
     .filter(Boolean)
-    .join('\n');
+    .join('\n')
   return `
   function mountRoute() {
 ${mountBody}
@@ -508,7 +510,7 @@ ${gate}    return pnextIslandMounts;
   }
 
   return { mountRoute, remountRoute, unmountRoute };
-`;
+`
 }
 
 /**
@@ -529,7 +531,7 @@ function markRouteHydrated() {
   window.dispatchEvent(new Event('pnext:hydrated'));
 }
 `
-    : '';
+    : ''
   return `
 ${routerImportSource(facts)}
 ${mark}
@@ -542,12 +544,12 @@ export function unmountRoute() {}
 ${installRouterCall(facts.router)}${installCallsSource(facts)}
 if (${autoMountGuard(facts.router)}) mountRoute();
 if (window.__PNEXT_REGISTER_ENTRY__) window.__PNEXT_REGISTER_ENTRY__(import.meta.url, { mountRoute, unmountRoute });
-`;
+`
 }
 
 /** `installRouter()`, or nothing when the route can never soft-navigate. */
 function installRouterCall(router?: boolean) {
-  return router ? 'installRouter();\n' : '';
+  return router ? 'installRouter();\n' : ''
 }
 
 /**
@@ -556,7 +558,7 @@ function installRouterCall(router?: boolean) {
  * `routerImportActive` - that one import would pull the whole first-paint hub back onto the page.
  */
 function autoMountGuard(router?: boolean) {
-  return router ? '!routerImportActive()' : '!((window.__PNEXT_ROUTER_IMPORTS__ ?? 0) > 0)';
+  return router ? '!routerImportActive()' : '!((window.__PNEXT_ROUTER_IMPORTS__ ?? 0) > 0)'
 }
 
 // The compat install calls that follow installRouter() in every entry shape.
@@ -567,8 +569,9 @@ function installCallsSource({
   globalErrorFile,
   notFoundFile,
 }: EntryCompatFacts) {
-  if (!nextCompat) return '';
-  const overlay = actions && errorFile ? 'installActionErrorOverlay(__PNextRouteErrorComponent);\n' : '';
+  if (!nextCompat) return ''
+  const overlay =
+    actions && errorFile ? 'installActionErrorOverlay(__PNextRouteErrorComponent);\n' : ''
   return `${actions ? 'installActionRouter();\n' : ''}installNavCompat();
 ${overlay}installClientErrors({ errorComponent: ${
     errorFile ? '__PNextRouteErrorComponent' : 'undefined'
@@ -576,7 +579,7 @@ ${overlay}installClientErrors({ errorComponent: ${
     globalErrorFile ? '__PNextGlobalErrorComponent' : 'undefined'
   }, notFoundComponent: ${
     notFoundFile ? '__PNextRouteNotFoundComponent' : 'undefined'
-  }, isActionError: ${actions ? 'isActionError' : 'undefined'} });`;
+  }, isActionError: ${actions ? 'isActionError' : 'undefined'} });`
 }
 
 /**
@@ -584,29 +587,29 @@ ${overlay}installClientErrors({ errorComponent: ${
  * ships only when some route in the app can actually use it.
  */
 export interface ClientRuntimeFacts {
-  nextCompat?: boolean;
+  nextCompat?: boolean
   /** Any route mounts islands (island scan, revival, static children). */
-  islands?: boolean;
+  islands?: boolean
   /** Any route is a whole-page `'use client'` component. */
-  page?: boolean;
+  page?: boolean
   /** Any route hydrates a client root layout as the document shell. */
-  shell?: boolean;
+  shell?: boolean
   /** Any route has a `dynamic(..., { ssr: false })` island (DeferredIsland). */
-  deferredIslands?: boolean;
+  deferredIslands?: boolean
   /** Any island loads on visibility (IntersectionObserver tier). */
-  visibleIslands?: boolean;
+  visibleIslands?: boolean
   /**
    * Compat runtime must support suspension (Suspense island wrapper, preact/compat). False only when
    * the app's client graph provably never suspends (see clientCompatSurface); undefined outside compat.
    */
-  suspense?: boolean;
+  suspense?: boolean
 }
 
 /** Module specifier the generated route stubs import their runtime from. */
-export const CLIENT_RUNTIME_MODULE = 'pnext-client-runtime';
+export const CLIENT_RUNTIME_MODULE = 'pnext-client-runtime'
 
 /** Dev split: single-instance vendor modules the entry shares with on-demand chunks. */
-export const DYN_SHARED_GLOBAL = '__PNEXT_DYN_SHARED__';
+export const DYN_SHARED_GLOBAL = '__PNEXT_DYN_SHARED__'
 export function dynSharedSpecifiers(nextCompat?: boolean) {
   return nextCompat
     ? [
@@ -617,7 +620,7 @@ export function dynSharedSpecifiers(nextCompat?: boolean) {
         'preact/jsx-runtime',
         'preact/jsx-dev-runtime',
       ]
-    : ['preact', 'preact/hooks', 'preact/jsx-runtime'];
+    : ['preact', 'preact/hooks', 'preact/jsx-runtime']
 }
 
 // A separately-built dynamic chunk must render with THIS entry's preact (hooks
@@ -629,15 +632,15 @@ function dynSharedTableSource(
   nextCompat?: boolean,
   deferredDynamicHref?: (reference: ClientReference) => string | undefined,
 ) {
-  if (!deferredDynamicHref) return '';
-  const specifiers = dynSharedSpecifiers(nextCompat);
+  if (!deferredDynamicHref) return ''
+  const specifiers = dynSharedSpecifiers(nextCompat)
   const imports = specifiers.map(
     (specifier, index) => `import * as __pnextDynShared${index} from ${JSON.stringify(specifier)};`,
-  );
+  )
   const entries = specifiers.map(
     (specifier, index) => `${JSON.stringify(specifier)}: __pnextDynShared${index}`,
-  );
-  return `${imports.join('\n')}\nwindow.${DYN_SHARED_GLOBAL} = { ${entries.join(', ')} };\n`;
+  )
+  return `${imports.join('\n')}\nwindow.${DYN_SHARED_GLOBAL} = { ${entries.join(', ')} };\n`
 }
 
 export function clientRuntimeFacts(
@@ -645,21 +648,21 @@ export function clientRuntimeFacts(
   nextCompat?: boolean,
   suspense?: boolean,
 ): ClientRuntimeFacts {
-  const references = routes.flatMap(({ route }) => route.clientReferences);
+  const references = routes.flatMap(({ route }) => route.clientReferences)
   return {
     nextCompat,
-    suspense: nextCompat ? suspense ?? true : undefined,
+    suspense: nextCompat ? (suspense ?? true) : undefined,
     islands: references.length > 0,
     page: routes.some(({ route }) => route.client),
     shell: routes.some(entry => entry.shell),
     deferredIslands: references.some(reference => reference.dynamic?.ssr === false),
     visibleIslands: references.some(reference => reference.dynamic?.load === 'visible'),
-  };
+  }
 }
 
 interface RouteFacts {
-  client?: boolean;
-  clientReferences: ClientReference[];
+  client?: boolean
+  clientReferences: ClientReference[]
 }
 
 /**
@@ -668,11 +671,11 @@ interface RouteFacts {
  * Route-specific values (islands, the client page, shell layouts, error components) arrive as config.
  */
 export function clientRuntimeSource(facts: ClientRuntimeFacts) {
-  const { nextCompat, deferredIslands, page, shell } = facts;
-  const suspense = nextCompat && facts.suspense !== false;
+  const { nextCompat, deferredIslands, page, shell } = facts
+  const suspense = nextCompat && facts.suspense !== false
   // The shell re-renders the whole document through the client root layout, so
   // it revives island DOM exactly like an island mount does.
-  const revival = Boolean(facts.islands || shell);
+  const revival = Boolean(facts.islands || shell)
   return `
 import { h, hydrate, render } from 'preact';
 ${nextCompat ? "import { options as __pnextPreactOptions } from 'preact';" : ''}
@@ -699,12 +702,19 @@ ${shell ? hydrateClientShellSource(nextCompat) : ''}
 ${page ? hydratePageSource(nextCompat) : ''}
 ${routeLifecycleSource(facts)}
 }
-`;
+`
 }
 
 export function clientEntrySource(options: ClientEntryOptions) {
-  const { pageFile, clientReferences, nextCompat, errorFile, notFoundFile, clientRootLayout, shellLayoutOrder } =
-    options;
+  const {
+    pageFile,
+    clientReferences,
+    nextCompat,
+    errorFile,
+    notFoundFile,
+    clientRootLayout,
+    shellLayoutOrder,
+  } = options
   const facts: EntryCompatFacts = {
     nextCompat,
     suspense: options.suspense,
@@ -715,27 +725,31 @@ export function clientEntrySource(options: ClientEntryOptions) {
     controlFlow: options.controlFlow,
     // The router-only entry shape exists BECAUSE this route needs the router.
     router: options.router || (!pageFile && clientReferences.length === 0),
-  };
+  }
   if (!pageFile && clientReferences.length === 0) {
-    return routerOnlyEntrySource(facts);
+    return routerOnlyEntrySource(facts)
   }
-  if (!pageFile && clientReferences.length > 0 && clientReferences.every(isVisibleDynamicReference)) {
-    return visibleDynamicIslandEntrySource(clientReferences, facts, options.deferredDynamicHref);
+  if (
+    !pageFile &&
+    clientReferences.length > 0 &&
+    clientReferences.every(isVisibleDynamicReference)
+  ) {
+    return visibleDynamicIslandEntrySource(clientReferences, facts, options.deferredDynamicHref)
   }
 
   const imports = clientReferences
     .map((reference, index) => {
-      if (reference.dynamic) return null;
+      if (reference.dynamic) return null
       // A side-effect-only client module (bare `import './client-only'`) is
       // bundled and run for its top-level code but never mounted as an island —
       // webpack-style eager initialization of all client references.
-      if (reference.sideEffect) return `import ${JSON.stringify(reference.file)};`;
+      if (reference.sideEffect) return `import ${JSON.stringify(reference.file)};`
       return reference.exportName === 'default'
         ? `import Island${index} from ${JSON.stringify(reference.file)};`
-        : `import { ${reference.exportName} as Island${index} } from ${JSON.stringify(reference.file)};`;
+        : `import { ${reference.exportName} as Island${index} } from ${JSON.stringify(reference.file)};`
     })
     .filter((item): item is string => Boolean(item))
-    .join('\n');
+    .join('\n')
   const islandManifest = clientReferences
     .map((reference, index) =>
       reference.sideEffect
@@ -745,27 +759,27 @@ export function clientEntrySource(options: ClientEntryOptions) {
           : `{ id: ${JSON.stringify(reference.id)}, Component: Island${index} }`,
     )
     .filter((item): item is string => item !== null)
-    .join(',\n  ');
+    .join(',\n  ')
 
   // Island bindings are named by position in the FULL reference array (see
   // `imports` above), so the shell must carry those names rather than re-index
   // its own filtered/reordered view.
   const islandNames = new Map(
     clientReferences.map((reference, index) => [reference, `Island${index}`]),
-  );
+  )
   const shellReferences = shellClientReferences(
     clientReferences,
     errorFile,
     notFoundFile,
     shellLayoutOrder,
-  );
+  )
   const shellNames =
     !pageFile && clientRootLayout && shellReferences.some(reference => !reference.dynamic)
       ? shellReferences
           .map(reference => (reference.dynamic ? undefined : islandNames.get(reference)))
           .filter((name): name is string => Boolean(name))
-      : undefined;
-  const needsCss = clientReferences.some(reference => referenceCssHref(reference));
+      : undefined
+  const needsCss = clientReferences.some(reference => referenceCssHref(reference))
 
   return `
 import { bootstrapRoute${needsCss ? ', loadIslandCss' : ''} } from ${JSON.stringify(CLIENT_RUNTIME_MODULE)};
@@ -785,7 +799,7 @@ export { mountRoute, remountRoute, unmountRoute };
 ${installRouterCall(facts.router)}${installCallsSource(facts)}
 if (${autoMountGuard(facts.router)}) void mountRoute();
 if (window.__PNEXT_REGISTER_ENTRY__) window.__PNEXT_REGISTER_ENTRY__(import.meta.url, { mountRoute, unmountRoute });
-`;
+`
 }
 
 /**
@@ -795,14 +809,14 @@ if (window.__PNEXT_REGISTER_ENTRY__) window.__PNEXT_REGISTER_ENTRY__(import.meta
  * the app-wide runtime chunk.
  */
 function boundaryConfigSource(facts: EntryCompatFacts) {
-  if (!facts.nextCompat) return '';
+  if (!facts.nextCompat) return ''
   const base = `\n  errorComponent: ${facts.errorFile ? '__PNextRouteErrorComponent' : 'undefined'},\n  notFoundComponent: ${
     facts.notFoundFile ? '__PNextRouteNotFoundComponent' : 'undefined'
-  },`;
-  if (!hasErrorBoundary(facts)) return `${base}\n  errorBoundary: BareErrorBoundary,`;
+  },`
+  if (!hasErrorBoundary(facts)) return `${base}\n  errorBoundary: BareErrorBoundary,`
   return `${base}\n  errorBoundary: ClientErrorBoundary,\n  onBoundaryReset: softRefreshRoute,${
     facts.notFoundFile ? '' : '\n  builtInNotFound: __PNextBuiltInNotFound,'
-  }`;
+  }`
 }
 
 function shellClientReferences(
@@ -813,31 +827,29 @@ function shellClientReferences(
 ) {
   const shell = clientReferences.filter(
     reference =>
-      !reference.sideEffect &&
-      reference.file !== errorFile &&
-      reference.file !== notFoundFile,
-  );
+      !reference.sideEffect && reference.file !== errorFile && reference.file !== notFoundFile,
+  )
   // The shell nests outermost-first, but `clientReferences` is path-hash
   // sorted — layouts must lead in hierarchy order or a non-layout reference
   // can end up outermost and silently drop the layout subtree. Non-layout
   // references keep their relative order behind the chain.
-  if (!shellLayoutOrder?.length) return shell;
-  const rank = new Map(shellLayoutOrder.map((file, index) => [file, index]));
+  if (!shellLayoutOrder?.length) return shell
+  const rank = new Map(shellLayoutOrder.map((file, index) => [file, index]))
   return shell
     .map((reference, index) => ({ reference, index }))
     .sort((a, b) => {
-      const aRank = rank.get(a.reference.file);
-      const bRank = rank.get(b.reference.file);
-      if (aRank !== undefined && bRank !== undefined) return aRank - bRank;
-      if (aRank !== undefined) return -1;
-      if (bRank !== undefined) return 1;
-      return a.index - b.index;
+      const aRank = rank.get(a.reference.file)
+      const bRank = rank.get(b.reference.file)
+      if (aRank !== undefined && bRank !== undefined) return aRank - bRank
+      if (aRank !== undefined) return -1
+      if (bRank !== undefined) return 1
+      return a.index - b.index
     })
-    .map(entry => entry.reference);
+    .map(entry => entry.reference)
 }
 
 function isVisibleDynamicReference(reference: ClientReference) {
-  return reference.dynamic?.load === 'visible';
+  return reference.dynamic?.load === 'visible'
 }
 
 function visibleDynamicIslandEntrySource(
@@ -845,11 +857,14 @@ function visibleDynamicIslandEntrySource(
   facts: EntryCompatFacts,
   deferredDynamicHref?: (reference: ClientReference) => string | undefined,
 ) {
-  const { nextCompat, errorFile, notFoundFile } = facts;
-  const boundary = hasErrorBoundary(facts);
+  const { nextCompat, errorFile, notFoundFile } = facts
+  const boundary = hasErrorBoundary(facts)
   const islandManifest = clientReferences
-    .map(reference => `{ id: ${JSON.stringify(reference.id)}, ${visibleDynamicLoader(reference, deferredDynamicHref?.(reference))} }`)
-    .join(',\n  ');
+    .map(
+      reference =>
+        `{ id: ${JSON.stringify(reference.id)}, ${visibleDynamicLoader(reference, deferredDynamicHref?.(reference))} }`,
+    )
+    .join(',\n  ')
 
   const compatBoundary = !nextCompat
     ? ''
@@ -868,7 +883,7 @@ function visibleDynamicIslandEntrySource(
         `function pnextClientBoundary(h, vnode) {
   return h(BareErrorBoundary, null, vnode);
 }
-`;
+`
 
   return `
 ${nextCompat ? "import { options as __pnextPreactOptions } from 'preact';" : ''}
@@ -1088,27 +1103,25 @@ function domProps(element) {
 function isNestedIslandRoot(root) {
   return root.parentElement?.closest('pnext-client') != null;
 }
-`;
+`
 }
 
 function visibleDynamicLoader(reference: ClientReference, href?: string) {
-  return `options: ${JSON.stringify(reference.dynamic ?? {})}, ${dynamicLoader(reference, href)}`;
+  return `options: ${JSON.stringify(reference.dynamic ?? {})}, ${dynamicLoader(reference, href)}`
 }
 
 function dynamicLoader(reference: ClientReference, href?: string) {
   const imported =
-    reference.exportName === 'default'
-      ? 'module.default'
-      : `module.${reference.exportName}`;
-  const importExpression = `import(${JSON.stringify(href ?? reference.file)}).then(module => ${imported})`;
-  const cssHref = referenceCssHref(reference);
+    reference.exportName === 'default' ? 'module.default' : `module.${reference.exportName}`
+  const importExpression = `import(${JSON.stringify(href ?? reference.file)}).then(module => ${imported})`
+  const cssHref = referenceCssHref(reference)
   return cssHref
     ? `load: () => Promise.all([${importExpression}, loadIslandCss(${JSON.stringify(cssHref)})]).then(([module]) => module)`
-    : `load: () => ${importExpression}`;
+    : `load: () => ${importExpression}`
 }
 
 function referenceCssHref(reference: ClientReference) {
-  return reference.cssImports?.length ? `/assets/${reference.id}.css` : undefined;
+  return reference.cssImports?.length ? `/assets/${reference.id}.css` : undefined
 }
 
 // The island's stylesheet loads with the island, not with the route: a
@@ -1128,7 +1141,7 @@ export function loadIslandCss(href) {
     document.head.append(link);
   });
 }
-`;
+`
 }
 
 function mountSource() {
@@ -1146,7 +1159,7 @@ function mount(root, vnode) {
   root.__pnextLive = render;
   pnextMountedRoots.add(root);
 }
-`;
+`
 }
 
 function hydratePageSource(nextCompat?: boolean) {
@@ -1255,7 +1268,7 @@ function pageMarkerContainer(open, close, parent) {
     closest(selector) { return parent.closest ? parent.closest(selector) : null; },
   };
 }
-`;
+`
 }
 
 // Under next compat every hydrated island and the page mount wraps in the in-tree
@@ -1263,7 +1276,7 @@ function pageMarkerContainer(open, close, parent) {
 // without Suspense kills the Preact tree). The boundary renders the route error.js and reset() soft-
 // refreshes.
 function wrapInBoundary(vnodeExpression: string, nextCompat?: boolean) {
-  return nextCompat ? `pnextBoundary(${vnodeExpression})` : vnodeExpression;
+  return nextCompat ? `pnextBoundary(${vnodeExpression})` : vnodeExpression
 }
 
 // Emits the per-route boundary helper referenced by wrapInBoundary. The Suspense wrapper is
@@ -1272,7 +1285,7 @@ function wrapInBoundary(vnodeExpression: string, nextCompat?: boolean) {
 // shared app-wide, so naming the full boundary would put the whole cluster - and its built-in 404 UI -
 // on the first paint of every route in an app where any single route has an error file.
 function clientBoundaryHelperSource(nextCompat?: boolean, suspense?: boolean) {
-  if (!nextCompat) return '';
+  if (!nextCompat) return ''
   // A suspense-free app (no lazy/use/async components anywhere in its client graph) keeps the error
   // boundary but drops the Suspense wrapper - and preact/compat with it.
   const boundary = `h(config.errorBoundary, {
@@ -1280,12 +1293,12 @@ function clientBoundaryHelperSource(nextCompat?: boolean, suspense?: boolean) {
       notFoundComponent: config.notFoundComponent,
       builtInNotFound: config.builtInNotFound,
       onReset: config.onBoundaryReset,
-    }, vnode)`;
+    }, vnode)`
   return `
   function pnextBoundary(vnode) {
     return ${suspense ? `h(Suspense, { fallback: null }, ${boundary})` : boundary};
   }
-`;
+`
 }
 
 function hydrateIslandsSource({ nextCompat, visibleIslands, deferredIslands }: ClientRuntimeFacts) {
@@ -1339,8 +1352,10 @@ function mountIsland(root, island) {
 
 async function mountIslandTree(root, island) {
   const Component = island.Component ?? await island.load();${
-    nextCompat ? `
-  window.__PNEXT_ACTIONS__?.registerClientReference(island.id, Component);` : ''
+    nextCompat
+      ? `
+  window.__PNEXT_ACTIONS__?.registerClientReference(island.id, Component);`
+      : ''
   }
   const rawProps = root.getAttribute('data-pnext-props') ?? '{}';
   const incoming = root.__pnextIncoming;
@@ -1442,7 +1457,7 @@ async function domNode(node) {
 
   return h(element.localName, domProps(element), await domChildren(element));
 }
-`;
+`
 }
 
 // Helpers with no per-route state: they live once in the shared runtime module,
@@ -1496,7 +1511,7 @@ function DeferredIsland({ load, props, children }) {
 }
 `
       : ''
-  }`;
+  }`
 }
 
 function hydrateClientShellSource(nextCompat?: boolean) {
@@ -1505,7 +1520,7 @@ function hydrateClientShellSource(nextCompat?: boolean) {
   const shell = `shell.reduceRight(
     (children, Component, index) => h(Component, index === 0 ? slotProps : null, children),
     page,
-  )`;
+  )`
 
   return `
 // A client root layout is re-rendered whole here, but its parallel-route slot
@@ -1536,5 +1551,5 @@ async function hydrateClientShell() {
   const slotProps = await collectRootSlotProps();
   mount(document.body, ${wrapInBoundary(shell, nextCompat)});
 }
-`;
+`
 }