bun-dev-server 1.0.0 → 1.0.2

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,222 +1026,182 @@ 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";
+import { mkdir } from "fs/promises";
+async function ensureDestinationDirectory(destinationPath) {
+  try {
+    await mkdir(destinationPath, { recursive: true });
+  } catch (e) {
+    console.error("Unable to create directory", e);
+    throw e;
   }
-  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 };
+}
+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"));
+    }
   }
-  if (foundServer.socket) {
-    return;
+}
+function convertBytes(bytes) {
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  if (bytes == 0) {
+    return "n/a";
   }
-  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);
+  const floored = Math.floor(Math.log(bytes) / Math.log(1024));
+  const i = floored;
+  if (i == 0) {
+    return bytes + " " + sizes[i];
   }
-  function messageHandler(msg) {
-    let parsed = msg.data;
+  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;
+  }
+}
+
+// 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 (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;
+  } else {
+    if (requestPath.toLowerCase() !== "/index.html") {
+      finalConfig.logRequests && console.log(`${404} ${req.url}`);
+      return withCORSHeaders(new Response("", { status: 404 }), req);
     }
-    if (parsed?.type === "tscerror") {
-      console.error(parsed.message);
-      return;
+    requestPath = "/";
+    isDirectory = true;
+    fsPath = destinationPath + requestPath;
+  }
+  if (!isDirectory) {
+    return handleFileRequest(fsPath, req, finalConfig);
+  }
+  return handleDirectoryRequest(fsPath, requestPath, req, finalConfig);
+}
+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);
     }
-    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;
-    }
-  }
-  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);
+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 {
+        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);
+  }
 }
 
-// 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" };
-      });
-    }
-  };
-  return bunHMRPlugin;
-}
-function getBunHMRFooter(config) {
-  return `;(${bunHotReload(config)})();`;
-}
+// src/staticAssets.ts
+import { resolve } from "path";
 
-// 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/static/serveOutputStyles.css
+var serveOutputStyles_default = "./assets/serveOutputStyles.css";
 
-// src/tsChecker.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
-var {$ } = globalThis.Bun;
-var success = {
-  error: false,
-  message: ""
+// 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))
 };
-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}`);
-      return {
-        error: true,
-        message: errOutput
-      };
-    }
-  }
-  return success;
-}
+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);
@@ -1265,7 +1225,7 @@ function pTimeout(promise, options) {
   } = 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}\``);
     }
@@ -1279,7 +1239,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve, reject);
+    promise.then(resolve2, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -1287,7 +1247,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(undefined, () => {
       if (fallback) {
         try {
-          resolve(fallback());
+          resolve2(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1297,7 +1257,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve();
+        resolve2();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1545,13 +1505,6 @@ class PQueue extends import__.default {
     this.#concurrency = newConcurrency;
     this.#processQueue();
   }
-  async#throwOnAbort(signal) {
-    return new Promise((_resolve, reject) => {
-      signal.addEventListener("abort", () => {
-        reject(signal.reason);
-      }, { once: true });
-    });
-  }
   setPriority(id, priority) {
     if (typeof priority !== "number" || !Number.isFinite(priority)) {
       throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
@@ -1564,7 +1517,7 @@ class PQueue extends import__.default {
       timeout: this.timeout,
       ...options
     };
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const taskSymbol = Symbol(`task-${options.id}`);
       this.#queue.enqueue(async () => {
         this.#pending++;
@@ -1574,6 +1527,7 @@ class PQueue extends import__.default {
           startTime: Date.now(),
           timeout: options.timeout
         });
+        let eventListener;
         try {
           try {
             options.signal?.throwIfAborted();
@@ -1592,15 +1546,24 @@ class PQueue extends import__.default {
             });
           }
           if (options.signal) {
-            operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
+            const { signal } = options;
+            operation = Promise.race([operation, new Promise((_resolve, reject2) => {
+              eventListener = () => {
+                reject2(signal.reason);
+              };
+              signal.addEventListener("abort", eventListener, { once: true });
+            })]);
           }
           const result = await operation;
-          resolve(result);
+          resolve2(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
           this.emit("error", error);
         } finally {
+          if (eventListener) {
+            options.signal?.removeEventListener("abort", eventListener);
+          }
           this.#runningTasks.delete(taskSymbol);
           queueMicrotask(() => {
             this.#next();
@@ -1675,13 +1638,13 @@ class PQueue extends import__.default {
     });
   }
   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);
     });
@@ -1740,151 +1703,80 @@ class PQueue extends import__.default {
   }
 }
 
-// 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);
-      }
+// 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 {
-      throw e;
-    }
-  }
-  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);
-  }
-  if (finalConfig.hotReload === "plugin") {
-    if (!buildCfg.plugins) {
-      buildCfg.plugins = [];
+      const errOutput = tsc.stdout.toString();
+      console.log(import_picocolors.default.bgRed("\u2718 [ERROR]"), `\r
+${errOutput}`);
+      return {
+        error: true,
+        message: errOutput
+      };
     }
-    buildCfg.plugins.push(bunHotReloadPlugin(buncfg));
   }
-  if (serverConfig.cleanServePath) {
-    await cleanDirectory(destinationPath);
-  }
-  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);
-    }
+  return success;
+}
+
+// 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));
 }
-function getThrottledBuildAndNotify(serverConfig) {
-  const anotherThrottle = new PQueue({
+
+// 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);
-  }
+async function cleanBuildAndNotify(importerMeta, finalConfig, paths, buildCfg, bunServer, event) {
   const buildEnv = {
     importerMeta,
     finalConfig,
-    destinationPath,
+    ...paths,
     buildCfg,
     bunServer,
     event
   };
   await finalConfig.beforeBuild?.(buildEnv);
   try {
+    await ensureDestinationDirectory(paths.buildDestination);
     const output = await build(buildCfg);
     publishOutputLogs(bunServer, output, finalConfig, event);
     if (finalConfig.createIndexHTML) {
-      publishIndexHTML(destinationPath, finalConfig.serveIndexHtmlEjs, output, event);
+      publishIndexHTML(paths, finalConfig.serveIndexHtmlEjs, output, event);
     }
     if (finalConfig.writeManifest) {
-      writeManifest(output, destinationPath, finalConfig.manifestWithHash, finalConfig.manifestName);
+      writeManifest(output, paths.serveDestination, finalConfig.manifestWithHash, finalConfig.manifestName);
     }
     await finalConfig.afterBuild?.(output, buildEnv);
     if (finalConfig.reloadOnChange && !finalConfig.waitForTSCSuccessBeforeReload) {
@@ -1898,17 +1790,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");
@@ -1923,123 +1817,348 @@ 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 }));
   }
 }
-function publishIndexHTML(destinationPath, template, output, _event) {
+function publishIndexHTML(paths, template, output, _event) {
   const eps = output.outputs.filter((o) => o.kind === "entry-point");
   const hashedImports = [];
+  const cssFiles = [];
+  const basePathUrl = Bun.pathToFileURL(paths.serveDestination);
   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}`;
+    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(paths.buildDestination + "/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, paths, buildCfg, bunServer) {
+  const queue = getThrottledBuildQueue(finalConfig);
+  await queue.add(async () => {
+    await cleanBuildAndNotify(importMeta, finalConfig, paths, 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, paths, 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
+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 defaultBuildDir = finalConfig.buildConfig.outdir ?? "./dist";
+  const servePart = finalConfig.servePath ?? defaultBuildDir;
+  const serveDestination = resolve2(importMeta.dir, servePart);
+  const watchDestination = resolve2(importMeta.dir, finalConfig.watchDir);
+  const buildDestination = resolve2(importMeta.dir, defaultBuildDir);
+  const allEntries = serverConfig.buildConfig.entrypoints.splice(0, serverConfig.buildConfig.entrypoints.length);
+  const resolvedEntries = allEntries.map((e) => resolve2(importMeta.dir, e));
+  serverConfig.buildConfig.entrypoints = resolvedEntries;
+  await ensureDestinationDirectory(buildDestination);
+  await ensureDestinationDirectory(serveDestination);
+  const buncfg = {
+    port: finalConfig.port,
+    tls: finalConfig.tls,
+    websocketPath: finalConfig.websocketPath,
+    secure: finalConfig.tls !== undefined
+  };
+  const buildCfg = {
+    ...serverConfig.buildConfig,
+    outdir: buildDestination
+  };
+  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) => {
+    const buildDirOverOfServe = serveDestination.indexOf(buildDestination) !== -1;
+    const serveDirOverOfBuild = buildDestination.indexOf(serveDestination) !== -1;
+    if (serverConfig.cleanBuildPath && buildDirOverOfServe) {
+      await cleanDirectory(env.buildDestination);
+    }
+    if (serverConfig.cleanServePath && serveDirOverOfBuild) {
+      await cleanDirectory(env.serveDestination);
+    }
+    await userBeforeBuild?.(env);
+  };
+  return {
+    finalConfig,
+    serveDestination,
+    buildDestination,
+    watchDestination,
+    buildCfg
+  };
 }
-async function checkObjectExists(fsPath, req) {
+
+// src/server.ts
+async function startBunDevServer(serverConfig, importMeta) {
+  const { finalConfig, buildCfg, ...paths } = 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)));
+    console.log(import_picocolors3.default.bold(import_picocolors3.default.green("\uD83D\uDCC1 Serving files from")) + " " + import_picocolors3.default.cyan(import_picocolors3.default.underline(paths.serveDestination)));
+  }
+  await ensureDestinationDirectory(paths.serveDestination);
+  let bunServer;
   try {
-    await access(fsPath, constants.R_OK);
-    return true;
-  } catch (e) {
-    if (e?.code === "ENOENT") {
-      return false;
+    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, paths.serveDestination);
+      },
+      websocket: {
+        open(ws) {
+          ws.subscribe("message");
+        },
+        message(ws, message) {
+        },
+        sendPings: true
+      }
+    });
+  } catch (error) {
+    if (isTestMode) {
+      return;
     }
-    const msg = `Error while accessing path ${fsPath}`;
-    console.error(msg, e);
-    return false;
+    throw error;
+  }
+  if (bunServer) {
+    await startFileWatcher(paths.watchDestination, importMeta, finalConfig, paths, buildCfg, bunServer);
   }
 }
 export {