@orieljs/framework 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/{chunk-OXAATQA6.js → chunk-7NA4HALO.js}

@@ -2,7 +2,7 @@ import {
   Arr,
   ClassRegistry as ClassRegistry2,
   Collection,
-  Container,
+  Container as Container2,
   ContainerNotAvailableError,
   ServiceProvider,
   Str,
@@ -10,14 +10,16 @@ import {
   facade,
   fileType_exports,
   inject
-} from "./chunk-7ZQZYDOC.js";
+} from "./chunk-MURTCTRH.js";
 import {
   Application,
   AuthFactory,
   BusDispatcher,
+  ClassNames,
   ClassRegistry,
   ConfigRepository,
   ConsoleKernel,
+  Container,
   CookieJar,
   CurrentRoute,
   DatabaseManager,
@@ -45,7 +47,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-GVNLZZTN.js";
+} from "./chunk-HTJKT2R2.js";
 
 // ../Config/dist/index.js
 import { existsSync, readFileSync } from "fs";
@@ -177,8 +179,137 @@ async function loadConfiguration(configPath) {
 import { join as join3 } from "path";
 import { isAbsolute, join as join4 } from "path";
 import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
+
+// ../Obfuscate/dist/index.js
+var FIRST = "abcdefghijklmnopqrstuvwxyz";
+var REST = `${FIRST}0123456789`;
+var CLASS_ATTRIBUTE = /^(class|o:[^\s=]*-class[^\s=]*)$/i;
+var RAW_TEXT = /* @__PURE__ */ new Set(["script", "style", "textarea", "title", "xmp", "noembed", "noframes"]);
+function rewriteHtml(html, map) {
+  if (Object.keys(map).length === 0) return html;
+  return replaceHtmlClasses(html, (token2) => map[decodeEntities(token2)] ?? token2);
+}
+function replaceHtmlClasses(html, replace) {
+  let out = "";
+  let last = 0;
+  let i = 0;
+  while (i < html.length) {
+    const open = html.indexOf("<", i);
+    if (open === -1) break;
+    if (html.startsWith("<!--", open)) {
+      const close = html.indexOf("-->", open + 4);
+      i = close === -1 ? html.length : close + 3;
+      continue;
+    }
+    const tag = /^<([a-zA-Z][^\s/>]*)/.exec(html.slice(open, open + 64));
+    if (tag === null) {
+      i = open + 1;
+      continue;
+    }
+    let j = open + tag[0].length;
+    while (j < html.length && html[j] !== ">") {
+      if (/[\s/]/.test(html[j])) {
+        j++;
+        continue;
+      }
+      const nameEnd = attributeNameEnd(html, j);
+      const name = html.slice(j, nameEnd);
+      j = nameEnd;
+      while (/\s/.test(html[j] ?? "")) j++;
+      if (html[j] !== "=") continue;
+      j++;
+      while (/\s/.test(html[j] ?? "")) j++;
+      const quote2 = html[j] === '"' || html[j] === "'" ? html[j] : "";
+      const valueStart = quote2 === "" ? j : j + 1;
+      const valueEnd = quote2 === "" ? unquotedEnd(html, valueStart) : indexOrEnd(html, quote2, valueStart);
+      if (CLASS_ATTRIBUTE.test(name)) {
+        const value = html.slice(valueStart, valueEnd);
+        const renamed = value.replace(/\S+/g, replace);
+        if (renamed !== value) {
+          out += html.slice(last, valueStart) + renamed;
+          last = valueEnd;
+        }
+      }
+      j = quote2 === "" ? valueEnd : valueEnd + 1;
+    }
+    i = j + 1;
+    const element = tag[1].toLowerCase();
+    if (RAW_TEXT.has(element)) {
+      const close = new RegExp(`</${element}`, "gi");
+      close.lastIndex = i;
+      i = close.exec(html)?.index ?? html.length;
+    }
+  }
+  return out + html.slice(last);
+}
+function attributeNameEnd(html, i) {
+  let j = i + 1;
+  while (j < html.length && !/[\s/>=]/.test(html[j])) j++;
+  return j;
+}
+function unquotedEnd(html, i) {
+  let j = i;
+  while (j < html.length && !/[\s>]/.test(html[j])) j++;
+  return j;
+}
+function indexOrEnd(html, search, from) {
+  const index = html.indexOf(search, from);
+  return index === -1 ? html.length : index;
+}
+var NAMED = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\xA0" };
+function decodeEntities(value) {
+  if (!value.includes("&")) return value;
+  return value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (entity, body) => {
+    if (body[0] === "#") return String.fromCodePoint(body[1] === "x" || body[1] === "X" ? Number.parseInt(body.slice(2), 16) : Number(body.slice(1)));
+    return NAMED[body.toLowerCase()] ?? entity;
+  });
+}
+
+// ../Foundation/dist/index.js
+import { existsSync as existsSync22, readFileSync as readFileSync22, statSync as statSync2 } from "fs";
 import { createHash, randomBytes } from "crypto";
 import { join as join22 } from "path";
+var RAW_TEXT2 = /<(script|style|textarea|title|xmp|noembed|noframes)\b[^>]*>(?![\s\S]*<\/\1)/i;
+var RenameClasses = class {
+  #container = inject(Container);
+  async handle(request2, next) {
+    const response2 = await next(request2);
+    if (response2.body === null || !/^text\/html\b/i.test(response2.headers.get("content-type") ?? "") || response2.headers.has("content-encoding")) return response2;
+    if (!this.#container.bound(ClassNames)) return response2;
+    const classNames = this.#container.make(ClassNames);
+    if (!classNames.active) return response2;
+    const headers = new Headers(response2.headers);
+    headers.delete("content-length");
+    return new Response(response2.body.pipeThrough(renamer((html) => classNames.html(html))), { status: response2.status, statusText: response2.statusText, headers });
+  }
+};
+function renamer(rename2) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let carry = "";
+  return new TransformStream({
+    transform(chunk2, controller) {
+      const text = carry + decoder.decode(chunk2, { stream: true });
+      const cut = safeCut(text);
+      carry = text.slice(cut);
+      if (cut > 0) controller.enqueue(encoder.encode(rename2(text.slice(0, cut))));
+    },
+    flush(controller) {
+      const text = carry + decoder.decode();
+      if (text !== "") controller.enqueue(encoder.encode(rename2(text)));
+    }
+  });
+}
+function safeCut(text) {
+  let cut = text.lastIndexOf(">") + 1;
+  if (cut === 0) return 0;
+  const head = text.slice(0, cut);
+  const comment = head.lastIndexOf("<!--");
+  if (comment !== -1 && head.indexOf("-->", comment + 4) === -1) cut = comment;
+  const raw = RAW_TEXT2.exec(text.slice(0, cut));
+  if (raw !== null) cut = raw.index;
+  return cut;
+}
 var ApplicationBuilder = class {
   constructor(app) {
     this.app = app;
@@ -223,12 +354,48 @@ var ApplicationBuilder = class {
     loadEnvironment(this.app.basePath());
     this.app.instance(ConfigRepository, new Repository(await loadConfiguration(this.app.configPath())));
     if (this.routing) this.app.instance(RoutingPaths, this.routing);
-    this.app.instance(MiddlewareCallbacks, this.middleware);
+    const middleware = [(m) => void m.prepend(RenameClasses), ...this.middleware];
+    this.app.instance(MiddlewareCallbacks, middleware);
     this.app.instance(ExceptionCallbacks, this.exceptions);
     for (const provider of this.providers) await this.app.register(provider);
     return this.app;
   }
 };
+var ClassNameMap = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  #loaded;
+  /** The map, or undefined: no scrambled build, the dev server is running, or the app is running its tests. */
+  classes() {
+    if (this.#testing() || existsSync3(this.app.publicPath("hot"))) return void 0;
+    const file = this.app.bootstrapPath("cache/classes.json");
+    let modified;
+    try {
+      modified = statSync(file).mtimeMs;
+    } catch {
+      this.#loaded = void 0;
+      return void 0;
+    }
+    if (this.#loaded?.modified !== modified) {
+      const parsed = JSON.parse(readFileSync2(file, "utf8"));
+      this.#loaded = { modified, classes: parsed.classes ?? {} };
+    }
+    return Object.keys(this.#loaded.classes).length === 0 ? void 0 : this.#loaded.classes;
+  }
+  /** The app runs its tests: Oriel's TestCase sets APP_ENV=testing, which a test that switches app.env leaves set. */
+  #testing() {
+    return this.app.runningUnitTests() || process.env.APP_ENV === "testing";
+  }
+  get active() {
+    return this.classes() !== void 0;
+  }
+  html(html) {
+    const classes = this.classes();
+    return classes === void 0 ? html : rewriteHtml(html, classes);
+  }
+};
 var ProviderBootError = class extends Error {
   constructor(provider, cause) {
     super(`Service provider [${provider}] failed to boot: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
@@ -335,11 +502,11 @@ var Vite = class {
     return this.#hotFile ?? this.app.publicPath("hot");
   }
   isRunningHot() {
-    return existsSync3(this.hotFile());
+    return existsSync22(this.hotFile());
   }
   /** The dev server URL written by @orieljs/vite, or undefined when it isn't running. */
   devServerUrl() {
-    return this.isRunningHot() ? readFileSync2(this.hotFile(), "utf8").trimEnd() : void 0;
+    return this.isRunningHot() ? readFileSync22(this.hotFile(), "utf8").trimEnd() : void 0;
   }
   // Tags -----------------------------------------------------------------------------------------------------
   /** Laravel's @vite([...]): preloads (styles first), then stylesheets, then scripts. */
@@ -408,25 +575,25 @@ var Vite = class {
   content(path, buildDirectory = this.#buildDirectory) {
     const chunk2 = this.#chunk(this.manifest(buildDirectory), path);
     const file = this.app.publicPath(join22(buildDirectory, chunk2.file));
-    if (!existsSync3(file)) throw new ViteError(`Unable to locate file from Vite manifest: ${file}.`);
-    return readFileSync2(file, "utf8");
+    if (!existsSync22(file)) throw new ViteError(`Unable to locate file from Vite manifest: ${file}.`);
+    return readFileSync22(file, "utf8");
   }
   /** md5 of the manifest (a cache-busting asset version); undefined while hot or without a build. */
   manifestHash(buildDirectory = this.#buildDirectory) {
     if (this.isRunningHot()) return void 0;
     const path = this.manifestPath(buildDirectory);
-    return existsSync3(path) ? createHash("md5").update(readFileSync2(path)).digest("hex") : void 0;
+    return existsSync22(path) ? createHash("md5").update(readFileSync22(path)).digest("hex") : void 0;
   }
   manifestPath(buildDirectory = this.#buildDirectory) {
     return this.app.publicPath(join22(buildDirectory, this.#manifestFilename));
   }
   manifest(buildDirectory = this.#buildDirectory) {
     const path = this.manifestPath(buildDirectory);
-    if (!existsSync3(path)) throw new ViteError(`Vite manifest not found at: ${path}`);
-    const { mtimeMs } = statSync(path);
+    if (!existsSync22(path)) throw new ViteError(`Vite manifest not found at: ${path}`);
+    const { mtimeMs } = statSync2(path);
     const cached = manifests.get(path);
     if (cached !== void 0 && cached.mtimeMs === mtimeMs) return cached.manifest;
-    const manifest = JSON.parse(readFileSync2(path, "utf8"));
+    const manifest = JSON.parse(readFileSync22(path, "utf8"));
     manifests.set(path, { mtimeMs, manifest });
     return manifest;
   }
@@ -521,18 +688,19 @@ function viteReactRefresh() {
   return currentVite().reactRefresh();
 }
 var SHUTDOWN_TIMEOUT_MS = 1e4;
-var Application2 = class _Application extends Container {
+var Application2 = class _Application extends Container2 {
   constructor(base) {
     super();
     this.base = base;
-    Container.setInstance(this);
+    Container2.setInstance(this);
     this.instance(Application, this);
     this.instance(_Application, this);
     this.singleton(ClassRegistry, ClassRegistry2);
     this.scoped(Vite, () => new Vite(this));
+    this.singleton(ClassNames, () => new ClassNameMap(this));
   }
   base;
-  version = "0.1.0-alpha.10";
+  version = "0.1.0-alpha.12";
   providers = [];
   bootingCallbacks = [];
   bootedCallbacks = [];
@@ -663,7 +831,7 @@ var Application2 = class _Application extends Container {
       return "done";
     })();
     let timer;
-    const deadline = new Promise((resolve2) => timer = setTimeout(() => resolve2("timeout"), SHUTDOWN_TIMEOUT_MS));
+    const deadline = new Promise((resolve4) => timer = setTimeout(() => resolve4("timeout"), SHUTDOWN_TIMEOUT_MS));
     const outcome = await Promise.race([run, deadline]);
     clearTimeout(timer);
     if (outcome === "timeout") {
@@ -710,21 +878,25 @@ import { basename } from "path";
 import { Readable } from "stream";
 import { readFile } from "fs/promises";
 import { fileURLToPath } from "url";
+import { existsSync as existsSync4, lstatSync, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { cp, mkdir, mkdtemp, rename, rm, writeFile } from "fs/promises";
+import { basename as basename2, dirname, join as join5, resolve as resolve2 } from "path";
 import { createReadStream as createReadStream2 } from "fs";
 import { stat as stat2 } from "fs/promises";
 import { Readable as Readable2 } from "stream";
 import { relative, resolve, sep } from "path";
+import { posix } from "path";
 import { createServer } from "http";
 import { Readable as Readable3 } from "stream";
 import { pipeline } from "stream/promises";
-import { existsSync as existsSync32 } from "fs";
-import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
-import * as util from "util";
-import { existsSync as existsSync22, statSync as statSync2, watch as watchPath } from "fs";
+import { existsSync as existsSync42 } 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 { existsSync as existsSync23, readFileSync as readFileSync3 } from "fs";
 import { join as join23 } from "path";
+import * as util from "util";
+import { existsSync as existsSync32, statSync as statSync22, watch as watchPath } from "fs";
+import { join as join32 } from "path";
 import { createServer as createServer2 } from "net";
 import { spawn as spawnProcess } from "child_process";
 var HttpException = class extends Error {
@@ -2250,6 +2422,131 @@ function exitOnSignals(close, closed, app) {
   });
 }
 var displayHost = (hostname) => hostname.includes(":") ? `[${hostname}]` : hostname;
+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);
+}
+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 && existsSync4(join5(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(join5(dirname(output), `.${basename2(output)}-`));
+  try {
+    if (publicPath !== void 0 && existsSync4(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(join5(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 target2 = sitePath(location, url2, options.baseUrl);
+        if (target2 !== void 0 && !seen.has(target2) && !excluded(target2) && !isPublicFile(target2)) {
+          seen.add(target2);
+          queue.push(target2);
+        }
+        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(join5(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 (!existsSync4(output)) return;
+  if (statSync3(output).isDirectory() && (existsSync4(join5(output, MARKER)) || readdirSync2(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 = join5(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) => existsSync4(path) && statSync3(path).isFile();
+var wildcard = (pattern) => new RegExp(`^${rooted(pattern).replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
 function bunRuntime() {
   return globalThis.Bun;
 }
@@ -2257,7 +2554,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,
@@ -2275,8 +2572,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);
@@ -2374,40 +2671,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);
@@ -2463,8 +2764,8 @@ function serverEnvironment(options = {}) {
   if (typeof parseEnv2 !== "function") return env2;
   const cwd = options.cwd ?? process.cwd();
   for (const name of BUN_ENV_FILES) {
-    const file = join5(cwd, name);
-    if (!existsSync4(file)) continue;
+    const file = join23(cwd, name);
+    if (!existsSync23(file)) continue;
     let values;
     try {
       values = parseEnv2(readFileSync3(file, "utf8"));
@@ -2508,7 +2809,7 @@ function watchFiles(basePath, onChange, options = {}) {
   const reportedLate = (path) => {
     if (Date.now() - startedAt >= settle) return false;
     try {
-      const modified = statSync2(join23(basePath, path), { throwIfNoEntry: false })?.mtimeMs;
+      const modified = statSync22(join32(basePath, path), { throwIfNoEntry: false })?.mtimeMs;
       return modified === void 0 || modified < startedAt + 1;
     } catch {
       return false;
@@ -2527,7 +2828,7 @@ function watchFiles(basePath, onChange, options = {}) {
   const handles = [];
   const start = (folder, recursive, toPath) => {
     try {
-      const handle = watch(folder === "." ? basePath : join23(basePath, folder), { recursive }, (_event, file) => {
+      const handle = watch(folder === "." ? basePath : join32(basePath, folder), { recursive }, (_event, file) => {
         const path = toPath(file);
         if (path !== void 0) record(path);
       });
@@ -2539,7 +2840,7 @@ function watchFiles(basePath, onChange, options = {}) {
   };
   start(".", false, (file) => file === null ? void 0 : toSlashes(file));
   for (const folder of WATCHED_FOLDERS) {
-    if (existsSync22(join23(basePath, folder))) start(folder, true, (file) => `${folder}/${file === null ? "" : toSlashes(file)}`);
+    if (existsSync32(join32(basePath, folder))) start(folder, true, (file) => `${folder}/${file === null ? "" : toSlashes(file)}`);
   }
   return {
     close() {
@@ -2550,13 +2851,13 @@ function watchFiles(basePath, onChange, options = {}) {
   };
 }
 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);
@@ -2584,7 +2885,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();
@@ -2623,14 +2924,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) => {
@@ -2766,6 +3067,38 @@ async function serveWatching(app, out, port, run) {
     error: (message) => out.error(message)
   });
 }
+async function exportCommand(app, out) {
+  const config = (key2, fallback) => app.bound(ConfigRepository) ? app.make(ConfigRepository).get(key2, 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);
@@ -2824,25 +3157,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 (existsSync32(routesFile) && !out.flag("force")) {
+    if (existsSync42(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 = existsSync32(bootstrapFile) ? await readFile2(bootstrapFile, "utf8") : void 0;
+    const source = existsSync42(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;
@@ -2885,13 +3221,13 @@ import { isDeepStrictEqual } from "util";
 import { createHmac, timingSafeEqual } from "crypto";
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 import { randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
 import { join as join6, relative as relative2, sep as sep2 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { AsyncLocalStorage } from "async_hooks";
-import { existsSync as existsSync23 } from "fs";
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join24, relative as relative22, sep as sep22 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join24, relative as relative22, sep as sep22 } from "path";
 var LiveError = class extends Error {
   name = "LiveError";
   kind = "Server";
@@ -3505,7 +3841,7 @@ function stripTags(html) {
   return html.replace(/<[^>]*>/g, "");
 }
 var VOID = /* @__PURE__ */ new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"]);
-var RAW_TEXT = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
+var RAW_TEXT3 = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
 var TOKEN = /<\/([A-Za-z][\w:-]*)\s*>|<([A-Za-z][\w:-]*)(?:\s+[^\s"'<>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*\s*(\/?)>/g;
 function rootTag(html, component) {
   const fail22 = () => {
@@ -3527,7 +3863,7 @@ function rootTag(html, component) {
         if (depth === 0) rootEnd = match.index + token2.length;
         continue;
       }
-      if (RAW_TEXT.has(tag)) {
+      if (RAW_TEXT3.has(tag)) {
         const closer = new RegExp(`</${tag}`, "gi");
         closer.lastIndex = TOKEN.lastIndex;
         const end = closer.exec(source);
@@ -3785,7 +4121,7 @@ var fail = (message, actual, expected) => {
 var getPath = (target2, path) => path.split(".").reduce((node, segment) => typeof node === "object" && node !== null ? node[segment] : void 0, target2);
 var TestRequestScope = token("Testing.RequestScope");
 function requestScope2() {
-  const container2 = currentContainer() ?? Container.getInstance();
+  const container2 = currentContainer() ?? Container2.getInstance();
   return container2?.bound(TestRequestScope) === true ? container2.make(TestRequestScope) : (run) => run();
 }
 function currentSession() {
@@ -4019,7 +4355,7 @@ function defaultName(cls) {
 }
 function componentFiles(directory) {
   if (!existsSync5(directory)) return [];
-  return readdirSync2(directory, { recursive: true, encoding: "utf8" }).filter((file) => /\.(tsx|ts|jsx|js|mts|mjs)$/.test(file) && !/\.(test|spec|d)\.[^.]+$/.test(file)).map((file) => file.split(sep2).join("/")).sort();
+  return readdirSync3(directory, { recursive: true, encoding: "utf8" }).filter((file) => /\.(tsx|ts|jsx|js|mts|mjs)$/.test(file) && !/\.(test|spec|d)\.[^.]+$/.test(file)).map((file) => file.split(sep2).join("/")).sort();
 }
 async function discover(directory) {
   const found = [];
@@ -4565,7 +4901,9 @@ var LiveComponentManager = class {
     );
     await hook2(instance, "rendered", html);
     memo.children = context.children;
-    return { html: html.trim(), tag: rootTag(html, memo.name) };
+    const container2 = this.container();
+    const renamed = container2.bound(ClassNames) ? container2.make(ClassNames).html(html) : html;
+    return { html: renamed.trim(), tag: rootTag(renamed, memo.name) };
   }
   /** The absolute URL of the page a memo path belongs to, on the current request's origin ('/' + path without one). */
   pageUrl(path) {
@@ -4625,7 +4963,7 @@ test('{{ name }} renders', async () => {
 `;
 var CLASS_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function importPath(from, to) {
-  const path = relative22(dirname2(from), to).split(sep22).join("/").replace(/\.tsx?$/, "");
+  const path = relative22(dirname3(from), to).split(sep22).join("/").replace(/\.tsx?$/, "");
   return path.startsWith(".") ? path : `./${path}`;
 }
 function registerLiveCommands(kernel, app) {
@@ -4640,23 +4978,23 @@ function registerLiveCommands(kernel, app) {
     const directory = config?.get("live.class_path") ?? app.appPath("Live");
     const file = join24(directory, ...segments.slice(0, -1), `${className}.tsx`);
     const force = this.option("force") === true;
-    if (existsSync23(file) && !force) {
+    if (existsSync24(file) && !force) {
       this.error(`Component [${relative22(app.basePath(), file)}] already exists.`);
       return 1;
     }
-    await mkdir2(dirname2(file), { recursive: true });
-    await writeFile2(file, COMPONENT_STUB.replace("{{ class }}", () => className));
+    await mkdir3(dirname3(file), { recursive: true });
+    await writeFile3(file, COMPONENT_STUB.replace("{{ class }}", () => className));
     this.info(`Component [${relative22(app.basePath(), file)}] created successfully.`);
     if (this.option("test") === true) {
       const testFile = app.basePath(join24("tests", "Feature", "Live", ...segments.slice(0, -1), `${className}.test.ts`));
-      if (existsSync23(testFile) && !force) {
+      if (existsSync24(testFile) && !force) {
         this.error(`Test [${relative22(app.basePath(), testFile)}] already exists.`);
         return 1;
       }
       const name = segments.map((segment) => Str.kebab(segment)).join(".");
       const test = TEST_STUB.replaceAll("{{ class }}", () => className).replace("{{ component }}", () => importPath(testFile, file)).replace("{{ testCase }}", () => importPath(testFile, app.basePath(join24("tests", "TestCase.ts")))).replace("{{ name }}", () => name);
-      await mkdir2(dirname2(testFile), { recursive: true });
-      await writeFile2(testFile, test);
+      await mkdir3(dirname3(testFile), { recursive: true });
+      await writeFile3(testFile, test);
       this.info(`Test [${relative22(app.basePath(), testFile)}] created successfully.`);
     }
     return 0;
@@ -4743,7 +5081,7 @@ import { randomUUID } from "crypto";
 import { randomUUID as randomUUID2 } from "crypto";
 import { randomUUID as randomUUID3 } from "crypto";
 import { randomBytes as randomBytes3 } from "crypto";
-import { posix } from "path";
+import { posix as posix2 } from "path";
 import { deflateSync } from "zlib";
 var original;
 var testNow;
@@ -5552,7 +5890,7 @@ function decryptCookie(encrypter, name, value) {
     return void 0;
   }
 }
-var decode = (text) => {
+var decode2 = (text) => {
   try {
     return decodeURIComponent(text);
   } catch {
@@ -5563,8 +5901,8 @@ function parseSetCookie(header) {
   const [pair = "", ...attributes] = header.split(";");
   const eq = pair.indexOf("=");
   const cookie = {
-    name: decode(pair.slice(0, eq).trim()),
-    value: decode(pair.slice(eq + 1).trim().replace(/^"(.*)"$/, "$1")),
+    name: decode2(pair.slice(0, eq).trim()),
+    value: decode2(pair.slice(eq + 1).trim().replace(/^"(.*)"$/, "$1")),
     httpOnly: false,
     secure: false
   };
@@ -6518,8 +6856,8 @@ var InteractsWithApplication = class {
     } finally {
       this.destroying = [];
       this.application = void 0;
-      const global = Container.getInstance();
-      if (global === app) Container.setInstance(void 0);
+      const global = Container2.getInstance();
+      if (global === app) Container2.setInstance(void 0);
     }
   }
   /**
@@ -7823,7 +8161,7 @@ var FakeDisk = class {
   async put(path, contents, options = {}) {
     const key2 = normalize(path);
     const bytes = typeof contents === "string" ? new TextEncoder().encode(contents) : contents instanceof Uint8Array ? contents.slice() : await collect(contents);
-    this.write(key2, bytes, options.mimeType ?? diskType(posix.extname(key2)), options);
+    this.write(key2, bytes, options.mimeType ?? diskType(posix2.extname(key2)), options);
     return true;
   }
   putFile(directory, file, options = {}) {
@@ -8268,7 +8606,9 @@ export {
   Config,
   Repository,
   env,
+  RenameClasses,
   ApplicationBuilder,
+  ClassNameMap,
   ProviderBootError,
   ProviderRegisterError,
   ViteError,
@@ -8329,10 +8669,13 @@ export {
   ExceptionsConfiguration,
   applyExceptionCallbacks,
   servePublicFile,
+  ExportError,
+  exportSite,
   bunRuntime,
   serveBun,
   toWebRequest,
   writeResponse,
+  nodeRequestHandler,
   serveNode,
   detectRuntime,
   serve,
@@ -8430,4 +8773,4 @@ export {
   StorageFake,
   FakeFile
 };
-//# sourceMappingURL=chunk-OXAATQA6.js.map
+//# sourceMappingURL=chunk-7NA4HALO.js.map