@absolutejs/absolute 0.20.0-beta.66 → 0.20.0-beta.68

package/dist/dev/serverBootstrap.js

@@ -1,7 +1,520 @@
 // @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/constants.ts
+var DEFAULT_PORT = 3000, HOURS_IN_DAY = 24, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, TWO_THIRDS;
+var init_constants = __esm(() => {
+  MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+  MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+  TWO_THIRDS = 2 / 3;
+});
+
+// src/dev/bootLifecycle.ts
+var getBootPhase = () => globalThis.__absoluteBootPhase;
+var init_bootLifecycle = __esm(() => {
+  init_constants();
+});
+
+// src/dev/earlyListener.ts
+var exports_earlyListener = {};
+__export(exports_earlyListener, {
+  BOOT_STATUS_HEADER: () => BOOT_STATUS_HEADER,
+  bootStatusSnapshot: () => bootStatusSnapshot,
+  buildingResponse: () => buildingResponse,
+  installEarlyListenerServeGuard: () => installEarlyListenerServeGuard,
+  releaseEarlyListener: () => releaseEarlyListener,
+  startEarlyListener: () => startEarlyListener
+});
+var HTTP_SERVICE_UNAVAILABLE = 503, RETRY_AFTER_SECONDS = 2, BIND_RETRY_INTERVAL_MS = 250, BIND_RETRY_LIMIT = 40, POLL_INTERVAL_MS, NOSCRIPT_REFRESH_SECONDS = 10, BOOT_STATUS_HEADER = "X-Absolute-Boot", bindingPlaceholder = false, escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;"), bootStatusSnapshot = (startedAt) => {
+  const elapsedMs = Math.max(0, Date.now() - startedAt);
+  return {
+    elapsedMs,
+    elapsedSeconds: Math.floor(elapsedMs / MILLISECONDS_IN_A_SECOND),
+    phase: getBootPhase() ?? "starting",
+    status: "building"
+  };
+}, buildingPage = (snapshot) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="refresh" content="${NOSCRIPT_REFRESH_SECONDS}">
+<title>Building\u2026</title>
+<style>
+:root{color-scheme:light dark}
+body{margin:0;min-height:100vh;display:grid;place-items:center;font:15px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif;background:#0f1115;color:#e6e8ee}
+main{text-align:center;padding:2rem}
+.spin{width:36px;height:36px;margin:0 auto 1rem;border:3px solid rgba(255,255,255,.15);border-top-color:#8ab4ff;border-radius:50%;animation:s 1s linear infinite}
+@keyframes s{to{transform:rotate(360deg)}}
+h1{font-size:1.15rem;font-weight:600;margin:0 0 .25rem}
+p{margin:0;opacity:.6;font-size:.85rem}
+code{font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
+</style>
+</head>
+<body>
+<main>
+<div class="spin" aria-hidden="true"></div>
+<h1>Building\u2026 <span id="t">${snapshot.elapsedSeconds}</span>s</h1>
+<p>AbsoluteJS dev server \xB7 <code id="p">${escapeHtml(snapshot.phase)}</code></p>
+</main>
+<script>
+(function(){
+var started=Date.now()-${snapshot.elapsedMs};
+var t=document.getElementById('t');
+setInterval(function(){t.textContent=String(Math.floor((Date.now()-started)/1000));},1000);
+function poll(){
+fetch(location.href,{cache:'no-store',headers:{accept:'application/json'}}).then(function(r){
+if(r.headers.get('${BOOT_STATUS_HEADER.toLowerCase()}')!=='building'){location.reload();return;}
+return r.json().then(function(j){if(j&&j.phase){document.getElementById('p').textContent=j.phase;}});
+}).catch(function(){}).then(function(){setTimeout(poll,${POLL_INTERVAL_MS});});
+}
+setTimeout(poll,${POLL_INTERVAL_MS});
+})();
+</script>
+</body>
+</html>
+`, buildingResponse = (request, startedAt) => {
+  const snapshot = bootStatusSnapshot(startedAt);
+  const headers = {
+    "Cache-Control": "no-store",
+    "Retry-After": String(RETRY_AFTER_SECONDS),
+    "X-Absolute-Boot": "building"
+  };
+  const isUpgrade = request.headers.get("upgrade")?.toLowerCase() === "websocket";
+  const accept = request.headers.get("accept") ?? "";
+  if (!isUpgrade && accept.includes("text/html")) {
+    headers["Content-Type"] = "text/html; charset=utf-8";
+    return new Response(buildingPage(snapshot), {
+      headers,
+      status: HTTP_SERVICE_UNAVAILABLE
+    });
+  }
+  if (!isUpgrade && accept.includes("application/json")) {
+    headers["Content-Type"] = "application/json; charset=utf-8";
+    return new Response(JSON.stringify(snapshot), {
+      headers,
+      status: HTTP_SERVICE_UNAVAILABLE
+    });
+  }
+  headers["Content-Type"] = "text/plain; charset=utf-8";
+  return new Response(`AbsoluteJS dev server is building (${snapshot.elapsedSeconds}s, ${snapshot.phase}). Retry shortly.
+`, { headers, status: HTTP_SERVICE_UNAVAILABLE });
+}, installEarlyListenerServeGuard = (port) => {
+  if (globalThis.__absoluteEarlyListenerServeGuard)
+    return;
+  const originalServe = Bun.serve;
+  const guardedServe = (serveOptions) => {
+    const requested = Number(serveOptions.port ?? port);
+    const listener = globalThis.__absoluteEarlyListener;
+    if (!bindingPlaceholder && listener && (requested === port || Number.isNaN(requested))) {
+      releaseEarlyListener();
+    }
+    return originalServe.call(Bun, serveOptions);
+  };
+  if (Reflect.set(Bun, "serve", guardedServe)) {
+    globalThis.__absoluteEarlyListenerServeGuard = true;
+  }
+}, releaseEarlyListener = () => {
+  const listener = globalThis.__absoluteEarlyListener;
+  if (!listener)
+    return false;
+  const hadServer = listener.server !== null;
+  listener.release();
+  globalThis.__absoluteEarlyListener = undefined;
+  return hadServer;
+}, startEarlyListener = (options) => {
+  const startedAt = Date.now();
+  let server = null;
+  let released = false;
+  let attempts = 0;
+  let retryTimer;
+  const tryBind = () => {
+    if (released)
+      return;
+    attempts += 1;
+    bindingPlaceholder = true;
+    try {
+      server = Bun.serve({
+        hostname: options.host,
+        port: options.port,
+        fetch: (request) => buildingResponse(request, startedAt),
+        ...options.tls ? { tls: options.tls } : {}
+      });
+    } catch {
+      if (attempts >= BIND_RETRY_LIMIT)
+        return;
+      retryTimer = setTimeout(tryBind, BIND_RETRY_INTERVAL_MS);
+      retryTimer.unref();
+    } finally {
+      bindingPlaceholder = false;
+    }
+  };
+  const release = () => {
+    if (released)
+      return;
+    released = true;
+    if (retryTimer)
+      clearTimeout(retryTimer);
+    const active = server;
+    server = null;
+    if (!active)
+      return;
+    try {
+      active.stop(true);
+    } catch {}
+  };
+  tryBind();
+  const listener = {
+    release,
+    startedAt,
+    get released() {
+      return released;
+    },
+    get server() {
+      return server;
+    }
+  };
+  globalThis.__absoluteEarlyListener = listener;
+  return listener;
+};
+var init_earlyListener = __esm(() => {
+  init_constants();
+  init_bootLifecycle();
+  POLL_INTERVAL_MS = RETRY_AFTER_SECONDS * MILLISECONDS_IN_A_SECOND;
+});
+
+// src/dev/devCert.ts
+var exports_devCert = {};
+__export(exports_devCert, {
+  ensureDevCert: () => ensureDevCert,
+  getDevCertificateAuthorityPath: () => getDevCertificateAuthorityPath,
+  hasCert: () => hasCert,
+  hasMkcert: () => hasMkcert,
+  loadDevCert: () => loadDevCert,
+  normalizeDevCertificateHosts: () => normalizeDevCertificateHosts,
+  setupMkcert: () => setupMkcert
+});
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync
+} from "fs";
+import { X509Certificate } from "crypto";
+import { isIP } from "net";
+import { platform } from "os";
+import { join } from "path";
+var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE_HOSTS, CERTIFICATE_HOSTNAME_PATTERN, devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`), devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`), certFilesExist = () => existsSync(CERT_PATH) && existsSync(KEY_PATH), normalizeDevCertificateHosts = (hosts = []) => {
+  const normalized = new Set(DEFAULT_CERTIFICATE_HOSTS);
+  for (const host of hosts) {
+    const value = host.trim().toLowerCase();
+    if (!value || value === "0.0.0.0" || value === "::")
+      continue;
+    if (isIP(value) === 0 && !CERTIFICATE_HOSTNAME_PATTERN.test(value)) {
+      throw new TypeError(`Invalid development certificate host: ${host}`);
+    }
+    normalized.add(value);
+  }
+  return [...normalized];
+}, certificateIsUsable = (hosts) => {
+  try {
+    const certPem = readFileSync(CERT_PATH, "utf-8");
+    const certificate = new X509Certificate(certPem);
+    if (new Date(certificate.validTo).getTime() <= Date.now())
+      return false;
+    return normalizeDevCertificateHosts(hosts).every((host) => isIP(host) ? certificate.checkIP(host) !== undefined : certificate.checkHost(host) !== undefined);
+  } catch {
+    return false;
+  }
+}, hasMkcert = () => {
+  try {
+    const result = Bun.spawnSync(["mkcert", "-version"], {
+      stderr: "pipe",
+      stdout: "pipe"
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}, generateWithMkcert = (hosts = []) => {
+  const result = Bun.spawnSync([
+    "mkcert",
+    "-cert-file",
+    CERT_PATH,
+    "-key-file",
+    KEY_PATH,
+    ...normalizeDevCertificateHosts(hosts)
+  ], { stderr: "pipe", stdout: "pipe" });
+  if (result.exitCode !== 0) {
+    const err = new TextDecoder().decode(result.stderr);
+    throw new Error(`mkcert failed: ${err}`);
+  }
+}, generateSelfSigned = (hosts = []) => {
+  const subjectAlternativeNames = normalizeDevCertificateHosts(hosts).map((host) => `${isIP(host) ? "IP" : "DNS"}:${host}`).join(",");
+  const proc = Bun.spawnSync([
+    "openssl",
+    "req",
+    "-x509",
+    "-newkey",
+    "ec",
+    "-pkeyopt",
+    "ec_paramgen_curve:prime256v1",
+    "-days",
+    String(CERT_VALIDITY_DAYS),
+    "-nodes",
+    "-keyout",
+    KEY_PATH,
+    "-out",
+    CERT_PATH,
+    "-subj",
+    "/CN=localhost",
+    "-addext",
+    `subjectAltName=${subjectAlternativeNames}`
+  ], { stderr: "pipe", stdout: "pipe" });
+  if (proc.exitCode !== 0) {
+    const err = new TextDecoder().decode(proc.stderr);
+    throw new Error(`openssl failed: ${err}`);
+  }
+  devLog("Using self-signed certificate \u2014 browser will show a one-time warning");
+}, generateCert = (hosts = []) => {
+  if (hasMkcert()) {
+    generateWithMkcert(hosts);
+  } else {
+    generateSelfSigned(hosts);
+  }
+}, ensureDevCert = (hosts = []) => {
+  mkdirSync(CERT_DIR, { recursive: true });
+  if (hasCert(hosts)) {
+    return { cert: CERT_PATH, key: KEY_PATH };
+  }
+  if (certFilesExist()) {
+    devLog("Certificate is expired or missing a required host, regenerating...");
+  }
+  try {
+    generateCert(hosts);
+  } catch (err) {
+    devWarn(`Failed to generate certificate: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+  return { cert: CERT_PATH, key: KEY_PATH };
+}, hasCert = (hosts = []) => certFilesExist() && certificateIsUsable(hosts), loadDevCert = (hosts = []) => {
+  const paths = ensureDevCert(hosts);
+  if (!paths)
+    return null;
+  try {
+    return {
+      cert: readFileSync(paths.cert, "utf-8"),
+      key: readFileSync(paths.key, "utf-8")
+    };
+  } catch {
+    return null;
+  }
+}, commandExists = (cmd) => {
+  try {
+    const check = platform() === "win32" ? ["where", cmd] : ["which", cmd];
+    const result = Bun.spawnSync(check, {
+      stderr: "pipe",
+      stdout: "pipe"
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}, installMkcertDarwin = () => {
+  if (!commandExists("brew")) {
+    devWarn("Install Homebrew first: https://brew.sh");
+    return false;
+  }
+  devLog("Installing mkcert with Homebrew...");
+  const result = Bun.spawnSync(["brew", "install", "mkcert"], {
+    stderr: "pipe",
+    stdout: "pipe"
+  });
+  return result.exitCode === 0;
+}, installMkcertLinux = () => {
+  const sudoOpts = {
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "pipe"
+  };
+  if (commandExists("apt-get")) {
+    devLog("Installing mkcert (may prompt for password)...");
+    const result = Bun.spawnSync(["sudo", "apt-get", "install", "-y", "mkcert", "libnss3-tools"], sudoOpts);
+    if (result.exitCode === 0)
+      return true;
+  }
+  if (commandExists("dnf")) {
+    devLog("Installing mkcert (may prompt for password)...");
+    const result = Bun.spawnSync(["sudo", "dnf", "install", "-y", "mkcert"], sudoOpts);
+    if (result.exitCode === 0)
+      return true;
+  }
+  if (commandExists("pacman")) {
+    devLog("Installing mkcert (may prompt for password)...");
+    const result = Bun.spawnSync(["sudo", "pacman", "-S", "--noconfirm", "mkcert"], sudoOpts);
+    if (result.exitCode === 0)
+      return true;
+  }
+  devWarn("Could not install mkcert automatically.");
+  console.log("  See: https://github.com/FiloSottile/mkcert#installation");
+  return false;
+}, installMkcertWin32 = () => {
+  if (commandExists("choco")) {
+    devLog("Installing mkcert with Chocolatey...");
+    const result = Bun.spawnSync(["choco", "install", "-y", "mkcert"], {
+      stderr: "pipe",
+      stdout: "pipe"
+    });
+    if (result.exitCode === 0)
+      return true;
+  }
+  if (commandExists("winget")) {
+    devLog("Installing mkcert with winget...");
+    const result = Bun.spawnSync(["winget", "install", "--id", "FiloSottile.mkcert", "-e"], { stderr: "pipe", stdout: "pipe" });
+    if (result.exitCode === 0)
+      return true;
+  }
+  devWarn("Could not install mkcert automatically.");
+  console.log("  See: https://github.com/FiloSottile/mkcert#installation");
+  return false;
+}, installMkcert = () => {
+  const osPlatform = platform();
+  if (osPlatform === "darwin")
+    return installMkcertDarwin();
+  if (osPlatform === "linux")
+    return installMkcertLinux();
+  if (osPlatform === "win32")
+    return installMkcertWin32();
+  return false;
+}, ensureMkcert = () => {
+  if (hasMkcert())
+    return true;
+  if (!installMkcert())
+    return false;
+  if (!hasMkcert()) {
+    devWarn("mkcert installed but not found in PATH. Restart your terminal and try again.");
+    return false;
+  }
+  return true;
+}, isWSL = () => {
+  if (platform() !== "linux")
+    return false;
+  try {
+    return /microsoft|wsl/i.test(readFileSync("/proc/version", "utf-8"));
+  } catch {
+    return false;
+  }
+}, runCapture = (cmd) => {
+  try {
+    const result = Bun.spawnSync(cmd, { stderr: "pipe", stdout: "pipe" });
+    if (result.exitCode !== 0)
+      return null;
+    const out = new TextDecoder().decode(result.stdout).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}, mkcertCaRoot = () => runCapture(["mkcert", "-CAROOT"]), getDevCertificateAuthorityPath = () => {
+  const caRoot = hasMkcert() ? mkcertCaRoot() : null;
+  const rootCertificate = caRoot ? join(caRoot, "rootCA.pem") : null;
+  if (rootCertificate && existsSync(rootCertificate))
+    return rootCertificate;
+  if (certFilesExist())
+    return CERT_PATH;
+  return null;
+}, toWindowsPath = (linuxPath) => runCapture(["wslpath", "-w", linuxPath]), windowsTempDir = () => {
+  const winTemp = runCapture(["cmd.exe", "/c", "echo %TEMP%"]);
+  if (!winTemp)
+    return null;
+  return runCapture(["wslpath", "-u", winTemp]);
+}, trustCaOnWindows = () => {
+  const caRoot = mkcertCaRoot();
+  if (!caRoot)
+    return false;
+  const rootCa = join(caRoot, "rootCA.pem");
+  if (!existsSync(rootCa))
+    return false;
+  const winTemp = windowsTempDir();
+  if (!winTemp)
+    return false;
+  const staged = join(winTemp, "absolutejs-mkcert-rootCA.crt");
+  try {
+    copyFileSync(rootCa, staged);
+  } catch {
+    return false;
+  }
+  const stagedWin = toWindowsPath(staged);
+  if (!stagedWin) {
+    rmSync(staged, { force: true });
+    return false;
+  }
+  const result = Bun.spawnSync([
+    "powershell.exe",
+    "-NoProfile",
+    "-Command",
+    `Import-Certificate -FilePath '${stagedWin}' -CertStoreLocation Cert:\\CurrentUser\\Root`
+  ], { stderr: "pipe", stdout: "pipe" });
+  rmSync(staged, { force: true });
+  return result.exitCode === 0;
+}, setupMkcert = (hosts = []) => {
+  if (!ensureMkcert())
+    return false;
+  const installResult = Bun.spawnSync(["mkcert", "-install"], {
+    stderr: "pipe",
+    stdin: "inherit",
+    stdout: "pipe"
+  });
+  if (installResult.exitCode !== 0) {
+    devWarn("Failed to install local CA");
+    return false;
+  }
+  if (isWSL()) {
+    if (trustCaOnWindows()) {
+      devLog("Trusted the local CA in the Windows store \u2014 Chrome/Edge on Windows now accept dev HTTPS");
+    } else {
+      const caRoot = mkcertCaRoot();
+      const hint = caRoot ? toWindowsPath(join(caRoot, "rootCA.pem")) : null;
+      devWarn("Could not auto-trust the local CA on Windows; Windows browsers may warn.");
+      if (hint) {
+        console.log(`  Run in PowerShell: Import-Certificate -FilePath "${hint}" -CertStoreLocation Cert:\\CurrentUser\\Root`);
+      }
+    }
+  }
+  rmSync(CERT_PATH, { force: true });
+  rmSync(KEY_PATH, { force: true });
+  mkdirSync(CERT_DIR, { recursive: true });
+  generateWithMkcert(hosts);
+  console.log("");
+  devLog("mkcert installed \u2014 HTTPS certificates are now locally trusted");
+  return true;
+};
+var init_devCert = __esm(() => {
+  CERT_DIR = join(process.cwd(), ".absolutejs");
+  CERT_PATH = join(CERT_DIR, "cert.pem");
+  KEY_PATH = join(CERT_DIR, "key.pem");
+  DEFAULT_CERTIFICATE_HOSTS = ["localhost", "127.0.0.1", "::1"];
+  CERTIFICATE_HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/u;
+});
+
 // src/dev/serverBootstrap.ts
-import { copyFileSync, existsSync, readdirSync, unlinkSync } from "fs";
-import { dirname, extname, join, resolve } from "path";
+init_constants();
+import { copyFileSync as copyFileSync2, existsSync as existsSync2, readdirSync, unlinkSync } from "fs";
+import { dirname, extname, join as join2, resolve } from "path";
 
 // src/dev/serverEntryCopies.ts
 var ENTRY_COPY_OWNER_PATTERN = /^\.absolutejs-hmr-(\d+)-(?:bootstrap-)?\d+\.[^.]+$/;
@@ -33,7 +546,7 @@ if (!originalEntry) {
   throw new Error("ABSOLUTE_SERVER_ENTRY is required by the AbsoluteJS dev bootstrap");
 }
 var entryPath = resolve(originalEntry);
-if (!existsSync(entryPath)) {
+if (!existsSync2(entryPath)) {
   throw new Error(`AbsoluteJS server entry does not exist: ${entryPath}`);
 }
 var entryDir = dirname(entryPath);
@@ -52,13 +565,13 @@ if (!isHotReevaluation) {
     }
     if (!isStaleAbsoluteServerEntryCopy(name))
       continue;
-    removeEntryCopy(join(entryDir, name));
+    removeEntryCopy(join2(entryDir, name));
   }
 }
 var bootstrapSequence = (globalThis.__absoluteEntryBootstrapSequence ?? 0) + 1;
 globalThis.__absoluteEntryBootstrapSequence = bootstrapSequence;
-var bootstrapCopy = join(entryDir, `${copyPrefix}${process.pid}-bootstrap-${bootstrapSequence}${entryExtension}`);
-copyFileSync(entryPath, bootstrapCopy);
+var bootstrapCopy = join2(entryDir, `${copyPrefix}${process.pid}-bootstrap-${bootstrapSequence}${entryExtension}`);
+copyFileSync2(entryPath, bootstrapCopy);
 var entryCopies = globalThis.__absoluteEntryCopies ?? new Set;
 entryCopies.add(bootstrapCopy);
 globalThis.__absoluteEntryCopies = entryCopies;
@@ -70,4 +583,29 @@ if (!globalThis.__absoluteEntryCleanupRegistered) {
     }
   });
 }
+if (!isHotReevaluation && !globalThis.__absoluteBunServer && process.env.ABSOLUTE_EARLY_LISTEN !== "0") {
+  const { startEarlyListener: startEarlyListener2, installEarlyListenerServeGuard: installEarlyListenerServeGuard2 } = await Promise.resolve().then(() => (init_earlyListener(), exports_earlyListener));
+  const earlyHost = process.env.ABSOLUTE_HOST ?? process.env.HOST ?? "localhost";
+  const earlyPort = Number(process.env.ABSOLUTE_PORT ?? process.env.PORT ?? DEFAULT_PORT);
+  const loadEarlyTls = async () => {
+    if (false)
+      ;
+    if (process.env.ABSOLUTE_HTTPS !== "true")
+      return null;
+    try {
+      const { loadDevCert: loadDevCert2 } = await Promise.resolve().then(() => (init_devCert(), exports_devCert));
+      return loadDevCert2();
+    } catch {
+      return null;
+    }
+  };
+  if (Number.isInteger(earlyPort) && earlyPort > 0) {
+    startEarlyListener2({
+      host: earlyHost,
+      port: earlyPort,
+      tls: await loadEarlyTls()
+    });
+    installEarlyListenerServeGuard2(earlyPort);
+  }
+}
 await import(bootstrapCopy);