bun-dev-server 0.9.85 → 1.0.1

package/dist/index.js

@@ -17,6 +17,76 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
 // node_modules/ejs/lib/utils.js
 var require_utils = __commonJS((exports) => {
   var regExpChars = /[|\\{}()[\]^$+*?.]/g;
@@ -776,76 +846,6 @@ var require_ejs = __commonJS((exports) => {
   }
 });
 
-// node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS((exports, module) => {
-  var p = process || {};
-  var argv = p.argv || [];
-  var env = p.env || {};
-  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-  var formatter = (open, close, replace = open) => (input) => {
-    let string = "" + input, index = string.indexOf(close, open.length);
-    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-  };
-  var replaceClose = (string, close, replace, index) => {
-    let result = "", cursor = 0;
-    do {
-      result += string.substring(cursor, index) + replace;
-      cursor = index + close.length;
-      index = string.indexOf(close, cursor);
-    } while (~index);
-    return result + string.substring(cursor);
-  };
-  var createColors = (enabled = isColorSupported) => {
-    let f = enabled ? formatter : () => String;
-    return {
-      isColorSupported: enabled,
-      reset: f("\x1B[0m", "\x1B[0m"),
-      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-      italic: f("\x1B[3m", "\x1B[23m"),
-      underline: f("\x1B[4m", "\x1B[24m"),
-      inverse: f("\x1B[7m", "\x1B[27m"),
-      hidden: f("\x1B[8m", "\x1B[28m"),
-      strikethrough: f("\x1B[9m", "\x1B[29m"),
-      black: f("\x1B[30m", "\x1B[39m"),
-      red: f("\x1B[31m", "\x1B[39m"),
-      green: f("\x1B[32m", "\x1B[39m"),
-      yellow: f("\x1B[33m", "\x1B[39m"),
-      blue: f("\x1B[34m", "\x1B[39m"),
-      magenta: f("\x1B[35m", "\x1B[39m"),
-      cyan: f("\x1B[36m", "\x1B[39m"),
-      white: f("\x1B[37m", "\x1B[39m"),
-      gray: f("\x1B[90m", "\x1B[39m"),
-      bgBlack: f("\x1B[40m", "\x1B[49m"),
-      bgRed: f("\x1B[41m", "\x1B[49m"),
-      bgGreen: f("\x1B[42m", "\x1B[49m"),
-      bgYellow: f("\x1B[43m", "\x1B[49m"),
-      bgBlue: f("\x1B[44m", "\x1B[49m"),
-      bgMagenta: f("\x1B[45m", "\x1B[49m"),
-      bgCyan: f("\x1B[46m", "\x1B[49m"),
-      bgWhite: f("\x1B[47m", "\x1B[49m"),
-      blackBright: f("\x1B[90m", "\x1B[39m"),
-      redBright: f("\x1B[91m", "\x1B[39m"),
-      greenBright: f("\x1B[92m", "\x1B[39m"),
-      yellowBright: f("\x1B[93m", "\x1B[39m"),
-      blueBright: f("\x1B[94m", "\x1B[39m"),
-      magentaBright: f("\x1B[95m", "\x1B[39m"),
-      cyanBright: f("\x1B[96m", "\x1B[39m"),
-      whiteBright: f("\x1B[97m", "\x1B[39m"),
-      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-      bgRedBright: f("\x1B[101m", "\x1B[49m"),
-      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-    };
-  };
-  module.exports = createColors();
-  module.exports.createColors = createColors;
-});
-
 // node_modules/eventemitter3/index.js
 var require_eventemitter3 = __commonJS((exports, module) => {
   var has = Object.prototype.hasOwnProperty;
@@ -1026,278 +1026,219 @@ var require_eventemitter3 = __commonJS((exports, module) => {
 });
 
 // src/server.ts
-var import_ejs = __toESM(require_ejs(), 1);
-var {$: $2, build } = globalThis.Bun;
-
-// src/serveOutputTemplate.ejs
-var serveOutputTemplate_default = `<!DOCTYPE html>\r
-<html lang="en">\r
-\r
-  <head>\r
-    <meta charset="UTF-8" />\r
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />\r
-    <title>Document</title>\r
-  </head>\r
-\r
-  <body>\r
-    <a href="../">..</a>\r
-    <% dirs.forEach(element => { %> <br /><a href=".<%= element.requestPath %>/<%= element.name %>"><%= element.name %></a> <% }) %>\r
-    <% files.forEach(element => { %> <br /><a href=".<%= element.requestPath %>/<%= element.name %>"><%= element.name %></a> <% }) %>\r
-  </body>\r
-\r
-</html>`;
+var import_picocolors3 = __toESM(require_picocolors(), 1);
 
-// src/indexHTMLTemplate.ejs
-var indexHTMLTemplate_default = `<!DOCTYPE html>\r
-<html lang="en">\r
-  <head>\r
-    <meta charset="UTF-8" />\r
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />\r
-    <title>Bun HTML File</title>\r
-    <% for (const hashedJs of hashedImports) { %>\r
-    <script type="module" src="<%= hashedJs %>"></script>\r
-    <% } %>\r
-  </head>\r
-\r
-  <body>\r
-    <div id="app"></div>\r
-  </body>\r
-</html>\r
-`;
+// src/httpHandler.ts
+var import_ejs = __toESM(require_ejs(), 1);
+import { readFile, readdir } from "fs/promises";
 
-// src/server.ts
-import { watch, readdir, access, readFile as readFile2, constants } from "fs/promises";
-import { resolve } from "path";
+// src/utils/cors.ts
+function withCORSHeaders(response, request) {
+  response.headers.set("Access-Control-Allow-Origin", request?.headers.get("origin") ?? "*");
+  response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+  response.headers.set("Access-Control-Allow-Credentials", "true");
+  response.headers.set("Cache-Control", "no-store, no-cache, must-revalidate");
+  return response;
+}
 
-// src/bunClientHmr.ts
-function hotReload() {
-  if (!window.BUN_DEV_SERVER) {
-    window.BUN_DEV_SERVER = [];
+// src/utils/filesystem.ts
+var {$ } = globalThis.Bun;
+import { access, constants } from "fs/promises";
+async function cleanDirectory(dst) {
+  const { stderr, exitCode } = await $`rm -rf ${dst}/*`.nothrow();
+  if (exitCode !== 0) {
+    if (stderr.indexOf("no matches found") > -1) {
+      console.log("Directory is empty");
+    } else {
+      console.warn("Unable to clean directory", stderr.toString("utf8"));
+    }
   }
-  const devServer = "[Bun Dev Server]";
-  const connectAddress = "[REPLACE_ENDPOINT]";
-  let foundServer = window.BUN_DEV_SERVER.find((server) => server.url === connectAddress);
-  if (!foundServer) {
-    foundServer = { url: connectAddress, socket: null };
+}
+function convertBytes(bytes) {
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  if (bytes == 0) {
+    return "n/a";
   }
-  if (foundServer.socket) {
-    return;
+  const floored = Math.floor(Math.log(bytes) / Math.log(1024));
+  const i = floored;
+  if (i == 0) {
+    return bytes + " " + sizes[i];
   }
-  console.log(devServer, "Connecting to Bun Dev Server at", connectAddress);
-  foundServer.socket = new WebSocket(connectAddress);
-  window.BUN_DEV_SERVER.push(foundServer);
-  function errorHandler(err) {
-    console.error(devServer, "ERROR", err);
+  return (bytes / Math.pow(1024, i)).toFixed(1) + " " + sizes[i];
+}
+async function checkObjectExists(fsPath) {
+  try {
+    await access(fsPath, constants.R_OK);
+    return true;
+  } catch (e) {
+    if (e?.code === "ENOENT") {
+      return false;
+    }
+    const msg = `Error while accessing path ${fsPath}`;
+    console.error(msg, e);
+    return false;
   }
-  function messageHandler(msg) {
-    let parsed = msg.data;
+}
+
+// src/httpHandler.ts
+function handleErrorResponse(req, err) {
+  const msg = `Error while processing request ${req.url}`;
+  console.error(msg, err);
+  return withCORSHeaders(new Response(msg, { status: 500 }), req);
+}
+async function handlePathRequest(requestPath, req, finalConfig, destinationPath) {
+  let fsPath = destinationPath + requestPath;
+  const objThere = await checkObjectExists(fsPath);
+  let isDirectory = false;
+  if (objThere) {
     try {
-      parsed = JSON.parse(msg.data);
+      await readFile(fsPath);
     } catch (e) {
-    }
-    if (parsed?.type === "message") {
-      console.log(devServer, parsed.message);
-      return;
-    }
-    if (parsed?.type === "output") {
-      console.table(devServer, parsed.message);
-      return;
-    }
-    if (parsed?.type === "reload") {
-      window.location.reload();
-      return;
-    }
-    if (parsed?.type === "tscerror") {
-      console.error(parsed.message);
-      return;
-    }
-    if (parsed?.type === "error") {
-      console.error(parsed.message);
-      let newDiv = window.document.getElementById("bun-hmr-error");
-      const divExists = !!newDiv;
-      if (!newDiv) {
-        newDiv = window.document.createElement("div");
-      }
-      newDiv.id = "bun-hmr-error";
-      newDiv.innerText += parsed.message;
-      if (!divExists) {
-        window.document.body.appendChild(newDiv);
+      if (e.code === "EISDIR") {
+        isDirectory = true;
+      } else {
+        throw e;
       }
-      return;
     }
+  } else {
+    if (requestPath.toLowerCase() !== "/index.html") {
+      finalConfig.logRequests && console.log(`${404} ${req.url}`);
+      return withCORSHeaders(new Response("", { status: 404 }), req);
+    }
+    requestPath = "/";
+    isDirectory = true;
+    fsPath = destinationPath + requestPath;
   }
-  function closeHandler(ev) {
-    console.warn(devServer, "Connection closed. Will retry in 5 seconds...");
-    foundServer.socket?.removeEventListener("error", errorHandler);
-    foundServer.socket?.removeEventListener("message", messageHandler);
-    foundServer.socket?.removeEventListener("open", messageHandler);
-    foundServer.socket?.removeEventListener("close", closeHandler);
-    foundServer.socket = null;
-    setTimeout(function() {
-      console.log(devServer, "Attempting to reconnect...");
-      hotReload();
-    }, 5000);
-  }
-  function openHandler(ev) {
-    console.log(devServer, "Connected to Bun Dev Server");
+  if (!isDirectory) {
+    return handleFileRequest(fsPath, req, finalConfig);
   }
-  foundServer.socket.addEventListener("error", errorHandler);
-  foundServer.socket.addEventListener("message", messageHandler);
-  foundServer.socket.addEventListener("close", closeHandler);
-  foundServer.socket.addEventListener("open", openHandler);
+  return handleDirectoryRequest(fsPath, requestPath, req, finalConfig);
 }
-var DEFAULT_HMR_PATH = "/hmr-ws";
-function bunHotReload(bunServerConfig) {
-  const socketPath = bunServerConfig.websocketPath || DEFAULT_HMR_PATH;
-  const endPath = socketPath.startsWith("/") ? socketPath : `/${socketPath}`;
-  const path = `${bunServerConfig.secure ? "wss" : "ws"}://localhost:${bunServerConfig.port}${endPath}`;
-  return hotReload.toString().replace("[REPLACE_ENDPOINT]", path);
-}
-
-// src/bunHmrPlugin.ts
-import { readFile } from "fs/promises";
-function bunHotReloadPlugin(config) {
-  const bunHMRPlugin = {
-    name: "hmr",
-    target: "browser",
-    setup(build) {
-      const entryPoints = [];
-      const addedEnryPoints = new Set;
-      build.config.entrypoints.forEach((entry) => {
-        let entryPath = entry.replace(/^\.*/, "");
-        if (process.platform === "win32") {
-          entryPath = entryPath.replace(/\//g, "\\");
-        }
-        entryPoints.push(entryPath);
-      });
-      build.onLoad({ filter: /\.m?tsx?/ }, async (args) => {
-        const contents = await readFile(args.path, { encoding: "utf-8" });
-        const isTSx = /\.m?tsx$/.test(args.path);
-        const isJSx = /\.m?jsx$/.test(args.path);
-        const isJS = /\.m?js$/.test(args.path);
-        const isTS = /\.m?ts$/.test(args.path);
-        const loader = isTSx ? "tsx" : isJSx ? "jsx" : isTS ? "ts" : isJS ? "js" : "text";
-        const isEntry = entryPoints.some((entry) => args.path.endsWith(entry));
-        if (!addedEnryPoints.has(args.path) && isEntry) {
-          addedEnryPoints.add(args.path);
-          return { contents: `import "bun-hot-reload"
-` + contents, loader };
-        }
-        return { contents, loader };
-      });
-      build.onLoad({ filter: /./, namespace: "bun-hot-reload" }, async (args) => {
-        return { contents: `(${bunHotReload(config)})()
-`, loader: "ts" };
-      });
-      build.onResolve({ filter: /^bun-hot-reload$/ }, (args) => {
-        return { path: args.path, namespace: "bun-hot-reload" };
-      });
+async function handleFileRequest(fsPath, req, finalConfig) {
+  try {
+    const fl = Bun.file(fsPath);
+    finalConfig.logRequests && console.log(`${200} ${req.url}`);
+    return withCORSHeaders(new Response(fl), req);
+  } catch (e) {
+    if (e?.code === "ENOENT") {
+      finalConfig.logRequests && console.log(`${404} ${req.url}`);
+      return withCORSHeaders(new Response("", { status: 404 }), req);
+    } else {
+      return handleErrorResponse(req, e);
     }
-  };
-  return bunHMRPlugin;
-}
-function getBunHMRFooter(config) {
-  return `;(${bunHotReload(config)})();`;
-}
-
-// src/bunManifest.ts
-var {write, pathToFileURL } = globalThis.Bun;
-function writeManifest(output, outdir, withHash = false, manifestName = "bun_server_manifest.json") {
-  const entryPoints = output.outputs.filter((o) => o.kind === "entry-point");
-  const epTable = [];
-  for (const ep of entryPoints) {
-    const basePathUrl = pathToFileURL(outdir);
-    const epUrl = pathToFileURL(ep.path);
-    const relativePath = epUrl.href.replace(`${basePathUrl.href}/`, "");
-    const hashedImport = `${relativePath}${withHash ? `?${ep.hash}` : ``}`;
-    epTable.push(hashedImport);
   }
-  const outObj = { js: epTable };
-  write(`${outdir}/${manifestName}`, JSON.stringify(outObj));
 }
-
-// src/tsChecker.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
-var {$ } = globalThis.Bun;
-var success = {
-  error: false,
-  message: ""
-};
-async function performTSC(finalConfig, importMeta) {
-  if (finalConfig.enableTSC) {
-    console.log("Performing TSC check");
-    const tsc = await $`tsc --noEmit --noErrorTruncation -p ${finalConfig.tscConfigPath}`.cwd(importMeta.dir).quiet().nothrow();
-    if (tsc.exitCode === 0) {
-      console.log(import_picocolors.default.bgGreen("\u2714 [SUCCESS]"), "TSC check passed");
-      return success;
-    } else {
-      const errOutput = tsc.stdout.toString();
-      console.log(import_picocolors.default.bgRed("\u2718 [ERROR]"), `\r
-${errOutput}`);
+async function handleDirectoryRequest(fsPath, requestPath, req, finalConfig) {
+  try {
+    const allEntries = await readdir(fsPath, {
+      withFileTypes: true
+    });
+    const dirs = allEntries.filter((entry) => entry.isDirectory()).map((entry) => {
       return {
-        error: true,
-        message: errOutput
+        requestPath: requestPath === "/" ? "" : requestPath,
+        name: entry.name
       };
-    }
+    });
+    const files = allEntries.filter((entry) => entry.isFile()).map((entry) => {
+      return {
+        requestPath: requestPath === "/" ? "" : requestPath,
+        name: entry.name
+      };
+    });
+    const templatePath = requestPath === "/" ? "" : requestPath;
+    const rnd = import_ejs.render(finalConfig.serveOutputEjs, {
+      dirs,
+      files,
+      requestPath: templatePath
+    });
+    finalConfig.logRequests && console.log(`${200} ${req.url}`);
+    return withCORSHeaders(new Response(rnd, { headers: { "Content-Type": "text/html" } }), req);
+  } catch (err) {
+    return handleErrorResponse(req, err);
   }
-  return success;
 }
 
+// src/staticAssets.ts
+import { resolve } from "path";
+
+// src/static/serveOutputStyles.css
+var serveOutputStyles_default = "./assets/serveOutputStyles.css";
+
+// src/static/file.svg
+var file_default = "./assets/file.svg";
+
+// src/static/folder.svg
+var folder_default = "./assets/folder.svg";
+
+// src/static/parent.svg
+var parent_default = "./assets/parent.svg";
+
+// src/staticAssets.ts
+var staticAssets = {
+  listingStyle: Bun.file(resolve(import.meta.dir, serveOutputStyles_default)),
+  fileSvg: Bun.file(resolve(import.meta.dir, file_default)),
+  folderSvg: Bun.file(resolve(import.meta.dir, folder_default)),
+  parentSvg: Bun.file(resolve(import.meta.dir, parent_default))
+};
+var staticAssetRoutes = {
+  "/__bun_dev_server__/serveOutputStyles.css": staticAssets.listingStyle,
+  "/__bun_dev_server__/file.svg": staticAssets.fileSvg,
+  "/__bun_dev_server__/folder.svg": staticAssets.folderSvg,
+  "/__bun_dev_server__/parent.svg": staticAssets.parentSvg
+};
+
+// src/fileWatcher.ts
+import { watch } from "fs/promises";
+
+// src/buildManager.ts
+var import_ejs2 = __toESM(require_ejs(), 1);
+var {build } = globalThis.Bun;
+
 // node_modules/eventemitter3/index.mjs
 var import__ = __toESM(require_eventemitter3(), 1);
 
 // node_modules/p-timeout/index.js
 class TimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-}
-
-class AbortError extends Error {
-  constructor(message) {
-    super();
-    this.name = "AbortError";
-    this.message = message;
+  name = "TimeoutError";
+  constructor(message, options) {
+    super(message, options);
+    Error.captureStackTrace?.(this, TimeoutError);
   }
 }
-var getDOMException = (errorMessage) => globalThis.DOMException === undefined ? new AbortError(errorMessage) : new DOMException(errorMessage);
-var getAbortedReason = (signal) => {
-  const reason = signal.reason === undefined ? getDOMException("This operation was aborted.") : signal.reason;
-  return reason instanceof Error ? reason : getDOMException(reason);
-};
+var getAbortedReason = (signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError");
 function pTimeout(promise, options) {
   const {
     milliseconds,
     fallback,
     message,
-    customTimers = { setTimeout, clearTimeout }
+    customTimers = { setTimeout, clearTimeout },
+    signal
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve, reject) => {
+  const wrappedPromise = new Promise((resolve2, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
-    if (options.signal) {
-      const { signal } = options;
-      if (signal.aborted) {
-        reject(getAbortedReason(signal));
-      }
+    if (signal?.aborted) {
+      reject(getAbortedReason(signal));
+      return;
+    }
+    if (signal) {
       abortHandler = () => {
         reject(getAbortedReason(signal));
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
+    promise.then(resolve2, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
-      promise.then(resolve, reject);
       return;
     }
     const timeoutError = new TimeoutError;
     timer = customTimers.setTimeout.call(undefined, () => {
       if (fallback) {
         try {
-          resolve(fallback());
+          resolve2(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1307,7 +1248,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve();
+        resolve2();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1315,18 +1256,11 @@ function pTimeout(promise, options) {
         reject(timeoutError);
       }
     }, milliseconds);
-    (async () => {
-      try {
-        resolve(await promise);
-      } catch (error) {
-        reject(error);
-      }
-    })();
   });
   const cancelablePromise = wrappedPromise.finally(() => {
     cancelablePromise.clear();
-    if (abortHandler && options.signal) {
-      options.signal.removeEventListener("abort", abortHandler);
+    if (abortHandler && signal) {
+      signal.removeEventListener("abort", abortHandler);
     }
   });
   cancelablePromise.clear = () => {
@@ -1357,16 +1291,13 @@ function lowerBound(array, value, comparator) {
 class PriorityQueue {
   #queue = [];
   enqueue(run, options) {
-    options = {
-      priority: 0,
-      ...options
-    };
+    const { priority = 0, id } = options ?? {};
     const element = {
-      priority: options.priority,
-      id: options.id,
+      priority,
+      id,
       run
     };
-    if (this.size === 0 || this.#queue[this.size - 1].priority >= options.priority) {
+    if (this.size === 0 || this.#queue[this.size - 1].priority >= priority) {
       this.#queue.push(element);
       return;
     }
@@ -1395,12 +1326,15 @@ class PriorityQueue {
 
 // node_modules/p-queue/dist/index.js
 class PQueue extends import__.default {
-  #carryoverConcurrencyCount;
+  #carryoverIntervalCount;
   #isIntervalIgnored;
   #intervalCount = 0;
   #intervalCap;
+  #rateLimitedInInterval = false;
+  #rateLimitFlushScheduled = false;
   #interval;
   #intervalEnd = 0;
+  #lastExecutionTime = 0;
   #intervalId;
   #timeoutId;
   #queue;
@@ -1408,13 +1342,13 @@ class PQueue extends import__.default {
   #pending = 0;
   #concurrency;
   #isPaused;
-  #throwOnTimeout;
   #idAssigner = 1n;
+  #runningTasks = new Map;
   timeout;
   constructor(options) {
     super();
     options = {
-      carryoverConcurrencyCount: false,
+      carryoverIntervalCount: false,
       intervalCap: Number.POSITIVE_INFINITY,
       interval: 0,
       concurrency: Number.POSITIVE_INFINITY,
@@ -1428,16 +1362,19 @@ class PQueue extends import__.default {
     if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
       throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
     }
-    this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+    this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
     this.#intervalCap = options.intervalCap;
     this.#interval = options.interval;
     this.#queue = new options.queueClass;
     this.#queueClass = options.queueClass;
     this.concurrency = options.concurrency;
+    if (options.timeout !== undefined && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+      throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+    }
     this.timeout = options.timeout;
-    this.#throwOnTimeout = options.throwOnTimeout === true;
     this.#isPaused = options.autoStart === false;
+    this.#setupRateLimitTracking();
   }
   get #doesIntervalAllowAnother() {
     return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
@@ -1447,6 +1384,9 @@ class PQueue extends import__.default {
   }
   #next() {
     this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
     this.#tryToStartAnother();
     this.emit("next");
   }
@@ -1460,46 +1400,70 @@ class PQueue extends import__.default {
     if (this.#intervalId === undefined) {
       const delay = this.#intervalEnd - now;
       if (delay < 0) {
-        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
-      } else {
-        if (this.#timeoutId === undefined) {
-          this.#timeoutId = setTimeout(() => {
-            this.#onResumeInterval();
-          }, delay);
+        if (this.#lastExecutionTime > 0) {
+          const timeSinceLastExecution = now - this.#lastExecutionTime;
+          if (timeSinceLastExecution < this.#interval) {
+            this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
+            return true;
+          }
         }
+        this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      } else {
+        this.#createIntervalTimeout(delay);
         return true;
       }
     }
     return false;
   }
+  #createIntervalTimeout(delay) {
+    if (this.#timeoutId !== undefined) {
+      return;
+    }
+    this.#timeoutId = setTimeout(() => {
+      this.#onResumeInterval();
+    }, delay);
+  }
+  #clearIntervalTimer() {
+    if (this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = undefined;
+    }
+  }
+  #clearTimeoutTimer() {
+    if (this.#timeoutId) {
+      clearTimeout(this.#timeoutId);
+      this.#timeoutId = undefined;
+    }
+  }
   #tryToStartAnother() {
     if (this.#queue.size === 0) {
-      if (this.#intervalId) {
-        clearInterval(this.#intervalId);
-      }
-      this.#intervalId = undefined;
+      this.#clearIntervalTimer();
       this.emit("empty");
       if (this.#pending === 0) {
+        this.#clearTimeoutTimer();
         this.emit("idle");
       }
       return false;
     }
+    let taskStarted = false;
     if (!this.#isPaused) {
       const canInitializeInterval = !this.#isIntervalPaused;
       if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
         const job = this.#queue.dequeue();
-        if (!job) {
-          return false;
+        if (!this.#isIntervalIgnored) {
+          this.#intervalCount++;
+          this.#scheduleRateLimitUpdate();
         }
         this.emit("active");
+        this.#lastExecutionTime = Date.now();
         job();
         if (canInitializeInterval) {
           this.#initializeIntervalIfNeeded();
         }
-        return true;
+        taskStarted = true;
       }
     }
-    return false;
+    return taskStarted;
   }
   #initializeIntervalIfNeeded() {
     if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
@@ -1512,11 +1476,11 @@ class PQueue extends import__.default {
   }
   #onInterval() {
     if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-      clearInterval(this.#intervalId);
-      this.#intervalId = undefined;
+      this.#clearIntervalTimer();
     }
-    this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+    this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
     this.#processQueue();
+    this.#scheduleRateLimitUpdate();
   }
   #processQueue() {
     while (this.#tryToStartAnother()) {
@@ -1540,40 +1504,58 @@ class PQueue extends import__.default {
     });
   }
   setPriority(id, priority) {
+    if (typeof priority !== "number" || !Number.isFinite(priority)) {
+      throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
+    }
     this.#queue.setPriority(id, priority);
   }
   async add(function_, options = {}) {
     options.id ??= (this.#idAssigner++).toString();
     options = {
       timeout: this.timeout,
-      throwOnTimeout: this.#throwOnTimeout,
       ...options
     };
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
+      const taskSymbol = Symbol(`task-${options.id}`);
       this.#queue.enqueue(async () => {
         this.#pending++;
-        this.#intervalCount++;
+        this.#runningTasks.set(taskSymbol, {
+          id: options.id,
+          priority: options.priority ?? 0,
+          startTime: Date.now(),
+          timeout: options.timeout
+        });
         try {
-          options.signal?.throwIfAborted();
+          try {
+            options.signal?.throwIfAborted();
+          } catch (error) {
+            if (!this.#isIntervalIgnored) {
+              this.#intervalCount--;
+            }
+            this.#runningTasks.delete(taskSymbol);
+            throw error;
+          }
           let operation = function_({ signal: options.signal });
           if (options.timeout) {
-            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+            operation = pTimeout(Promise.resolve(operation), {
+              milliseconds: options.timeout,
+              message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`
+            });
           }
           if (options.signal) {
             operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
           }
           const result = await operation;
-          resolve(result);
+          resolve2(result);
           this.emit("completed", result);
         } catch (error) {
-          if (error instanceof TimeoutError && !options.throwOnTimeout) {
-            resolve();
-            return;
-          }
           reject(error);
           this.emit("error", error);
         } finally {
-          this.#next();
+          this.#runningTasks.delete(taskSymbol);
+          queueMicrotask(() => {
+            this.#next();
+          });
         }
       }, options);
       this.emit("add");
@@ -1596,6 +1578,7 @@ class PQueue extends import__.default {
   }
   clear() {
     this.#queue = new this.#queueClass;
+    this.#updateRateLimitState();
   }
   async onEmpty() {
     if (this.#queue.size === 0) {
@@ -1615,14 +1598,41 @@ class PQueue extends import__.default {
     }
     await this.#onEvent("idle");
   }
+  async onPendingZero() {
+    if (this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("pendingZero");
+  }
+  async onRateLimit() {
+    if (this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimit");
+  }
+  async onRateLimitCleared() {
+    if (!this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimitCleared");
+  }
+  async onError() {
+    return new Promise((_resolve, reject) => {
+      const handleError = (error) => {
+        this.off("error", handleError);
+        reject(error);
+      };
+      this.on("error", handleError);
+    });
+  }
   async#onEvent(event, filter) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve();
+        resolve2();
       };
       this.on(event, listener);
     });
@@ -1639,136 +1649,104 @@ class PQueue extends import__.default {
   get isPaused() {
     return this.#isPaused;
   }
-}
-
-// src/server.ts
-async function startBunDevServer(serverConfig, importMeta) {
-  const defaultConfig = {
-    port: 3000,
-    websocketPath: DEFAULT_HMR_PATH,
-    serveOutputEjs: serveOutputTemplate_default,
-    serveIndexHtmlEjs: indexHTMLTemplate_default,
-    createIndexHTML: true,
-    tscConfigPath: resolve(importMeta.dir, "./tsconfig.json"),
-    broadcastBuildOutputToConsole: true,
-    broadcastBuildOutputToClient: true
-  };
-  const finalConfig = { ...defaultConfig, ...serverConfig };
-  if (serverConfig.tscConfigPath) {
-    finalConfig.tscConfigPath = resolve(importMeta.dir, serverConfig.tscConfigPath);
-  }
-  if (!finalConfig.watchDir) {
-    throw new Error("watchDir must be set");
-  }
-  const servePart = finalConfig.buildConfig.outdir ?? finalConfig.servePath ?? "./dist";
-  const serveDestination = resolve(importMeta.dir, servePart);
-  const watchDestination = resolve(importMeta.dir, finalConfig.watchDir);
-  const allEntries = serverConfig.buildConfig.entrypoints.splice(0, serverConfig.buildConfig.entrypoints.length);
-  const resolvedEntries = allEntries.map((e) => resolve(importMeta.dir, e));
-  serverConfig.buildConfig.entrypoints = resolvedEntries;
-  const destinationPath = serveDestination;
-  const srcWatch = watchDestination;
-  try {
-    await readdir(destinationPath);
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      console.log("Directory not found, creating it...");
-      try {
-        await $2`mkdir ${destinationPath}`;
-      } catch (e2) {
-        console.error("Unable to create directory", e2);
-      }
-    } else {
-      throw e;
+  #setupRateLimitTracking() {
+    if (this.#isIntervalIgnored) {
+      return;
     }
+    this.on("add", () => {
+      if (this.#queue.size > 0) {
+        this.#scheduleRateLimitUpdate();
+      }
+    });
+    this.on("next", () => {
+      this.#scheduleRateLimitUpdate();
+    });
   }
-  const buncfg = { port: finalConfig.port, tls: finalConfig.tls, websocketPath: finalConfig.websocketPath, secure: finalConfig.tls !== undefined };
-  const buildCfg = {
-    ...serverConfig.buildConfig,
-    outdir: destinationPath
-  };
-  if (finalConfig.hotReload === "footer") {
-    if (!buildCfg.footer) {
-      buildCfg.footer = "";
+  #scheduleRateLimitUpdate() {
+    if (this.#isIntervalIgnored || this.#rateLimitFlushScheduled) {
+      return;
     }
-    buildCfg.footer += getBunHMRFooter(buncfg);
+    this.#rateLimitFlushScheduled = true;
+    queueMicrotask(() => {
+      this.#rateLimitFlushScheduled = false;
+      this.#updateRateLimitState();
+    });
   }
-  if (finalConfig.hotReload === "plugin") {
-    if (!buildCfg.plugins) {
-      buildCfg.plugins = [];
+  #updateRateLimitState() {
+    const previous = this.#rateLimitedInInterval;
+    const shouldBeRateLimited = !this.#isIntervalIgnored && this.#intervalCount >= this.#intervalCap && this.#queue.size > 0;
+    if (shouldBeRateLimited !== previous) {
+      this.#rateLimitedInInterval = shouldBeRateLimited;
+      this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
     }
-    buildCfg.plugins.push(bunHotReloadPlugin(buncfg));
   }
-  if (serverConfig.cleanServePath) {
-    await cleanDirectory(destinationPath);
+  get isRateLimited() {
+    return this.#rateLimitedInInterval;
   }
-  console.log("Starting Bun Dev Server on port", finalConfig.port);
-  const bunServer = Bun.serve({
-    port: finalConfig.port,
-    development: true,
-    tls: finalConfig.tls,
-    routes: {
-      "/favicon.ico": withCORSHeaders(new Response("", { status: 404 })),
-      ...finalConfig.routes
-    },
-    async fetch(req, server) {
-      if (req.method === "OPTIONS") {
-        finalConfig.logRequests && console.log(`${200} ${req.url} OPTIONS`);
-        return withCORSHeaders(new Response("", { status: 200 }), req);
-      }
-      if (req.url.toLowerCase().endsWith(finalConfig.websocketPath)) {
-        finalConfig.logRequests && console.log(`${req.url} Socket Upgrade`);
-        if (server.upgrade(req)) {
-          return withCORSHeaders(new Response("", { status: 200 }), req);
-        }
-      }
-      const url = new URL(req.url);
-      let requestPath = url.pathname;
-      return handlePathRequest(requestPath, req, finalConfig, destinationPath);
-    },
-    websocket: {
-      open(ws) {
-        ws.subscribe("message");
-      },
-      message(ws, message) {
-      },
-      sendPings: true
-    }
-  });
-  const queue = getThrottledBuildAndNotify(finalConfig);
-  await queue.add(async () => {
-    await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
-  });
-  const watcher = watch(srcWatch, { recursive: true });
-  for await (const event of watcher) {
-    if (queue.pending > 0) {
-      continue;
-    }
-    try {
-      if (queue.size > 0) {
-        queue.clear();
-      }
-      queue.add(async () => {
-        await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, event);
-      });
-    } catch (e) {
-      console.error("Error while processing file change", e);
+  get isSaturated() {
+    return this.#pending === this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+  }
+  get runningTasks() {
+    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+  }
+}
+
+// src/buildManager.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+
+// src/tsChecker.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var {$: $2 } = globalThis.Bun;
+var success = {
+  error: false,
+  message: ""
+};
+async function performTSC(finalConfig, importMeta) {
+  if (finalConfig.enableTSC) {
+    console.log("Performing TSC check");
+    const tsc = await $2`tsc --noEmit --noErrorTruncation -p ${finalConfig.tscConfigPath}`.cwd(importMeta.dir).quiet().nothrow();
+    if (tsc.exitCode === 0) {
+      console.log(import_picocolors.default.bgGreen("\u2714 [SUCCESS]"), "TSC check passed");
+      return success;
+    } else {
+      const errOutput = tsc.stdout.toString();
+      console.log(import_picocolors.default.bgRed("\u2718 [ERROR]"), `\r
+${errOutput}`);
+      return {
+        error: true,
+        message: errOutput
+      };
     }
   }
+  return success;
 }
-function getThrottledBuildAndNotify(serverConfig) {
-  const anotherThrottle = new PQueue({
+
+// src/bunManifest.ts
+var {write, pathToFileURL } = globalThis.Bun;
+function writeManifest(output, outdir, withHash = false, manifestName = "bun_server_manifest.json") {
+  const entryPoints = output.outputs.filter((o) => o.kind === "entry-point");
+  const epTable = [];
+  for (const ep of entryPoints) {
+    const basePathUrl = pathToFileURL(outdir);
+    const epUrl = pathToFileURL(ep.path);
+    const relativePath = epUrl.href.replace(`${basePathUrl.href}/`, "");
+    const hashedImport = `${relativePath}${withHash ? `?${ep.hash}` : ``}`;
+    epTable.push(hashedImport);
+  }
+  const outObj = { js: epTable };
+  write(`${outdir}/${manifestName}`, JSON.stringify(outObj));
+}
+
+// src/buildManager.ts
+function getThrottledBuildQueue(serverConfig) {
+  return new PQueue({
     concurrency: 1,
     intervalCap: 1,
     interval: serverConfig.watchDelay ?? 1000,
     carryoverConcurrencyCount: true
   });
-  return anotherThrottle;
 }
 async function cleanBuildAndNotify(importerMeta, finalConfig, destinationPath, buildCfg, bunServer, event) {
-  if (finalConfig.cleanServePath) {
-    await cleanDirectory(destinationPath);
-  }
   const buildEnv = {
     importerMeta,
     finalConfig,
@@ -1779,6 +1757,12 @@ async function cleanBuildAndNotify(importerMeta, finalConfig, destinationPath, b
   };
   await finalConfig.beforeBuild?.(buildEnv);
   try {
+    if (buildCfg.outdir) {
+      const outdirExists = await checkObjectExists(buildCfg.outdir);
+      if (!outdirExists) {
+        return;
+      }
+    }
     const output = await build(buildCfg);
     publishOutputLogs(bunServer, output, finalConfig, event);
     if (finalConfig.createIndexHTML) {
@@ -1799,17 +1783,19 @@ async function cleanBuildAndNotify(importerMeta, finalConfig, destinationPath, b
       bunServer.publish("message", JSON.stringify({ type: "tscerror", message: tscSuccess.message }));
     }
   } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : String(e);
+    if (errorMessage.includes("test-file-watcher") || errorMessage.includes("test-build") || errorMessage.includes("test-watch-dir")) {
+      return;
+    }
     console.error(e);
   }
 }
-function handleErrorResponse(req, err) {
-  const msg = `Error while processing request ${req.url}`;
-  console.error(msg, err);
-  return withCORSHeaders(new Response(msg, { status: 500 }), req);
-}
 function publishOutputLogs(bunServer, output, config, event) {
   output.logs.forEach(console.log);
-  bunServer.publish("message", JSON.stringify({ type: "message", message: `[Bun HMR] ${event.filename} ${event.eventType}` }));
+  bunServer.publish("message", JSON.stringify({
+    type: "message",
+    message: `[Bun HMR] ${event.filename} ${event.eventType}`
+  }));
   const outTable = output.outputs.filter((o) => o.kind !== "sourcemap").map((o) => {
     const a = Bun.pathToFileURL(o.path);
     const distPath = Bun.pathToFileURL(config.buildConfig.outdir ?? "./dist");
@@ -1824,7 +1810,7 @@ function publishOutputLogs(bunServer, output, config, event) {
     };
   });
   if (config.broadcastBuildOutputToConsole) {
-    console.table(outTable);
+    printPrettyBuildOutput(outTable);
   }
   if (config.broadcastBuildOutputToClient) {
     bunServer.publish("message", JSON.stringify({ type: "output", message: outTable }));
@@ -1833,114 +1819,348 @@ function publishOutputLogs(bunServer, output, config, event) {
 function publishIndexHTML(destinationPath, template, output, _event) {
   const eps = output.outputs.filter((o) => o.kind === "entry-point");
   const hashedImports = [];
+  const cssFiles = [];
+  const basePathUrl = Bun.pathToFileURL(destinationPath);
   for (const ep of eps) {
-    const basePathUrl = Bun.pathToFileURL(destinationPath);
     const epUrl = Bun.pathToFileURL(ep.path);
     const hashedImport = `${epUrl.href.replace(basePathUrl.href, "")}?${ep.hash}`;
     hashedImports.push(hashedImport);
   }
-  Bun.write(destinationPath + "/index.html", import_ejs.render(template, { hashedImports }));
+  const cssOutputs = output.outputs.filter((o) => o.path.endsWith(".css"));
+  for (const cssFile of cssOutputs) {
+    const cssUrl = Bun.pathToFileURL(cssFile.path);
+    const hashedCss = `${cssUrl.href.replace(basePathUrl.href, "")}?${cssFile.hash}`;
+    cssFiles.push(hashedCss);
+  }
+  Bun.write(destinationPath + "/index.html", import_ejs2.render(template, { hashedImports, cssFiles }));
 }
-function withCORSHeaders(response, request) {
-  response.headers.set("Access-Control-Allow-Origin", request?.headers.get("origin") ?? "*");
-  response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
-  response.headers.set("Access-Control-Allow-Credentials", "true");
-  response.headers.set("Cache-Control", "no-store, no-cache, must-revalidate");
-  return response;
+function printPrettyBuildOutput(outTable) {
+  if (outTable.length === 0)
+    return;
+  const totalFiles = outTable.length;
+  const fileWord = totalFiles === 1 ? "file" : "files";
+  console.log(`
+` + import_picocolors2.default.bold(import_picocolors2.default.cyan(`\uD83D\uDCE6 Build Output (${totalFiles} ${fileWord})`)));
+  outTable.forEach((row) => {
+    const checkmark = import_picocolors2.default.green("  \u2713");
+    const filePath = import_picocolors2.default.white(row.path);
+    const size = import_picocolors2.default.dim(`(${row.size})`);
+    console.log(`${checkmark} ${filePath} ${size}`);
+  });
+  console.log("");
 }
-async function cleanDirectory(dst) {
-  const { stderr, exitCode } = await $2`rm -rf ${dst}/*`.nothrow();
-  if (exitCode !== 0) {
-    if (stderr.indexOf("no matches found") > -1) {
-      console.log("Directory is empty");
-    } else {
-      console.warn("Unable to clean directory", stderr.toString("utf8"));
+
+// src/fileWatcher.ts
+async function startFileWatcher(srcWatch, importMeta, finalConfig, destinationPath, buildCfg, bunServer) {
+  const queue = getThrottledBuildQueue(finalConfig);
+  await queue.add(async () => {
+    await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
+  });
+  const watcher = watch(srcWatch, { recursive: true });
+  try {
+    for await (const event of watcher) {
+      if (queue.pending > 0) {
+        continue;
+      }
+      try {
+        if (queue.size > 0) {
+          queue.clear();
+        }
+        queue.add(async () => {
+          await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, event);
+        });
+      } catch (e) {
+        console.error("Error while processing file change", e);
+      }
+    }
+  } catch (e) {
+    if (e?.code !== "EPERM") {
+      console.error("Error in file watcher", e);
     }
   }
 }
-function convertBytes(bytes) {
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
-  if (bytes == 0) {
-    return "n/a";
+
+// src/configManager.ts
+var {$: $3 } = globalThis.Bun;
+import { readdir as readdir2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+
+// src/templates/output.ejs
+var output_default = "./assets/output.ejs";
+
+// src/templates/index.ejs
+var templates_default = "./assets/index.ejs";
+
+// src/bunClientHmr.ts
+function hotReload() {
+  if (!window.BUN_DEV_SERVER) {
+    window.BUN_DEV_SERVER = [];
   }
-  const floored = Math.floor(Math.log(bytes) / Math.log(1024));
-  const i = floored;
-  if (i == 0) {
-    return bytes + " " + sizes[i];
+  const devServer = "[Bun Dev Server]";
+  const connectAddress = "[REPLACE_ENDPOINT]";
+  let foundServer = window.BUN_DEV_SERVER.find((server) => server.url === connectAddress);
+  if (!foundServer) {
+    foundServer = { url: connectAddress, socket: null };
   }
-  return (bytes / Math.pow(1024, i)).toFixed(1) + " " + sizes[i];
-}
-async function handlePathRequest(requestPath, req, finalConfig, destinationPath) {
-  let fsPath = destinationPath + requestPath;
-  const objThere = await checkObjectExists(fsPath, req);
-  let isDirectory = false;
-  if (objThere) {
+  if (foundServer.socket) {
+    return;
+  }
+  console.log(devServer, "Connecting to Bun Dev Server at", connectAddress);
+  foundServer.socket = new WebSocket(connectAddress);
+  window.BUN_DEV_SERVER.push(foundServer);
+  function errorHandler(err) {
+    console.error(devServer, "ERROR", err);
+  }
+  function messageHandler(msg) {
+    let parsed = msg.data;
     try {
-      await readFile2(fsPath);
+      parsed = JSON.parse(msg.data);
     } catch (e) {
-      if (e.code === "EISDIR") {
-        isDirectory = true;
-      } else {
-        throw e;
+    }
+    if (parsed?.type === "message") {
+      console.log(devServer, parsed.message);
+      return;
+    }
+    if (parsed?.type === "output") {
+      console.table(devServer, parsed.message);
+      return;
+    }
+    if (parsed?.type === "reload") {
+      window.location.reload();
+      return;
+    }
+    if (parsed?.type === "tscerror") {
+      console.error(parsed.message);
+      return;
+    }
+    if (parsed?.type === "error") {
+      console.error(parsed.message);
+      let newDiv = window.document.getElementById("bun-hmr-error");
+      const divExists = !!newDiv;
+      if (!newDiv) {
+        newDiv = window.document.createElement("div");
+      }
+      newDiv.id = "bun-hmr-error";
+      newDiv.innerText += parsed.message;
+      if (!divExists) {
+        window.document.body.appendChild(newDiv);
       }
+      return;
     }
-  } else {
-    if (requestPath.toLowerCase() !== "/index.html") {
-      finalConfig.logRequests && console.log(`${404} ${req.url}`);
-      return withCORSHeaders(new Response("", { status: 404 }), req);
+  }
+  function closeHandler(ev) {
+    console.warn(devServer, "Connection closed. Will retry in 5 seconds...");
+    foundServer.socket?.removeEventListener("error", errorHandler);
+    foundServer.socket?.removeEventListener("message", messageHandler);
+    foundServer.socket?.removeEventListener("open", messageHandler);
+    foundServer.socket?.removeEventListener("close", closeHandler);
+    foundServer.socket = null;
+    setTimeout(function() {
+      console.log(devServer, "Attempting to reconnect...");
+      hotReload();
+    }, 5000);
+  }
+  function openHandler(ev) {
+    console.log(devServer, "Connected to Bun Dev Server");
+  }
+  foundServer.socket.addEventListener("error", errorHandler);
+  foundServer.socket.addEventListener("message", messageHandler);
+  foundServer.socket.addEventListener("close", closeHandler);
+  foundServer.socket.addEventListener("open", openHandler);
+}
+var DEFAULT_HMR_PATH = "/hmr-ws";
+function bunHotReload(bunServerConfig) {
+  const socketPath = bunServerConfig.websocketPath || DEFAULT_HMR_PATH;
+  const endPath = socketPath.startsWith("/") ? socketPath : `/${socketPath}`;
+  const path = `${bunServerConfig.secure ? "wss" : "ws"}://localhost:${bunServerConfig.port}${endPath}`;
+  return hotReload.toString().replace("[REPLACE_ENDPOINT]", path);
+}
+
+// src/bunHmrPlugin.ts
+import { readFile as readFile2 } from "fs/promises";
+function bunHotReloadPlugin(config) {
+  const bunHMRPlugin = {
+    name: "hmr",
+    target: "browser",
+    setup(build2) {
+      const entryPoints = [];
+      const addedEnryPoints = new Set;
+      build2.config.entrypoints.forEach((entry) => {
+        let entryPath = entry.replace(/^\.*/, "");
+        if (process.platform === "win32") {
+          entryPath = entryPath.replace(/\//g, "\\");
+        }
+        entryPoints.push(entryPath);
+      });
+      build2.onLoad({ filter: /\.m?(t|j)sx?/ }, async (args) => {
+        const contents = await readFile2(args.path, { encoding: "utf-8" });
+        const isTSx = /\.m?tsx$/.test(args.path);
+        const isJSx = /\.m?jsx$/.test(args.path);
+        const isJS = /\.m?js$/.test(args.path);
+        const isTS = /\.m?ts$/.test(args.path);
+        const loader = isTSx ? "tsx" : isJSx ? "jsx" : isTS ? "ts" : isJS ? "js" : "text";
+        const isEntry = entryPoints.some((entry) => args.path.endsWith(entry));
+        if (!addedEnryPoints.has(args.path) && isEntry) {
+          addedEnryPoints.add(args.path);
+          return { contents: `import "bun-hot-reload"
+` + contents, loader };
+        }
+        return { contents, loader };
+      });
+      build2.onLoad({ filter: /./, namespace: "bun-hot-reload" }, async (args) => {
+        return { contents: `(${bunHotReload(config)})()
+`, loader: "ts" };
+      });
+      build2.onResolve({ filter: /^bun-hot-reload$/ }, (args) => {
+        return { path: args.path, namespace: "bun-hot-reload" };
+      });
     }
-    requestPath = "/";
-    isDirectory = true;
-    fsPath = destinationPath + requestPath;
+  };
+  return bunHMRPlugin;
+}
+function getBunHMRFooter(config) {
+  return `;(${bunHotReload(config)})();`;
+}
+
+// src/configManager.ts
+var serveTemplate = await Bun.file(Bun.fileURLToPath(import.meta.resolve(output_default))).text();
+var indexTemplate = await Bun.file(Bun.fileURLToPath(import.meta.resolve(templates_default))).text();
+async function prepareConfiguration(serverConfig, importMeta) {
+  const defaultConfig = {
+    port: 3000,
+    websocketPath: DEFAULT_HMR_PATH,
+    serveOutputEjs: serveTemplate,
+    serveIndexHtmlEjs: indexTemplate,
+    createIndexHTML: true,
+    tscConfigPath: resolve2(importMeta.dir, "./tsconfig.json"),
+    broadcastBuildOutputToConsole: true,
+    broadcastBuildOutputToClient: true
+  };
+  const finalConfig = { ...defaultConfig, ...serverConfig };
+  if (serverConfig.tscConfigPath) {
+    finalConfig.tscConfigPath = resolve2(importMeta.dir, serverConfig.tscConfigPath);
   }
-  if (!isDirectory) {
-    try {
-      const fl = Bun.file(fsPath);
-      finalConfig.logRequests && console.log(`${200} ${req.url}`);
-      return withCORSHeaders(new Response(fl), req);
-    } catch (e) {
-      if (e?.code === "ENOENT") {
-        finalConfig.logRequests && console.log(`${404} ${req.url}`);
-        return withCORSHeaders(new Response("", { status: 404 }), req);
-      } else {
-        return handleErrorResponse(req, e);
-      }
+  if (!finalConfig.watchDir) {
+    throw new Error("watchDir must be set");
+  }
+  const servePart = finalConfig.buildConfig.outdir ?? finalConfig.servePath ?? "./dist";
+  const serveDestination = resolve2(importMeta.dir, servePart);
+  const watchDestination = resolve2(importMeta.dir, finalConfig.watchDir);
+  const allEntries = serverConfig.buildConfig.entrypoints.splice(0, serverConfig.buildConfig.entrypoints.length);
+  const resolvedEntries = allEntries.map((e) => resolve2(importMeta.dir, e));
+  serverConfig.buildConfig.entrypoints = resolvedEntries;
+  const destinationPath = serveDestination;
+  const srcWatch = watchDestination;
+  await ensureDestinationDirectory(destinationPath);
+  const buncfg = {
+    port: finalConfig.port,
+    tls: finalConfig.tls,
+    websocketPath: finalConfig.websocketPath,
+    secure: finalConfig.tls !== undefined
+  };
+  const buildCfg = {
+    ...serverConfig.buildConfig,
+    outdir: destinationPath
+  };
+  if (finalConfig.hotReload === "footer") {
+    if (!buildCfg.footer) {
+      buildCfg.footer = "";
     }
+    buildCfg.footer += getBunHMRFooter(buncfg);
   }
-  try {
-    const allEntries = await readdir(fsPath, {
-      withFileTypes: true
-    });
-    const dirs = allEntries.filter((entry) => entry.isDirectory()).map((entry) => {
-      return {
-        requestPath: requestPath === "/" ? "" : requestPath,
-        name: entry.name
-      };
-    });
-    const files = allEntries.filter((entry) => entry.isFile()).map((entry) => {
-      return {
-        requestPath: requestPath === "/" ? "" : requestPath,
-        name: entry.name
-      };
-    });
-    const rnd = import_ejs.render(finalConfig.serveOutputEjs, { dirs, files });
-    finalConfig.logRequests && console.log(`${200} ${req.url}`);
-    return withCORSHeaders(new Response(rnd, { headers: { "Content-Type": "text/html" } }), req);
-  } catch (err) {
-    return handleErrorResponse(req, err);
+  if (finalConfig.hotReload === "plugin") {
+    if (!buildCfg.plugins) {
+      buildCfg.plugins = [];
+    }
+    buildCfg.plugins.push(bunHotReloadPlugin(buncfg));
   }
+  const userBeforeBuild = finalConfig.beforeBuild;
+  finalConfig.beforeBuild = async (env) => {
+    if (serverConfig.cleanServePath) {
+      await cleanDirectory(env.destinationPath);
+    }
+    await userBeforeBuild?.(env);
+  };
+  return {
+    finalConfig,
+    destinationPath,
+    srcWatch,
+    buildCfg
+  };
 }
-async function checkObjectExists(fsPath, req) {
+async function ensureDestinationDirectory(destinationPath) {
   try {
-    await access(fsPath, constants.R_OK);
-    return true;
+    await readdir2(destinationPath);
   } catch (e) {
-    if (e?.code === "ENOENT") {
-      return false;
+    if (e.code === "ENOENT") {
+      console.log("Directory not found, creating it...");
+      try {
+        await $3`mkdir ${destinationPath}`;
+      } catch (e2) {
+        console.error("Unable to create directory", e2);
+      }
+    } else {
+      throw e;
     }
-    const msg = `Error while accessing path ${fsPath}`;
-    console.error(msg, e);
-    return false;
+  }
+}
+
+// src/server.ts
+async function startBunDevServer(serverConfig, importMeta) {
+  const { finalConfig, destinationPath, srcWatch, buildCfg } = await prepareConfiguration(serverConfig, importMeta);
+  const protocol = finalConfig.tls ? "https" : "http";
+  const serverUrl = `${protocol}://localhost:${finalConfig.port}`;
+  const isTestMode = process.env.BUN_TEST === "true" || typeof Bun !== "undefined" && Bun.main.includes("test");
+  if (!isTestMode) {
+    console.log(import_picocolors3.default.bold(import_picocolors3.default.green("\uD83D\uDE80 Server running at")) + " " + import_picocolors3.default.cyan(import_picocolors3.default.underline(serverUrl)));
+  }
+  let bunServer;
+  try {
+    bunServer = Bun.serve({
+      port: finalConfig.port,
+      development: {
+        console: true,
+        hmr: true,
+        chromeDevToolsAutomaticWorkspaceFolders: true
+      },
+      tls: finalConfig.tls,
+      routes: {
+        "/favicon.ico": withCORSHeaders(new Response("", { status: 404 })),
+        ...finalConfig.routes,
+        ...staticAssetRoutes
+      },
+      async fetch(req, server) {
+        if (req.method === "OPTIONS") {
+          finalConfig.logRequests && console.log(`${200} ${req.url} OPTIONS`);
+          return withCORSHeaders(new Response("", { status: 200 }), req);
+        }
+        if (req.url.toLowerCase().endsWith(finalConfig.websocketPath)) {
+          finalConfig.logRequests && console.log(`${req.url} Socket Upgrade`);
+          if (server.upgrade(req)) {
+            return withCORSHeaders(new Response("", { status: 200 }), req);
+          }
+        }
+        const url = new URL(req.url);
+        let requestPath = url.pathname;
+        return handlePathRequest(requestPath, req, finalConfig, destinationPath);
+      },
+      websocket: {
+        open(ws) {
+          ws.subscribe("message");
+        },
+        message(ws, message) {
+        },
+        sendPings: true
+      }
+    });
+  } catch (error) {
+    if (isTestMode) {
+      return;
+    }
+    throw error;
+  }
+  if (bunServer) {
+    await startFileWatcher(srcWatch, importMeta, finalConfig, destinationPath, buildCfg, bunServer);
   }
 }
 export {