nukejs 0.0.17 → 0.0.18

package/dist/build-node.js

@@ -0,0 +1,217 @@
+import fs from "fs";
+import path from "path";
+import { loadConfig } from "./config.js";
+import {
+  analyzeFile,
+  walkFiles,
+  buildPages,
+  bundleApiHandler,
+  buildCombinedBundle,
+  copyPublicFiles
+} from "./build-common.js";
+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();
+const SERVER_DIR = path.resolve(config.serverDir);
+const PAGES_DIR = path.resolve("./app/pages");
+const PUBLIC_DIR = path.resolve("./app/public");
+const manifest = [];
+function funcPathToFilename(funcPath, prefix) {
+  return funcPath.replace(new RegExp(`^\\/${prefix}\\/`), "") + ".mjs";
+}
+const apiFiles = walkFiles(SERVER_DIR);
+if (apiFiles.length === 0) console.warn(`\u26A0  No server files found in ${SERVER_DIR}`);
+const apiRoutes = apiFiles.map((relPath) => ({ ...analyzeFile(relPath, "api"), absPath: path.join(SERVER_DIR, relPath) })).sort((a, b) => b.specificity - a.specificity);
+for (const { srcRegex, paramNames, catchAllNames, funcPath, absPath } of apiRoutes) {
+  console.log(`  building  ${path.relative(SERVER_DIR, absPath)}  \u2192  ${funcPath}`);
+  const filename = funcPathToFilename(funcPath, "api");
+  const outPath = path.join(API_DIR, filename);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(outPath, await bundleApiHandler(absPath));
+  manifest.push({ srcRegex, paramNames, catchAllNames, handler: path.join("api", filename), type: "api" });
+}
+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);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  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)
+);
+await buildCombinedBundle(STATIC_DIR);
+copyPublicFiles(PUBLIC_DIR, STATIC_DIR);
+const MIME_MAP_ENTRIES = `
+  '.html': 'text/html; charset=utf-8',
+  '.htm':  'text/html; charset=utf-8',
+  '.css':  'text/css; charset=utf-8',
+  '.js':   'application/javascript; charset=utf-8',
+  '.mjs':  'application/javascript; charset=utf-8',
+  '.cjs':  'application/javascript; charset=utf-8',
+  '.map':  'application/json; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.xml':  'application/xml; charset=utf-8',
+  '.txt':  'text/plain; charset=utf-8',
+  '.csv':  'text/csv; charset=utf-8',
+  '.png':  'image/png',
+  '.jpg':  'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif':  'image/gif',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.svg':  'image/svg+xml',
+  '.ico':  'image/x-icon',
+  '.bmp':  'image/bmp',
+  '.woff': 'font/woff',
+  '.woff2':'font/woff2',
+  '.ttf':  'font/ttf',
+  '.otf':  'font/otf',
+  '.mp4':  'video/mp4',
+  '.webm': 'video/webm',
+  '.mp3':  'audio/mpeg',
+  '.wav':  'audio/wav',
+  '.ogg':  'audio/ogg',
+  '.pdf':  'application/pdf',
+  '.wasm': 'application/wasm',
+`.trim();
+const serverEntry = `import http from 'http';
+import path from 'path';
+import fs   from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const { routes } = JSON.parse(fs.readFileSync(path.join(__dirname, 'manifest.json'), 'utf-8'));
+const compiled   = routes.map(r => ({ ...r, regex: new RegExp(r.srcRegex) }));
+
+const STATIC_DIR = path.join(__dirname, 'static');
+const MIME_MAP   = { ${MIME_MAP_ENTRIES} };
+
+const server = http.createServer(async (req, res) => {
+  const url   = req.url || '/';
+  const clean = url.split('?')[0];
+
+  // 1. Static files \u2014 app/public/ files are copied into STATIC_DIR last at
+  //    build time (after framework bundles), so they take priority over
+  //    framework files on name collision.  path.join normalises '..' segments
+  //    before the startsWith guard, preventing directory traversal.
+  {
+    const candidate  = path.join(STATIC_DIR, clean);
+    const staticBase = STATIC_DIR.endsWith(path.sep) ? STATIC_DIR : STATIC_DIR + path.sep;
+    if (
+      candidate.startsWith(staticBase) &&
+      candidate !== STATIC_DIR &&
+      fs.existsSync(candidate) &&
+      fs.statSync(candidate).isFile()
+    ) {
+      res.setHeader('Content-Type', MIME_MAP[path.extname(candidate)] ?? 'application/octet-stream');
+      res.end(fs.readFileSync(candidate));
+      return;
+    }
+  }
+
+  // 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);
+    if (!m) continue;
+
+    const catchAllSet = new Set(catchAllNames);
+    const qs = new URLSearchParams(Object.fromEntries(new URL(url, 'http://localhost').searchParams));
+    paramNames.forEach((name, i) => {
+      const raw = m[i + 1] ?? '';
+      if (catchAllSet.has(name)) {
+        raw.split('/').filter(Boolean).forEach(seg => qs.append(name, seg));
+      } else {
+        qs.set(name, raw);
+      }
+    });
+    req.url = clean + (qs.toString() ? '?' + qs.toString() : '');
+
+    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');
+});
+
+const PORT = Number(process.env.PORT ?? 3000);
+server.listen(PORT, () => console.log('nukejs built server listening on http://localhost:' + PORT));
+`;
+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");

package/dist/build-vercel.js

@@ -0,0 +1,359 @@
+import fs from "fs";
+import path from "path";
+import { randomBytes } from "node:crypto";
+import { build } from "esbuild";
+import { loadConfig } from "./config.js";
+import {
+  walkFiles,
+  analyzeFile,
+  collectServerPages,
+  collectGlobalClientRegistry,
+  bundleClientComponents,
+  findPageLayouts,
+  buildPerPageRegistry,
+  makePageAdapterSource,
+  buildCombinedBundle,
+  copyPublicFiles
+} from "./build-common.js";
+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();
+const SERVER_DIR = path.resolve(config.serverDir);
+const PAGES_DIR = path.resolve("./app/pages");
+const PUBLIC_DIR = path.resolve("./app/public");
+const NODE_BUILTINS = [
+  "node:*",
+  "http",
+  "https",
+  "fs",
+  "path",
+  "url",
+  "crypto",
+  "stream",
+  "buffer",
+  "events",
+  "util",
+  "os",
+  "net",
+  "tls",
+  "child_process",
+  "worker_threads",
+  "cluster",
+  "dgram",
+  "dns",
+  "readline",
+  "zlib",
+  "assert",
+  "module",
+  "perf_hooks",
+  "string_decoder",
+  "timers",
+  "async_hooks",
+  "v8",
+  "vm"
+];
+const CJS_COMPAT_BANNER = {
+  js: `import { createRequire } from 'module';
+const require = createRequire(import.meta.url);`
+};
+function emitVercelFunction(name, bundleText) {
+  const funcDir = path.join(FUNCTIONS_DIR, `${name}.func`);
+  fs.mkdirSync(funcDir, { recursive: true });
+  fs.writeFileSync(path.join(funcDir, "index.mjs"), bundleText);
+  fs.writeFileSync(
+    path.join(funcDir, ".vc-config.json"),
+    JSON.stringify({ runtime: "nodejs20.x", handler: "index.mjs", launcherType: "Nodejs" }, null, 2)
+  );
+}
+function makeApiDispatcherSource(routes) {
+  const imports = routes.map((r, i) => `import * as __api_${i}__ from ${JSON.stringify(r.absPath)};`).join("\n");
+  const routeEntries = routes.map(
+    (r, i) => `  { regex: ${JSON.stringify(r.srcRegex)}, params: ${JSON.stringify(r.paramNames)}, mod: __api_${i}__ },`
+  ).join("\n");
+  return `import type { IncomingMessage, ServerResponse } from 'http';
+${imports}
+
+function enhance(res: ServerResponse) {
+  (res as any).json = function(data: any, status = 200) {
+    this.statusCode = status;
+    this.setHeader('Content-Type', 'application/json');
+    this.end(JSON.stringify(data));
+  };
+  (res as any).status = function(code: number) { this.statusCode = code; return this; };
+  return res;
+}
+
+async function parseBody(req: IncomingMessage): Promise<any> {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', (chunk: any) => { body += chunk.toString(); });
+    req.on('end', () => {
+      try {
+        resolve(
+          body && req.headers['content-type']?.includes('application/json')
+            ? JSON.parse(body)
+            : body,
+        );
+      } catch (e) { reject(e); }
+    });
+    req.on('error', reject);
+  });
+}
+
+const ROUTES = [
+${routeEntries}
+];
+
+export default async function handler(req: IncomingMessage, res: ServerResponse) {
+  const url      = new URL(req.url || '/', 'http://localhost');
+  const pathname = url.pathname;
+
+  for (const route of ROUTES) {
+    const m = pathname.match(new RegExp(route.regex));
+    if (!m) continue;
+
+    const method = (req.method || 'GET').toUpperCase();
+    const apiRes = enhance(res);
+    const apiReq = req as any;
+
+    apiReq.body   = await parseBody(req);
+    apiReq.query  = Object.fromEntries(url.searchParams);
+    apiReq.params = {};
+    route.params.forEach((name: string, i: number) => { apiReq.params[name] = m[i + 1]; });
+
+    const fn = (route.mod as any)[method] ?? (route.mod as any)['default'];
+    if (typeof fn !== 'function') {
+      (apiRes as any).json({ error: \`Method \${method} not allowed\` }, 405);
+      return;
+    }
+    await fn(apiReq, apiRes);
+    return;
+  }
+
+  res.statusCode = 404;
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify({ error: 'Not Found' }));
+}
+`;
+}
+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;
+  params:   string[];
+  catchAll: string[];
+  handler:  (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+}> = [
+${routeEntries}
+];
+
+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;
+
+    const catchAllSet = new Set(route.catchAll);
+    route.params.forEach((name, i) => {
+      const raw = m[i + 1] ?? '';
+      if (catchAllSet.has(name)) {
+        raw.split('/').filter(Boolean).forEach(seg => url.searchParams.append(name, seg));
+      } else {
+        url.searchParams.set(name, raw);
+      }
+    });
+    req.url = pathname + (url.search || '');
+
+    try {
+      return await route.handler(req, res);
+    } catch (err) {
+      console.error('[handler error]', err);
+${errorHandler}
+      return;
+    }
+  }
+
+${notFoundHandler}
+}
+`;
+}
+const vercelRoutes = [];
+const apiFiles = walkFiles(SERVER_DIR);
+if (apiFiles.length === 0) console.warn(`\u26A0  No server files found in ${SERVER_DIR}`);
+const apiRoutes = apiFiles.map((relPath) => ({ ...analyzeFile(relPath, "api"), absPath: path.join(SERVER_DIR, relPath) })).sort((a, b) => b.specificity - a.specificity);
+if (apiRoutes.length > 0) {
+  const dispatcherPath = path.join(SERVER_DIR, `_api_dispatcher_${randomBytes(4).toString("hex")}.ts`);
+  fs.writeFileSync(dispatcherPath, makeApiDispatcherSource(apiRoutes));
+  try {
+    const result = await build({
+      entryPoints: [dispatcherPath],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node20",
+      banner: CJS_COMPAT_BANNER,
+      external: NODE_BUILTINS,
+      write: false
+    });
+    emitVercelFunction("api", result.outputFiles[0].text);
+    console.log(`  built     API dispatcher \u2192 api.func  (${apiRoutes.length} route(s))`);
+  } finally {
+    fs.unlinkSync(dispatcherPath);
+  }
+  for (const { srcRegex } of apiRoutes)
+    vercelRoutes.push({ src: srcRegex, dest: "/api" });
+}
+const serverPages = collectServerPages(PAGES_DIR);
+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);
+  const tempAdapterPaths = [];
+  for (const page of serverPages) {
+    const adapterDir = path.dirname(page.absPath);
+    const adapterPath = path.join(adapterDir, `_page_adapter_${randomBytes(4).toString("hex")}.ts`);
+    const layoutPaths = findPageLayouts(page.absPath, PAGES_DIR);
+    const { registry, clientComponentNames } = buildPerPageRegistry(page.absPath, 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(page.absPath)),
+        layoutImports,
+        clientComponentNames,
+        allClientIds: [...registry.keys()],
+        layoutArrayItems: layoutPaths.map((_, i) => `__layout_${i}__`).join(", "),
+        prerenderedHtml: prerenderedRecord,
+        routeParamNames: page.paramNames,
+        catchAllNames: page.catchAllNames
+      })
+    );
+    tempAdapterPaths.push(adapterPath);
+    console.log(`  prepared  ${path.relative(PAGES_DIR, page.absPath)}  \u2192  ${page.funcPath}  [page]`);
+  }
+  const dispatcherRoutes = serverPages.map((page, i) => ({
+    adapterPath: tempAdapterPaths[i],
+    srcRegex: page.srcRegex,
+    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, errorAdapters));
+  try {
+    const result = await build({
+      entryPoints: [dispatcherPath],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node20",
+      jsx: "automatic",
+      banner: CJS_COMPAT_BANNER,
+      external: NODE_BUILTINS,
+      define: { "process.env.NODE_ENV": '"production"' },
+      write: false
+    });
+    emitVercelFunction("pages", result.outputFiles[0].text);
+    console.log(`  built     Pages dispatcher \u2192 pages.func  (${serverPages.length} page(s))`);
+  } 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" });
+}
+fs.writeFileSync(
+  path.join(OUTPUT_DIR, "config.json"),
+  JSON.stringify({ version: 3, routes: [{ handle: "filesystem" }, ...vercelRoutes] }, null, 2)
+);
+fs.writeFileSync(
+  path.resolve("vercel.json"),
+  JSON.stringify({ runtime: "nodejs20.x" }, null, 2)
+);
+await buildCombinedBundle(STATIC_DIR);
+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`);

package/dist/builder.js

@@ -0,0 +1,95 @@
+import { build } from "esbuild";
+import fs from "fs";
+import { execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const srcDir = path.resolve(__dirname, "");
+const outDir = path.resolve(__dirname, "../dist");
+function cleanDist(dir) {
+  if (!fs.existsSync(dir)) return;
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log(`\u{1F5D1}\uFE0F  Cleared ${dir}`);
+}
+function collectFiles(dir, exclude = []) {
+  const files = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!exclude.includes(entry.name)) files.push(...collectFiles(full, exclude));
+    } else if (/\.[tj]sx?$/.test(entry.name)) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+function processDist(dir) {
+  (function walk(currentDir) {
+    fs.readdirSync(currentDir, { withFileTypes: true }).forEach((d) => {
+      const fullPath = path.join(currentDir, d.name);
+      if (d.isDirectory()) {
+        walk(fullPath);
+      } else if (fullPath.endsWith(".js")) {
+        let content = fs.readFileSync(fullPath, "utf-8");
+        content = content.replace(/from\s+['"](\.\/.*?)['"]/g, 'from "$1.js"');
+        content = content.replace(/import\(['"](\.\/.*?)['"]\)/g, 'import("$1.js")');
+        fs.writeFileSync(fullPath, content, "utf-8");
+      }
+    });
+  })(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",
+  "store",
+  "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);
+    console.log("\u{1F680}  Building sources\u2026");
+    await build({
+      entryPoints: collectFiles(srcDir),
+      outdir: outDir,
+      platform: "node",
+      format: "esm",
+      target: ["node20"],
+      packages: "external"
+    });
+    console.log("\u2705  Build done.");
+    processDist(outDir);
+    console.log("\u{1F4C4}  Generating TypeScript declarations\u2026");
+    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);
+    process.exit(1);
+  }
+}
+runBuild();