@utoo/pack 1.2.13 → 1.3.0-alpha.1

package/cjs/binding.d.ts

@@ -9,22 +9,6 @@ export declare class ExternalObject<T> {
     [K: symbol]: T
   }
 }
-/** Arguments for `NapiTurbopackCallbacks::throw_turbopack_internal_error`. */
-export interface TurbopackInternalErrorOpts {
-  message: string
-  anonymizedLocation?: string
-}
-export interface NapiTurbopackCallbacksJsObject {
-  /**
-   * Called when we've encountered a bug in Turbopack and not in the user's code. Constructs and
-   * throws a `TurbopackInternalError` type. Logs to anonymized telemetry.
-   *
-   * As a result of the use of `ErrorStrategy::CalleeHandled`, the first argument is an error if
-   * there's a runtime conversion error. This should never happen, but if it does, the function
-   * can throw it instead.
-   */
-  throwTurbopackInternalError: (conversionError: Error | null, opts: TurbopackInternalErrorOpts) => never
-}
 export declare function registerWorkerScheduler(creator: (arg: NapiWorkerCreation) => any, terminator: (arg: NapiWorkerTermination) => any): void
 export declare function workerCreated(workerId: number): void
 export interface NapiWorkerCreation {
@@ -93,11 +77,6 @@ export interface NapiProjectOptions {
   config: string
   /** A map of environment variables to use when compiling code. */
   processEnv: Array<NapiEnvVar>
-  /**
-   * A map of environment variables which should get injected at compile
-   * time.
-   */
-  defineEnv: NapiDefineEnv
   /** The mode in which Next.js is running. */
   dev: boolean
   /** The build id. */
@@ -119,11 +98,6 @@ export interface NapiPartialProjectOptions {
   config?: string
   /** A map of environment variables to use when compiling code. */
   processEnv?: Array<NapiEnvVar>
-  /**
-   * A map of environment variables which should get injected at compile
-   * time.
-   */
-  defineEnv?: NapiDefineEnv
   /** The mode in which Next.js is running. */
   dev?: boolean
   /** The build id. */
@@ -136,11 +110,6 @@ export interface NapiPartialProjectOptions {
   noMangling?: boolean
   packPath?: string
 }
-export interface NapiDefineEnv {
-  client: Array<NapiEnvVar>
-  edge: Array<NapiEnvVar>
-  nodejs: Array<NapiEnvVar>
-}
 export interface NapiTurboEngineOptions {
   /** Use the new backend with persistent caching enabled. */
   persistentCaching?: boolean
@@ -214,6 +183,11 @@ export declare function projectTraceSource(project: { __napiType: "Project" }, f
 export declare function projectGetSourceForAsset(project: { __napiType: "Project" }, filePath: string): Promise<string | null>
 export declare function projectGetSourceMap(project: { __napiType: "Project" }, filePath: RcStr): Promise<string | null>
 export declare function projectGetSourceMapSync(project: { __napiType: "Project" }, filePath: RcStr): string | null
+/** Arguments for `NapiTurbopackCallbacks::throw_turbopack_internal_error`. */
+export interface TurbopackInternalErrorOpts {
+  message: string
+  anonymizedLocation?: string
+}
 /**
  * A version of [`NapiTurbopackCallbacks`] that can accepted as an argument to a napi function.
  *

package/cjs/commands/build.js

@@ -28,7 +28,7 @@ function build(options, projectPath, rootPath) {
     return buildInternal(bundleOptions, projectPath, rootPath);
 }
 async function buildInternal(bundleOptions, projectPath, rootPath) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f;
     (0, common_1.blockStdout)();
     if (process.env.XCODE_PROFILE) {
         await (0, xcodeProfile_1.xcodeProfilingReady)();
@@ -39,15 +39,10 @@ async function buildInternal(bundleOptions, projectPath, rootPath) {
     const createProject = (0, project_1.projectFactory)();
     const project = await createProject({
         processEnv: (_a = bundleOptions.processEnv) !== null && _a !== void 0 ? _a : {},
-        defineEnv: (0, common_1.createDefineEnv)({
-            config: bundleOptions.config,
-            dev: (_b = bundleOptions.dev) !== null && _b !== void 0 ? _b : false,
-            optionDefineEnv: bundleOptions.defineEnv,
-        }),
         watch: {
             enable: false,
         },
-        dev: (_c = bundleOptions.dev) !== null && _c !== void 0 ? _c : false,
+        dev: (_b = bundleOptions.dev) !== null && _b !== void 0 ? _b : false,
         buildId: bundleOptions.buildId || (0, nanoid_1.nanoid)(),
         config: {
             ...bundleOptions.config,
@@ -59,7 +54,7 @@ async function buildInternal(bundleOptions, projectPath, rootPath) {
         rootPath: rootPath || projectPath || process.cwd(),
         packPath: (0, common_1.getPackPath)(),
     }, {
-        persistentCaching: (_d = bundleOptions.config.persistentCaching) !== null && _d !== void 0 ? _d : false,
+        persistentCaching: (_c = bundleOptions.config.persistentCaching) !== null && _c !== void 0 ? _c : false,
     });
     const entrypoints = await project.writeAllEntrypointsToDisk();
     (0, pack_shared_1.handleIssues)(entrypoints.issues);
@@ -75,20 +70,20 @@ async function buildInternal(bundleOptions, projectPath, rootPath) {
     ];
     if (htmlConfigs.length > 0) {
         const assets = { js: [], css: [] };
-        const outputDir = ((_e = bundleOptions.config.output) === null || _e === void 0 ? void 0 : _e.path) || path_1.default.join(process.cwd(), "dist");
+        const outputDir = ((_d = bundleOptions.config.output) === null || _d === void 0 ? void 0 : _d.path) || path_1.default.join(process.cwd(), "dist");
         if (assets.js.length === 0 && assets.css.length === 0) {
             const discovered = (0, getInitialAssets_1.getInitialAssetsFromStats)(outputDir);
             assets.js.push(...discovered.js);
             assets.css.push(...discovered.css);
         }
-        const publicPath = (_f = bundleOptions.config.output) === null || _f === void 0 ? void 0 : _f.publicPath;
+        const publicPath = (_e = bundleOptions.config.output) === null || _e === void 0 ? void 0 : _e.publicPath;
         for (const config of htmlConfigs) {
             const plugin = new HtmlPlugin_1.HtmlPlugin(config);
             await plugin.generate(outputDir, assets, publicPath);
         }
     }
     if (process.env.ANALYZE) {
-        await analyzeBundle(((_g = bundleOptions.config.output) === null || _g === void 0 ? void 0 : _g.path) || "dist");
+        await analyzeBundle(((_f = bundleOptions.config.output) === null || _f === void 0 ? void 0 : _f.path) || "dist");
     }
     await project.shutdown();
     // TODO: Maybe run tasks in worker is a better way, see

package/cjs/commands/dev-legacy.d.ts

@@ -0,0 +1,44 @@
+import { IncomingMessage, ServerResponse } from "http";
+import send from "send";
+import { Duplex, Writable } from "stream";
+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>;
+export interface SelfSignedCertificate {
+    key: string;
+    cert: string;
+    rootCA?: string;
+}
+export interface StartServerOptions {
+    port: number;
+    https?: boolean;
+    hostname?: string;
+    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;

package/cjs/commands/dev-legacy.js

@@ -0,0 +1,458 @@
+"use strict";
+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 fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+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");
+const findRoot_1 = require("../utils/findRoot");
+const mkcert_1 = require("../utils/mkcert");
+const printServerInfo_1 = require("../utils/printServerInfo");
+const xcodeProfile_1 = require("../utils/xcodeProfile");
+function parsePath(pathStr) {
+    const hashIndex = pathStr.indexOf("#");
+    const queryIndex = pathStr.indexOf("?");
+    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+    if (hasQuery || hashIndex > -1) {
+        return {
+            pathname: pathStr.substring(0, hasQuery ? queryIndex : hashIndex),
+            query: hasQuery
+                ? pathStr.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined)
+                : "",
+            hash: hashIndex > -1 ? pathStr.slice(hashIndex) : "",
+        };
+    }
+    return { pathname: pathStr, query: "", hash: "" };
+}
+function pathHasPrefix(pathStr, prefix) {
+    if (typeof pathStr !== "string") {
+        return false;
+    }
+    const { pathname } = parsePath(pathStr);
+    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) {
+    const escapedPublicPath = (publicPath === null || publicPath === void 0 ? void 0 : publicPath.replace(/^\/+|\/+$/g, "")) || false;
+    if (!escapedPublicPath) {
+        return "";
+    }
+    try {
+        if (URL.canParse(escapedPublicPath)) {
+            const url = new URL(escapedPublicPath).toString();
+            return url.endsWith("/") ? url.slice(0, -1) : url;
+        }
+    }
+    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) {
+        try {
+            // createSelfSignedCertificate may return undefined on failure
+            const cert = await (0, mkcert_1.createSelfSignedCertificate)(serverOpts.hostname);
+            if (cert)
+                serverOpts.selfSignedCertificate = cert;
+        }
+        catch (e) {
+            // ignore and fall back to http if certificate generation fails
+        }
+    }
+    await startServer(serverOpts, {
+        ...options,
+        config: {
+            ...options.config,
+            devServer: {
+                hot: true,
+                ...(options.config.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 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);
+            }
+            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();
+        },
+    };
+}
+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;
+    }
+}
+exports.ResponseAborted = ResponseAborted;
+function createWriterFromResponse(res, waitUntilForEnd) {
+    let started = false;
+    let drained = new DetachedPromise();
+    function onDrain() {
+        drained.resolve();
+    }
+    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();
+            }
+            try {
+                const ok = res.write(chunk);
+                if ("flush" in res && typeof res.flush === "function") {
+                    res.flush();
+                }
+                if (!ok) {
+                    await drained.promise;
+                    drained = new DetachedPromise();
+                }
+            }
+            catch (err) {
+                res.end();
+                throw new Error("failed to write chunk to response", { cause: err });
+            }
+        },
+        abort: (err) => {
+            if (res.writableFinished)
+                return;
+            res.destroy(err);
+        },
+        close: async () => {
+            if (waitUntilForEnd) {
+                await waitUntilForEnd;
+            }
+            if (res.writableFinished)
+                return;
+            res.end();
+            return finished.promise;
+        },
+    });
+}
+class DetachedPromise {
+    constructor() {
+        let resolve;
+        let reject;
+        this.promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        this.resolve = resolve;
+        this.reject = reject;
+    }
+}
+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;
+}

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>;