@orieljs/http 0.1.0-alpha.10 → 0.1.0-alpha.11

package/dist/index.d.ts

@@ -412,6 +412,59 @@ declare function stackFrames(error: Error): StackFrame[];
 /** The APP_DEBUG page: class, message, request, a source excerpt of the first app frame, the stack and causes. */
 declare function debugPage(error: unknown, method: string, url: string): Promise<string>;
 
+interface ExportOptions {
+    /** The folder the site is written to. */
+    output: string;
+    /** The URL the pages are requested at (the app's `app.url`); only its origin's links are followed. */
+    baseUrl: string;
+    /** Follow every same-site link from `/` (and from `paths`). */
+    crawl: boolean;
+    /** Paths exported besides `/` (pages nothing links to, a feed, …). */
+    paths: string[];
+    /** Paths left out; `*` matches anything (`/drafts/*`). */
+    exclude: string[];
+    /** `/docs/routing` → `docs/routing.html` (`'html'`) or `docs/routing/index.html` (`'directory'`). */
+    fileNames: 'html' | 'directory';
+    /** Copied into the output first (the built assets, images); false copies nothing. */
+    publicPath: string | false;
+}
+interface ExportResult {
+    /** The paths written, in the order they were found. */
+    pages: string[];
+    /** Redirects met while following links: listed, not written. */
+    redirects: Array<{
+        path: string;
+        location: string;
+    }>;
+    /** Whether the app's 404 page was written as `404.html`. */
+    notFoundPage: boolean;
+}
+/** A page answered with an error: the export stops, and the last export stays as it was. */
+declare class ExportError extends Error {
+    readonly path: string;
+    readonly status: number;
+    readonly name = "ExportError";
+    constructor(path: string, status: number);
+}
+/**
+ * Exports an app's pages as files: requests `/` and `paths` inside the process (as `serve` handles a request),
+ * follows same-site links, and writes every page into `output`, after a copy of `publicPath`. The site is written
+ * into a temporary folder beside `output` and swapped in at the end, so a failed export leaves the last one intact.
+ */
+declare function exportSite(app: Application, options: ExportOptions): Promise<ExportResult>;
+
+/**
+ * The file a page is written to, relative to the output folder: `/` → `index.html`, `/docs/routing` →
+ * `docs/routing.html` (or `docs/routing/index.html`). A path with an extension (`/feed.xml`) keeps its name.
+ */
+declare function exportFileName(path: string, style: 'html' | 'directory'): string;
+/**
+ * The paths a page links to on the same site (the origin of `baseUrl`): resolved against the page's URL, decoded,
+ * without query, hash or a trailing slash, each once, in document order. Links to other origins, `mailto:`, `tel:`,
+ * `javascript:` and to an anchor on the same page are left out.
+ */
+declare function sameSiteLinks(html: string, pageUrl: string, baseUrl: string): string[];
+
 type Runtime = 'node' | 'bun';
 interface ServeOptions {
     /** Default: PORT, then SERVER_PORT, then 8000 (Laravel's serve). 0 picks a free port. */
@@ -472,6 +525,15 @@ declare function serveBun(app: Application, options: ResolvedServeOptions): Prom
 declare function toWebRequest(req: IncomingMessage, res: ServerResponse, fallbackHost: string): Request;
 /** Web Response → ServerResponse, streaming the body with backpressure. Several Set-Cookie headers stay separate. */
 declare function writeResponse(res: ServerResponse, response: Response): Promise<void>;
+/**
+ * A node:http request listener for the app: a public file when one matches, else the app's answer, then the
+ * terminable middleware. `serve` uses it, and so does any host that hands Oriel Node's request and response (Vercel's
+ * functions). `fallbackHost` is the Host used when a request has none.
+ */
+declare function nodeRequestHandler(app: Application, options: {
+    publicPath?: string;
+    fallbackHost: string;
+}): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
 declare function serveNode(app: Application, options: ResolvedServeOptions): Promise<RunningServer>;
 
 declare function detectRuntime(): Runtime;
@@ -549,7 +611,7 @@ interface HttpCommandOptions {
     /** Replaces `serve --watch`'s restarting server (tests). Resolves the command's exit code. */
     watch?: (options: WatchedServerOptions) => Promise<number>;
 }
-/** Registers `serve`, `route:list` and `install:api` as closure commands (PC1). */
+/** Registers `serve`, `route:list`, `export` and `install:api` as closure commands (PC1). */
 declare function registerHttpCommands(kernel: ConsoleKernel, app: Application, options?: HttpCommandOptions): void;
 
 /**
@@ -565,4 +627,4 @@ declare class HttpServiceProvider extends ServiceProvider {
     boot(): void;
 }
 
-export { API_ROUTES_STUB, ConvertEmptyStringsToNull, type ErrorClass, ErrorHandler, ExceptionsConfiguration, FormUploadedFile, type HttpCommandOptions, HttpException, HttpRedirectResponse, HttpRedirector, HttpResponseException, HttpResponseFactory, HttpServerError, HttpServiceProvider, IncomingRequest, type IncomingRequestOptions, type JsonWhenCallback, Kernel, MiddlewareConfiguration, type RenderCallback, type ReportCallback, type ResolvedServeOptions, type RouteListFilters, type RouteListRow, type RunningServer, type Runtime, type ServeOptions, type StackFrame, TrimStrings, type TypedRedirector, abort, abortIf, abortUnless, addApiRouting, applyExceptionCallbacks, applyMiddlewareCallbacks, back, bunRuntime, clientAddress, contentDisposition, currentRequest, debugPage, detectRuntime, escapeHtml, exceedsJsonDepth, extensionFromMime, filterRouteList, formatRouteList, fromEntries, ipMatches, isBlank, mergeRecursive, mimeFromExtension, minimalPage, normalizeLists, optionalCookieJar, optionalSession, parseBracketKey, readBody, redirect, registerHttpCommands, request, requestScope, response, route, routeListRows, sanitize, serve, serveBun, serveNode, servePublicFile, setClientAddress, stackFrames, statusFor, statusText, summarizeValidation, toWebRequest, transformLeaves, url, writeResponse };
+export { API_ROUTES_STUB, ConvertEmptyStringsToNull, type ErrorClass, ErrorHandler, ExceptionsConfiguration, ExportError, type ExportOptions, type ExportResult, FormUploadedFile, type HttpCommandOptions, HttpException, HttpRedirectResponse, HttpRedirector, HttpResponseException, HttpResponseFactory, HttpServerError, HttpServiceProvider, IncomingRequest, type IncomingRequestOptions, type JsonWhenCallback, Kernel, MiddlewareConfiguration, type RenderCallback, type ReportCallback, type ResolvedServeOptions, type RouteListFilters, type RouteListRow, type RunningServer, type Runtime, type ServeOptions, type StackFrame, TrimStrings, type TypedRedirector, abort, abortIf, abortUnless, addApiRouting, applyExceptionCallbacks, applyMiddlewareCallbacks, back, bunRuntime, clientAddress, contentDisposition, currentRequest, debugPage, detectRuntime, escapeHtml, exceedsJsonDepth, exportFileName, exportSite, extensionFromMime, filterRouteList, formatRouteList, fromEntries, ipMatches, isBlank, mergeRecursive, mimeFromExtension, minimalPage, nodeRequestHandler, normalizeLists, optionalCookieJar, optionalSession, parseBracketKey, readBody, redirect, registerHttpCommands, request, requestScope, response, route, routeListRows, sameSiteLinks, sanitize, serve, serveBun, serveNode, servePublicFile, setClientAddress, stackFrames, statusFor, statusText, summarizeValidation, toWebRequest, transformLeaves, url, writeResponse };

package/dist/index.js

@@ -1562,6 +1562,11 @@ function applyExceptionCallbacks(app, handler) {
   for (const callback of app.make(ExceptionCallbacks)) callback(configurator);
 }
 
+// export/export.ts
+import { existsSync, lstatSync, readdirSync, statSync } from "fs";
+import { cp, mkdir, mkdtemp, rename, rm, writeFile } from "fs/promises";
+import { basename as basename2, dirname, join, resolve as resolve2 } from "path";
+
 // server/types.ts
 import { HttpKernel } from "@orieljs/contracts";
 
@@ -1631,6 +1636,136 @@ function exitOnSignals(close, closed, app) {
 }
 var displayHost = (hostname) => hostname.includes(":") ? `[${hostname}]` : hostname;
 
+// export/paths.ts
+import { posix } from "path";
+var ANCHOR = /<a\b[^>]*?\shref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/gi;
+var decode = (path) => {
+  try {
+    return decodeURIComponent(path);
+  } catch {
+    return path;
+  }
+};
+function exportFileName(path, style) {
+  const trimmed = decode(path).replace(/^\/+|\/+$/g, "");
+  if (trimmed === "") return "index.html";
+  if (posix.extname(trimmed) !== "") return trimmed;
+  return style === "directory" ? `${trimmed}/index.html` : `${trimmed}.html`;
+}
+function sameSiteLinks(html, pageUrl, baseUrl) {
+  const origin = new URL(baseUrl).origin;
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of html.matchAll(ANCHOR)) {
+    const href = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+    if (href === "" || href.startsWith("#")) continue;
+    const path = sitePath(href, pageUrl, origin);
+    if (path === void 0 || seen.has(path)) continue;
+    seen.add(path);
+    found.push(path);
+  }
+  return found;
+}
+function sitePath(href, pageUrl, origin) {
+  let url2;
+  try {
+    url2 = new URL(href, pageUrl);
+  } catch {
+    return void 0;
+  }
+  if (url2.origin !== new URL(origin).origin) return void 0;
+  return decode(url2.pathname.length > 1 ? url2.pathname.replace(/\/+$/, "") : url2.pathname);
+}
+
+// export/export.ts
+var ExportError = class extends Error {
+  constructor(path, status) {
+    super(`[${path}] answered ${status}.`);
+    this.path = path;
+    this.status = status;
+  }
+  path;
+  status;
+  name = "ExportError";
+};
+var MARKER = ".oriel-export";
+var NOT_FOUND_PATH = "/__oriel-export-not-found__";
+async function exportSite(app, options) {
+  const output = resolve2(options.output);
+  const publicPath = options.publicPath === false ? void 0 : resolve2(options.publicPath);
+  if (publicPath !== void 0 && existsSync(join(publicPath, "hot"))) {
+    throw new Error("The Vite dev server is running (public/hot exists): stop `npm run dev`, build the assets with `npm run build`, then export.");
+  }
+  assertReplaceable(output);
+  const staging = await mkdtemp(join(dirname(output), `.${basename2(output)}-`));
+  try {
+    if (publicPath !== void 0 && existsSync(publicPath)) {
+      await cp(publicPath, staging, { recursive: true, filter: (source) => basename2(source) !== "hot" && !lstatSync(source).isSymbolicLink() });
+    }
+    const excluded = (path) => options.exclude.some((pattern) => wildcard(pattern).test(path));
+    const isPublicFile = (path) => publicPath !== void 0 && path !== "/" && isFile(join(publicPath, path));
+    const queue = [.../* @__PURE__ */ new Set(["/", ...options.paths.map(rooted)])].filter((path) => path === "/" || !excluded(path));
+    const seen = new Set(queue);
+    const pages = [];
+    const redirects = [];
+    while (queue.length > 0) {
+      const path = queue.shift();
+      const url2 = new URL(path, options.baseUrl).href;
+      const answer = await fetchPage(app, url2);
+      if (answer.status >= 300 && answer.status < 400) {
+        const location = new URL(answer.headers.get("location") ?? "/", url2).href;
+        redirects.push({ path, location });
+        const target = sitePath(location, url2, options.baseUrl);
+        if (target !== void 0 && !seen.has(target) && !excluded(target) && !isPublicFile(target)) {
+          seen.add(target);
+          queue.push(target);
+        }
+        continue;
+      }
+      if (answer.status >= 400) throw new ExportError(path, answer.status);
+      await writeInto(staging, exportFileName(path, options.fileNames), answer.body);
+      pages.push(path);
+      if (!options.crawl || !isHtml(answer.headers)) continue;
+      for (const link of sameSiteLinks(answer.body.toString("utf8"), url2, options.baseUrl)) {
+        if (seen.has(link) || excluded(link) || isPublicFile(link)) continue;
+        seen.add(link);
+        queue.push(link);
+      }
+    }
+    const notFound = await fetchPage(app, new URL(NOT_FOUND_PATH, options.baseUrl).href);
+    const notFoundPage = notFound.status === 404 && isHtml(notFound.headers);
+    if (notFoundPage) await writeInto(staging, "404.html", notFound.body);
+    await writeFile(join(staging, MARKER), "");
+    await rm(output, { recursive: true, force: true });
+    await rename(staging, output);
+    return { pages, redirects, notFoundPage };
+  } catch (error) {
+    await rm(staging, { recursive: true, force: true });
+    throw error;
+  }
+}
+function assertReplaceable(output) {
+  if (!existsSync(output)) return;
+  if (statSync(output).isDirectory() && (existsSync(join(output, MARKER)) || readdirSync(output).length === 0)) return;
+  throw new Error(`[${output}] exists and wasn't made by oriel export: remove it, or export somewhere else with --output.`);
+}
+async function fetchPage(app, url2) {
+  const request2 = new Request(url2, { headers: { accept: "text/html" } });
+  const response2 = await handleSafely(app, request2);
+  const body = Buffer.from(await response2.arrayBuffer());
+  await terminateRequest(app, request2, response2);
+  return { status: response2.status, headers: response2.headers, body };
+}
+async function writeInto(folder, file, body) {
+  const path = join(folder, file);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, body);
+}
+var isHtml = (headers) => (headers.get("content-type") ?? "").includes("text/html");
+var rooted = (path) => path.startsWith("/") ? path : `/${path}`;
+var isFile = (path) => existsSync(path) && statSync(path).isFile();
+var wildcard = (pattern) => new RegExp(`^${rooted(pattern).replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+
 // server/bun.ts
 function bunRuntime() {
   return globalThis.Bun;
@@ -1639,7 +1774,7 @@ async function serveBun(app, options) {
   const bun = bunRuntime();
   if (bun === void 0) throw new HttpServerError("Bun.serve is not available: the process is not running on Bun.");
   let markClosed = () => void 0;
-  const closed = new Promise((resolve2) => markClosed = resolve2);
+  const closed = new Promise((resolve4) => markClosed = resolve4);
   const server = bun.serve({
     port: options.port,
     hostname: options.hostname,
@@ -1657,8 +1792,8 @@ async function serveBun(app, options) {
   let closing;
   const close = () => closing ??= (async () => {
     let timer;
-    const forced = new Promise((resolve2) => {
-      timer = setTimeout(() => void Promise.resolve(server.stop(true)).then(resolve2), options.shutdownTimeout);
+    const forced = new Promise((resolve4) => {
+      timer = setTimeout(() => void Promise.resolve(server.stop(true)).then(resolve4), options.shutdownTimeout);
     });
     await Promise.race([Promise.resolve(server.stop(false)), forced]);
     clearTimeout(timer);
@@ -1761,40 +1896,44 @@ async function writeResponse(res, response2) {
   }
   await pipeline(Readable3.fromWeb(response2.body), res);
 }
+function nodeRequestHandler(app, options) {
+  return async (req, res) => {
+    let request2;
+    try {
+      request2 = toWebRequest(req, res, options.fallbackHost);
+    } catch {
+      res.statusCode = 400;
+      res.end("Bad Request");
+      return;
+    }
+    setClientAddress(request2, req.socket.remoteAddress);
+    const response2 = await handleSafely(app, request2, options.publicPath);
+    try {
+      await writeResponse(res, response2);
+    } catch {
+      res.destroy();
+    }
+    await terminateRequest(app, request2, response2);
+  };
+}
 async function serveNode(app, options) {
-  const fallbackHost = `${displayHost(options.hostname)}:${options.port}`;
-  const server = createServer((req, res) => {
-    void (async () => {
-      let request2;
-      try {
-        request2 = toWebRequest(req, res, fallbackHost);
-      } catch {
-        res.statusCode = 400;
-        res.end("Bad Request");
-        return;
-      }
-      setClientAddress(request2, req.socket.remoteAddress);
-      const response2 = await handleSafely(app, request2, options.publicPath);
-      try {
-        await writeResponse(res, response2);
-      } catch {
-        res.destroy();
-      }
-      await terminateRequest(app, request2, response2);
-    })();
+  const handle = nodeRequestHandler(app, {
+    ...options.publicPath !== void 0 && { publicPath: options.publicPath },
+    fallbackHost: `${displayHost(options.hostname)}:${options.port}`
   });
-  await new Promise((resolve2, reject) => {
+  const server = createServer((req, res) => void handle(req, res));
+  await new Promise((resolve4, reject) => {
     server.once("error", reject);
     server.listen(options.port, options.hostname, () => {
       server.off("error", reject);
-      resolve2();
+      resolve4();
     });
   });
   const address = server.address();
-  const closed = new Promise((resolve2) => server.once("close", () => resolve2()));
+  const closed = new Promise((resolve4) => server.once("close", () => resolve4()));
   let closing;
   const close = () => closing ??= (async () => {
-    const done = new Promise((resolve2) => server.close(() => resolve2()));
+    const done = new Promise((resolve4) => server.close(() => resolve4()));
     server.closeIdleConnections();
     const idle = setInterval(() => server.closeIdleConnections(), 50);
     const force = setTimeout(() => server.closeAllConnections(), options.shutdownTimeout);
@@ -1834,16 +1973,17 @@ async function serve(app, options = {}) {
 }
 
 // commands.ts
-import { existsSync as existsSync3 } from "fs";
-import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import { dirname } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve3 } from "path";
 import {
+  ConfigRepository as ConfigRepository4,
   Router as Router3
 } from "@orieljs/contracts";
 
 // watch/environment.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
 import * as util from "util";
 var launchEnvironment = Object.freeze({ ...process.env });
 var BUN_ENV_FILES = [
@@ -1865,8 +2005,8 @@ function serverEnvironment(options = {}) {
   if (typeof parseEnv2 !== "function") return env;
   const cwd = options.cwd ?? process.cwd();
   for (const name of BUN_ENV_FILES) {
-    const file = join(cwd, name);
-    if (!existsSync(file)) continue;
+    const file = join2(cwd, name);
+    if (!existsSync2(file)) continue;
     let values;
     try {
       values = parseEnv2(readFileSync(file, "utf8"));
@@ -1882,8 +2022,8 @@ function serverEnvironment(options = {}) {
 }
 
 // watch/files.ts
-import { existsSync as existsSync2, statSync, watch as watchPath } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, statSync as statSync2, watch as watchPath } from "fs";
+import { join as join3 } from "path";
 var WATCHED_FOLDERS = ["app", "bootstrap", "config", "lang", "resources/lang", "resources/views", "routes"];
 var WATCHED_ROOT_FILES = ["package.json", "tsconfig.json"];
 var IGNORED_FOLDERS = ["bootstrap/ssr", "bootstrap/cache"];
@@ -1914,7 +2054,7 @@ function watchFiles(basePath, onChange, options = {}) {
   const reportedLate = (path) => {
     if (Date.now() - startedAt >= settle) return false;
     try {
-      const modified = statSync(join2(basePath, path), { throwIfNoEntry: false })?.mtimeMs;
+      const modified = statSync2(join3(basePath, path), { throwIfNoEntry: false })?.mtimeMs;
       return modified === void 0 || modified < startedAt + 1;
     } catch {
       return false;
@@ -1933,7 +2073,7 @@ function watchFiles(basePath, onChange, options = {}) {
   const handles = [];
   const start = (folder, recursive, toPath) => {
     try {
-      const handle = watch(folder === "." ? basePath : join2(basePath, folder), { recursive }, (_event, file) => {
+      const handle = watch(folder === "." ? basePath : join3(basePath, folder), { recursive }, (_event, file) => {
         const path = toPath(file);
         if (path !== void 0) record(path);
       });
@@ -1945,7 +2085,7 @@ function watchFiles(basePath, onChange, options = {}) {
   };
   start(".", false, (file) => file === null ? void 0 : toSlashes(file));
   for (const folder of WATCHED_FOLDERS) {
-    if (existsSync2(join2(basePath, folder))) start(folder, true, (file) => `${folder}/${file === null ? "" : toSlashes(file)}`);
+    if (existsSync3(join3(basePath, folder))) start(folder, true, (file) => `${folder}/${file === null ? "" : toSlashes(file)}`);
   }
   return {
     close() {
@@ -1959,13 +2099,13 @@ function watchFiles(basePath, onChange, options = {}) {
 // watch/port.ts
 import { createServer as createServer2 } from "net";
 function claimPort(hostname, port) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const server = createServer2();
     server.once("error", reject);
     try {
       server.listen({ port, host: hostname, exclusive: true }, () => {
         const { port: claimed } = server.address();
-        server.close(() => resolve2(claimed));
+        server.close(() => resolve4(claimed));
       });
     } catch (error) {
       reject(error);
@@ -1996,7 +2136,7 @@ var WatchedServer = class {
   };
   /** Starts the server and keeps it current until stopped. Resolves 0 once the last server has exited. */
   run() {
-    const done = new Promise((resolve2) => this.finish = resolve2);
+    const done = new Promise((resolve4) => this.finish = resolve4);
     const stopListening = this.listenForSignals();
     const watcher = this.options.watch((files) => void this.changed(files));
     this.start();
@@ -2035,14 +2175,14 @@ var WatchedServer = class {
       stdio: ["ignore", "inherit", "inherit"]
     });
     const running = { child, stopping: false, killed: false, exited: Promise.resolve() };
-    running.exited = new Promise((resolve2) => {
+    running.exited = new Promise((resolve4) => {
       let settled = false;
       const settle = (report) => {
         if (settled) return;
         settled = true;
         if (this.running === running) this.running = void 0;
         if (!running.stopping && !this.stopping) this.options.error(`${report}. Waiting for changes before restarting...`);
-        resolve2();
+        resolve4();
       };
       child.once("exit", (code, signal) => settle(signal !== null ? `The server stopped (signal ${signal})` : `The server stopped (exit code ${code})`));
       child.once("error", (error) => {
@@ -2180,6 +2320,38 @@ async function serveWatching(app, out, port, run) {
     error: (message) => out.error(message)
   });
 }
+async function exportCommand(app, out) {
+  const config = (key, fallback) => app.bound(ConfigRepository4) ? app.make(ConfigRepository4).get(key, fallback) : fallback;
+  const fileNames = config("export.file_names", "html");
+  if (fileNames !== "html" && fileNames !== "directory") {
+    out.error(`export.file_names is "html" or "directory", not "${fileNames}".`);
+    return 1;
+  }
+  const output = out.option("output") ?? config("export.output", "dist");
+  const baseUrl = config("app.url", "http://localhost");
+  const started = performance.now();
+  try {
+    const result = await exportSite(app, {
+      output: resolve3(app.basePath(), output),
+      baseUrl,
+      crawl: config("export.crawl", true),
+      paths: config("export.paths", []),
+      exclude: config("export.exclude", []),
+      fileNames,
+      publicPath: app.publicPath()
+    });
+    const origin = new URL(baseUrl).origin;
+    for (const { path, location } of result.redirects) {
+      out.line(`Redirect ${path} \u2192 ${location.startsWith(origin) ? location.slice(origin.length) || "/" : location}, not written.`);
+    }
+    const pages = result.pages.length === 1 ? "1 page" : `${result.pages.length} pages`;
+    out.info(`Exported ${pages} to [${output}] in ${Math.round(performance.now() - started)} ms.`);
+    return 0;
+  } catch (error) {
+    out.error(error instanceof ExportError ? error.message : error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
 function registerHttpCommands(kernel, app, options = {}) {
   const serveApp = options.serve ?? serve;
   const terminalWidth = options.terminalWidth ?? (() => process.stdout.columns ?? 120);
@@ -2238,25 +2410,28 @@ function registerHttpCommands(kernel, app, options = {}) {
       return 0;
     }
   ).purpose("List all registered routes");
+  kernel.command("export {--output= : The folder to write the site to (default: config export.output, else dist)}", function() {
+    return exportCommand(app, io(this));
+  }).purpose("Export the application's pages as static files");
   kernel.command("install:api {--force : Overwrite any existing API routes file}", async function() {
     const out = io(this);
     const routesFile = app.basePath("routes/api.ts");
-    if (existsSync3(routesFile) && !out.flag("force")) {
+    if (existsSync4(routesFile) && !out.flag("force")) {
       out.error("API routes file already exists.");
     } else {
-      await mkdir(dirname(routesFile), { recursive: true });
-      await writeFile(routesFile, API_ROUTES_STUB);
+      await mkdir2(dirname2(routesFile), { recursive: true });
+      await writeFile2(routesFile, API_ROUTES_STUB);
       out.info("Published API routes file.");
     }
     const bootstrapFile = app.bootstrapPath("app.ts");
-    const source = existsSync3(bootstrapFile) ? await readFile2(bootstrapFile, "utf8") : void 0;
+    const source = existsSync4(bootstrapFile) ? await readFile2(bootstrapFile, "utf8") : void 0;
     const updated = source === void 0 ? void 0 : addApiRouting(source);
     if (updated === void 0) {
       out.warn(
         "Unable to automatically add API route definition to bootstrap file. Add api: 'routes/api.ts' to withRouting() in bootstrap/app.ts."
       );
     } else if (updated !== source) {
-      await writeFile(bootstrapFile, updated);
+      await writeFile2(bootstrapFile, updated);
     }
     out.info("API scaffolding installed.");
     return 0;
@@ -2301,6 +2476,7 @@ export {
   ConvertEmptyStringsToNull,
   ErrorHandler,
   ExceptionsConfiguration,
+  ExportError,
   FormUploadedFile,
   HttpException,
   HttpRedirectResponse,
@@ -2328,6 +2504,8 @@ export {
   detectRuntime,
   escapeHtml,
   exceedsJsonDepth,
+  exportFileName,
+  exportSite,
   extensionFromMime,
   filterRouteList,
   formatRouteList,
@@ -2337,6 +2515,7 @@ export {
   mergeRecursive,
   mimeFromExtension,
   minimalPage,
+  nodeRequestHandler,
   normalizeLists,
   optionalCookieJar,
   optionalSession,
@@ -2349,6 +2528,7 @@ export {
   response,
   route,
   routeListRows,
+  sameSiteLinks,
   sanitize,
   serve,
   serveBun,