nukejs 0.0.10 → 0.0.12

package/dist/build-node.js

@@ -13,6 +13,10 @@ const OUT_DIR = path.resolve("dist");
 const API_DIR = path.join(OUT_DIR, "api");
 const PAGES_DIR_ = path.join(OUT_DIR, "pages");
 const STATIC_DIR = path.join(OUT_DIR, "static");
+if (fs.existsSync(OUT_DIR)) {
+  fs.rmSync(OUT_DIR, { recursive: true, force: true });
+  console.log("\u{1F5D1}\uFE0F  Cleaned dist/");
+}
 for (const dir of [API_DIR, PAGES_DIR_, STATIC_DIR])
   fs.mkdirSync(dir, { recursive: true });
 const config = await loadConfig();
@@ -34,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);
@@ -42,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)
@@ -117,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);
@@ -135,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');
@@ -152,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

@@ -18,6 +18,10 @@ import {
 const OUTPUT_DIR = path.resolve(".vercel/output");
 const FUNCTIONS_DIR = path.join(OUTPUT_DIR, "functions");
 const STATIC_DIR = path.join(OUTPUT_DIR, "static");
+if (fs.existsSync(OUTPUT_DIR)) {
+  fs.rmSync(OUTPUT_DIR, { recursive: true, force: true });
+  console.log("\u{1F5D1}\uFE0F  Cleaned .vercel/output/");
+}
 for (const dir of [FUNCTIONS_DIR, STATIC_DIR])
   fs.mkdirSync(dir, { recursive: true });
 const config = await loadConfig();
@@ -139,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;
@@ -160,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;
@@ -168,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);
@@ -176,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}
 }
 `;
 }
@@ -212,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);
@@ -235,6 +278,7 @@ if (serverPages.length > 0) {
         allClientIds: [...registry.keys()],
         layoutArrayItems: layoutPaths.map((_, i) => `__layout_${i}__`).join(", "),
         prerenderedHtml: prerenderedRecord,
+        routeParamNames: page.paramNames,
         catchAllNames: page.catchAllNames
       })
     );
@@ -247,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],
@@ -267,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" });
@@ -284,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,33 @@ function processDist(dir) {
   })(dir);
   console.log("\u{1F527} Post-processing done: relative imports \u2192 .js extensions.");
 }
+const PUBLIC_STEMS = /* @__PURE__ */ new Set([
+  "index",
+  "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 +76,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 +90,3 @@ async function runBuild() {
   }
 }
 runBuild();
-//# sourceMappingURL=builder.js.map

package/dist/bundle.d.ts

@@ -53,6 +53,13 @@ export interface RuntimeData {
     allIds: string[];
     url: string;
     params: Record<string, any>;
+    /** Query string parameters parsed from the URL. Multi-value keys are arrays. */
+    query: Record<string, string | string[]>;
+    /**
+     * Safe subset of the incoming request headers (cookie, authorization, and
+     * proxy-authorization are stripped before embedding in the HTML document).
+     */
+    headers: Record<string, string>;
     debug: ClientDebugLevel;
 }
 /**

package/dist/bundle.js

@@ -77,9 +77,38 @@ async function loadModules(ids, log, bust = "") {
   return mods;
 }
 const activeRoots = [];
+let clientErrorPending = false;
+function navigateToClientError(err) {
+  if (clientErrorPending) return;
+  if (window.location.search.includes("__clientError")) return;
+  clientErrorPending = true;
+  const message = err instanceof Error ? err.message : String(err);
+  const stack = err instanceof Error && err.stack ? err.stack : void 0;
+  const params = new URLSearchParams();
+  params.set("__clientError", message);
+  if (stack) params.set("__clientStack", stack);
+  window.dispatchEvent(new CustomEvent("locationchange", {
+    detail: { href: window.location.pathname + "?" + params.toString() }
+  }));
+}
 async function mountNodes(mods, log) {
   const { hydrateRoot, createRoot } = await import("react-dom/client");
   const React = await import("react");
+  class NukeErrorBoundary extends React.default.Component {
+    constructor(props) {
+      super(props);
+      this.state = { caught: false };
+    }
+    static getDerivedStateFromError() {
+      return { caught: true };
+    }
+    componentDidCatch(error) {
+      navigateToClientError(error);
+    }
+    render() {
+      return this.state.caught ? null : this.props.children;
+    }
+  }
   const nodes = document.querySelectorAll("[data-hydrate-id]");
   log.verbose("Found", nodes.length, "hydration point(s)");
   for (const node of nodes) {
@@ -97,7 +126,8 @@ async function mountNodes(mods, log) {
       log.error("Props parse error for", id, e);
     }
     try {
-      const element = React.default.createElement(Comp, await reconstructProps(rawProps, mods));
+      const inner = React.default.createElement(Comp, await reconstructProps(rawProps, mods));
+      const element = React.default.createElement(NukeErrorBoundary, null, inner);
       let root;
       if (node.innerHTML.trim()) {
         root = hydrateRoot(node, element);
@@ -223,8 +253,13 @@ function setupNavigation(log) {
       const fetchUrl = hmr ? href + (href.includes("?") ? "&" : "?") + "__hmr=1" : href;
       const response = await fetch(fetchUrl, { headers: { Accept: "text/html" } });
       if (!response.ok) {
-        log.error("Navigation fetch failed:", response.status);
-        return;
+        const ct = response.headers.get("content-type") ?? "";
+        if (!ct.includes("text/html")) {
+          log.error("Navigation fetch failed:", response.status, "\u2014 falling back to full reload");
+          window.location.href = href;
+          return;
+        }
+        log.info("Navigation returned", response.status, "\u2014 rendering error page in-place");
       }
       const parser = new DOMParser();
       const doc = parser.parseFromString(await response.text(), "text/html");
@@ -251,6 +286,8 @@ function setupNavigation(log) {
     } catch (err) {
       log.error("Navigation error, falling back to full reload:", err);
       window.location.href = href;
+    } finally {
+      clientErrorPending = false;
     }
   });
 }
@@ -258,6 +295,13 @@ async function initRuntime(data) {
   const log = makeLogger(data.debug ?? "silent");
   log.info("\u{1F680} Partial hydration:", data.hydrateIds.length, "root component(s)");
   setupNavigation(log);
+  window.onerror = (_msg, _src, _line, _col, err) => {
+    navigateToClientError(err ?? _msg);
+    return true;
+  };
+  window.onunhandledrejection = (e) => {
+    navigateToClientError(e.reason);
+  };
   const mods = await loadModules(data.allIds, log);
   await mountNodes(mods, log);
   log.info("\u{1F389} Done!");
@@ -267,4 +311,3 @@ export {
   initRuntime,
   setupLocationChangeMonitor
 };
-//# sourceMappingURL=bundle.js.map

package/dist/bundler.js

@@ -97,4 +97,3 @@ export {
   serveNukeBundle,
   serveReactBundle
 };
-//# sourceMappingURL=bundler.js.map

package/dist/component-analyzer.js

@@ -123,4 +123,3 @@ export {
   getComponentCache,
   invalidateComponentCache
 };
-//# sourceMappingURL=component-analyzer.js.map

package/dist/config.js

@@ -27,4 +27,3 @@ async function loadConfig() {
 export {
   loadConfig
 };
-//# sourceMappingURL=config.js.map

package/dist/hmr-bundle.js

@@ -86,4 +86,3 @@ hmr();
 export {
   hmr as default
 };
-//# sourceMappingURL=hmr-bundle.js.map

package/dist/hmr.js

@@ -24,6 +24,10 @@ function pageFileToUrl(filename) {
 function buildPayload(filename) {
   const normalized = filename.replace(/\\/g, "/");
   if (normalized.startsWith("pages/")) {
+    const stem = path.basename(normalized, path.extname(normalized));
+    if (stem === "_404" || stem === "_500") {
+      return { type: "replace", component: stem };
+    }
     const url = pageFileToUrl(normalized);
     return { type: "reload", url };
   }
@@ -59,4 +63,3 @@ export {
   hmrClients,
   watchDir
 };
-//# sourceMappingURL=hmr.js.map

package/dist/html-store.js

@@ -39,4 +39,3 @@ export {
   resolveTitle,
   runWithHtmlStore
 };
-//# sourceMappingURL=html-store.js.map

package/dist/http-server.js

@@ -170,4 +170,3 @@ export {
   parseBody,
   parseQuery
 };
-//# sourceMappingURL=http-server.js.map

package/dist/index.d.ts

@@ -1,6 +1,9 @@
 export { useHtml } from './use-html';
 export type { HtmlOptions, TitleValue, HtmlAttrs, BodyAttrs, MetaTag, LinkTag, ScriptTag, StyleTag, } from './use-html';
 export { default as useRouter } from './use-router';
+export { useRequest } from './use-request';
+export type { RequestContext } from './use-request';
+export { normaliseHeaders, sanitiseHeaders } from './request-store';
 export { default as Link } from './Link';
 export { setupLocationChangeMonitor, initRuntime } from './bundle';
 export type { RuntimeData } from './bundle';

package/dist/index.js

@@ -1,5 +1,7 @@
 import { useHtml } from "./use-html.js";
 import { default as default2 } from "./use-router.js";
+import { useRequest } from "./use-request.js";
+import { normaliseHeaders, sanitiseHeaders } from "./request-store.js";
 import { default as default3 } from "./Link.js";
 import { setupLocationChangeMonitor, initRuntime } from "./bundle.js";
 import { escapeHtml } from "./utils.js";
@@ -12,9 +14,11 @@ export {
   getDebugLevel,
   initRuntime,
   log,
+  normaliseHeaders,
+  sanitiseHeaders,
   setDebugLevel,
   setupLocationChangeMonitor,
   useHtml,
+  useRequest,
   default2 as useRouter
 };
-//# sourceMappingURL=index.js.map

package/dist/logger.js

@@ -50,4 +50,3 @@ export {
   log,
   setDebugLevel
 };
-//# sourceMappingURL=logger.js.map

package/dist/metadata.js

@@ -40,4 +40,3 @@ export {
   renderScriptTag,
   renderStyleTag
 };
-//# sourceMappingURL=metadata.js.map

package/dist/middleware-loader.js

@@ -47,4 +47,3 @@ export {
   loadMiddleware,
   runMiddleware
 };
-//# sourceMappingURL=middleware-loader.js.map

package/dist/middleware.example.js

@@ -55,4 +55,3 @@ function isRateLimited(ip) {
 export {
   middleware as default
 };
-//# sourceMappingURL=middleware.example.js.map

package/dist/middleware.js

@@ -69,4 +69,3 @@ async function middleware(req, res) {
 export {
   middleware as default
 };
-//# sourceMappingURL=middleware.js.map

package/dist/renderer.js

@@ -96,14 +96,9 @@ async function renderFunctionComponent(type, props, ctx) {
       return `<div style="color:red">Error rendering client component: ${escapeHtml(String(err))}</div>`;
     }
   }
-  try {
-    const result = type(props);
-    const resolved = result?.then ? await result : result;
-    return renderElementToHtml(resolved, ctx);
-  } catch (err) {
-    log.error("Error rendering component:", err);
-    return `<div style="color:red">Error rendering component: ${escapeHtml(String(err))}</div>`;
-  }
+  const result = type(props);
+  const resolved = result?.then ? await result : result;
+  return renderElementToHtml(resolved, ctx);
 }
 function serializePropsForHydration(props, registry) {
   if (!props || typeof props !== "object") return props;
@@ -153,4 +148,3 @@ function serializeReactElement(element, registry) {
 export {
   renderElementToHtml
 };
-//# sourceMappingURL=renderer.js.map

package/dist/request-store.d.ts

@@ -0,0 +1,84 @@
+/**
+ * request-store.ts — Per-Request Server Context Store
+ *
+ * Provides a request-scoped store that server components can read via
+ * `useRequest()` during SSR.  The store is populated by the SSR pipeline
+ * before rendering and cleared in a `finally` block after — preventing any
+ * cross-request contamination.
+ *
+ * Why globalThis?
+ *   Node's module system may import this file multiple times when the page
+ *   module and the nukejs package resolve to different copies (common in dev
+ *   with tsx/tsImport).  Using a well-known Symbol on globalThis guarantees
+ *   all copies share the same store instance, exactly like html-store.ts.
+ *
+ * Request isolation:
+ *   runWithRequestStore() creates a fresh store before rendering and clears
+ *   it in the `finally` block, so concurrent requests cannot bleed into each
+ *   other even if rendering throws.
+ *
+ * Headers in __n_data:
+ *   A safe subset of headers is embedded in the HTML `__n_data` blob so
+ *   client components can read them after hydration.  Sensitive headers
+ *   (cookie, authorization, proxy-authorization) are intentionally excluded
+ *   from the client payload.  The server-side store always has ALL headers.
+ */
+export interface RequestContext {
+    /** Full URL with query string (e.g. '/blog/hello?lang=en'). */
+    url: string;
+    /** Pathname only, no query string (e.g. '/blog/hello'). */
+    pathname: string;
+    /**
+     * Dynamic route segments matched by the file-system router.
+     * e.g. for `/blog/[slug]` → `{ slug: 'hello' }`
+     */
+    params: Record<string, string | string[]>;
+    /**
+     * Query string parameters, parsed from the URL.
+     * Multi-value params (e.g. `?tag=a&tag=b`) become arrays.
+     * e.g. `{ lang: 'en', tag: ['a', 'b'] }`
+     */
+    query: Record<string, string | string[]>;
+    /**
+     * Incoming request headers.
+     *
+     * Server-side (SSR): all headers from IncomingMessage.headers.
+     * Client-side: safe subset embedded in __n_data (cookie, authorization,
+     *   proxy-authorization are stripped before serialisation).
+     *
+     * Multi-value headers are joined with ', '.
+     */
+    headers: Record<string, string>;
+}
+/**
+ * Normalises raw Node `IncomingMessage.headers` into a flat `Record<string,string>`.
+ * Array values (multi-value headers) are joined with `', '`.
+ * Undefined values are dropped.
+ *
+ * Used server-side so all headers — including cookies and auth tokens — are
+ * available to server components that need them.
+ */
+export declare function normaliseHeaders(raw: Record<string, string | string[] | undefined>): Record<string, string>;
+/**
+ * Same as `normaliseHeaders` but additionally strips headers that must never
+ * appear in a serialised HTML document.  Used when embedding headers in the
+ * `__n_data` blob so credentials cannot leak into cached or logged HTML pages.
+ */
+export declare function sanitiseHeaders(raw: Record<string, string | string[] | undefined>): Record<string, string>;
+/**
+ * Runs `fn` inside the context of the given request, then clears the store.
+ *
+ * Usage in the SSR pipeline:
+ * ```ts
+ * const store = await runWithRequestStore(ctx, async () => {
+ *   appHtml = await renderElementToHtml(element, renderCtx);
+ * });
+ * ```
+ */
+export declare function runWithRequestStore<T>(ctx: RequestContext, fn: () => Promise<T>): Promise<T>;
+/**
+ * Returns the current request context, or `null` when called outside of
+ * an active `runWithRequestStore` scope (e.g. in the browser, in tests,
+ * or in a client component).
+ */
+export declare function getRequestStore(): RequestContext | null;