bun-dev-server 1.0.1 → 1.0.3

package/dist/index.js

@@ -4,18 +4,45 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 
 // node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
@@ -87,771 +114,11 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
-// node_modules/ejs/lib/utils.js
-var require_utils = __commonJS((exports) => {
-  var regExpChars = /[|\\{}()[\]^$+*?.]/g;
-  var hasOwnProperty = Object.prototype.hasOwnProperty;
-  var hasOwn = function(obj, key) {
-    return hasOwnProperty.apply(obj, [key]);
-  };
-  exports.escapeRegExpChars = function(string) {
-    if (!string) {
-      return "";
-    }
-    return String(string).replace(regExpChars, "\\$&");
-  };
-  var _ENCODE_HTML_RULES = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&#34;",
-    "'": "&#39;"
-  };
-  var _MATCH_HTML = /[&<>'"]/g;
-  function encode_char(c) {
-    return _ENCODE_HTML_RULES[c] || c;
-  }
-  var escapeFuncStr = `var _ENCODE_HTML_RULES = {
-` + `      "&": "&amp;"
-` + `    , "<": "&lt;"
-` + `    , ">": "&gt;"
-` + `    , '"': "&#34;"
-` + `    , "'": "&#39;"
-` + `    }
-` + `  , _MATCH_HTML = /[&<>'"]/g;
-` + `function encode_char(c) {
-` + `  return _ENCODE_HTML_RULES[c] || c;
-` + `};
-`;
-  exports.escapeXML = function(markup) {
-    return markup == undefined ? "" : String(markup).replace(_MATCH_HTML, encode_char);
-  };
-  function escapeXMLToString() {
-    return Function.prototype.toString.call(this) + `;
-` + escapeFuncStr;
-  }
-  try {
-    if (typeof Object.defineProperty === "function") {
-      Object.defineProperty(exports.escapeXML, "toString", { value: escapeXMLToString });
-    } else {
-      exports.escapeXML.toString = escapeXMLToString;
-    }
-  } catch (err) {
-    console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
-  }
-  exports.shallowCopy = function(to, from) {
-    from = from || {};
-    if (to !== null && to !== undefined) {
-      for (var p in from) {
-        if (!hasOwn(from, p)) {
-          continue;
-        }
-        if (p === "__proto__" || p === "constructor") {
-          continue;
-        }
-        to[p] = from[p];
-      }
-    }
-    return to;
-  };
-  exports.shallowCopyFromList = function(to, from, list) {
-    list = list || [];
-    from = from || {};
-    if (to !== null && to !== undefined) {
-      for (var i = 0;i < list.length; i++) {
-        var p = list[i];
-        if (typeof from[p] != "undefined") {
-          if (!hasOwn(from, p)) {
-            continue;
-          }
-          if (p === "__proto__" || p === "constructor") {
-            continue;
-          }
-          to[p] = from[p];
-        }
-      }
-    }
-    return to;
-  };
-  exports.cache = {
-    _data: {},
-    set: function(key, val) {
-      this._data[key] = val;
-    },
-    get: function(key) {
-      return this._data[key];
-    },
-    remove: function(key) {
-      delete this._data[key];
-    },
-    reset: function() {
-      this._data = {};
-    }
-  };
-  exports.hyphenToCamel = function(str) {
-    return str.replace(/-[a-z]/g, function(match) {
-      return match[1].toUpperCase();
-    });
-  };
-  exports.createNullProtoObjWherePossible = function() {
-    if (typeof Object.create == "function") {
-      return function() {
-        return Object.create(null);
-      };
-    }
-    if (!({ __proto__: null } instanceof Object)) {
-      return function() {
-        return { __proto__: null };
-      };
-    }
-    return function() {
-      return {};
-    };
-  }();
-  exports.hasOwnOnlyObject = function(obj) {
-    var o = exports.createNullProtoObjWherePossible();
-    for (var p in obj) {
-      if (hasOwn(obj, p)) {
-        o[p] = obj[p];
-      }
-    }
-    return o;
-  };
-});
-
-// node_modules/ejs/package.json
-var require_package = __commonJS((exports, module) => {
-  module.exports = {
-    name: "ejs",
-    description: "Embedded JavaScript templates",
-    keywords: [
-      "template",
-      "engine",
-      "ejs"
-    ],
-    version: "3.1.10",
-    author: "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)",
-    license: "Apache-2.0",
-    bin: {
-      ejs: "./bin/cli.js"
-    },
-    main: "./lib/ejs.js",
-    jsdelivr: "ejs.min.js",
-    unpkg: "ejs.min.js",
-    repository: {
-      type: "git",
-      url: "git://github.com/mde/ejs.git"
-    },
-    bugs: "https://github.com/mde/ejs/issues",
-    homepage: "https://github.com/mde/ejs",
-    dependencies: {
-      jake: "^10.8.5"
-    },
-    devDependencies: {
-      browserify: "^16.5.1",
-      eslint: "^6.8.0",
-      "git-directory-deploy": "^1.5.1",
-      jsdoc: "^4.0.2",
-      "lru-cache": "^4.0.1",
-      mocha: "^10.2.0",
-      "uglify-js": "^3.3.16"
-    },
-    engines: {
-      node: ">=0.10.0"
-    },
-    scripts: {
-      test: "npx jake test"
-    }
-  };
-});
-
-// node_modules/ejs/lib/ejs.js
-var require_ejs = __commonJS((exports) => {
-  var fs = import.meta.require("fs");
-  var path = import.meta.require("path");
-  var utils = require_utils();
-  var scopeOptionWarned = false;
-  var _VERSION_STRING = require_package().version;
-  var _DEFAULT_OPEN_DELIMITER = "<";
-  var _DEFAULT_CLOSE_DELIMITER = ">";
-  var _DEFAULT_DELIMITER = "%";
-  var _DEFAULT_LOCALS_NAME = "locals";
-  var _NAME = "ejs";
-  var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
-  var _OPTS_PASSABLE_WITH_DATA = [
-    "delimiter",
-    "scope",
-    "context",
-    "debug",
-    "compileDebug",
-    "client",
-    "_with",
-    "rmWhitespace",
-    "strict",
-    "filename",
-    "async"
-  ];
-  var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
-  var _BOM = /^\uFEFF/;
-  var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-  exports.cache = utils.cache;
-  exports.fileLoader = fs.readFileSync;
-  exports.localsName = _DEFAULT_LOCALS_NAME;
-  exports.promiseImpl = new Function("return this;")().Promise;
-  exports.resolveInclude = function(name, filename, isDir) {
-    var dirname = path.dirname;
-    var extname = path.extname;
-    var resolve = path.resolve;
-    var includePath = resolve(isDir ? filename : dirname(filename), name);
-    var ext = extname(name);
-    if (!ext) {
-      includePath += ".ejs";
-    }
-    return includePath;
-  };
-  function resolvePaths(name, paths) {
-    var filePath;
-    if (paths.some(function(v) {
-      filePath = exports.resolveInclude(name, v, true);
-      return fs.existsSync(filePath);
-    })) {
-      return filePath;
-    }
-  }
-  function getIncludePath(path2, options) {
-    var includePath;
-    var filePath;
-    var views = options.views;
-    var match = /^[A-Za-z]+:\\|^\//.exec(path2);
-    if (match && match.length) {
-      path2 = path2.replace(/^\/*/, "");
-      if (Array.isArray(options.root)) {
-        includePath = resolvePaths(path2, options.root);
-      } else {
-        includePath = exports.resolveInclude(path2, options.root || "/", true);
-      }
-    } else {
-      if (options.filename) {
-        filePath = exports.resolveInclude(path2, options.filename);
-        if (fs.existsSync(filePath)) {
-          includePath = filePath;
-        }
-      }
-      if (!includePath && Array.isArray(views)) {
-        includePath = resolvePaths(path2, views);
-      }
-      if (!includePath && typeof options.includer !== "function") {
-        throw new Error('Could not find the include file "' + options.escapeFunction(path2) + '"');
-      }
-    }
-    return includePath;
-  }
-  function handleCache(options, template) {
-    var func;
-    var filename = options.filename;
-    var hasTemplate = arguments.length > 1;
-    if (options.cache) {
-      if (!filename) {
-        throw new Error("cache option requires a filename");
-      }
-      func = exports.cache.get(filename);
-      if (func) {
-        return func;
-      }
-      if (!hasTemplate) {
-        template = fileLoader(filename).toString().replace(_BOM, "");
-      }
-    } else if (!hasTemplate) {
-      if (!filename) {
-        throw new Error("Internal EJS error: no file name or template " + "provided");
-      }
-      template = fileLoader(filename).toString().replace(_BOM, "");
-    }
-    func = exports.compile(template, options);
-    if (options.cache) {
-      exports.cache.set(filename, func);
-    }
-    return func;
-  }
-  function tryHandleCache(options, data, cb) {
-    var result;
-    if (!cb) {
-      if (typeof exports.promiseImpl == "function") {
-        return new exports.promiseImpl(function(resolve, reject) {
-          try {
-            result = handleCache(options)(data);
-            resolve(result);
-          } catch (err) {
-            reject(err);
-          }
-        });
-      } else {
-        throw new Error("Please provide a callback function");
-      }
-    } else {
-      try {
-        result = handleCache(options)(data);
-      } catch (err) {
-        return cb(err);
-      }
-      cb(null, result);
-    }
-  }
-  function fileLoader(filePath) {
-    return exports.fileLoader(filePath);
-  }
-  function includeFile(path2, options) {
-    var opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);
-    opts.filename = getIncludePath(path2, opts);
-    if (typeof options.includer === "function") {
-      var includerResult = options.includer(path2, opts.filename);
-      if (includerResult) {
-        if (includerResult.filename) {
-          opts.filename = includerResult.filename;
-        }
-        if (includerResult.template) {
-          return handleCache(opts, includerResult.template);
-        }
-      }
-    }
-    return handleCache(opts);
-  }
-  function rethrow(err, str, flnm, lineno, esc) {
-    var lines = str.split(`
-`);
-    var start = Math.max(lineno - 3, 0);
-    var end = Math.min(lines.length, lineno + 3);
-    var filename = esc(flnm);
-    var context = lines.slice(start, end).map(function(line, i) {
-      var curr = i + start + 1;
-      return (curr == lineno ? " >> " : "    ") + curr + "| " + line;
-    }).join(`
-`);
-    err.path = filename;
-    err.message = (filename || "ejs") + ":" + lineno + `
-` + context + `
-
-` + err.message;
-    throw err;
-  }
-  function stripSemi(str) {
-    return str.replace(/;(\s*$)/, "$1");
-  }
-  exports.compile = function compile(template, opts) {
-    var templ;
-    if (opts && opts.scope) {
-      if (!scopeOptionWarned) {
-        console.warn("`scope` option is deprecated and will be removed in EJS 3");
-        scopeOptionWarned = true;
-      }
-      if (!opts.context) {
-        opts.context = opts.scope;
-      }
-      delete opts.scope;
-    }
-    templ = new Template(template, opts);
-    return templ.compile();
-  };
-  exports.render = function(template, d, o) {
-    var data = d || utils.createNullProtoObjWherePossible();
-    var opts = o || utils.createNullProtoObjWherePossible();
-    if (arguments.length == 2) {
-      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
-    }
-    return handleCache(opts, template)(data);
-  };
-  exports.renderFile = function() {
-    var args = Array.prototype.slice.call(arguments);
-    var filename = args.shift();
-    var cb;
-    var opts = { filename };
-    var data;
-    var viewOpts;
-    if (typeof arguments[arguments.length - 1] == "function") {
-      cb = args.pop();
-    }
-    if (args.length) {
-      data = args.shift();
-      if (args.length) {
-        utils.shallowCopy(opts, args.pop());
-      } else {
-        if (data.settings) {
-          if (data.settings.views) {
-            opts.views = data.settings.views;
-          }
-          if (data.settings["view cache"]) {
-            opts.cache = true;
-          }
-          viewOpts = data.settings["view options"];
-          if (viewOpts) {
-            utils.shallowCopy(opts, viewOpts);
-          }
-        }
-        utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
-      }
-      opts.filename = filename;
-    } else {
-      data = utils.createNullProtoObjWherePossible();
-    }
-    return tryHandleCache(opts, data, cb);
-  };
-  exports.Template = Template;
-  exports.clearCache = function() {
-    exports.cache.reset();
-  };
-  function Template(text, optsParam) {
-    var opts = utils.hasOwnOnlyObject(optsParam);
-    var options = utils.createNullProtoObjWherePossible();
-    this.templateText = text;
-    this.mode = null;
-    this.truncate = false;
-    this.currentLine = 1;
-    this.source = "";
-    options.client = opts.client || false;
-    options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;
-    options.compileDebug = opts.compileDebug !== false;
-    options.debug = !!opts.debug;
-    options.filename = opts.filename;
-    options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;
-    options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
-    options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
-    options.strict = opts.strict || false;
-    options.context = opts.context;
-    options.cache = opts.cache || false;
-    options.rmWhitespace = opts.rmWhitespace;
-    options.root = opts.root;
-    options.includer = opts.includer;
-    options.outputFunctionName = opts.outputFunctionName;
-    options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;
-    options.views = opts.views;
-    options.async = opts.async;
-    options.destructuredLocals = opts.destructuredLocals;
-    options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
-    if (options.strict) {
-      options._with = false;
-    } else {
-      options._with = typeof opts._with != "undefined" ? opts._with : true;
-    }
-    this.opts = options;
-    this.regex = this.createRegex();
-  }
-  Template.modes = {
-    EVAL: "eval",
-    ESCAPED: "escaped",
-    RAW: "raw",
-    COMMENT: "comment",
-    LITERAL: "literal"
-  };
-  Template.prototype = {
-    createRegex: function() {
-      var str = _REGEX_STRING;
-      var delim = utils.escapeRegExpChars(this.opts.delimiter);
-      var open = utils.escapeRegExpChars(this.opts.openDelimiter);
-      var close = utils.escapeRegExpChars(this.opts.closeDelimiter);
-      str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
-      return new RegExp(str);
-    },
-    compile: function() {
-      var src;
-      var fn;
-      var opts = this.opts;
-      var prepended = "";
-      var appended = "";
-      var escapeFn = opts.escapeFunction;
-      var ctor;
-      var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
-      if (!this.source) {
-        this.generateSource();
-        prepended += `  var __output = "";
-` + `  function __append(s) { if (s !== undefined && s !== null) __output += s }
-`;
-        if (opts.outputFunctionName) {
-          if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
-            throw new Error("outputFunctionName is not a valid JS identifier.");
-          }
-          prepended += "  var " + opts.outputFunctionName + " = __append;" + `
-`;
-        }
-        if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
-          throw new Error("localsName is not a valid JS identifier.");
-        }
-        if (opts.destructuredLocals && opts.destructuredLocals.length) {
-          var destructuring = "  var __locals = (" + opts.localsName + ` || {}),
-`;
-          for (var i = 0;i < opts.destructuredLocals.length; i++) {
-            var name = opts.destructuredLocals[i];
-            if (!_JS_IDENTIFIER.test(name)) {
-              throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
-            }
-            if (i > 0) {
-              destructuring += `,
-  `;
-            }
-            destructuring += name + " = __locals." + name;
-          }
-          prepended += destructuring + `;
-`;
-        }
-        if (opts._with !== false) {
-          prepended += "  with (" + opts.localsName + " || {}) {" + `
-`;
-          appended += "  }" + `
-`;
-        }
-        appended += "  return __output;" + `
-`;
-        this.source = prepended + this.source + appended;
-      }
-      if (opts.compileDebug) {
-        src = "var __line = 1" + `
-` + "  , __lines = " + JSON.stringify(this.templateText) + `
-` + "  , __filename = " + sanitizedFilename + ";" + `
-` + "try {" + `
-` + this.source + "} catch (e) {" + `
-` + "  rethrow(e, __lines, __filename, __line, escapeFn);" + `
-` + "}" + `
-`;
-      } else {
-        src = this.source;
-      }
-      if (opts.client) {
-        src = "escapeFn = escapeFn || " + escapeFn.toString() + ";" + `
-` + src;
-        if (opts.compileDebug) {
-          src = "rethrow = rethrow || " + rethrow.toString() + ";" + `
-` + src;
-        }
-      }
-      if (opts.strict) {
-        src = `"use strict";
-` + src;
-      }
-      if (opts.debug) {
-        console.log(src);
-      }
-      if (opts.compileDebug && opts.filename) {
-        src = src + `
-` + "//# sourceURL=" + sanitizedFilename + `
-`;
-      }
-      try {
-        if (opts.async) {
-          try {
-            ctor = new Function("return (async function(){}).constructor;")();
-          } catch (e) {
-            if (e instanceof SyntaxError) {
-              throw new Error("This environment does not support async/await");
-            } else {
-              throw e;
-            }
-          }
-        } else {
-          ctor = Function;
-        }
-        fn = new ctor(opts.localsName + ", escapeFn, include, rethrow", src);
-      } catch (e) {
-        if (e instanceof SyntaxError) {
-          if (opts.filename) {
-            e.message += " in " + opts.filename;
-          }
-          e.message += ` while compiling ejs
-
-`;
-          e.message += `If the above error is not helpful, you may want to try EJS-Lint:
-`;
-          e.message += "https://github.com/RyanZim/EJS-Lint";
-          if (!opts.async) {
-            e.message += `
-`;
-            e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
-          }
-        }
-        throw e;
-      }
-      var returnedFn = opts.client ? fn : function anonymous(data) {
-        var include = function(path2, includeData) {
-          var d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);
-          if (includeData) {
-            d = utils.shallowCopy(d, includeData);
-          }
-          return includeFile(path2, opts)(d);
-        };
-        return fn.apply(opts.context, [data || utils.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
-      };
-      if (opts.filename && typeof Object.defineProperty === "function") {
-        var filename = opts.filename;
-        var basename = path.basename(filename, path.extname(filename));
-        try {
-          Object.defineProperty(returnedFn, "name", {
-            value: basename,
-            writable: false,
-            enumerable: false,
-            configurable: true
-          });
-        } catch (e) {
-        }
-      }
-      return returnedFn;
-    },
-    generateSource: function() {
-      var opts = this.opts;
-      if (opts.rmWhitespace) {
-        this.templateText = this.templateText.replace(/[\r\n]+/g, `
-`).replace(/^\s+|\s+$/gm, "");
-      }
-      this.templateText = this.templateText.replace(/[ \t]*<%_/gm, "<%_").replace(/_%>[ \t]*/gm, "_%>");
-      var self = this;
-      var matches = this.parseTemplateText();
-      var d = this.opts.delimiter;
-      var o = this.opts.openDelimiter;
-      var c = this.opts.closeDelimiter;
-      if (matches && matches.length) {
-        matches.forEach(function(line, index) {
-          var closing;
-          if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
-            closing = matches[index + 2];
-            if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) {
-              throw new Error('Could not find matching close tag for "' + line + '".');
-            }
-          }
-          self.scanLine(line);
-        });
-      }
-    },
-    parseTemplateText: function() {
-      var str = this.templateText;
-      var pat = this.regex;
-      var result = pat.exec(str);
-      var arr = [];
-      var firstPos;
-      while (result) {
-        firstPos = result.index;
-        if (firstPos !== 0) {
-          arr.push(str.substring(0, firstPos));
-          str = str.slice(firstPos);
-        }
-        arr.push(result[0]);
-        str = str.slice(result[0].length);
-        result = pat.exec(str);
-      }
-      if (str) {
-        arr.push(str);
-      }
-      return arr;
-    },
-    _addOutput: function(line) {
-      if (this.truncate) {
-        line = line.replace(/^(?:\r\n|\r|\n)/, "");
-        this.truncate = false;
-      }
-      if (!line) {
-        return line;
-      }
-      line = line.replace(/\\/g, "\\\\");
-      line = line.replace(/\n/g, "\\n");
-      line = line.replace(/\r/g, "\\r");
-      line = line.replace(/"/g, "\\\"");
-      this.source += '    ; __append("' + line + '")' + `
-`;
-    },
-    scanLine: function(line) {
-      var self = this;
-      var d = this.opts.delimiter;
-      var o = this.opts.openDelimiter;
-      var c = this.opts.closeDelimiter;
-      var newLineCount = 0;
-      newLineCount = line.split(`
-`).length - 1;
-      switch (line) {
-        case o + d:
-        case o + d + "_":
-          this.mode = Template.modes.EVAL;
-          break;
-        case o + d + "=":
-          this.mode = Template.modes.ESCAPED;
-          break;
-        case o + d + "-":
-          this.mode = Template.modes.RAW;
-          break;
-        case o + d + "#":
-          this.mode = Template.modes.COMMENT;
-          break;
-        case o + d + d:
-          this.mode = Template.modes.LITERAL;
-          this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")' + `
-`;
-          break;
-        case d + d + c:
-          this.mode = Template.modes.LITERAL;
-          this.source += '    ; __append("' + line.replace(d + d + c, d + c) + '")' + `
-`;
-          break;
-        case d + c:
-        case "-" + d + c:
-        case "_" + d + c:
-          if (this.mode == Template.modes.LITERAL) {
-            this._addOutput(line);
-          }
-          this.mode = null;
-          this.truncate = line.indexOf("-") === 0 || line.indexOf("_") === 0;
-          break;
-        default:
-          if (this.mode) {
-            switch (this.mode) {
-              case Template.modes.EVAL:
-              case Template.modes.ESCAPED:
-              case Template.modes.RAW:
-                if (line.lastIndexOf("//") > line.lastIndexOf(`
-`)) {
-                  line += `
-`;
-                }
-            }
-            switch (this.mode) {
-              case Template.modes.EVAL:
-                this.source += "    ; " + line + `
-`;
-                break;
-              case Template.modes.ESCAPED:
-                this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))" + `
-`;
-                break;
-              case Template.modes.RAW:
-                this.source += "    ; __append(" + stripSemi(line) + ")" + `
-`;
-                break;
-              case Template.modes.COMMENT:
-                break;
-              case Template.modes.LITERAL:
-                this._addOutput(line);
-                break;
-            }
-          } else {
-            this._addOutput(line);
-          }
-      }
-      if (self.opts.compileDebug && newLineCount) {
-        this.currentLine += newLineCount;
-        this.source += "    ; __line = " + this.currentLine + `
-`;
-      }
-    }
-  };
-  exports.escapeXML = utils.escapeXML;
-  exports.__express = exports.renderFile;
-  exports.VERSION = _VERSION_STRING;
-  exports.name = _NAME;
-  if (typeof window != "undefined") {
-    window.ejs = exports;
-  }
-});
-
 // node_modules/eventemitter3/index.js
 var require_eventemitter3 = __commonJS((exports, module) => {
   var has = Object.prototype.hasOwnProperty;
   var prefix = "~";
-  function Events() {
-  }
+  function Events() {}
   if (Object.create) {
     Events.prototype = Object.create(null);
     if (!new Events().__proto__)
@@ -1028,8 +295,717 @@ var require_eventemitter3 = __commonJS((exports, module) => {
 // src/server.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
 
+// node_modules/ejs/lib/esm/ejs.js
+import fs from "fs";
+import path from "path";
+
+// node_modules/ejs/lib/esm/utils.js
+var exports_utils = {};
+__export(exports_utils, {
+  default: () => utils_default
+});
+var utils = {};
+var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = function(obj, key) {
+  return hasOwnProperty.apply(obj, [key]);
+};
+utils.escapeRegExpChars = function(string) {
+  if (!string) {
+    return "";
+  }
+  return String(string).replace(regExpChars, "\\$&");
+};
+var _ENCODE_HTML_RULES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&#34;",
+  "'": "&#39;"
+};
+var _MATCH_HTML = /[&<>'"]/g;
+function encode_char(c) {
+  return _ENCODE_HTML_RULES[c] || c;
+}
+var escapeFuncStr = `var _ENCODE_HTML_RULES = {
+` + `      "&": "&amp;"
+` + `    , "<": "&lt;"
+` + `    , ">": "&gt;"
+` + `    , '"': "&#34;"
+` + `    , "'": "&#39;"
+` + `    }
+` + `  , _MATCH_HTML = /[&<>'"]/g;
+` + `function encode_char(c) {
+` + `  return _ENCODE_HTML_RULES[c] || c;
+` + `};
+`;
+utils.escapeXML = function(markup) {
+  return markup == undefined ? "" : String(markup).replace(_MATCH_HTML, encode_char);
+};
+function escapeXMLToString() {
+  return Function.prototype.toString.call(this) + `;
+` + escapeFuncStr;
+}
+try {
+  if (typeof Object.defineProperty === "function") {
+    Object.defineProperty(utils.escapeXML, "toString", { value: escapeXMLToString });
+  } else {
+    utils.escapeXML.toString = escapeXMLToString;
+  }
+} catch (err) {
+  console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
+}
+utils.shallowCopy = function(to, from) {
+  from = from || {};
+  if (to !== null && to !== undefined) {
+    for (var p in from) {
+      if (!hasOwn(from, p)) {
+        continue;
+      }
+      if (p === "__proto__" || p === "constructor") {
+        continue;
+      }
+      to[p] = from[p];
+    }
+  }
+  return to;
+};
+utils.shallowCopyFromList = function(to, from, list) {
+  list = list || [];
+  from = from || {};
+  if (to !== null && to !== undefined) {
+    for (var i = 0;i < list.length; i++) {
+      var p = list[i];
+      if (typeof from[p] != "undefined") {
+        if (!hasOwn(from, p)) {
+          continue;
+        }
+        if (p === "__proto__" || p === "constructor") {
+          continue;
+        }
+        to[p] = from[p];
+      }
+    }
+  }
+  return to;
+};
+utils.cache = {
+  _data: {},
+  set: function(key, val) {
+    this._data[key] = val;
+  },
+  get: function(key) {
+    return this._data[key];
+  },
+  remove: function(key) {
+    delete this._data[key];
+  },
+  reset: function() {
+    this._data = {};
+  }
+};
+utils.hyphenToCamel = function(str) {
+  return str.replace(/-[a-z]/g, function(match) {
+    return match[1].toUpperCase();
+  });
+};
+utils.createNullProtoObjWherePossible = function() {
+  if (typeof Object.create == "function") {
+    return function() {
+      return Object.create(null);
+    };
+  }
+  if (!({ __proto__: null } instanceof Object)) {
+    return function() {
+      return { __proto__: null };
+    };
+  }
+  return function() {
+    return {};
+  };
+}();
+utils.hasOwnOnlyObject = function(obj) {
+  var o = utils.createNullProtoObjWherePossible();
+  for (var p in obj) {
+    if (hasOwn(obj, p)) {
+      o[p] = obj[p];
+    }
+  }
+  return o;
+};
+if (typeof exports_utils != "undefined") {
+  module_utils.exports = utils;
+}
+var utils_default = utils;
+
+// node_modules/ejs/lib/esm/ejs.js
+var DECLARATION_KEYWORD = "let";
+var ejs = {};
+var _DEFAULT_OPEN_DELIMITER = "<";
+var _DEFAULT_CLOSE_DELIMITER = ">";
+var _DEFAULT_DELIMITER = "%";
+var _DEFAULT_LOCALS_NAME = "locals";
+var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
+var _OPTS_PASSABLE_WITH_DATA = [
+  "delimiter",
+  "scope",
+  "context",
+  "debug",
+  "compileDebug",
+  "_with",
+  "rmWhitespace",
+  "strict",
+  "filename",
+  "async"
+];
+var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
+var _BOM = /^\uFEFF/;
+var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+ejs.cache = utils_default.cache;
+ejs.fileLoader = fs.readFileSync;
+ejs.localsName = _DEFAULT_LOCALS_NAME;
+ejs.promiseImpl = new Function("return this;")().Promise;
+ejs.resolveInclude = function(name, filename, isDir) {
+  let dirname = path.dirname;
+  let extname = path.extname;
+  let resolve = path.resolve;
+  let includePath = resolve(isDir ? filename : dirname(filename), name);
+  let ext = extname(name);
+  if (!ext) {
+    includePath += ".ejs";
+  }
+  return includePath;
+};
+function resolvePaths(name, paths) {
+  let filePath;
+  if (paths.some(function(v) {
+    filePath = ejs.resolveInclude(name, v, true);
+    return fs.existsSync(filePath);
+  })) {
+    return filePath;
+  }
+}
+function getIncludePath(path2, options) {
+  let includePath;
+  let filePath;
+  let views = options.views;
+  let match = /^[A-Za-z]+:\\|^\//.exec(path2);
+  if (match && match.length) {
+    path2 = path2.replace(/^\/*/, "");
+    if (Array.isArray(options.root)) {
+      includePath = resolvePaths(path2, options.root);
+    } else {
+      includePath = ejs.resolveInclude(path2, options.root || "/", true);
+    }
+  } else {
+    if (options.filename) {
+      filePath = ejs.resolveInclude(path2, options.filename);
+      if (fs.existsSync(filePath)) {
+        includePath = filePath;
+      }
+    }
+    if (!includePath && Array.isArray(views)) {
+      includePath = resolvePaths(path2, views);
+    }
+    if (!includePath && typeof options.includer !== "function") {
+      throw new Error('Could not find the include file "' + options.escapeFunction(path2) + '"');
+    }
+  }
+  return includePath;
+}
+function handleCache(options, template) {
+  let func;
+  let filename = options.filename;
+  let hasTemplate = arguments.length > 1;
+  if (options.cache) {
+    if (!filename) {
+      throw new Error("cache option requires a filename");
+    }
+    func = ejs.cache.get(filename);
+    if (func) {
+      return func;
+    }
+    if (!hasTemplate) {
+      template = fileLoader(filename).toString().replace(_BOM, "");
+    }
+  } else if (!hasTemplate) {
+    if (!filename) {
+      throw new Error("Internal EJS error: no file name or template " + "provided");
+    }
+    template = fileLoader(filename).toString().replace(_BOM, "");
+  }
+  func = ejs.compile(template, options);
+  if (options.cache) {
+    ejs.cache.set(filename, func);
+  }
+  return func;
+}
+function tryHandleCache(options, data, cb) {
+  let result;
+  if (!cb) {
+    if (typeof ejs.promiseImpl == "function") {
+      return new ejs.promiseImpl(function(resolve, reject) {
+        try {
+          result = handleCache(options)(data);
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        }
+      });
+    } else {
+      throw new Error("Please provide a callback function");
+    }
+  } else {
+    try {
+      result = handleCache(options)(data);
+    } catch (err) {
+      return cb(err);
+    }
+    cb(null, result);
+  }
+}
+function fileLoader(filePath) {
+  return ejs.fileLoader(filePath);
+}
+function includeFile(path2, options) {
+  let opts = utils_default.shallowCopy(utils_default.createNullProtoObjWherePossible(), options);
+  opts.filename = getIncludePath(path2, opts);
+  if (typeof options.includer === "function") {
+    let includerResult = options.includer(path2, opts.filename);
+    if (includerResult) {
+      if (includerResult.filename) {
+        opts.filename = includerResult.filename;
+      }
+      if (includerResult.template) {
+        return handleCache(opts, includerResult.template);
+      }
+    }
+  }
+  return handleCache(opts);
+}
+function rethrow(err, str, flnm, lineno, esc) {
+  let lines = str.split(`
+`);
+  let start = Math.max(lineno - 3, 0);
+  let end = Math.min(lines.length, lineno + 3);
+  let filename = esc(flnm);
+  let context = lines.slice(start, end).map(function(line, i) {
+    let curr = i + start + 1;
+    return (curr == lineno ? " >> " : "    ") + curr + "| " + line;
+  }).join(`
+`);
+  err.path = filename;
+  err.message = (filename || "ejs") + ":" + lineno + `
+` + context + `
+
+` + err.message;
+  throw err;
+}
+function stripSemi(str) {
+  return str.replace(/;(\s*$)/, "$1");
+}
+ejs.compile = function compile(template, opts) {
+  let templ;
+  if (opts && opts.scope) {
+    console.warn("`scope` option is deprecated and will be removed in future EJS");
+    if (!opts.context) {
+      opts.context = opts.scope;
+    }
+    delete opts.scope;
+  }
+  templ = new Template(template, opts);
+  return templ.compile();
+};
+ejs.render = function(template, d, o) {
+  let data = d || utils_default.createNullProtoObjWherePossible();
+  let opts = o || utils_default.createNullProtoObjWherePossible();
+  if (arguments.length == 2) {
+    utils_default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+  }
+  return handleCache(opts, template)(data);
+};
+ejs.renderFile = function() {
+  let args = Array.prototype.slice.call(arguments);
+  let filename = args.shift();
+  let cb;
+  let opts = { filename };
+  let data;
+  let viewOpts;
+  if (typeof arguments[arguments.length - 1] == "function") {
+    cb = args.pop();
+  }
+  if (args.length) {
+    data = args.shift();
+    if (args.length) {
+      utils_default.shallowCopy(opts, args.pop());
+    } else {
+      if (data.settings) {
+        if (data.settings.views) {
+          opts.views = data.settings.views;
+        }
+        if (data.settings["view cache"]) {
+          opts.cache = true;
+        }
+        viewOpts = data.settings["view options"];
+        if (viewOpts) {
+          utils_default.shallowCopy(opts, viewOpts);
+        }
+      }
+      utils_default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
+    }
+    opts.filename = filename;
+  } else {
+    data = utils_default.createNullProtoObjWherePossible();
+  }
+  return tryHandleCache(opts, data, cb);
+};
+ejs.Template = Template;
+ejs.clearCache = function() {
+  ejs.cache.reset();
+};
+function Template(text, optsParam) {
+  let opts = utils_default.hasOwnOnlyObject(optsParam);
+  let options = utils_default.createNullProtoObjWherePossible();
+  this.templateText = text;
+  this.mode = null;
+  this.truncate = false;
+  this.currentLine = 1;
+  this.source = "";
+  options.escapeFunction = opts.escape || opts.escapeFunction || utils_default.escapeXML;
+  options.compileDebug = opts.compileDebug !== false;
+  options.debug = !!opts.debug;
+  options.filename = opts.filename;
+  options.openDelimiter = opts.openDelimiter || ejs.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+  options.closeDelimiter = opts.closeDelimiter || ejs.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+  options.delimiter = opts.delimiter || ejs.delimiter || _DEFAULT_DELIMITER;
+  options.strict = opts.strict || false;
+  options.context = opts.context;
+  options.cache = opts.cache || false;
+  options.rmWhitespace = opts.rmWhitespace;
+  options.root = opts.root;
+  options.includer = opts.includer;
+  options.outputFunctionName = opts.outputFunctionName;
+  options.localsName = opts.localsName || ejs.localsName || _DEFAULT_LOCALS_NAME;
+  options.views = opts.views;
+  options.async = opts.async;
+  options.destructuredLocals = opts.destructuredLocals;
+  options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
+  if (options.strict) {
+    options._with = false;
+  } else {
+    options._with = typeof opts._with != "undefined" ? opts._with : true;
+  }
+  this.opts = options;
+  this.regex = this.createRegex();
+}
+Template.modes = {
+  EVAL: "eval",
+  ESCAPED: "escaped",
+  RAW: "raw",
+  COMMENT: "comment",
+  LITERAL: "literal"
+};
+Template.prototype = {
+  createRegex: function() {
+    let str = _REGEX_STRING;
+    let delim = utils_default.escapeRegExpChars(this.opts.delimiter);
+    let open = utils_default.escapeRegExpChars(this.opts.openDelimiter);
+    let close = utils_default.escapeRegExpChars(this.opts.closeDelimiter);
+    str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
+    return new RegExp(str);
+  },
+  compile: function() {
+    let src;
+    let fn;
+    let opts = this.opts;
+    let prepended = "";
+    let appended = "";
+    let escapeFn = opts.escapeFunction;
+    let ctor;
+    let sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
+    if (!this.source) {
+      this.generateSource();
+      prepended += `  ${DECLARATION_KEYWORD} __output = "";
+` + `  function __append(s) { if (s !== undefined && s !== null) __output += s }
+`;
+      if (opts.outputFunctionName) {
+        if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
+          throw new Error("outputFunctionName is not a valid JS identifier.");
+        }
+        prepended += `  ${DECLARATION_KEYWORD} ` + opts.outputFunctionName + " = __append;" + `
+`;
+      }
+      if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
+        throw new Error("localsName is not a valid JS identifier.");
+      }
+      if (opts.destructuredLocals && opts.destructuredLocals.length) {
+        let destructuring = `  ${DECLARATION_KEYWORD} __locals = (` + opts.localsName + ` || {}),
+`;
+        for (let i = 0;i < opts.destructuredLocals.length; i++) {
+          let name = opts.destructuredLocals[i];
+          if (!_JS_IDENTIFIER.test(name)) {
+            throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
+          }
+          if (i > 0) {
+            destructuring += `,
+  `;
+          }
+          destructuring += name + " = __locals." + name;
+        }
+        prepended += destructuring + `;
+`;
+      }
+      if (opts._with !== false) {
+        prepended += "  with (" + opts.localsName + " || {}) {" + `
+`;
+        appended += "  }" + `
+`;
+      }
+      appended += "  return __output;" + `
+`;
+      this.source = prepended + this.source + appended;
+    }
+    if (opts.compileDebug) {
+      src = `${DECLARATION_KEYWORD} __line = 1` + `
+` + "  , __lines = " + JSON.stringify(this.templateText) + `
+` + "  , __filename = " + sanitizedFilename + ";" + `
+` + "try {" + `
+` + this.source + "} catch (e) {" + `
+` + "  rethrow(e, __lines, __filename, __line, escapeFn);" + `
+` + "}" + `
+`;
+    } else {
+      src = this.source;
+    }
+    if (opts.strict) {
+      src = `"use strict";
+` + src;
+    }
+    if (opts.debug) {
+      console.log(src);
+    }
+    if (opts.compileDebug && opts.filename) {
+      src = src + `
+` + "//# sourceURL=" + sanitizedFilename + `
+`;
+    }
+    try {
+      if (opts.async) {
+        try {
+          ctor = new Function("return (async function(){}).constructor;")();
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            throw new Error("This environment does not support async/await");
+          } else {
+            throw e;
+          }
+        }
+      } else {
+        ctor = Function;
+      }
+      fn = new ctor(opts.localsName + ", escapeFn, include, rethrow", src);
+    } catch (e) {
+      if (e instanceof SyntaxError) {
+        if (opts.filename) {
+          e.message += " in " + opts.filename;
+        }
+        e.message += ` while compiling ejs
+
+`;
+        e.message += `If the above error is not helpful, you may want to try EJS-Lint:
+`;
+        e.message += "https://github.com/RyanZim/EJS-Lint";
+        if (!opts.async) {
+          e.message += `
+`;
+          e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
+        }
+      }
+      throw e;
+    }
+    let returnedFn = function anonymous(data) {
+      let include = function(path2, includeData) {
+        let d = utils_default.shallowCopy(utils_default.createNullProtoObjWherePossible(), data);
+        if (includeData) {
+          d = utils_default.shallowCopy(d, includeData);
+        }
+        return includeFile(path2, opts)(d);
+      };
+      return fn.apply(opts.context, [data || utils_default.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
+    };
+    if (opts.filename && typeof Object.defineProperty === "function") {
+      let filename = opts.filename;
+      let basename = path.basename(filename, path.extname(filename));
+      try {
+        Object.defineProperty(returnedFn, "name", {
+          value: basename,
+          writable: false,
+          enumerable: false,
+          configurable: true
+        });
+      } catch (e) {}
+    }
+    return returnedFn;
+  },
+  generateSource: function() {
+    let opts = this.opts;
+    if (opts.rmWhitespace) {
+      this.templateText = this.templateText.replace(/[\r\n]+/g, `
+`).replace(/^\s+|\s+$/gm, "");
+    }
+    let self = this;
+    let d = this.opts.delimiter;
+    let o = this.opts.openDelimiter;
+    let c = this.opts.closeDelimiter;
+    let openWhitespaceSlurpTag = utils_default.escapeRegExpChars(o + d + "_");
+    let closeWhitespaceSlurpTag = utils_default.escapeRegExpChars("_" + d + c);
+    let openWhitespaceSlurpReplacement = o + d + "_";
+    let closeWhitespaceSlurpReplacement = "_" + d + c;
+    this.templateText = this.templateText.replace(new RegExp("[ \\t]*" + openWhitespaceSlurpTag, "gm"), openWhitespaceSlurpReplacement).replace(new RegExp(closeWhitespaceSlurpTag + "[ \\t]*", "gm"), closeWhitespaceSlurpReplacement);
+    let matches = this.parseTemplateText();
+    if (matches && matches.length) {
+      matches.forEach(function(line, index) {
+        let closing;
+        if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
+          closing = matches[index + 2];
+          if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) {
+            throw new Error('Could not find matching close tag for "' + line + '".');
+          }
+        }
+        self.scanLine(line);
+      });
+    }
+  },
+  parseTemplateText: function() {
+    let str = this.templateText;
+    let pat = this.regex;
+    let result = pat.exec(str);
+    let arr = [];
+    let firstPos;
+    while (result) {
+      firstPos = result.index;
+      if (firstPos !== 0) {
+        arr.push(str.substring(0, firstPos));
+        str = str.slice(firstPos);
+      }
+      arr.push(result[0]);
+      str = str.slice(result[0].length);
+      result = pat.exec(str);
+    }
+    if (str) {
+      arr.push(str);
+    }
+    return arr;
+  },
+  _addOutput: function(line) {
+    if (this.truncate) {
+      line = line.replace(/^(?:\r\n|\r|\n)/, "");
+      this.truncate = false;
+    }
+    if (!line) {
+      return line;
+    }
+    line = line.replace(/\\/g, "\\\\");
+    line = line.replace(/\n/g, "\\n");
+    line = line.replace(/\r/g, "\\r");
+    line = line.replace(/"/g, "\\\"");
+    this.source += '    ; __append("' + line + '")' + `
+`;
+  },
+  scanLine: function(line) {
+    let self = this;
+    let d = this.opts.delimiter;
+    let o = this.opts.openDelimiter;
+    let c = this.opts.closeDelimiter;
+    let newLineCount = 0;
+    newLineCount = line.split(`
+`).length - 1;
+    switch (line) {
+      case o + d:
+      case o + d + "_":
+        this.mode = Template.modes.EVAL;
+        break;
+      case o + d + "=":
+        this.mode = Template.modes.ESCAPED;
+        break;
+      case o + d + "-":
+        this.mode = Template.modes.RAW;
+        break;
+      case o + d + "#":
+        this.mode = Template.modes.COMMENT;
+        break;
+      case o + d + d:
+        this.mode = Template.modes.LITERAL;
+        this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")' + `
+`;
+        break;
+      case d + d + c:
+        this.mode = Template.modes.LITERAL;
+        this.source += '    ; __append("' + line.replace(d + d + c, d + c) + '")' + `
+`;
+        break;
+      case d + c:
+      case "-" + d + c:
+      case "_" + d + c:
+        if (this.mode == Template.modes.LITERAL) {
+          this._addOutput(line);
+        }
+        this.mode = null;
+        this.truncate = line.indexOf("-") === 0 || line.indexOf("_") === 0;
+        break;
+      default:
+        if (this.mode) {
+          switch (this.mode) {
+            case Template.modes.EVAL:
+            case Template.modes.ESCAPED:
+            case Template.modes.RAW:
+              if (line.lastIndexOf("//") > line.lastIndexOf(`
+`)) {
+                line += `
+`;
+              }
+          }
+          switch (this.mode) {
+            case Template.modes.EVAL:
+              this.source += "    ; " + line + `
+`;
+              break;
+            case Template.modes.ESCAPED:
+              this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))" + `
+`;
+              break;
+            case Template.modes.RAW:
+              this.source += "    ; __append(" + stripSemi(line) + ")" + `
+`;
+              break;
+            case Template.modes.COMMENT:
+              break;
+            case Template.modes.LITERAL:
+              this._addOutput(line);
+              break;
+          }
+        } else {
+          this._addOutput(line);
+        }
+    }
+    if (self.opts.compileDebug && newLineCount) {
+      this.currentLine += newLineCount;
+      this.source += "    ; __line = " + this.currentLine + `
+`;
+    }
+  }
+};
+ejs.escapeXML = utils_default.escapeXML;
+ejs.__express = ejs.renderFile;
+if (typeof window != "undefined") {
+  window.ejs = ejs;
+}
+if (typeof module_ejs != "undefined") {
+  module_ejs.exports = ejs;
+}
+var ejs_default = ejs;
+
 // src/httpHandler.ts
-var import_ejs = __toESM(require_ejs(), 1);
 import { readFile, readdir } from "fs/promises";
 
 // src/utils/cors.ts
@@ -1044,6 +1020,15 @@ function withCORSHeaders(response, request) {
 // 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;
+  }
+}
 async function cleanDirectory(dst) {
   const { stderr, exitCode } = await $`rm -rf ${dst}/*`.nothrow();
   if (exitCode !== 0) {
@@ -1146,7 +1131,7 @@ async function handleDirectoryRequest(fsPath, requestPath, req, finalConfig) {
       };
     });
     const templatePath = requestPath === "/" ? "" : requestPath;
-    const rnd = import_ejs.render(finalConfig.serveOutputEjs, {
+    const rnd = ejs_default.render(finalConfig.serveOutputEjs, {
       dirs,
       files,
       requestPath: templatePath
@@ -1162,7 +1147,7 @@ async function handleDirectoryRequest(fsPath, requestPath, req, finalConfig) {
 import { resolve } from "path";
 
 // src/static/serveOutputStyles.css
-var serveOutputStyles_default = "./assets/serveOutputStyles.css";
+var serveOutputStyles_default = {};
 
 // src/static/file.svg
 var file_default = "./assets/file.svg";
@@ -1191,7 +1176,6 @@ var staticAssetRoutes = {
 import { watch } from "fs/promises";
 
 // src/buildManager.ts
-var import_ejs2 = __toESM(require_ejs(), 1);
 var {build } = globalThis.Bun;
 
 // node_modules/eventemitter3/index.mjs
@@ -1337,6 +1321,9 @@ class PQueue extends import__.default {
   #lastExecutionTime = 0;
   #intervalId;
   #timeoutId;
+  #strict;
+  #strictTicks = [];
+  #strictTicksStartIndex = 0;
   #queue;
   #queueClass;
   #pending = 0;
@@ -1354,6 +1341,7 @@ class PQueue extends import__.default {
       concurrency: Number.POSITIVE_INFINITY,
       autoStart: true,
       queueClass: PriorityQueue,
+      strict: false,
       ...options
     };
     if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
@@ -1362,10 +1350,17 @@ 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})`);
     }
+    if (options.strict && options.interval === 0) {
+      throw new TypeError("The `strict` option requires a non-zero `interval`");
+    }
+    if (options.strict && options.intervalCap === Number.POSITIVE_INFINITY) {
+      throw new TypeError("The `strict` option requires a finite `intervalCap`");
+    }
     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.#strict = options.strict;
     this.#queue = new options.queueClass;
     this.#queueClass = options.queueClass;
     this.concurrency = options.concurrency;
@@ -1376,8 +1371,48 @@ class PQueue extends import__.default {
     this.#isPaused = options.autoStart === false;
     this.#setupRateLimitTracking();
   }
+  #cleanupStrictTicks(now) {
+    while (this.#strictTicksStartIndex < this.#strictTicks.length) {
+      const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+      if (oldestTick !== undefined && now - oldestTick >= this.#interval) {
+        this.#strictTicksStartIndex++;
+      } else {
+        break;
+      }
+    }
+    const shouldCompact = this.#strictTicksStartIndex > 100 && this.#strictTicksStartIndex > this.#strictTicks.length / 2 || this.#strictTicksStartIndex === this.#strictTicks.length;
+    if (shouldCompact) {
+      this.#strictTicks = this.#strictTicks.slice(this.#strictTicksStartIndex);
+      this.#strictTicksStartIndex = 0;
+    }
+  }
+  #consumeIntervalSlot(now) {
+    if (this.#strict) {
+      this.#strictTicks.push(now);
+    } else {
+      this.#intervalCount++;
+    }
+  }
+  #rollbackIntervalSlot() {
+    if (this.#strict) {
+      if (this.#strictTicks.length > this.#strictTicksStartIndex) {
+        this.#strictTicks.pop();
+      }
+    } else if (this.#intervalCount > 0) {
+      this.#intervalCount--;
+    }
+  }
+  #getActiveTicksCount() {
+    return this.#strictTicks.length - this.#strictTicksStartIndex;
+  }
   get #doesIntervalAllowAnother() {
-    return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+    if (this.#isIntervalIgnored) {
+      return true;
+    }
+    if (this.#strict) {
+      return this.#getActiveTicksCount() < this.#intervalCap;
+    }
+    return this.#intervalCount < this.#intervalCap;
   }
   get #doesConcurrentAllowAnother() {
     return this.#pending < this.#concurrency;
@@ -1391,12 +1426,22 @@ class PQueue extends import__.default {
     this.emit("next");
   }
   #onResumeInterval() {
+    this.#timeoutId = undefined;
     this.#onInterval();
     this.#initializeIntervalIfNeeded();
-    this.#timeoutId = undefined;
   }
-  get #isIntervalPaused() {
-    const now = Date.now();
+  #isIntervalPausedAt(now) {
+    if (this.#strict) {
+      this.#cleanupStrictTicks(now);
+      const activeTicksCount = this.#getActiveTicksCount();
+      if (activeTicksCount >= this.#intervalCap) {
+        const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+        const delay = this.#interval - (now - oldestTick);
+        this.#createIntervalTimeout(delay);
+        return true;
+      }
+      return false;
+    }
     if (this.#intervalId === undefined) {
       const delay = this.#intervalEnd - now;
       if (delay < 0) {
@@ -1441,21 +1486,25 @@ class PQueue extends import__.default {
       this.emit("empty");
       if (this.#pending === 0) {
         this.#clearTimeoutTimer();
+        if (this.#strict && this.#strictTicksStartIndex > 0) {
+          const now = Date.now();
+          this.#cleanupStrictTicks(now);
+        }
         this.emit("idle");
       }
       return false;
     }
     let taskStarted = false;
     if (!this.#isPaused) {
-      const canInitializeInterval = !this.#isIntervalPaused;
+      const now = Date.now();
+      const canInitializeInterval = !this.#isIntervalPausedAt(now);
       if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
         const job = this.#queue.dequeue();
         if (!this.#isIntervalIgnored) {
-          this.#intervalCount++;
+          this.#consumeIntervalSlot(now);
           this.#scheduleRateLimitUpdate();
         }
         this.emit("active");
-        this.#lastExecutionTime = Date.now();
         job();
         if (canInitializeInterval) {
           this.#initializeIntervalIfNeeded();
@@ -1469,22 +1518,26 @@ class PQueue extends import__.default {
     if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
       return;
     }
+    if (this.#strict) {
+      return;
+    }
     this.#intervalId = setInterval(() => {
       this.#onInterval();
     }, this.#interval);
     this.#intervalEnd = Date.now() + this.#interval;
   }
   #onInterval() {
-    if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-      this.#clearIntervalTimer();
+    if (!this.#strict) {
+      if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+        this.#clearIntervalTimer();
+      }
+      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
     }
-    this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
     this.#processQueue();
     this.#scheduleRateLimitUpdate();
   }
   #processQueue() {
-    while (this.#tryToStartAnother()) {
-    }
+    while (this.#tryToStartAnother()) {}
   }
   get concurrency() {
     return this.#concurrency;
@@ -1496,13 +1549,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})`);
@@ -1510,10 +1556,10 @@ class PQueue extends import__.default {
     this.#queue.setPriority(id, priority);
   }
   async add(function_, options = {}) {
-    options.id ??= (this.#idAssigner++).toString();
     options = {
       timeout: this.timeout,
-      ...options
+      ...options,
+      id: options.id ?? (this.#idAssigner++).toString()
     };
     return new Promise((resolve2, reject) => {
       const taskSymbol = Symbol(`task-${options.id}`);
@@ -1525,16 +1571,16 @@ class PQueue extends import__.default {
           startTime: Date.now(),
           timeout: options.timeout
         });
+        let eventListener;
         try {
           try {
             options.signal?.throwIfAborted();
           } catch (error) {
-            if (!this.#isIntervalIgnored) {
-              this.#intervalCount--;
-            }
+            this.#rollbackIntervalConsumption();
             this.#runningTasks.delete(taskSymbol);
             throw error;
           }
+          this.#lastExecutionTime = Date.now();
           let operation = function_({ signal: options.signal });
           if (options.timeout) {
             operation = pTimeout(Promise.resolve(operation), {
@@ -1543,7 +1589,13 @@ 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;
           resolve2(result);
@@ -1552,6 +1604,9 @@ class PQueue extends import__.default {
           reject(error);
           this.emit("error", error);
         } finally {
+          if (eventListener) {
+            options.signal?.removeEventListener("abort", eventListener);
+          }
           this.#runningTasks.delete(taskSymbol);
           queueMicrotask(() => {
             this.#next();
@@ -1578,7 +1633,14 @@ class PQueue extends import__.default {
   }
   clear() {
     this.#queue = new this.#queueClass;
+    this.#clearIntervalTimer();
     this.#updateRateLimitState();
+    this.emit("empty");
+    if (this.#pending === 0) {
+      this.#clearTimeoutTimer();
+      this.emit("idle");
+    }
+    this.emit("next");
   }
   async onEmpty() {
     if (this.#queue.size === 0) {
@@ -1616,7 +1678,7 @@ class PQueue extends import__.default {
     }
     await this.#onEvent("rateLimitCleared");
   }
-  async onError() {
+  onError() {
     return new Promise((_resolve, reject) => {
       const handleError = (error) => {
         this.off("error", handleError);
@@ -1672,9 +1734,31 @@ class PQueue extends import__.default {
       this.#updateRateLimitState();
     });
   }
+  #rollbackIntervalConsumption() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.#rollbackIntervalSlot();
+    this.#scheduleRateLimitUpdate();
+  }
   #updateRateLimitState() {
     const previous = this.#rateLimitedInInterval;
-    const shouldBeRateLimited = !this.#isIntervalIgnored && this.#intervalCount >= this.#intervalCap && this.#queue.size > 0;
+    if (this.#isIntervalIgnored || this.#queue.size === 0) {
+      if (previous) {
+        this.#rateLimitedInInterval = false;
+        this.emit("rateLimitCleared");
+      }
+      return;
+    }
+    let count;
+    if (this.#strict) {
+      const now = Date.now();
+      this.#cleanupStrictTicks(now);
+      count = this.#getActiveTicksCount();
+    } else {
+      count = this.#intervalCount;
+    }
+    const shouldBeRateLimited = count >= this.#intervalCap;
     if (shouldBeRateLimited !== previous) {
       this.#rateLimitedInInterval = shouldBeRateLimited;
       this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
@@ -1729,7 +1813,7 @@ function writeManifest(output, outdir, withHash = false, manifestName = "bun_ser
   for (const ep of entryPoints) {
     const basePathUrl = pathToFileURL(outdir);
     const epUrl = pathToFileURL(ep.path);
-    const relativePath = epUrl.href.replace(`${basePathUrl.href}/`, "");
+    const relativePath = epUrl.href.replace(`${basePathUrl.href}/`, "./");
     const hashedImport = `${relativePath}${withHash ? `?${ep.hash}` : ``}`;
     epTable.push(hashedImport);
   }
@@ -1746,30 +1830,25 @@ function getThrottledBuildQueue(serverConfig) {
     carryoverConcurrencyCount: true
   });
 }
-async function cleanBuildAndNotify(importerMeta, finalConfig, destinationPath, buildCfg, bunServer, event) {
+async function cleanBuildAndNotify(importerMeta, finalConfig, paths, buildCfg, bunServer, event) {
   const buildEnv = {
     importerMeta,
     finalConfig,
-    destinationPath,
+    ...paths,
     buildCfg,
     bunServer,
     event
   };
   await finalConfig.beforeBuild?.(buildEnv);
   try {
-    if (buildCfg.outdir) {
-      const outdirExists = await checkObjectExists(buildCfg.outdir);
-      if (!outdirExists) {
-        return;
-      }
-    }
+    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) {
@@ -1816,23 +1895,23 @@ function publishOutputLogs(bunServer, output, config, event) {
     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(destinationPath);
+  const basePathUrl = Bun.pathToFileURL(paths.serveDestination);
   for (const ep of eps) {
     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);
   }
   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}`;
+    const hashedCss = `${cssUrl.href.replace(`${basePathUrl.href}/`, "./")}?${cssFile.hash}`;
     cssFiles.push(hashedCss);
   }
-  Bun.write(destinationPath + "/index.html", import_ejs2.render(template, { hashedImports, cssFiles }));
+  Bun.write(paths.buildDestination + "/index.html", ejs_default.render(template, { hashedImports, cssFiles }));
 }
 function printPrettyBuildOutput(outTable) {
   if (outTable.length === 0)
@@ -1851,10 +1930,10 @@ function printPrettyBuildOutput(outTable) {
 }
 
 // src/fileWatcher.ts
-async function startFileWatcher(srcWatch, importMeta, finalConfig, destinationPath, buildCfg, bunServer) {
+async function startFileWatcher(srcWatch, importMeta, finalConfig, paths, buildCfg, bunServer) {
   const queue = getThrottledBuildQueue(finalConfig);
   await queue.add(async () => {
-    await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
+    await cleanBuildAndNotify(importMeta, finalConfig, paths, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
   });
   const watcher = watch(srcWatch, { recursive: true });
   try {
@@ -1867,7 +1946,7 @@ async function startFileWatcher(srcWatch, importMeta, finalConfig, destinationPa
           queue.clear();
         }
         queue.add(async () => {
-          await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, event);
+          await cleanBuildAndNotify(importMeta, finalConfig, paths, buildCfg, bunServer, event);
         });
       } catch (e) {
         console.error("Error while processing file change", e);
@@ -1881,8 +1960,6 @@ async function startFileWatcher(srcWatch, importMeta, finalConfig, destinationPa
 }
 
 // src/configManager.ts
-var {$: $3 } = globalThis.Bun;
-import { readdir as readdir2 } from "fs/promises";
 import { resolve as resolve2 } from "path";
 
 // src/templates/output.ejs
@@ -1915,8 +1992,7 @@ function hotReload() {
     let parsed = msg.data;
     try {
       parsed = JSON.parse(msg.data);
-    } catch (e) {
-    }
+    } catch (e) {}
     if (parsed?.type === "message") {
       console.log(devServer, parsed.message);
       return;
@@ -1972,8 +2048,8 @@ 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);
+  const path2 = `${bunServerConfig.secure ? "wss" : "ws"}://localhost:${bunServerConfig.port}${endPath}`;
+  return hotReload.toString().replace("[REPLACE_ENDPOINT]", path2);
 }
 
 // src/bunHmrPlugin.ts
@@ -2043,15 +2119,16 @@ async function prepareConfiguration(serverConfig, importMeta) {
   if (!finalConfig.watchDir) {
     throw new Error("watchDir must be set");
   }
-  const servePart = finalConfig.buildConfig.outdir ?? finalConfig.servePath ?? "./dist";
+  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;
-  const destinationPath = serveDestination;
-  const srcWatch = watchDestination;
-  await ensureDestinationDirectory(destinationPath);
+  await ensureDestinationDirectory(buildDestination);
+  await ensureDestinationDirectory(serveDestination);
   const buncfg = {
     port: finalConfig.port,
     tls: finalConfig.tls,
@@ -2060,7 +2137,7 @@ async function prepareConfiguration(serverConfig, importMeta) {
   };
   const buildCfg = {
     ...serverConfig.buildConfig,
-    outdir: destinationPath
+    outdir: buildDestination
   };
   if (finalConfig.hotReload === "footer") {
     if (!buildCfg.footer) {
@@ -2076,44 +2153,36 @@ async function prepareConfiguration(serverConfig, importMeta) {
   }
   const userBeforeBuild = finalConfig.beforeBuild;
   finalConfig.beforeBuild = async (env) => {
-    if (serverConfig.cleanServePath) {
-      await cleanDirectory(env.destinationPath);
+    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,
-    destinationPath,
-    srcWatch,
+    serveDestination,
+    buildDestination,
+    watchDestination,
     buildCfg
   };
 }
-async function ensureDestinationDirectory(destinationPath) {
-  try {
-    await readdir2(destinationPath);
-  } catch (e) {
-    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;
-    }
-  }
-}
 
 // src/server.ts
 async function startBunDevServer(serverConfig, importMeta) {
-  const { finalConfig, destinationPath, srcWatch, buildCfg } = await prepareConfiguration(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 {
     bunServer = Bun.serve({
@@ -2142,14 +2211,13 @@ async function startBunDevServer(serverConfig, importMeta) {
         }
         const url = new URL(req.url);
         let requestPath = url.pathname;
-        return handlePathRequest(requestPath, req, finalConfig, destinationPath);
+        return handlePathRequest(requestPath, req, finalConfig, paths.serveDestination);
       },
       websocket: {
         open(ws) {
           ws.subscribe("message");
         },
-        message(ws, message) {
-        },
+        message(ws, message) {},
         sendPings: true
       }
     });
@@ -2160,7 +2228,7 @@ async function startBunDevServer(serverConfig, importMeta) {
     throw error;
   }
   if (bunServer) {
-    await startFileWatcher(srcWatch, importMeta, finalConfig, destinationPath, buildCfg, bunServer);
+    await startFileWatcher(paths.watchDestination, importMeta, finalConfig, paths, buildCfg, bunServer);
   }
 }
 export {