bun-dev-server 0.9.82 → 0.9.83

package/dist/bunServeConfig.d.ts

@@ -124,30 +124,6 @@ export interface BunDevServerConfig extends Partial<BunServeConfig> {
     * @param env Supplied environment for the build
     */
     afterBuild?: (output: BuildOutput, env: BuildEnv) => void;
-    /**
-     * throttle-debounce library options used internally to limit build execution.
-     */
-    throttleOptions?: {
-        /**
-         * Optional, defaults to `false`.
-         * If noTrailing is `true`, callback will only execute every delay milliseconds while the throttled-function is being called.
-         * If noTrailing is `false` or unspecified, callback will be executed one final time after the last throttled-function call.
-         * (After the throttled-function has not been called for delay milliseconds, the internal counter is reset)
-         */
-        noLeading?: boolean;
-        /**
-         * Optional, defaults to `false`.
-         * If noLeading is `false`, the first throttled-function call will execute callback immediately.
-         * If noLeading is `true`, the first the callback execution will be skipped.
-         * It should be noted that callback will never executed if both noLeading = `true` and noTrailing = `true`.
-         */
-        noTrailing?: boolean;
-        /**
-         * If debounceMode is `true` (at begin), schedule clear to execute after delay ms.
-         * If debounceMode is `false` (at end), schedule callback to execute after delay ms.
-         */
-        debounceMode?: boolean;
-    };
 }
 export interface BunServeConfig {
     port: number;

package/dist/index.js

@@ -846,9 +846,188 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
+// node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS((exports, module) => {
+  var has = Object.prototype.hasOwnProperty;
+  var prefix = "~";
+  function Events() {
+  }
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__)
+      prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt])
+      emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn)
+      emitter._events[evt].push(listener);
+    else
+      emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0)
+      emitter._events = new Events;
+    else
+      delete emitter._events[evt];
+  }
+  function EventEmitter() {
+    this._events = new Events;
+    this._eventsCount = 0;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [], events, name;
+    if (this._eventsCount === 0)
+      return names;
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+    if (!handlers)
+      return [];
+    if (handlers.fn)
+      return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+    if (!listeners)
+      return 0;
+    if (listeners.fn)
+      return 1;
+    return listeners.length;
+  };
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return false;
+    var listeners = this._events[evt], len = arguments.length, args, i;
+    if (listeners.fn) {
+      if (listeners.once)
+        this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1);i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length, j;
+      for (i = 0;i < length; i++) {
+        if (listeners[i].once)
+          this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args)
+              for (j = 1, args = new Array(len - 1);j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length)
+        this._events[evt] = events.length === 1 ? events[0] : events;
+      else
+        clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt])
+        clearEvent(this, evt);
+    } else {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if (typeof module !== "undefined") {
+    module.exports = EventEmitter;
+  }
+});
+
 // src/server.ts
 var import_ejs = __toESM(require_ejs(), 1);
-var {$: $2 } = globalThis.Bun;
+var {$: $2, build } = globalThis.Bun;
 
 // src/serveOutputTemplate.ejs
 var serveOutputTemplate_default = `<!DOCTYPE html>\r
@@ -1064,57 +1243,402 @@ ${errOutput}`);
   return success;
 }
 
-// node_modules/throttle-debounce/esm/index.js
-function throttle(delay, callback, options) {
-  var _ref = options || {}, _ref$noTrailing = _ref.noTrailing, noTrailing = _ref$noTrailing === undefined ? false : _ref$noTrailing, _ref$noLeading = _ref.noLeading, noLeading = _ref$noLeading === undefined ? false : _ref$noLeading, _ref$debounceMode = _ref.debounceMode, debounceMode = _ref$debounceMode === undefined ? undefined : _ref$debounceMode;
-  var timeoutID;
-  var cancelled = false;
-  var lastExec = 0;
-  function clearExistingTimeout() {
-    if (timeoutID) {
-      clearTimeout(timeoutID);
-    }
-  }
-  function cancel(options2) {
-    var _ref2 = options2 || {}, _ref2$upcomingOnly = _ref2.upcomingOnly, upcomingOnly = _ref2$upcomingOnly === undefined ? false : _ref2$upcomingOnly;
-    clearExistingTimeout();
-    cancelled = !upcomingOnly;
-  }
-  function wrapper() {
-    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0;_key < _len; _key++) {
-      arguments_[_key] = arguments[_key];
-    }
-    var self = this;
-    var elapsed = Date.now() - lastExec;
-    if (cancelled) {
+// node_modules/eventemitter3/index.mjs
+var import__ = __toESM(require_eventemitter3(), 1);
+
+// node_modules/p-timeout/index.js
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+
+class AbortError extends Error {
+  constructor(message) {
+    super();
+    this.name = "AbortError";
+    this.message = message;
+  }
+}
+var getDOMException = (errorMessage) => globalThis.DOMException === undefined ? new AbortError(errorMessage) : new DOMException(errorMessage);
+var getAbortedReason = (signal) => {
+  const reason = signal.reason === undefined ? getDOMException("This operation was aborted.") : signal.reason;
+  return reason instanceof Error ? reason : getDOMException(reason);
+};
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout }
+  } = options;
+  let timer;
+  let abortHandler;
+  const wrappedPromise = new Promise((resolve, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (options.signal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        reject(getAbortedReason(signal));
+      }
+      abortHandler = () => {
+        reject(getAbortedReason(signal));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      promise.then(resolve, reject);
+      return;
+    }
+    const timeoutError = new TimeoutError;
+    timer = customTimers.setTimeout.call(undefined, () => {
+      if (fallback) {
+        try {
+          resolve(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+        reject(timeoutError);
+      }
+    }, milliseconds);
+    (async () => {
+      try {
+        resolve(await promise);
+      } catch (error) {
+        reject(error);
+      }
+    })();
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+    if (abortHandler && options.signal) {
+      options.signal.removeEventListener("abort", abortHandler);
+    }
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(undefined, timer);
+    timer = undefined;
+  };
+  return cancelablePromise;
+}
+
+// node_modules/p-queue/dist/lower-bound.js
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+
+// node_modules/p-queue/dist/priority-queue.js
+class PriorityQueue {
+  #queue = [];
+  enqueue(run, options) {
+    options = {
+      priority: 0,
+      ...options
+    };
+    const element = {
+      priority: options.priority,
+      id: options.id,
+      run
+    };
+    if (this.size === 0 || this.#queue[this.size - 1].priority >= options.priority) {
+      this.#queue.push(element);
       return;
     }
-    function exec() {
-      lastExec = Date.now();
-      callback.apply(self, arguments_);
+    const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+    this.#queue.splice(index, 0, element);
+  }
+  setPriority(id, priority) {
+    const index = this.#queue.findIndex((element) => element.id === id);
+    if (index === -1) {
+      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
     }
-    function clear() {
-      timeoutID = undefined;
+    const [item] = this.#queue.splice(index, 1);
+    this.enqueue(item.run, { priority, id });
+  }
+  dequeue() {
+    const item = this.#queue.shift();
+    return item?.run;
+  }
+  filter(options) {
+    return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return this.#queue.length;
+  }
+}
+
+// node_modules/p-queue/dist/index.js
+class PQueue extends import__.default {
+  #carryoverConcurrencyCount;
+  #isIntervalIgnored;
+  #intervalCount = 0;
+  #intervalCap;
+  #interval;
+  #intervalEnd = 0;
+  #intervalId;
+  #timeoutId;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  #concurrency;
+  #isPaused;
+  #throwOnTimeout;
+  #idAssigner = 1n;
+  timeout;
+  constructor(options) {
+    super();
+    options = {
+      carryoverConcurrencyCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
     }
-    if (!noLeading && debounceMode && !timeoutID) {
-      exec();
+    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})`);
     }
-    clearExistingTimeout();
-    if (debounceMode === undefined && elapsed > delay) {
-      if (noLeading) {
-        lastExec = Date.now();
-        if (!noTrailing) {
-          timeoutID = setTimeout(debounceMode ? clear : exec, delay);
-        }
+    this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+    this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+    this.#intervalCap = options.intervalCap;
+    this.#interval = options.interval;
+    this.#queue = new options.queueClass;
+    this.#queueClass = options.queueClass;
+    this.concurrency = options.concurrency;
+    this.timeout = options.timeout;
+    this.#throwOnTimeout = options.throwOnTimeout === true;
+    this.#isPaused = options.autoStart === false;
+  }
+  get #doesIntervalAllowAnother() {
+    return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+  }
+  get #doesConcurrentAllowAnother() {
+    return this.#pending < this.#concurrency;
+  }
+  #next() {
+    this.#pending--;
+    this.#tryToStartAnother();
+    this.emit("next");
+  }
+  #onResumeInterval() {
+    this.#onInterval();
+    this.#initializeIntervalIfNeeded();
+    this.#timeoutId = undefined;
+  }
+  get #isIntervalPaused() {
+    const now = Date.now();
+    if (this.#intervalId === undefined) {
+      const delay = this.#intervalEnd - now;
+      if (delay < 0) {
+        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
       } else {
-        exec();
+        if (this.#timeoutId === undefined) {
+          this.#timeoutId = setTimeout(() => {
+            this.#onResumeInterval();
+          }, delay);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      if (this.#intervalId) {
+        clearInterval(this.#intervalId);
       }
-    } else if (noTrailing !== true) {
-      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
+      this.#intervalId = undefined;
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.emit("idle");
+      }
+      return false;
+    }
+    if (!this.#isPaused) {
+      const canInitializeInterval = !this.#isIntervalPaused;
+      if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+        const job = this.#queue.dequeue();
+        if (!job) {
+          return false;
+        }
+        this.emit("active");
+        job();
+        if (canInitializeInterval) {
+          this.#initializeIntervalIfNeeded();
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #initializeIntervalIfNeeded() {
+    if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
+      return;
+    }
+    this.#intervalId = setInterval(() => {
+      this.#onInterval();
+    }, this.#interval);
+    this.#intervalEnd = Date.now() + this.#interval;
+  }
+  #onInterval() {
+    if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = undefined;
+    }
+    this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+    this.#processQueue();
+  }
+  #processQueue() {
+    while (this.#tryToStartAnother()) {
+    }
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  async#throwOnAbort(signal) {
+    return new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+      }, { once: true });
+    });
+  }
+  setPriority(id, priority) {
+    this.#queue.setPriority(id, priority);
+  }
+  async add(function_, options = {}) {
+    options.id ??= (this.#idAssigner++).toString();
+    options = {
+      timeout: this.timeout,
+      throwOnTimeout: this.#throwOnTimeout,
+      ...options
+    };
+    return new Promise((resolve, reject) => {
+      this.#queue.enqueue(async () => {
+        this.#pending++;
+        this.#intervalCount++;
+        try {
+          options.signal?.throwIfAborted();
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
+          }
+          const result = await operation;
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          if (error instanceof TimeoutError && !options.throwOnTimeout) {
+            resolve();
+            return;
+          }
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          this.#next();
+        }
+      }, options);
+      this.emit("add");
+      this.#tryToStartAnother();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  pause() {
+    this.#isPaused = true;
+  }
+  clear() {
+    this.#queue = new this.#queueClass;
+  }
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
     }
+    await this.#onEvent("empty");
+  }
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  async onIdle() {
+    if (this.#pending === 0 && this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  async#onEvent(event, filter) {
+    return new Promise((resolve) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve();
+      };
+      this.on(event, listener);
+    });
+  }
+  get size() {
+    return this.#queue.size;
+  }
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  get pending() {
+    return this.#pending;
+  }
+  get isPaused() {
+    return this.#isPaused;
   }
-  wrapper.cancel = cancel;
-  return wrapper;
 }
 
 // src/server.ts
@@ -1127,12 +1651,7 @@ async function startBunDevServer(serverConfig, importMeta) {
     createIndexHTML: true,
     tscConfigPath: resolve(importMeta.dir, "./tsconfig.json"),
     broadcastBuildOutputToConsole: true,
-    broadcastBuildOutputToClient: true,
-    throttleOptions: {
-      noLeading: false,
-      noTrailing: false,
-      debounceMode: undefined
-    }
+    broadcastBuildOutputToClient: true
   };
   const finalConfig = { ...defaultConfig, ...serverConfig };
   if (serverConfig.tscConfigPath) {
@@ -1216,51 +1735,69 @@ async function startBunDevServer(serverConfig, importMeta) {
       sendPings: true
     }
   });
-  const debouncedbuildAndNotify = getThrottledBuildAndNotify(finalConfig);
-  debouncedbuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
+  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) {
-    debouncedbuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, event);
-  }
-}
-function getThrottledBuildAndNotify(serverConfig) {
-  return throttle(serverConfig.watchDelay ?? 1000, async (importerMeta, finalConfig, destinationPath, buildCfg, bunServer, event) => {
-    if (finalConfig.cleanServePath) {
-      await cleanDirectory(destinationPath);
-    }
-    const buildEnv = {
-      importerMeta,
-      finalConfig,
-      destinationPath,
-      buildCfg,
-      bunServer,
-      event
-    };
-    finalConfig.beforeBuild?.(buildEnv);
     try {
-      const output = await Bun.build(buildCfg);
-      publishOutputLogs(bunServer, output, finalConfig, event);
-      if (finalConfig.createIndexHTML) {
-        publishIndexHTML(destinationPath, finalConfig.serveIndexHtmlEjs, output, event);
-      }
-      if (finalConfig.writeManifest) {
-        writeManifest(output, destinationPath, finalConfig.manifestWithHash, finalConfig.manifestName);
-      }
-      finalConfig.afterBuild?.(output, buildEnv);
-      if (finalConfig.reloadOnChange && !finalConfig.waitForTSCSuccessBeforeReload) {
-        bunServer.publish("message", JSON.stringify({ type: "reload" }));
-      }
-      const tscSuccess = await performTSC(finalConfig, importerMeta);
-      if (finalConfig.reloadOnChange && finalConfig.waitForTSCSuccessBeforeReload && !tscSuccess.error) {
-        bunServer.publish("message", JSON.stringify({ type: "reload" }));
-      }
-      if (tscSuccess.error && finalConfig.broadcastTSCErrorToClient) {
-        bunServer.publish("message", JSON.stringify({ type: "tscerror", message: tscSuccess.message }));
+      if (queue.size > 0) {
+        queue.clear();
       }
+      queue.add(async () => {
+        await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, event);
+      });
     } catch (e) {
-      console.error(e);
+      console.error("Error while processing file change", e);
+    }
+  }
+}
+function getThrottledBuildAndNotify(serverConfig) {
+  const anotherThrottle = new PQueue({
+    concurrency: 1,
+    intervalCap: 1,
+    interval: serverConfig.watchDelay ?? 1000,
+    carryoverConcurrencyCount: true
+  });
+  return anotherThrottle;
+}
+async function cleanBuildAndNotify(importerMeta, finalConfig, destinationPath, buildCfg, bunServer, event) {
+  if (finalConfig.cleanServePath) {
+    await cleanDirectory(destinationPath);
+  }
+  const buildEnv = {
+    importerMeta,
+    finalConfig,
+    destinationPath,
+    buildCfg,
+    bunServer,
+    event
+  };
+  finalConfig.beforeBuild?.(buildEnv);
+  try {
+    const output = await build(buildCfg);
+    publishOutputLogs(bunServer, output, finalConfig, event);
+    if (finalConfig.createIndexHTML) {
+      publishIndexHTML(destinationPath, finalConfig.serveIndexHtmlEjs, output, event);
+    }
+    if (finalConfig.writeManifest) {
+      writeManifest(output, destinationPath, finalConfig.manifestWithHash, finalConfig.manifestName);
     }
-  }, serverConfig.throttleOptions);
+    finalConfig.afterBuild?.(output, buildEnv);
+    if (finalConfig.reloadOnChange && !finalConfig.waitForTSCSuccessBeforeReload) {
+      bunServer.publish("message", JSON.stringify({ type: "reload" }));
+    }
+    const tscSuccess = await performTSC(finalConfig, importerMeta);
+    if (finalConfig.reloadOnChange && finalConfig.waitForTSCSuccessBeforeReload && !tscSuccess.error) {
+      bunServer.publish("message", JSON.stringify({ type: "reload" }));
+    }
+    if (tscSuccess.error && finalConfig.broadcastTSCErrorToClient) {
+      bunServer.publish("message", JSON.stringify({ type: "tscerror", message: tscSuccess.message }));
+    }
+  } catch (e) {
+    console.error(e);
+  }
 }
 function handleErrorResponse(req, err) {
   const msg = `Error while processing request ${req.url}`;

package/package.json

@@ -24,7 +24,7 @@
   "exports": {
     ".": "./dist/index.js"
   },
-  "version": "0.9.82",
+  "version": "0.9.83",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",
@@ -32,16 +32,15 @@
     "build": "bun run ./build.ts"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.8",
-    "@types/throttle-debounce": "^5.0.2",
-    "throttle-debounce": "^5.0.2"
+    "@types/bun": "^1.2.8"
   },
   "peerDependencies": {
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.3"
   },
   "dependencies": {
     "@types/ejs": "^3.1.5",
     "ejs": "^3.1.10",
+    "p-queue": "^8.1.0",
     "picocolors": "^1.1.1"
   }
 }