@utoo/pack 1.2.13-alpha.0 → 1.3.0-alpha.0

package/cjs/commands/dev.d.ts

@@ -1,9 +1,9 @@
-import { IncomingMessage, ServerResponse } from "http";
-import send from "send";
-import { Duplex, Writable } from "stream";
+/**
+ * Dev server implementation using Hono + @hono/node-server + @hono/node-ws.
+ * Keeps the same public API as dev.ts; do not remove dev.ts until this is verified.
+ */
 import { BundleOptions } from "../config/types";
-import { WebpackConfig } from "../config/webpackCompat";
-export declare function serve(options: BundleOptions | WebpackConfig, projectPath?: string, rootPath?: string, serverOptions?: StartServerOptions): Promise<void>;
+import { type WebpackConfig } from "../config/webpackCompat";
 export interface SelfSignedCertificate {
     key: string;
     cert: string;
@@ -16,29 +16,4 @@ export interface StartServerOptions {
     logServerInfo?: boolean;
     selfSignedCertificate?: SelfSignedCertificate;
 }
-export type RequestHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-export type UpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => Promise<void>;
-export type ServerInitResult = {
-    requestHandler: RequestHandler;
-    upgradeHandler: UpgradeHandler;
-    closeUpgraded: () => void;
-};
-export declare function startServer(serverOptions: StartServerOptions, bundleOptions: BundleOptions, projectPath: string, rootPath?: string): Promise<void>;
-export declare function initialize(bundleOptions: BundleOptions, projectPath: string, rootPath?: string): Promise<ServerInitResult>;
-export declare function pipeToNodeResponse(readable: ReadableStream<Uint8Array>, res: ServerResponse, waitUntilForEnd?: Promise<unknown>): Promise<void>;
-export declare function createAbortController(response: Writable): AbortController;
-export declare function isAbortError(e: any): e is Error & {
-    name: "AbortError";
-};
-export declare const ResponseAbortedName = "ResponseAborted";
-export declare class ResponseAborted extends Error {
-    readonly name = "ResponseAborted";
-}
-export declare class DetachedPromise<T = any> {
-    readonly resolve: (value: T | PromiseLike<T>) => void;
-    readonly reject: (reason: any) => void;
-    readonly promise: Promise<T>;
-    constructor();
-}
-export declare function serveStatic(req: IncomingMessage, res: ServerResponse, path: string, opts?: Parameters<typeof send>[2]): Promise<void>;
-export declare function formatHostname(hostname: string): string;
+export declare function serve(options: BundleOptions | WebpackConfig, projectPath?: string, rootPath?: string, serverOptions?: StartServerOptions): Promise<void>;

package/cjs/commands/dev.js

@@ -1,24 +1,21 @@
 "use strict";
+/**
+ * Dev server implementation using Hono + @hono/node-server + @hono/node-ws.
+ * Keeps the same public API as dev.ts; do not remove dev.ts until this is verified.
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DetachedPromise = exports.ResponseAborted = exports.ResponseAbortedName = void 0;
 exports.serve = serve;
-exports.startServer = startServer;
-exports.initialize = initialize;
-exports.pipeToNodeResponse = pipeToNodeResponse;
-exports.createAbortController = createAbortController;
-exports.isAbortError = isAbortError;
-exports.serveStatic = serveStatic;
-exports.formatHostname = formatHostname;
+const node_server_1 = require("@hono/node-server");
+const serve_static_1 = require("@hono/node-server/serve-static");
+const node_ws_1 = require("@hono/node-ws");
 const fs_1 = __importDefault(require("fs"));
-const http_1 = __importDefault(require("http"));
+const get_port_1 = __importDefault(require("get-port"));
+const hono_1 = require("hono");
 const https_1 = __importDefault(require("https"));
-const net_1 = require("net");
 const path_1 = __importDefault(require("path"));
-const send_1 = __importDefault(require("send"));
-const url_1 = __importDefault(require("url"));
 const webpackCompat_1 = require("../config/webpackCompat");
 const hmr_1 = require("../core/hmr");
 const common_1 = require("../utils/common");
@@ -26,6 +23,7 @@ const findRoot_1 = require("../utils/findRoot");
 const mkcert_1 = require("../utils/mkcert");
 const printServerInfo_1 = require("../utils/printServerInfo");
 const xcodeProfile_1 = require("../utils/xcodeProfile");
+// --- Path helpers (same logic as dev.ts, not exported) ---
 function parsePath(pathStr) {
     const hashIndex = pathStr.indexOf("#");
     const queryIndex = pathStr.indexOf("?");
@@ -49,18 +47,13 @@ function pathHasPrefix(pathStr, prefix) {
     return pathname === prefix || pathname.startsWith(prefix + "/");
 }
 function removePathPrefix(pathStr, prefix) {
-    // If the path doesn't start with the prefix we can return it as is.
     if (!pathHasPrefix(pathStr, prefix)) {
         return pathStr;
     }
-    // Remove the prefix from the path via slicing.
     const withoutPrefix = pathStr.slice(prefix.length);
-    // If the path without the prefix starts with a `/` we can return it as is.
     if (withoutPrefix.startsWith("/")) {
         return withoutPrefix;
     }
-    // If the path without the prefix doesn't start with a `/` we need to add it
-    // back to the path to make sure it's a valid path.
     return `/${withoutPrefix}`;
 }
 function normalizedPublicPath(publicPath) {
@@ -70,389 +63,173 @@ function normalizedPublicPath(publicPath) {
     }
     try {
         if (URL.canParse(escapedPublicPath)) {
-            const url = new URL(escapedPublicPath).toString();
-            return url.endsWith("/") ? url.slice(0, -1) : url;
+            const u = new URL(escapedPublicPath).toString();
+            return u.endsWith("/") ? u.slice(0, -1) : u;
         }
     }
     catch (_a) { }
     return `/${escapedPublicPath}`;
 }
-function serve(options, projectPath, rootPath, serverOptions) {
-    const bundleOptions = (0, webpackCompat_1.resolveBundleOptions)(options, projectPath, rootPath);
-    if (!rootPath) {
-        rootPath = (0, findRoot_1.findRootDir)(projectPath || process.cwd());
-    }
-    return serveInternal(bundleOptions, projectPath, rootPath, serverOptions);
-}
-async function serveInternal(options, projectPath, rootPath, serverOptions) {
-    var _a;
-    (0, common_1.blockStdout)();
-    if (process.env.XCODE_PROFILE) {
-        await (0, xcodeProfile_1.xcodeProfilingReady)();
-    }
-    // FIXME: fix any type
-    const cfgDevServer = (((_a = options.config) === null || _a === void 0 ? void 0 : _a.devServer) || {});
-    const serverOpts = {
-        hostname: (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.hostname) || cfgDevServer.host || "localhost",
-        port: typeof (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.port) !== "undefined"
-            ? serverOptions.port
-            : cfgDevServer.port || 3000,
-        https: typeof (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.https) !== "undefined"
-            ? serverOptions.https
-            : cfgDevServer.https,
-        logServerInfo: serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.logServerInfo,
-        selfSignedCertificate: serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.selfSignedCertificate,
-    };
-    // If HTTPS is requested and no certificate provided, attempt to generate one.
-    if (serverOpts.https && !serverOpts.selfSignedCertificate) {
+async function resolveDevConfig(options, projectPath, rootPath, serverOptions) {
+    var _a, _b, _d, _e, _f, _g;
+    const cfgDevServer = (_b = (_a = options.config) === null || _a === void 0 ? void 0 : _a.devServer) !== null && _b !== void 0 ? _b : {};
+    const port = typeof (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.port) !== "undefined"
+        ? serverOptions.port
+        : ((_d = cfgDevServer.port) !== null && _d !== void 0 ? _d : 3000);
+    const hostname = (_f = (_e = serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.hostname) !== null && _e !== void 0 ? _e : cfgDevServer.host) !== null && _f !== void 0 ? _f : "localhost";
+    const useHttps = typeof (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.https) !== "undefined"
+        ? serverOptions.https
+        : cfgDevServer.https;
+    let selfSignedCertificate = serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.selfSignedCertificate;
+    if (useHttps && !selfSignedCertificate) {
         try {
-            // createSelfSignedCertificate may return undefined on failure
-            const cert = await (0, mkcert_1.createSelfSignedCertificate)(serverOpts.hostname);
+            const cert = await (0, mkcert_1.createSelfSignedCertificate)(hostname);
             if (cert)
-                serverOpts.selfSignedCertificate = cert;
+                selfSignedCertificate = cert;
         }
-        catch (e) {
-            // ignore and fall back to http if certificate generation fails
+        catch (_h) {
+            // fall back to http
         }
     }
-    await startServer(serverOpts, {
+    const bundleOptions = {
         ...options,
         config: {
             ...options.config,
             devServer: {
                 hot: true,
-                ...(options.config.devServer || {}),
+                ...(((_g = options.config) === null || _g === void 0 ? void 0 : _g.devServer) || {}),
             },
         },
         packPath: (0, common_1.getPackPath)(),
-    }, projectPath || process.cwd(), rootPath);
-}
-async function startServer(serverOptions, bundleOptions, projectPath, rootPath) {
-    let { port, hostname, selfSignedCertificate } = serverOptions;
-    process.title = "utoopack-dev-server";
-    let handlersReady = () => { };
-    let handlersError = () => { };
-    let handlersPromise = new Promise((resolve, reject) => {
-        handlersReady = resolve;
-        handlersError = reject;
-    });
-    let requestHandler = async (req, res) => {
-        if (handlersPromise) {
-            await handlersPromise;
-            return requestHandler(req, res);
-        }
-        throw new Error("Invariant request handler was not setup");
     };
-    let upgradeHandler = async (req, socket, head) => {
-        if (handlersPromise) {
-            await handlersPromise;
-            return upgradeHandler(req, socket, head);
-        }
-        throw new Error("Invariant upgrade handler was not setup");
-    };
-    async function requestListener(req, res) {
-        try {
-            if (handlersPromise) {
-                await handlersPromise;
-                handlersPromise = undefined;
-            }
-            await requestHandler(req, res);
-        }
-        catch (err) {
-            res.statusCode = 500;
-            res.end("Internal Server Error");
-            console.error(`Failed to handle request for ${req.url}`);
-            console.error(err);
-        }
+    const projectPathResolved = projectPath || process.cwd();
+    const rootPathResolved = rootPath !== null && rootPath !== void 0 ? rootPath : projectPathResolved;
+    const actualPort = await (0, get_port_1.default)({ port, host: hostname });
+    if (actualPort !== port) {
+        console.warn(`Port ${port} is in use, using available port ${actualPort} instead.`);
     }
-    const server = selfSignedCertificate
-        ? https_1.default.createServer({
-            key: fs_1.default.readFileSync(selfSignedCertificate.key),
-            cert: fs_1.default.readFileSync(selfSignedCertificate.cert),
-        }, requestListener)
-        : http_1.default.createServer(requestListener);
-    server.on("upgrade", async (req, socket, head) => {
-        try {
-            await upgradeHandler(req, socket, head);
-        }
-        catch (err) {
-            socket.destroy();
-            console.error(`Failed to handle request for ${req.url}`);
-            console.error(err);
-        }
-    });
-    let portRetryCount = 0;
-    const originalPort = port;
-    server.on("error", (err) => {
-        if (port && err.code === "EADDRINUSE" && portRetryCount < 10) {
-            port += 1;
-            portRetryCount += 1;
-            server.listen(port, hostname);
-        }
-        else {
-            console.error(`Failed to start server`);
-            console.error(err);
-            process.exit(1);
-        }
-    });
-    await new Promise((resolve) => {
-        server.on("listening", async () => {
-            const addr = server.address();
-            const actualHostname = formatHostname(typeof addr === "object"
-                ? (addr === null || addr === void 0 ? void 0 : addr.address) || hostname || "localhost"
-                : addr);
-            const formattedHostname = !hostname || actualHostname === "0.0.0.0"
-                ? "localhost"
-                : actualHostname === "[::]"
-                    ? "[::1]"
-                    : formatHostname(hostname);
-            port = typeof addr === "object" ? (addr === null || addr === void 0 ? void 0 : addr.port) || port : port;
-            if (portRetryCount) {
-                console.warn(`Port ${originalPort} is in use, using available port ${port} instead.`);
-            }
-            if (serverOptions.logServerInfo !== false) {
-                (0, printServerInfo_1.printServerInfo)(serverOptions.https ? "https" : "http", formattedHostname, port);
-            }
-            try {
-                let cleanupStarted = false;
-                let closeUpgraded = null;
-                const cleanup = () => {
-                    if (cleanupStarted) {
-                        return;
-                    }
-                    cleanupStarted = true;
-                    (async () => {
-                        console.debug("start-server process cleanup");
-                        await new Promise((res) => {
-                            server.close((err) => {
-                                if (err)
-                                    console.error(err);
-                                res();
-                            });
-                            server.closeAllConnections();
-                            closeUpgraded === null || closeUpgraded === void 0 ? void 0 : closeUpgraded();
-                        });
-                        console.debug("start-server process cleanup finished");
-                        process.exit(0);
-                    })();
-                };
-                const exception = (err) => {
-                    console.error(err);
-                };
-                process.on("SIGINT", cleanup);
-                process.on("SIGTERM", cleanup);
-                process.on("rejectionHandled", () => { });
-                process.on("uncaughtException", exception);
-                process.on("unhandledRejection", exception);
-                const initResult = await initialize(bundleOptions, projectPath, rootPath);
-                requestHandler = initResult.requestHandler;
-                upgradeHandler = initResult.upgradeHandler;
-                closeUpgraded = initResult.closeUpgraded;
-                handlersReady();
-            }
-            catch (err) {
-                handlersError();
-                console.error(err);
-                process.exit(1);
+    const serveOptsBase = {
+        port: actualPort,
+        hostname,
+        ...(useHttps && selfSignedCertificate
+            ? {
+                createServer: https_1.default.createServer,
+                serverOptions: {
+                    key: fs_1.default.readFileSync(selfSignedCertificate.key),
+                    cert: fs_1.default.readFileSync(selfSignedCertificate.cert),
+                },
             }
-            resolve();
-        });
-        server.listen(port, hostname);
-    });
-}
-async function initialize(bundleOptions, projectPath, rootPath) {
-    process.env.NODE_ENV = "development";
-    const hotReloader = await (0, hmr_1.createHotReloader)(bundleOptions, projectPath, rootPath);
-    await hotReloader.start();
-    const requestHandlerImpl = async (req, res) => {
-        req.on("error", console.error);
-        res.on("error", console.error);
-        const handleRequest = async () => {
-            var _a, _b;
-            if (!(req.method === "GET" || req.method === "HEAD")) {
-                res.setHeader("Allow", ["GET", "HEAD"]);
-                res.statusCode = 405;
-                res.end();
-            }
-            const distRoot = path_1.default.resolve(projectPath, ((_a = bundleOptions.config.output) === null || _a === void 0 ? void 0 : _a.path) || "./dist");
-            const publicPath = (_b = bundleOptions.config.output) === null || _b === void 0 ? void 0 : _b.publicPath;
-            try {
-                const reqUrl = req.url || "";
-                let requestPath = url_1.default.parse(reqUrl).pathname || "";
-                if (publicPath && publicPath !== "runtime") {
-                    const normalizedPrefix = normalizedPublicPath(publicPath);
-                    const isAbsoluteUrl = normalizedPrefix.startsWith("http://") ||
-                        normalizedPrefix.startsWith("https://");
-                    if (!isAbsoluteUrl && normalizedPrefix) {
-                        if (pathHasPrefix(requestPath, normalizedPrefix)) {
-                            requestPath = removePathPrefix(requestPath, normalizedPrefix);
-                        }
-                    }
-                }
-                return await serveStatic(req, res, requestPath, { root: distRoot });
-            }
-            catch (err) {
-                res.setHeader("Cache-Control", "private, no-cache, no-store, max-age=0, must-revalidate");
-                res.statusCode = 404;
-                res.end();
-            }
-        };
-        try {
-            await handleRequest();
-        }
-        catch (err) {
-            res.statusCode = 500;
-            res.end("Internal Server Error");
-        }
-    };
-    let requestHandler = requestHandlerImpl;
-    const logError = async (type, err) => {
-        if (type === "unhandledRejection") {
-            console.error("unhandledRejection: ", err);
-        }
-        else if (type === "uncaughtException") {
-            console.error("uncaughtException: ", err);
-        }
-    };
-    process.on("uncaughtException", logError.bind(null, "uncaughtException"));
-    process.on("unhandledRejection", logError.bind(null, "unhandledRejection"));
-    const upgradeHandler = async (req, socket, head) => {
-        var _a;
-        try {
-            const isHMRRequest = (_a = req.url) === null || _a === void 0 ? void 0 : _a.includes("turbopack-hmr");
-            if (isHMRRequest) {
-                hotReloader.onHMR(req, socket, head);
-            }
-            else {
-                socket.end();
-            }
-        }
-        catch (err) {
-            console.error("Error handling upgrade request", err);
-            socket.end();
-        }
+            : {}),
     };
     return {
-        requestHandler,
-        upgradeHandler,
-        closeUpgraded() {
-            hotReloader.close();
-        },
+        bundleOptions,
+        projectPathResolved,
+        rootPathResolved,
+        serveOptsBase,
     };
 }
-async function pipeToNodeResponse(readable, res, waitUntilForEnd) {
-    try {
-        const { errored, destroyed } = res;
-        if (errored || destroyed)
-            return;
-        const controller = createAbortController(res);
-        const writer = createWriterFromResponse(res, waitUntilForEnd);
-        await readable.pipeTo(writer, { signal: controller.signal });
-    }
-    catch (err) {
-        if (isAbortError(err))
-            return;
-        throw new Error("failed to pipe response", { cause: err });
-    }
-}
-function createAbortController(response) {
-    const controller = new AbortController();
-    response.once("close", () => {
-        if (response.writableFinished)
-            return;
-        controller.abort(new ResponseAborted());
-    });
-    return controller;
-}
-function isAbortError(e) {
-    return (e === null || e === void 0 ? void 0 : e.name) === "AbortError" || (e === null || e === void 0 ? void 0 : e.name) === exports.ResponseAbortedName;
-}
-exports.ResponseAbortedName = "ResponseAborted";
-class ResponseAborted extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = exports.ResponseAbortedName;
+// --- Entry ---
+function serve(options, projectPath, rootPath, serverOptions) {
+    const bundleOptions = (0, webpackCompat_1.resolveBundleOptions)(options, projectPath, rootPath);
+    if (!rootPath) {
+        rootPath = (0, findRoot_1.findRootDir)(projectPath || process.cwd());
     }
+    return runDev(bundleOptions, projectPath, rootPath, serverOptions);
 }
-exports.ResponseAborted = ResponseAborted;
-function createWriterFromResponse(res, waitUntilForEnd) {
-    let started = false;
-    let drained = new DetachedPromise();
-    function onDrain() {
-        drained.resolve();
+const HMR_PATH = "/turbopack-hmr";
+async function runDev(options, projectPath, rootPath, serverOptions) {
+    var _a, _b, _d, _e;
+    (0, common_1.blockStdout)();
+    process.title = "utoopack-dev-server";
+    if (process.env.XCODE_PROFILE) {
+        await (0, xcodeProfile_1.xcodeProfilingReady)();
     }
-    res.on("drain", onDrain);
-    res.once("close", () => {
-        res.off("drain", onDrain);
-        drained.resolve();
-    });
-    const finished = new DetachedPromise();
-    res.once("finish", () => {
-        finished.resolve();
-    });
-    return new WritableStream({
-        write: async (chunk) => {
-            if (!started) {
-                started = true;
-                res.flushHeaders();
-            }
+    process.env.NODE_ENV = "development";
+    const { bundleOptions, projectPathResolved, rootPathResolved, serveOptsBase, } = await resolveDevConfig(options, projectPath, rootPath, serverOptions);
+    const hotReloader = await (0, hmr_1.createHotReloader)(bundleOptions, projectPathResolved, rootPathResolved);
+    await hotReloader.start();
+    const distRoot = path_1.default.resolve(projectPathResolved, ((_b = (_a = options.config) === null || _a === void 0 ? void 0 : _a.output) === null || _b === void 0 ? void 0 : _b.path) || "./dist");
+    const publicPath = (_e = (_d = options.config) === null || _d === void 0 ? void 0 : _d.output) === null || _e === void 0 ? void 0 : _e.publicPath;
+    // Skip prefix stripping for "runtime" and when publicPath is absent (match dev.ts).
+    const normalizedPrefix = publicPath && publicPath !== "runtime"
+        ? normalizedPublicPath(publicPath)
+        : "";
+    const app = new hono_1.Hono();
+    const { injectWebSocket, upgradeWebSocket } = (0, node_ws_1.createNodeWebSocket)({ app });
+    const rewriteRequestPath = (reqPath) => {
+        if (!normalizedPrefix)
+            return reqPath;
+        // Absolute-URL publicPath: do not rewrite (match dev.ts).
+        if (normalizedPrefix.startsWith("http://") ||
+            normalizedPrefix.startsWith("https://")) {
+            return reqPath;
+        }
+        if (pathHasPrefix(reqPath, normalizedPrefix)) {
+            return removePathPrefix(reqPath, normalizedPrefix);
+        }
+        return reqPath;
+    };
+    // HMR WebSocket route must be registered before "/*" so it is not handled by serveStatic
+    app.get(HMR_PATH, upgradeWebSocket((_c) => ({
+        onOpen(_ev, ws) {
+            hotReloader.registerClient(ws);
+        },
+        onMessage(ev, ws) {
             try {
-                const ok = res.write(chunk);
-                if ("flush" in res && typeof res.flush === "function") {
-                    res.flush();
-                }
-                if (!ok) {
-                    await drained.promise;
-                    drained = new DetachedPromise();
-                }
+                const data = typeof ev.data === "string" ? ev.data : ev.data.toString();
+                hotReloader.handleClientMessage(ws, data);
             }
             catch (err) {
-                res.end();
-                throw new Error("failed to write chunk to response", { cause: err });
+                console.error("HMR message error", err);
             }
         },
-        abort: (err) => {
-            if (res.writableFinished)
-                return;
-            res.destroy(err);
+        onClose(_ev, ws) {
+            hotReloader.unregisterClient(ws);
         },
-        close: async () => {
-            if (waitUntilForEnd) {
-                await waitUntilForEnd;
-            }
-            if (res.writableFinished)
-                return;
-            res.end();
-            return finished.promise;
+        onError(err) {
+            console.error("HMR WebSocket error", err);
         },
+    })));
+    // GET handles HEAD automatically in Hono; serveStatic serves both
+    app.get("/*", (0, serve_static_1.serveStatic)({
+        root: distRoot,
+        rewriteRequestPath,
+    }));
+    app.all("*", (c) => c.body(null, 405, { Allow: "GET, HEAD" }));
+    const server = (0, node_server_1.serve)({
+        ...serveOptsBase,
+        fetch: app.fetch,
     });
-}
-class DetachedPromise {
-    constructor() {
-        let resolve;
-        let reject;
-        this.promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        this.resolve = resolve;
-        this.reject = reject;
+    injectWebSocket(server);
+    if ((serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.logServerInfo) !== false) {
+        const scheme = serveOptsBase.serverOptions ? "https" : "http";
+        const displayHost = serveOptsBase.hostname === "0.0.0.0"
+            ? "localhost"
+            : serveOptsBase.hostname;
+        (0, printServerInfo_1.printServerInfo)(scheme, displayHost, serveOptsBase.port);
     }
-}
-exports.DetachedPromise = DetachedPromise;
-function serveStatic(req, res, path, opts) {
-    return new Promise((resolve, reject) => {
-        (0, send_1.default)(req, path, opts)
-            .on("directory", () => {
-            const err = new Error("No directory access");
-            err.code = "ENOENT";
-            reject(err);
-        })
-            .on("error", reject)
-            .pipe(res)
-            .on("finish", resolve);
-    });
-}
-function formatHostname(hostname) {
-    return (0, net_1.isIPv6)(hostname) ? `[${hostname}]` : hostname;
+    const cleanup = () => {
+        hotReloader.close();
+        // We always create HTTP/1.1 server (http or https), so closeAllConnections exists; Hono's
+        // ServerType union includes HTTP/2, so TS does not narrow. Use runtime check to satisfy types.
+        if ("closeAllConnections" in server &&
+            typeof server.closeAllConnections === "function") {
+            server.closeAllConnections();
+        }
+        server.close((err) => {
+            if (err) {
+                console.error(err);
+                process.exit(1);
+            }
+            process.exit(0);
+        });
+    };
+    const exception = (err) => {
+        console.error(err);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    process.on("rejectionHandled", () => { });
+    process.on("uncaughtException", exception);
+    process.on("unhandledRejection", exception);
 }

package/cjs/core/hmr.d.ts

@@ -13,6 +13,11 @@ export interface WebpackStats {
     toJson(options?: any): any;
     toString(options?: any): string;
 }
+/** Client handle for HMR: any object with send(data) usable as Set/WeakMap key (e.g. ws WebSocket or hono WSContext). */
+export interface WSLike {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+}
 export interface HotReloaderInterface {
     turbopackProject?: Project;
     serverStats: WebpackStats | null;
@@ -20,9 +25,18 @@ export interface HotReloaderInterface {
     clearHmrServerError(): void;
     start(): Promise<void>;
     send(action: HMR_ACTION_TYPES): void;
+    /**
+     * @deprecated Used by legacy dev server (dev-legacy.ts). Prefer registerClient / unregisterClient / handleClientMessage (e.g. dev.ts).
+     */
     onHMR(req: IncomingMessage, socket: Duplex, head: Buffer, onUpgrade?: (client: {
         send(data: string): void;
     }) => void): void;
+    /** Register a WebSocket client (e.g. from @hono/node-ws upgradeWebSocket). Call unregisterClient on close. */
+    registerClient(ws: WSLike): void;
+    /** Unregister and cleanup subscriptions for a client. */
+    unregisterClient(ws: WSLike): void;
+    /** Handle a message from a client (JSON string). */
+    handleClientMessage(ws: WSLike, data: string): void;
     buildFallbackError(): Promise<void>;
     close(): void;
 }