nitropack-nightly 2.11.0-20250227-194814.c3d0e737 → 2.11.0-20250228-190633.b15db0a7

package/dist/core/index.mjs

@@ -8,7 +8,7 @@ import { watchConfig, loadConfig } from 'c12';
 import { resolveCompatibilityDatesFromEnv, formatDate, resolveCompatibilityDates, formatCompatibilityDate } from 'compatx';
 import { klona } from 'klona/full';
 import { isDebug, isTest, nodeMajorVersion, provider } from 'std-env';
-import { existsSync, promises, accessSync } from 'node:fs';
+import { existsSync, promises } from 'node:fs';
 import defu$1, { defu } from 'defu';
 import { withLeadingSlash, withoutTrailingSlash, withTrailingSlash, withBase, parseURL, joinURL, withoutBase } from 'ufo';
 import { colors } from 'consola/utils';
@@ -19,7 +19,7 @@ export { defineNitroPreset } from 'nitropack/kit';
 import { findWorkspaceDir } from 'pkg-types';
 import { createJiti } from 'jiti';
 import { globby } from 'globby';
-import fsp, { readFile, writeFile as writeFile$1, rm } from 'node:fs/promises';
+import fsp, { readFile, rm, writeFile as writeFile$1 } from 'node:fs/promises';
 import { ofetch } from 'ofetch';
 import { klona as klona$1 } from 'klona';
 import { createStorage as createStorage$1, builtinDrivers } from 'unstorage';
@@ -40,16 +40,16 @@ import { gzipSize } from 'gzip-size';
 import prettyBytes from 'pretty-bytes';
 import zlib from 'node:zlib';
 import { walk, parse } from 'ultrahtml';
+import { createError, setResponseHeaders, getRequestURL, setResponseStatus, getResponseHeader, setResponseHeader, send, getRequestHeader, getRequestHeaders, eventHandler, toNodeListener, createApp, fromNodeMiddleware } from 'h3';
 import { Worker } from 'node:worker_threads';
-import { setResponseHeaders, getRequestURL, setResponseStatus, getResponseHeader, setResponseHeader, send, getRequestHeader, getRequestHeaders, eventHandler, createError, createApp, fromNodeMiddleware, toNodeListener } from 'h3';
 import { createProxyServer } from 'httpxy';
-import { listen } from 'listhen';
-import { servePlaceholder } from 'serve-placeholder';
-import serveStatic from 'serve-static';
 import { resolve as resolve$1, dirname as dirname$1 } from 'node:path';
 import { ErrorParser } from 'youch-core';
 import { Youch } from 'youch';
 import { SourceMapConsumer } from 'source-map';
+import serveStatic from 'serve-static';
+import { listen } from 'listhen';
+import { servePlaceholder } from 'serve-placeholder';
 
 const NitroDefaults = {
   // General
@@ -1479,17 +1479,12 @@ function startRollupWatcher(nitro, rollupConfig) {
   let start;
   watcher.on("event", (event) => {
     switch (event.code) {
-      // The watcher is (re)starting
       case "START": {
-        return;
-      }
-      // Building an individual bundle
-      case "BUNDLE_START": {
         start = Date.now();
-        return;
+        nitro.hooks.callHook("dev:start");
+        break;
       }
-      // Finished building all bundles
-      case "END": {
+      case "BUNDLE_END": {
         nitro.hooks.callHook("compiled", nitro);
         if (nitro.options.logging.buildSuccess) {
           nitro.logger.success(
@@ -1498,11 +1493,11 @@ function startRollupWatcher(nitro, rollupConfig) {
           );
         }
         nitro.hooks.callHook("dev:reload");
-        return;
+        break;
       }
-      // Encountered an error while bundling
       case "ERROR": {
         nitro.logger.error(formatRollupError(event.error));
+        nitro.hooks.callHook("dev:error", event.error);
       }
     }
   });
@@ -2101,6 +2096,169 @@ ${[...parents.values()].map((link) => colors.gray(`  \u2502 \u2514\u2500\u2500 L
   }
 }
 
+function createHTTPProxy(defaults = {}) {
+  const proxy = createProxyServer(defaults);
+  proxy.on("proxyReq", (proxyReq, req) => {
+    if (!proxyReq.hasHeader("x-forwarded-for")) {
+      const address = req.socket.remoteAddress;
+      if (address) {
+        proxyReq.appendHeader("x-forwarded-for", address);
+      }
+    }
+    if (!proxyReq.hasHeader("x-forwarded-port")) {
+      const localPort = req?.socket?.localPort;
+      if (localPort) {
+        proxyReq.setHeader("x-forwarded-port", req.socket.localPort);
+      }
+    }
+    if (!proxyReq.hasHeader("x-forwarded-Proto")) {
+      const encrypted = req?.connection?.encrypted;
+      proxyReq.setHeader("x-forwarded-proto", encrypted ? "https" : "http");
+    }
+  });
+  const handleEvent = async (event, opts = {}) => {
+    try {
+      await proxy.web(event.node.req, event.node.res, opts);
+    } catch (error) {
+      if (error?.code !== "ECONNRESET") {
+        throw error;
+      }
+    }
+  };
+  return {
+    proxy,
+    handleEvent
+  };
+}
+
+class NodeDevWorker {
+  closed = false;
+  #id;
+  #workerDir;
+  #hooks;
+  #address;
+  #proxy;
+  #worker;
+  constructor(id, workerDir, hooks = {}) {
+    this.#id = id;
+    this.#workerDir = workerDir;
+    this.#hooks = hooks;
+    this.#proxy = createHTTPProxy();
+    this.#initWorker();
+  }
+  get ready() {
+    return Boolean(
+      !this.closed && this.#address && this.#proxy && this.#worker
+    );
+  }
+  handleEvent(event) {
+    if (!this.#address || !this.#proxy) {
+      throw createError({
+        statusCode: 503,
+        message: "worker is not ready yet"
+      });
+    }
+    return this.#proxy.handleEvent(event, { target: this.#address });
+  }
+  handleUpgrade(req, socket, head) {
+    if (!this.ready) {
+      return;
+    }
+    return this.#proxy.proxy.ws(
+      req,
+      socket,
+      { target: this.#address, xfwd: true },
+      head
+    );
+  }
+  #initWorker() {
+    const workerEntryPath = join(this.#workerDir, "index.mjs");
+    if (!existsSync(workerEntryPath)) {
+      this.close(`worker entry not found in "${workerEntryPath}".`);
+      return;
+    }
+    const worker = new Worker(workerEntryPath, {
+      env: {
+        ...process.env,
+        NITRO_DEV_WORKER_ID: String(this.#id),
+        NITRO_DEV_WORKER_DIR: this.#workerDir
+      }
+    });
+    worker.once("exit", (code) => {
+      worker._exitCode = code;
+      this.close(`worker exited with code ${code}`);
+    });
+    worker.once("error", (error) => {
+      this.close(error);
+    });
+    worker.on("message", (message) => {
+      if (message?.address) {
+        this.#address = message.address;
+        this.#hooks.onReady?.(this, this.#address);
+      }
+    });
+    this.#worker = worker;
+  }
+  async close(cause) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.#hooks.onClose?.(this, cause);
+    this.#hooks = {};
+    await Promise.all(
+      [this.#closeProxy(), this.#closeSocket(), this.#closeWorker()].map(
+        (p) => p.catch((error) => consola.error(error))
+      )
+    );
+  }
+  async #closeProxy() {
+    this.#proxy?.proxy?.close(() => {
+    });
+    this.#proxy = void 0;
+  }
+  async #closeSocket() {
+    const socketPath = this.#address?.socketPath;
+    if (socketPath && socketPath[0] !== "\0" && !socketPath.startsWith(String.raw`\\.\pipe`)) {
+      await rm(socketPath).catch(() => {
+      });
+    }
+    this.#address = void 0;
+  }
+  async #closeWorker() {
+    if (!this.#worker) {
+      return;
+    }
+    this.#worker.postMessage({ event: "shutdown" });
+    if (!this.#worker._exitCode) {
+      await new Promise((resolve) => {
+        const gracefulShutdownTimeoutSec = Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 5;
+        const timeout = setTimeout(() => {
+          consola.warn(
+            `force closing dev worker after ${gracefulShutdownTimeoutSec} seconds...`
+          );
+          resolve();
+        }, gracefulShutdownTimeoutSec * 1e3);
+        this.#worker?.on("message", (message) => {
+          if (message.event === "exit") {
+            clearTimeout(timeout);
+            resolve();
+          }
+        });
+      });
+    }
+    this.#worker.removeAllListeners();
+    await this.#worker.terminate().catch((error) => {
+      consola.error(error);
+    });
+    this.#worker = void 0;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    const status = this.closed ? "closed" : this.ready ? "ready" : "pending";
+    return `NodeDevWorker#${this.#id}(${status})`;
+  }
+}
+
 function defineNitroErrorHandler(handler) {
   return handler;
 }
@@ -2361,262 +2519,243 @@ const editorTemplate = (options) => `
 `;
 
 function createDevServer(nitro) {
-  const workerDir = resolve(
-    nitro.options.output.dir,
-    nitro.options.output.serverDir
-  );
-  const errorHandler = nitro.options.devErrorHandler || defaultErrorHandler;
-  let lastError;
-  let reloadPromise;
-  let currentWorker;
-  const reloadWorker = async () => {
-    const oldWorker = currentWorker;
-    currentWorker = void 0;
-    await killWorker(oldWorker, nitro);
-    currentWorker = await initWorker(workerDir);
-    if (!currentWorker) {
-      return;
+  const devServer = new DevServer(nitro);
+  return {
+    reload: () => devServer.reload(),
+    listen: (port, opts) => devServer.listen(port, opts),
+    close: () => devServer.close(),
+    upgrade: (req, socket, head) => devServer.handleUpgrade(req, socket, head),
+    get app() {
+      return devServer.app;
+    },
+    get watcher() {
+      return devServer.watcher;
     }
-    const buildInfoPath = resolve(nitro.options.buildDir, "nitro.json");
-    const buildInfo = {
-      date: (/* @__PURE__ */ new Date()).toJSON(),
-      preset: nitro.options.preset,
-      framework: nitro.options.framework,
-      versions: {
-        nitro: version
-      },
-      dev: {
-        pid: process.pid,
-        workerAddress: currentWorker?.address
-      }
-    };
-    await writeFile$1(buildInfoPath, JSON.stringify(buildInfo, null, 2));
   };
-  const reloadWorkerDebounced = debounce(() => {
-    reloadPromise = reloadWorker().then(() => {
-      lastError = void 0;
-    }).catch(async (error) => {
-      await loadStackTrace(error).catch(() => {
-      });
-      consola.error(error);
-      lastError = error;
-    }).finally(() => {
-      reloadPromise = void 0;
+}
+class DevServer {
+  nitro;
+  workerDir;
+  app;
+  listeners = [];
+  reloadPromise;
+  watcher;
+  workers = [];
+  workerIdCtr = 0;
+  workerError;
+  building = true;
+  buildError;
+  constructor(nitro) {
+    this.nitro = nitro;
+    this.workerDir = resolve(
+      nitro.options.output.dir,
+      nitro.options.output.serverDir
+    );
+    this.app = this.createApp();
+    nitro.hooks.hook("close", () => this.close());
+    nitro.hooks.hook("dev:start", () => {
+      this.building = true;
+      this.buildError = void 0;
     });
-    return reloadPromise;
-  });
-  nitro.hooks.hook("dev:reload", reloadWorkerDebounced);
-  const app = createApp();
-  for (const handler of nitro.options.devHandlers) {
-    app.use(handler.route || "/", handler.handler);
+    nitro.hooks.hook("dev:reload", () => {
+      this.buildError = void 0;
+      this.building = false;
+      this.reload();
+    });
+    nitro.hooks.hook("dev:error", (cause) => {
+      this.buildError = cause;
+      this.building = false;
+      for (const worker of this.workers) {
+        worker.close();
+      }
+    });
+    if (nitro.options.devServer.watch.length > 0) {
+      const debouncedReload = debounce(() => this.reload());
+      this.watcher = watch(
+        nitro.options.devServer.watch,
+        nitro.options.watchOptions
+      );
+      this.watcher.on("add", debouncedReload).on("change", debouncedReload);
+    }
   }
-  app.use("/_vfs", createVFSHandler(nitro));
-  for (const asset of nitro.options.publicAssets) {
-    const url = joinURL(
-      nitro.options.runtimeConfig.app.baseURL,
-      asset.baseURL || "/"
+  async listen(port, opts) {
+    const listener = await listen(toNodeListener(this.app), { port, ...opts });
+    this.listeners.push(listener);
+    listener.server.on(
+      "upgrade",
+      (req, sock, head) => this.handleUpgrade(req, sock, head)
     );
-    app.use(url, fromNodeMiddleware(serveStatic(asset.dir)));
-    if (!asset.fallthrough) {
-      app.use(url, fromNodeMiddleware(servePlaceholder()));
-    }
+    return listener;
   }
-  for (const route of Object.keys(nitro.options.devProxy).sort().reverse()) {
-    let opts = nitro.options.devProxy[route];
-    if (typeof opts === "string") {
-      opts = { target: opts };
-    }
-    const proxy2 = createProxy(opts);
-    app.use(
-      route,
-      eventHandler(async (event) => {
-        await proxy2.handle(event);
-      })
+  async close() {
+    await Promise.all(
+      [
+        Promise.all(this.listeners.map((l) => l.close())).then(() => {
+          this.listeners = [];
+        }),
+        Promise.all(this.workers.map((w) => w.close())).then(() => {
+          this.workers = [];
+        }),
+        Promise.resolve(this.watcher?.close()).then(() => {
+          this.watcher = void 0;
+        })
+      ].map(
+        (p) => p.catch((error) => {
+          consola.error(error);
+        })
+      )
     );
   }
-  const proxy = createProxy();
-  proxy.proxy.on("proxyReq", (proxyReq, req) => {
-    if (!proxyReq.hasHeader("x-forwarded-for")) {
-      const address = req.socket.remoteAddress;
-      if (address) {
-        proxyReq.appendHeader("x-forwarded-for", address);
-      }
+  reload() {
+    for (const worker2 of this.workers) {
+      worker2.close();
     }
-    if (!proxyReq.hasHeader("x-forwarded-port")) {
-      const localPort = req?.socket?.localPort;
-      if (localPort) {
-        proxyReq.setHeader("x-forwarded-port", req.socket.localPort);
+    const worker = new NodeDevWorker(++this.workerIdCtr, this.workerDir, {
+      onClose: (worker2, cause) => {
+        this.workerError = cause;
+        const index = this.workers.indexOf(worker2);
+        if (index !== -1) {
+          this.workers.splice(index, 1);
+        }
+      },
+      onReady: (worker2, addr) => {
+        this.writeBuildInfo(worker2, addr);
       }
+    });
+    if (!worker.closed) {
+      this.workers.unshift(worker);
     }
-    if (!proxyReq.hasHeader("x-forwarded-Proto")) {
-      const encrypted = req?.connection?.encrypted;
-      proxyReq.setHeader("x-forwarded-proto", encrypted ? "https" : "http");
-    }
-  });
-  const getWorkerAddress = () => {
-    const address = currentWorker?.address;
-    if (!address) {
-      return;
-    }
-    if (address.socketPath) {
-      try {
-        accessSync(address.socketPath);
-      } catch (error) {
-        if (!lastError) {
-          lastError = error;
-        }
+  }
+  async getWorker() {
+    let retry = 0;
+    while (this.building || ++retry < 10) {
+      if ((this.workers.length === 0 || this.buildError) && !this.building) {
         return;
       }
+      const activeWorker = this.workers.find((w) => w.ready);
+      if (activeWorker) {
+        return activeWorker;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 500));
     }
-    return address;
-  };
-  app.use(
-    eventHandler(async (event) => {
-      await reloadPromise;
-      let address = getWorkerAddress();
-      for (let i = 0; i < 10 && !address && !lastError; i++) {
-        await (reloadPromise || new Promise((resolve2) => setTimeout(resolve2, 200)));
-        address = getWorkerAddress();
+  }
+  writeBuildInfo(_worker, addr) {
+    const buildInfoPath = resolve(this.nitro.options.buildDir, "nitro.json");
+    const buildInfo = {
+      date: (/* @__PURE__ */ new Date()).toJSON(),
+      preset: this.nitro.options.preset,
+      framework: this.nitro.options.framework,
+      versions: {
+        nitro: version
+      },
+      dev: {
+        pid: process.pid,
+        workerAddress: addr
       }
-      if (!address || lastError) {
-        return errorHandler(
-          lastError || createError({
-            statusCode: 503,
-            message: "Worker not ready"
-          }),
-          event
-        );
+    };
+    writeFile$1(buildInfoPath, JSON.stringify(buildInfo, null, 2)).catch(
+      (error) => {
+        consola.error(error);
       }
-      await proxy.handle(event, { target: address }).catch((error) => {
-        lastError = error;
-        throw error;
-      });
-    })
-  );
-  const upgrade = (req, socket, head) => {
-    return proxy.proxy.ws(
-      req,
-      // @ts-expect-error
-      socket,
-      {
-        target: getWorkerAddress(),
-        xfwd: true
-      },
-      head
     );
-  };
-  let listeners = [];
-  const listen$1 = async (port, opts) => {
-    const listener = await listen(toNodeListener(app), { port, ...opts });
-    listener.server.on("upgrade", (req, sock, head) => {
-      upgrade(req, sock, head);
-    });
-    listeners.push(listener);
-    return listener;
-  };
-  let watcher;
-  if (nitro.options.devServer.watch.length > 0) {
-    watcher = watch(nitro.options.devServer.watch, nitro.options.watchOptions);
-    watcher.on("add", reloadWorkerDebounced).on("change", reloadWorkerDebounced);
-  }
-  const close = async () => {
-    if (watcher) {
-      await watcher.close();
-    }
-    await killWorker(currentWorker, nitro);
-    await Promise.all(listeners.map((l) => l.close()));
-    listeners = [];
-  };
-  nitro.hooks.hook("close", close);
-  return {
-    reload: reloadWorkerDebounced,
-    listen: listen$1,
-    app,
-    close,
-    watcher,
-    upgrade
-  };
-}
-function initWorker(workerDir) {
-  const workerEntry = join(workerDir, "index.mjs");
-  if (!existsSync(workerEntry)) {
-    return;
   }
-  return new Promise((resolve2, reject) => {
-    const worker = new Worker(workerEntry, {
-      env: {
-        ...process.env,
-        NITRO_DEV_WORKER_DIR: workerDir
+  createApp() {
+    const app = createApp({
+      onError: async (error, event) => {
+        const errorHandler = this.nitro.options.devErrorHandler || defaultErrorHandler;
+        await loadStackTrace(error).catch(() => {
+        });
+        return errorHandler(error, event);
       }
     });
-    worker.once("exit", (code) => {
-      reject(
-        new Error(
-          code ? "[worker] exited with code: " + code : "[worker] exited"
-        )
+    for (const handler of this.nitro.options.devHandlers) {
+      app.use(handler.route || "/", handler.handler);
+    }
+    app.use("/_vfs", createVFSHandler(this.nitro));
+    for (const asset of this.nitro.options.publicAssets) {
+      const url = joinURL(
+        this.nitro.options.runtimeConfig.app.baseURL,
+        asset.baseURL || "/"
       );
-    });
-    worker.once("error", async (error) => {
-      reject(error);
-    });
-    const addressListener = (event) => {
-      if (!event || !event?.address) {
-        return;
+      app.use(url, fromNodeMiddleware(serveStatic(asset.dir)));
+      if (!asset.fallthrough) {
+        app.use(url, fromNodeMiddleware(servePlaceholder()));
       }
-      worker.off("message", addressListener);
-      resolve2({
-        worker,
-        address: event.address
-      });
-    };
-    worker.on("message", addressListener);
-  });
-}
-async function killWorker(worker, nitro) {
-  if (!worker) {
-    return;
-  }
-  if (worker.worker) {
-    worker.worker.postMessage({ event: "shutdown" });
-    const gracefulShutdownTimeout = Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 3;
-    await new Promise((resolve2) => {
-      const timeout = setTimeout(() => {
-        nitro.logger.warn(
-          `[nitro] [dev] Force closing worker after ${gracefulShutdownTimeout} seconds...`
-        );
-        resolve2();
-      }, gracefulShutdownTimeout * 1e3);
-      worker.worker?.once("message", (message) => {
-        if (message.event === "exit") {
-          clearTimeout(timeout);
-          resolve2();
+    }
+    const routes = Object.keys(this.nitro.options.devProxy).sort().reverse();
+    for (const route of routes) {
+      let opts = this.nitro.options.devProxy[route];
+      if (typeof opts === "string") {
+        opts = { target: opts };
+      }
+      const proxy = createHTTPProxy(opts);
+      app.use(
+        route,
+        eventHandler((event) => proxy.handleEvent(event))
+      );
+    }
+    app.use(
+      eventHandler(async (event) => {
+        const worker = await this.getWorker();
+        if (!worker) {
+          return this.#generateError();
         }
+        return worker.handleEvent(event);
+      })
+    );
+    return app;
+  }
+  async handleUpgrade(req, socket, head) {
+    const worker = await this.getWorker();
+    if (!worker) {
+      throw createError({
+        statusCode: 503,
+        message: "No worker available."
       });
-    });
-    worker.worker.removeAllListeners();
-    await worker.worker.terminate();
-    worker.worker = null;
-  }
-  if (worker.address.socketPath) {
-    await rm(worker.address.socketPath).catch(() => {
-    });
+    }
+    return worker.handleUpgrade(req, socket, head);
   }
-}
-function createProxy(defaults = {}) {
-  const proxy = createProxyServer(defaults);
-  const handle = async (event, opts = {}) => {
-    try {
-      await proxy.web(event.node.req, event.node.res, opts);
-    } catch (error) {
-      if (error?.code !== "ECONNRESET") {
-        throw error;
+  #generateError() {
+    const error = this.buildError || this.workerError;
+    if (error) {
+      try {
+        error.unhandled = false;
+        let id = error.id || error.path;
+        if (id) {
+          const cause = error.errors?.[0];
+          const loc = error.location || error.loc || cause?.location || cause?.loc;
+          if (loc) {
+            id += `:${loc.line}:${loc.column}`;
+          }
+          error.stack = (error.stack || "").replace(
+            /(^\s*at\s+.+)/m,
+            `    at ${id}
+$1`
+          );
+        }
+      } catch {
       }
+      return createError(error);
     }
-  };
-  return {
-    proxy,
-    handle
-  };
+    return new Response(
+      JSON.stringify(
+        {
+          error: "The dev server is unavailable.",
+          hint: "Please reload the page and check the console for errors if the issue persists."
+        },
+        null,
+        2
+      ),
+      {
+        status: 503,
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store",
+          Refresh: "3"
+        }
+      }
+    );
+  }
 }
 
 const NEGATION_RE = /^(!?)(.*)$/;

package/dist/kit/index.d.mts

@@ -1,5 +1,5 @@
 import { NitroPreset, NitroPresetMeta, Nitro } from 'nitropack/types';
-import { N as NitroModule } from '../shared/nitro.CkNr_mO9.mjs';
+import { N as NitroModule } from '../shared/nitro.Bp0y4NyZ.mjs';
 import 'consola';
 import 'h3';
 import 'hookable';

package/dist/kit/index.d.ts

@@ -1,5 +1,5 @@
 import { NitroPreset, NitroPresetMeta, Nitro } from 'nitropack/types';
-import { N as NitroModule } from '../shared/nitro.CkNr_mO9.js';
+import { N as NitroModule } from '../shared/nitro.Bp0y4NyZ.js';
 import 'consola';
 import 'h3';
 import 'hookable';

package/dist/meta/index.d.mts

@@ -1,3 +1,3 @@
-const version = "2.11.0-20250227-194814.c3d0e737";
+const version = "2.11.0-20250228-190633.b15db0a7";
 
 export { version };

package/dist/meta/index.d.ts

@@ -1,3 +1,3 @@
-const version = "2.11.0-20250227-194814.c3d0e737";
+const version = "2.11.0-20250228-190633.b15db0a7";
 
 export { version };

package/dist/meta/index.mjs

@@ -1,3 +1,3 @@
-const version = "2.11.0-20250227-194814.c3d0e737";
+const version = "2.11.0-20250228-190633.b15db0a7";
 
 export { version };

package/dist/presets/_nitro/runtime/nitro-dev.mjs

@@ -6,7 +6,7 @@ import { startScheduleRunner } from "nitropack/runtime/internal";
 import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
 import { Server } from "node:http";
 import { join } from "node:path";
-import { parentPort, threadId } from "node:worker_threads";
+import { parentPort } from "node:worker_threads";
 import wsAdapter from "crossws/adapters/node";
 import {
   defineEventHandler,
@@ -15,7 +15,7 @@ import {
   readBody,
   toNodeListener
 } from "h3";
-import { isWindows, provider } from "std-env";
+const { NITRO_NO_UNIX_SOCKET, NITRO_DEV_WORKER_DIR, NITRO_DEV_WORKER_ID } = process.env;
 const nitroApp = useNitroApp();
 const server = new Server(toNodeListener(nitroApp.h3App));
 if (import.meta._websocket) {
@@ -23,15 +23,21 @@ if (import.meta._websocket) {
   server.on("upgrade", handleUpgrade);
 }
 function getAddress() {
-  if (provider === "stackblitz" || process.env.NITRO_NO_UNIX_SOCKET || process.versions.bun) {
+  if (NITRO_NO_UNIX_SOCKET || process.versions.webcontainer) {
     return 0;
   }
-  const socketName = `worker-${process.pid}-${threadId}.sock`;
-  if (isWindows) {
-    return join(String.raw`\\.\pipe\nitro`, socketName);
+  const socketName = `worker-${process.pid}-${NITRO_DEV_WORKER_ID}.sock`;
+  switch (process.platform) {
+    case "win32": {
+      return join(String.raw`\\.\pipe\nitro`, socketName);
+    }
+    case "linux": {
+      return `\0${socketName}`;
+    }
+    default: {
+      return join(NITRO_DEV_WORKER_DIR || ".", socketName);
+    }
   }
-  const workerDir = process.env.NITRO_DEV_WORKER_DIR || import.meta.dirname || process.cwd();
-  return join(workerDir, socketName);
 }
 const listenAddress = getAddress();
 const listener = server.listen(listenAddress, () => {

package/dist/shared/{nitro.CkNr_mO9.d.mts → nitro.Bp0y4NyZ.d.mts}

@@ -174,6 +174,8 @@ interface NitroHooks {
     "rollup:before": (nitro: Nitro, config: RollupConfig) => HookResult;
     compiled: (nitro: Nitro) => HookResult;
     "dev:reload": () => HookResult;
+    "dev:start": () => HookResult;
+    "dev:error": (cause?: unknown) => HookResult;
     "rollup:reload": () => HookResult;
     restart: () => HookResult;
     close: () => HookResult;
@@ -629,7 +631,7 @@ interface NitroBuildInfo {
     };
     dev?: {
         pid: number;
-        workerAddress: {
+        workerAddress?: {
             host: string;
             port: number;
             socketPath?: string;

package/dist/shared/{nitro.CkNr_mO9.d.ts → nitro.Bp0y4NyZ.d.ts}

@@ -174,6 +174,8 @@ interface NitroHooks {
     "rollup:before": (nitro: Nitro, config: RollupConfig) => HookResult;
     compiled: (nitro: Nitro) => HookResult;
     "dev:reload": () => HookResult;
+    "dev:start": () => HookResult;
+    "dev:error": (cause?: unknown) => HookResult;
     "rollup:reload": () => HookResult;
     restart: () => HookResult;
     close: () => HookResult;
@@ -629,7 +631,7 @@ interface NitroBuildInfo {
     };
     dev?: {
         pid: number;
-        workerAddress: {
+        workerAddress?: {
             host: string;
             port: number;
             socketPath?: string;

package/dist/types/index.d.mts

@@ -1,7 +1,7 @@
 import { App, Router, H3Event, RouterMethod } from 'h3';
 import { FetchRequest, FetchOptions, FetchResponse } from 'ofetch';
-import { a as NitroOptions, b as NitroConfig, N as NitroModule } from '../shared/nitro.CkNr_mO9.mjs';
-export { A as AppConfig, C as CacheEntry, c as CacheOptions, d as CachedEventHandlerOptions, e as CompressOptions, g as DatabaseConnectionConfig, h as DatabaseConnectionConfigs, D as DatabaseConnectionName, l as DevServerOptions, I as EsbuildOptions, O as HTTPStatusCode, L as LoadConfigOptions, u as Nitro, y as NitroBuildInfo, q as NitroDevEventHandler, n as NitroDevServer, v as NitroDynamicConfig, r as NitroErrorHandler, p as NitroEventHandler, x as NitroFrameworkInfo, s as NitroHooks, t as NitroModuleInput, k as NitroOpenAPIConfig, E as NitroPreset, F as NitroPresetMeta, Q as NitroRouteConfig, o as NitroRouteMeta, T as NitroRouteRules, j as NitroRuntimeConfig, i as NitroRuntimeConfigApp, w as NitroTypes, m as NitroWorker, J as NodeExternalsOptions, B as PrerenderGenerateRoute, z as PrerenderRoute, P as PublicAssetDir, M as RawOptions, R as ResponseCacheEntry, G as RollupConfig, H as RollupVirtualOptions, S as ServerAssetDir, K as ServerAssetOptions, f as StorageMounts, V as VirtualModule } from '../shared/nitro.CkNr_mO9.mjs';
+import { a as NitroOptions, b as NitroConfig, N as NitroModule } from '../shared/nitro.Bp0y4NyZ.mjs';
+export { A as AppConfig, C as CacheEntry, c as CacheOptions, d as CachedEventHandlerOptions, e as CompressOptions, g as DatabaseConnectionConfig, h as DatabaseConnectionConfigs, D as DatabaseConnectionName, l as DevServerOptions, I as EsbuildOptions, O as HTTPStatusCode, L as LoadConfigOptions, u as Nitro, y as NitroBuildInfo, q as NitroDevEventHandler, n as NitroDevServer, v as NitroDynamicConfig, r as NitroErrorHandler, p as NitroEventHandler, x as NitroFrameworkInfo, s as NitroHooks, t as NitroModuleInput, k as NitroOpenAPIConfig, E as NitroPreset, F as NitroPresetMeta, Q as NitroRouteConfig, o as NitroRouteMeta, T as NitroRouteRules, j as NitroRuntimeConfig, i as NitroRuntimeConfigApp, w as NitroTypes, m as NitroWorker, J as NodeExternalsOptions, B as PrerenderGenerateRoute, z as PrerenderRoute, P as PublicAssetDir, M as RawOptions, R as ResponseCacheEntry, G as RollupConfig, H as RollupVirtualOptions, S as ServerAssetDir, K as ServerAssetOptions, f as StorageMounts, V as VirtualModule } from '../shared/nitro.Bp0y4NyZ.mjs';
 import { Hookable } from 'hookable';
 import { NitroRuntimeHooks as NitroRuntimeHooks$1 } from 'nitropack';
 import { AbstractRequest, AbstractResponse } from 'node-mock-http';

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 import { App, Router, H3Event, RouterMethod } from 'h3';
 import { FetchRequest, FetchOptions, FetchResponse } from 'ofetch';
-import { a as NitroOptions, b as NitroConfig, N as NitroModule } from '../shared/nitro.CkNr_mO9.js';
-export { A as AppConfig, C as CacheEntry, c as CacheOptions, d as CachedEventHandlerOptions, e as CompressOptions, g as DatabaseConnectionConfig, h as DatabaseConnectionConfigs, D as DatabaseConnectionName, l as DevServerOptions, I as EsbuildOptions, O as HTTPStatusCode, L as LoadConfigOptions, u as Nitro, y as NitroBuildInfo, q as NitroDevEventHandler, n as NitroDevServer, v as NitroDynamicConfig, r as NitroErrorHandler, p as NitroEventHandler, x as NitroFrameworkInfo, s as NitroHooks, t as NitroModuleInput, k as NitroOpenAPIConfig, E as NitroPreset, F as NitroPresetMeta, Q as NitroRouteConfig, o as NitroRouteMeta, T as NitroRouteRules, j as NitroRuntimeConfig, i as NitroRuntimeConfigApp, w as NitroTypes, m as NitroWorker, J as NodeExternalsOptions, B as PrerenderGenerateRoute, z as PrerenderRoute, P as PublicAssetDir, M as RawOptions, R as ResponseCacheEntry, G as RollupConfig, H as RollupVirtualOptions, S as ServerAssetDir, K as ServerAssetOptions, f as StorageMounts, V as VirtualModule } from '../shared/nitro.CkNr_mO9.js';
+import { a as NitroOptions, b as NitroConfig, N as NitroModule } from '../shared/nitro.Bp0y4NyZ.js';
+export { A as AppConfig, C as CacheEntry, c as CacheOptions, d as CachedEventHandlerOptions, e as CompressOptions, g as DatabaseConnectionConfig, h as DatabaseConnectionConfigs, D as DatabaseConnectionName, l as DevServerOptions, I as EsbuildOptions, O as HTTPStatusCode, L as LoadConfigOptions, u as Nitro, y as NitroBuildInfo, q as NitroDevEventHandler, n as NitroDevServer, v as NitroDynamicConfig, r as NitroErrorHandler, p as NitroEventHandler, x as NitroFrameworkInfo, s as NitroHooks, t as NitroModuleInput, k as NitroOpenAPIConfig, E as NitroPreset, F as NitroPresetMeta, Q as NitroRouteConfig, o as NitroRouteMeta, T as NitroRouteRules, j as NitroRuntimeConfig, i as NitroRuntimeConfigApp, w as NitroTypes, m as NitroWorker, J as NodeExternalsOptions, B as PrerenderGenerateRoute, z as PrerenderRoute, P as PublicAssetDir, M as RawOptions, R as ResponseCacheEntry, G as RollupConfig, H as RollupVirtualOptions, S as ServerAssetDir, K as ServerAssetOptions, f as StorageMounts, V as VirtualModule } from '../shared/nitro.Bp0y4NyZ.js';
 import { Hookable } from 'hookable';
 import { NitroRuntimeHooks as NitroRuntimeHooks$1 } from 'nitropack';
 import { AbstractRequest, AbstractResponse } from 'node-mock-http';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitropack-nightly",
-  "version": "2.11.0-20250227-194814.c3d0e737",
+  "version": "2.11.0-20250228-190633.b15db0a7",
   "description": "Build and Deploy Universal JavaScript Servers",
   "repository": "nitrojs/nitro",
   "license": "MIT",