nukejs 0.0.11 → 0.0.13

package/README.md

@@ -24,6 +24,7 @@ npm create nuke@latest
 - [Configuration](#configuration)
 - [Link Component & Navigation](#link-component--navigation)
 - [useRequest() — URL Params, Query & Headers](#userequest--url-params-query--headers)
+- [Error Pages](#error-pages)
 - [Building & Deploying](#building--deploying)
 
 ## Overview
@@ -714,6 +715,152 @@ Changing `?lang=fr` in the URL re-renders client components automatically.
 
 ---
 
+## Error Pages
+
+NukeJS supports custom error pages for **404 Not Found** and **500 Internal Server Error**. Place them directly in `app/pages/` — they are standard server components and support everything regular pages do: layouts, `useHtml()`, client components, and HMR in dev.
+
+### `_404.tsx` — Page Not Found
+
+Rendered when no route matches the requested URL.
+
+```tsx
+// app/pages/_404.tsx
+import { useHtml } from 'nukejs';
+import { Link } from 'nukejs';
+
+export default function NotFound() {
+  useHtml({ title: 'Page Not Found' });
+
+  return (
+    <main>
+      <h1>404 — Page Not Found</h1>
+      <p>The page you're looking for doesn't exist.</p>
+      <Link href="/">Go home</Link>
+    </main>
+  );
+}
+```
+
+### `_500.tsx` — Internal Server Error
+
+Rendered when a page handler throws an unhandled error. The error is passed as optional props so you can display details in development.
+
+```tsx
+// app/pages/_500.tsx
+import { useHtml } from 'nukejs';
+import { Link } from 'nukejs';
+
+interface ErrorProps {
+  errorMessage?: string; // human-readable error description
+  errorStatus?:  string; // HTTP status code if present on the thrown error
+  errorStack?:   string; // stack trace — only populated in development
+}
+
+export default function ServerError({ errorMessage, errorStack }: ErrorProps) {
+  useHtml({ title: 'Something went wrong' });
+
+  return (
+    <main>
+      <h1>500 — Server Error</h1>
+      <p>Something went wrong on our end. Please try again.</p>
+      {errorMessage && <p><strong>{errorMessage}</strong></p>}
+      {errorStack   && <pre>{errorStack}</pre>}
+      <Link href="/">Go home</Link>
+    </main>
+  );
+}
+```
+
+### Server errors
+
+Any unhandled throw inside a server page component (including async data fetching) routes to `_500.tsx`. The error message and stack trace are forwarded as props automatically.
+
+```tsx
+// app/pages/dashboard.tsx
+export default async function Dashboard() {
+  const data = await fetchData(); // throws → _500.tsx is rendered
+  return <main>{data.name}</main>;
+}
+```
+
+You can also attach a `status` property to a thrown error to control the HTTP status code sent with the response:
+
+```tsx
+export default async function Post({ id }: { id: string }) {
+  const post = await db.getPost(id);
+
+  if (!post) {
+    const err = new Error('Post not found');
+    (err as any).status = 404;
+    throw err; // _500.tsx receives errorMessage="Post not found", errorStatus="404"
+  }
+
+  return <article>{post.title}</article>;
+}
+```
+
+### Client errors
+
+Unhandled errors in client components and async code are automatically caught and routed to `_500.tsx` via an in-place SPA navigation — no full page reload. Three mechanisms cover all cases:
+
+- **React Error Boundary** — wraps every hydrated `"use client"` component; catches render and lifecycle errors
+- **`window.onerror`** — catches synchronous throws in event handlers and other non-React code
+- **`window.onunhandledrejection`** — catches unhandled `Promise` rejections from `async` functions
+
+```tsx
+// app/components/FaultyButton.tsx
+"use client";
+
+export default function FaultyButton() {
+  const handleClick = () => {
+    throw new Error('Something broke!'); // caught by window.onerror → _500.tsx
+  };
+
+  return <button onClick={handleClick}>Click me</button>;
+}
+```
+
+```tsx
+// app/components/FaultyFetch.tsx
+"use client";
+import { useEffect } from 'react';
+
+export default function FaultyFetch() {
+  useEffect(() => {
+    // Unhandled rejection caught by window.onunhandledrejection → _500.tsx
+    fetch('/api/broken').then(res => {
+      if (!res.ok) throw new Error(`API error ${res.status}`);
+    });
+  }, []);
+
+  return <div>Loading...</div>;
+}
+```
+
+The `_500.tsx` page receives `errorMessage` and `errorStack` props from client errors just like server errors, so a single error page handles both origins consistently.
+
+### Behaviour
+
+| Scenario | Without `_500.tsx` | With `_500.tsx` |
+|---|---|---|
+| Server page throws | Plain-text `Internal Server Error` (500) | `_500.tsx` rendered with error props |
+| Client component render error | React crashes the component subtree | `_500.tsx` rendered in-place, no reload |
+| Unhandled event handler throw | Browser console error only | `_500.tsx` rendered in-place, no reload |
+| Unhandled promise rejection | Browser console error only | `_500.tsx` rendered in-place, no reload |
+| Unknown URL | Plain-text `Page not found` (404) | `_404.tsx` rendered with 404 status |
+| `<Link>` to unknown URL | Full page reload | In-place SPA navigation, no reload |
+| HMR save of `_404.tsx` / `_500.tsx` | — | Current page re-fetches immediately |
+
+### Notes
+
+- Error pages are **excluded from routing** — `/_404` and `/_500` are not reachable as URLs.
+- They participate in the root `layout.tsx` like any other page.
+- Both are fully bundled into the production output (Node.js and Vercel) — no runtime file-system access required.
+- The correct HTTP status code (404 or 500) is always sent in the response.
+- `errorStack` is only populated in development (`NODE_ENV !== 'production'`).
+
+---
+
 ## Building & Deploying
 
 ### Node.js server

package/dist/Link.js

@@ -13,4 +13,3 @@ var Link_default = Link;
 export {
   Link_default as default
 };
-//# sourceMappingURL=Link.js.map

package/dist/app.js

@@ -111,4 +111,3 @@ function printStartupBanner(port, isDev2) {
 }
 const actualPort = await tryListen(PORT);
 printStartupBanner(actualPort, isDev);
-//# sourceMappingURL=app.js.map

package/dist/build-common.js

@@ -147,7 +147,8 @@ function extractDefaultExportName(filePath) {
 function collectServerPages(pagesDir) {
   if (!fs.existsSync(pagesDir)) return [];
   return walkFiles(pagesDir).filter((relPath) => {
-    if (path.basename(relPath, path.extname(relPath)) === "layout") return false;
+    const stem = path.basename(relPath, path.extname(relPath));
+    if (stem === "layout" || stem === "_404" || stem === "_500") return false;
     return isServerComponent(path.join(pagesDir, relPath));
   }).map((relPath) => ({
     ...analyzeFile(relPath, "page"),
@@ -163,6 +164,15 @@ function collectGlobalClientRegistry(serverPages, pagesDir) {
       for (const [id, p] of findClientComponentsInTree(layoutPath, pagesDir))
         registry.set(id, p);
   }
+  for (const stem of ["_404", "_500"]) {
+    const errorFile = path.join(pagesDir, `${stem}.tsx`);
+    if (!fs.existsSync(errorFile)) continue;
+    for (const [id, p] of findClientComponentsInTree(errorFile, pagesDir))
+      registry.set(id, p);
+    for (const layoutPath of findPageLayouts(errorFile, pagesDir))
+      for (const [id, p] of findClientComponentsInTree(layoutPath, pagesDir))
+        registry.set(id, p);
+  }
   return registry;
 }
 function buildPerPageRegistry(absPath, layoutPaths, pagesDir) {
@@ -179,12 +189,15 @@ function buildPerPageRegistry(absPath, layoutPaths, pagesDir) {
   }
   return { registry, clientComponentNames };
 }
-async function buildPages(pagesDir, staticDir) {
+async function buildPages(pagesDir, staticDir, outPagesDir) {
   const serverPages = collectServerPages(pagesDir);
   if (fs.existsSync(pagesDir) && walkFiles(pagesDir).length > 0 && serverPages.length === 0) {
     console.warn(`\u26A0  Pages found in ${pagesDir} but none are server components`);
   }
-  if (serverPages.length === 0) return [];
+  if (serverPages.length === 0) {
+    const errorResult2 = outPagesDir ? await buildErrorPages(pagesDir, outPagesDir, {}) : { has404: false, has500: false };
+    return { pages: [], ...errorResult2 };
+  }
   const globalRegistry = collectGlobalClientRegistry(serverPages, pagesDir);
   const prerenderedHtml = await bundleClientComponents(globalRegistry, pagesDir, staticDir);
   const prerenderedRecord = Object.fromEntries(prerenderedHtml);
@@ -205,7 +218,8 @@ async function buildPages(pagesDir, staticDir) {
     });
     builtPages.push({ ...page, bundleText });
   }
-  return builtPages;
+  const errorResult = outPagesDir ? await buildErrorPages(pagesDir, outPagesDir, prerenderedRecord) : { has404: false, has500: false };
+  return { pages: builtPages, ...errorResult };
 }
 function makeApiAdapterSource(handlerFilename) {
   return `import type { IncomingMessage, ServerResponse } from 'http';
@@ -265,7 +279,8 @@ function makePageAdapterSource(opts) {
     layoutArrayItems,
     prerenderedHtml,
     routeParamNames,
-    catchAllNames
+    catchAllNames,
+    statusCode = 200
   } = opts;
   return `import type { IncomingMessage, ServerResponse } from 'http';
 import { createElement as __createElement__ } from 'react';
@@ -547,7 +562,15 @@ export default async function handler(req: IncomingMessage, res: ServerResponse)
 
     const hydrated = new Set<string>();
     // Merge query params into page props to match dev behaviour (ssr.ts mergedParams).
-    const merged = { ...query, ...params } as any;
+    // Error props (__errorMessage, __errorStack, __errorStatus) are injected by the
+    // server entry when routing to _500.mjs after a handler failure.
+    const errorProps: Record<string, string | undefined> = {};
+    const ep = parsed.searchParams;
+    if (ep.has('__errorMessage')) errorProps.errorMessage = ep.get('__errorMessage') ?? undefined;
+    if (ep.has('__errorStack'))   errorProps.errorStack   = ep.get('__errorStack')   ?? undefined;
+    if (ep.has('__errorStatus'))  errorProps.errorStatus  = ep.get('__errorStatus')  ?? undefined;
+
+    const merged = { ...query, ...params, ...errorProps } as any;
     const wrapped  = wrapWithLayouts({ type: __page__.default, props: merged, key: null, ref: null });
 
     let appHtml = '';
@@ -611,14 +634,13 @@ export default async function handler(req: IncomingMessage, res: ServerResponse)
 \${bodyScriptsHtml}</body>
 </html>\`;
 
-    res.statusCode = 200;
+    res.statusCode = ${statusCode};
     res.setHeader('Content-Type', 'text/html; charset=utf-8');
     res.end(html);
   } catch (err: any) {
-    console.error('[page render error]', err);
-    res.statusCode = 500;
-    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-    res.end('Internal Server Error');
+    // Re-throw so the server entry (build-node / build-vercel) can route to
+    // the _500 page handler. Do not swallow the error here.
+    throw err;
   }
 }
 `;
@@ -652,7 +674,8 @@ async function bundlePageHandler(opts) {
     layoutPaths,
     prerenderedHtml,
     routeParamNames,
-    catchAllNames
+    catchAllNames,
+    statusCode
   } = opts;
   const adapterDir = path.dirname(absPath);
   const adapterPath = path.join(adapterDir, `_page_adapter_${randomBytes(4).toString("hex")}.ts`);
@@ -668,7 +691,8 @@ async function bundlePageHandler(opts) {
     layoutArrayItems: layoutPaths.map((_, i) => `__layout_${i}__`).join(", "),
     prerenderedHtml,
     routeParamNames,
-    catchAllNames
+    catchAllNames,
+    statusCode
   }));
   let text;
   try {
@@ -740,6 +764,32 @@ async function bundleClientComponents(globalRegistry, pagesDir, staticDir) {
   console.log(`  bundled   ${globalRegistry.size} client component(s) \u2192 ${path.relative(process.cwd(), outDir)}/`);
   return prerendered;
 }
+async function buildErrorPages(pagesDir, outPagesDir, prerenderedHtml) {
+  const result = { has404: false, has500: false };
+  for (const statusCode of [404, 500]) {
+    const src = path.join(pagesDir, `_${statusCode}.tsx`);
+    if (!fs.existsSync(src)) continue;
+    console.log(`  building  _${statusCode}.tsx  \u2192  pages/_${statusCode}.mjs`);
+    const layoutPaths = findPageLayouts(src, pagesDir);
+    const { registry, clientComponentNames } = buildPerPageRegistry(src, layoutPaths, pagesDir);
+    const bundleText = await bundlePageHandler({
+      absPath: src,
+      pagesDir,
+      clientComponentNames,
+      allClientIds: [...registry.keys()],
+      layoutPaths,
+      prerenderedHtml,
+      routeParamNames: [],
+      catchAllNames: [],
+      statusCode
+    });
+    fs.mkdirSync(outPagesDir, { recursive: true });
+    fs.writeFileSync(path.join(outPagesDir, `_${statusCode}.mjs`), bundleText);
+    if (statusCode === 404) result.has404 = true;
+    if (statusCode === 500) result.has500 = true;
+  }
+  return result;
+}
 async function buildCombinedBundle(staticDir) {
   const nukeDir = path.dirname(fileURLToPath(import.meta.url));
   const bundleFile = nukeDir.endsWith("dist") ? "bundle" : "bundle.ts";
@@ -806,6 +856,7 @@ function copyPublicFiles(publicDir, destDir) {
 export {
   analyzeFile,
   buildCombinedBundle,
+  buildErrorPages,
   buildPages,
   buildPerPageRegistry,
   bundleApiHandler,
@@ -821,4 +872,3 @@ export {
   makePageAdapterSource,
   walkFiles
 };
-//# sourceMappingURL=build-common.js.map

package/dist/build-node.js

@@ -38,7 +38,7 @@ for (const { srcRegex, paramNames, catchAllNames, funcPath, absPath } of apiRout
   fs.writeFileSync(outPath, await bundleApiHandler(absPath));
   manifest.push({ srcRegex, paramNames, catchAllNames, handler: path.join("api", filename), type: "api" });
 }
-const builtPages = await buildPages(PAGES_DIR, STATIC_DIR);
+const { pages: builtPages, has404, has500 } = await buildPages(PAGES_DIR, STATIC_DIR, PAGES_DIR_);
 for (const { srcRegex, paramNames, catchAllNames, funcPath, bundleText } of builtPages) {
   const filename = funcPathToFilename(funcPath, "page");
   const outPath = path.join(PAGES_DIR_, filename);
@@ -46,6 +46,8 @@ for (const { srcRegex, paramNames, catchAllNames, funcPath, bundleText } of buil
   fs.writeFileSync(outPath, bundleText);
   manifest.push({ srcRegex, paramNames, catchAllNames, handler: path.join("pages", filename), type: "page" });
 }
+if (has404) console.log("  built     _404.tsx  \u2192  pages/_404.mjs");
+if (has500) console.log("  built     _500.tsx  \u2192  pages/_500.mjs");
 fs.writeFileSync(
   path.join(OUT_DIR, "manifest.json"),
   JSON.stringify({ routes: manifest }, null, 2)
@@ -121,7 +123,31 @@ const server = http.createServer(async (req, res) => {
     }
   }
 
-  // 2. Route dispatch \u2014 API routes appear before page routes in the manifest
+  // 2. Client-side error \u2014 navigate directly to _500 page.
+  {
+    const qs = new URL(url, 'http://localhost').searchParams;
+    if (qs.has('__clientError')) {
+      const e500 = path.join(__dirname, 'pages', '_500.mjs');
+      if (fs.existsSync(e500)) {
+        try {
+          const m500 = await import(pathToFileURL(e500).href);
+          const eq = new URLSearchParams();
+          eq.set('__errorMessage', qs.get('__clientError') || 'Client error');
+          const stack = qs.get('__clientStack');
+          if (stack) eq.set('__errorStack', stack);
+          req.url = '/_500?' + eq.toString();
+          await m500.default(req, res);
+          return;
+        } catch (e) { console.error('[_500 render error]', e); }
+      }
+      res.statusCode = 500;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end('Internal Server Error');
+      return;
+    }
+  }
+
+  // 3. Route dispatch \u2014 API routes appear before page routes in the manifest
   //    (built in build-node.ts), so they are matched first.
   for (const { regex, paramNames, catchAllNames, handler } of compiled) {
     const m = clean.match(regex);
@@ -139,11 +165,44 @@ const server = http.createServer(async (req, res) => {
     });
     req.url = clean + (qs.toString() ? '?' + qs.toString() : '');
 
-    const mod = await import(pathToFileURL(path.join(__dirname, handler)).href);
-    await mod.default(req, res);
+    try {
+      const mod = await import(pathToFileURL(path.join(__dirname, handler)).href);
+      await mod.default(req, res);
+    } catch (err) {
+      console.error('[handler error]', err);
+      const e500 = path.join(__dirname, 'pages', '_500.mjs');
+      if (fs.existsSync(e500)) {
+        try {
+          const m500 = await import(pathToFileURL(e500).href);
+          // Inject error info as query params so _500 page receives them as props.
+          const errMsg   = err instanceof Error ? err.message : String(err);
+          const errStack = err instanceof Error ? err.stack   : undefined;
+          const errStatus = err?.status ?? err?.statusCode;
+          const eq = new URLSearchParams();
+          eq.set('__errorMessage', errMsg);
+          if (errStack)  eq.set('__errorStack',  errStack);
+          if (errStatus) eq.set('__errorStatus', String(errStatus));
+          req.url = '/_500?' + eq.toString();
+          await m500.default(req, res);
+          return;
+        } catch (e) { console.error('[_500 render error]', e); }
+      }
+      res.statusCode = 500;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end('Internal Server Error');
+    }
     return;
   }
 
+  // 3. 404 \u2014 serve _404.mjs if built, otherwise plain text.
+  const e404 = path.join(__dirname, 'pages', '_404.mjs');
+  if (fs.existsSync(e404)) {
+    try {
+      const m404 = await import(pathToFileURL(e404).href);
+      await m404.default(req, res);
+      return;
+    } catch (err) { console.error('[_404 render error]', err); }
+  }
   res.statusCode = 404;
   res.setHeader('Content-Type', 'text/plain');
   res.end('Not found');
@@ -156,4 +215,3 @@ fs.writeFileSync(path.join(OUT_DIR, "index.mjs"), serverEntry);
 console.log(`
 \u2713 Node build complete \u2014 ${manifest.length} route(s) \u2192 dist/`);
 console.log("  run with: node dist/index.mjs");
-//# sourceMappingURL=build-node.js.map

package/dist/build-vercel.js

@@ -143,13 +143,43 @@ export default async function handler(req: IncomingMessage, res: ServerResponse)
 }
 `;
 }
-function makePagesDispatcherSource(routes) {
+function makePagesDispatcherSource(routes, errorAdapters = {}) {
   const imports = routes.map((r, i) => `import __page_${i}__ from ${JSON.stringify(r.adapterPath)};`).join("\n");
   const routeEntries = routes.map(
     (r, i) => `  { regex: ${JSON.stringify(r.srcRegex)}, params: ${JSON.stringify(r.paramNames)}, catchAll: ${JSON.stringify(r.catchAllNames)}, handler: __page_${i}__ },`
   ).join("\n");
+  const error404Import = errorAdapters.adapter404 ? `import __error_404__ from ${JSON.stringify(errorAdapters.adapter404)};` : "";
+  const error500Import = errorAdapters.adapter500 ? `import __error_500__ from ${JSON.stringify(errorAdapters.adapter500)};` : "";
+  const notFoundHandler = errorAdapters.adapter404 ? `  try { return await __error_404__(req, res); } catch(e) { console.error('[_404 error]', e); }` : `  res.statusCode = 404;
+  res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+  res.end('Not Found');`;
+  const clientErrorHandler = errorAdapters.adapter500 ? `    try {
+      const eq = new URLSearchParams();
+      eq.set('__errorMessage', url.searchParams.get('__clientError') || 'Client error');
+      const stack = url.searchParams.get('__clientStack');
+      if (stack) eq.set('__errorStack', stack);
+      req.url = '/_500?' + eq.toString();
+      return await __error_500__(req, res);
+    } catch(e) { console.error('[_500 client error]', e); }` : `    res.statusCode = 500;
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    res.end('Internal Server Error');`;
+  const errorHandler = errorAdapters.adapter500 ? `    try {
+      const errMsg    = err instanceof Error ? err.message : String(err);
+      const errStack  = err instanceof Error ? err.stack   : undefined;
+      const errStatus = err?.status ?? err?.statusCode;
+      const eq = new URLSearchParams();
+      eq.set('__errorMessage', errMsg);
+      if (errStack)  eq.set('__errorStack',  errStack);
+      if (errStatus) eq.set('__errorStatus', String(errStatus));
+      req.url = '/_500?' + eq.toString();
+      return await __error_500__(req, res);
+    } catch(e) { console.error('[_500 error]', e); }` : `    res.statusCode = 500;
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    res.end('Internal Server Error');`;
   return `import type { IncomingMessage, ServerResponse } from 'http';
 ${imports}
+${error404Import}
+${error500Import}
 
 const ROUTES: Array<{
   regex:    string;
@@ -164,6 +194,11 @@ export default async function handler(req: IncomingMessage, res: ServerResponse)
   const url      = new URL(req.url || '/', 'http://localhost');
   const pathname = url.pathname;
 
+  // Client-side error \u2014 navigate directly to _500 handler.
+  if (url.searchParams.has('__clientError')) {
+${clientErrorHandler}
+  }
+
   for (const route of ROUTES) {
     const m = pathname.match(new RegExp(route.regex));
     if (!m) continue;
@@ -172,7 +207,6 @@ export default async function handler(req: IncomingMessage, res: ServerResponse)
     route.params.forEach((name, i) => {
       const raw = m[i + 1] ?? '';
       if (catchAllSet.has(name)) {
-        // Encode catch-all as repeated keys so the handler can getAll() \u2192 string[]
         raw.split('/').filter(Boolean).forEach(seg => url.searchParams.append(name, seg));
       } else {
         url.searchParams.set(name, raw);
@@ -180,12 +214,16 @@ export default async function handler(req: IncomingMessage, res: ServerResponse)
     });
     req.url = pathname + (url.search || '');
 
-    return route.handler(req, res);
+    try {
+      return await route.handler(req, res);
+    } catch (err) {
+      console.error('[handler error]', err);
+${errorHandler}
+      return;
+    }
   }
 
-  res.statusCode = 404;
-  res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-  res.end('Not Found');
+${notFoundHandler}
 }
 `;
 }
@@ -216,7 +254,8 @@ if (apiRoutes.length > 0) {
     vercelRoutes.push({ src: srcRegex, dest: "/api" });
 }
 const serverPages = collectServerPages(PAGES_DIR);
-if (serverPages.length > 0) {
+const hasErrorPages = ["_404.tsx", "_500.tsx"].some((f) => fs.existsSync(path.join(PAGES_DIR, f)));
+if (serverPages.length > 0 || hasErrorPages) {
   const globalRegistry = collectGlobalClientRegistry(serverPages, PAGES_DIR);
   const prerenderedHtml = await bundleClientComponents(globalRegistry, PAGES_DIR, STATIC_DIR);
   const prerenderedRecord = Object.fromEntries(prerenderedHtml);
@@ -252,8 +291,36 @@ if (serverPages.length > 0) {
     paramNames: page.paramNames,
     catchAllNames: page.catchAllNames
   }));
+  const errorAdapters = {};
+  const errorAdapterPaths = [];
+  for (const [statusCode, key] of [[404, "adapter404"], [500, "adapter500"]]) {
+    const src = path.join(PAGES_DIR, `_${statusCode}.tsx`);
+    if (!fs.existsSync(src)) continue;
+    console.log(`  building  _${statusCode}.tsx  \u2192  pages.func  [error page]`);
+    const adapterDir = path.dirname(src);
+    const adapterPath = path.join(adapterDir, `_error_adapter_${randomBytes(4).toString("hex")}.ts`);
+    const layoutPaths = findPageLayouts(src, PAGES_DIR);
+    const { registry, clientComponentNames } = buildPerPageRegistry(src, layoutPaths, PAGES_DIR);
+    const layoutImports = layoutPaths.map((lp, i) => {
+      const rel = path.relative(adapterDir, lp).replace(/\\/g, "/");
+      return `import __layout_${i}__ from ${JSON.stringify(rel.startsWith(".") ? rel : "./" + rel)};`;
+    }).join("\n");
+    fs.writeFileSync(adapterPath, makePageAdapterSource({
+      pageImport: JSON.stringify("./" + path.basename(src)),
+      layoutImports,
+      clientComponentNames,
+      allClientIds: [...registry.keys()],
+      layoutArrayItems: layoutPaths.map((_, i) => `__layout_${i}__`).join(", "),
+      prerenderedHtml: prerenderedRecord,
+      routeParamNames: [],
+      catchAllNames: [],
+      statusCode
+    }));
+    errorAdapters[key] = adapterPath;
+    errorAdapterPaths.push(adapterPath);
+  }
   const dispatcherPath = path.join(PAGES_DIR, `_pages_dispatcher_${randomBytes(4).toString("hex")}.ts`);
-  fs.writeFileSync(dispatcherPath, makePagesDispatcherSource(dispatcherRoutes));
+  fs.writeFileSync(dispatcherPath, makePagesDispatcherSource(dispatcherRoutes, errorAdapters));
   try {
     const result = await build({
       entryPoints: [dispatcherPath],
@@ -272,6 +339,7 @@ if (serverPages.length > 0) {
   } finally {
     fs.unlinkSync(dispatcherPath);
     for (const p of tempAdapterPaths) if (fs.existsSync(p)) fs.unlinkSync(p);
+    for (const p of errorAdapterPaths) if (fs.existsSync(p)) fs.unlinkSync(p);
   }
   for (const { srcRegex } of serverPages)
     vercelRoutes.push({ src: srcRegex, dest: "/pages" });
@@ -289,4 +357,3 @@ copyPublicFiles(PUBLIC_DIR, STATIC_DIR);
 const fnCount = (apiRoutes.length > 0 ? 1 : 0) + (serverPages.length > 0 ? 1 : 0);
 console.log(`
 \u2713 Vercel build complete \u2014 ${fnCount} function(s) \u2192 .vercel/output`);
-//# sourceMappingURL=build-vercel.js.map

package/dist/builder.js

@@ -39,6 +39,35 @@ function processDist(dir) {
   })(dir);
   console.log("\u{1F527} Post-processing done: relative imports \u2192 .js extensions.");
 }
+const PUBLIC_STEMS = /* @__PURE__ */ new Set([
+  "index",
+  "html-store",
+  // exported types (TitleValue, LinkTag, MetaTag, …) live here
+  "use-html",
+  "use-router",
+  "use-request",
+  "request-store",
+  "Link",
+  "bundle",
+  "utils",
+  "logger"
+]);
+function prunePrivateDeclarations(dir) {
+  (function walk(currentDir) {
+    for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.name.endsWith(".d.ts") || entry.name.endsWith(".d.ts.map")) {
+        const stem = entry.name.replace(/\.d\.ts(\.map)?$/, "");
+        if (!PUBLIC_STEMS.has(stem)) {
+          fs.rmSync(fullPath);
+        }
+      }
+    }
+  })(dir);
+  console.log("\u2702\uFE0F  Pruned private .d.ts files (kept public API only).");
+}
 async function runBuild() {
   try {
     cleanDist(outDir);
@@ -49,13 +78,13 @@ async function runBuild() {
       platform: "node",
       format: "esm",
       target: ["node20"],
-      packages: "external",
-      sourcemap: true
+      packages: "external"
     });
     console.log("\u2705  Build done.");
     processDist(outDir);
     console.log("\u{1F4C4}  Generating TypeScript declarations\u2026");
-    execSync("tsc --emitDeclarationOnly --declaration --outDir dist", { stdio: "inherit" });
+    execSync("tsc --emitDeclarationOnly --declaration --declarationMap false --outDir dist", { stdio: "inherit" });
+    prunePrivateDeclarations(outDir);
     console.log("\n\u{1F389}  Build complete \u2192 dist/");
   } catch (err) {
     console.error("\u274C  Build failed:", err);
@@ -63,4 +92,3 @@ async function runBuild() {
   }
 }
 runBuild();
-//# sourceMappingURL=builder.js.map