@utoo/pack 0.0.1-alpha.1 → 0.0.1-alpha.13

package/cjs/hmr.js

@@ -0,0 +1,285 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAST_REFRESH_RUNTIME_RELOAD = void 0;
+exports.createHotReloader = createHotReloader;
+const nanoid_1 = require("nanoid");
+const ws_1 = __importDefault(require("ws"));
+const project_1 = require("./project");
+const util_1 = require("./util");
+const wsServer = new ws_1.default.Server({ noServer: true });
+const sessionId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random());
+exports.FAST_REFRESH_RUNTIME_RELOAD = "Fast Refresh had to perform a full reload due to a runtime error.";
+async function createHotReloader(bundleOptions, projectPath, rootPath) {
+    var _a;
+    const createProject = (0, project_1.projectFactory)();
+    const project = await createProject({
+        processEnv: (_a = bundleOptions.processEnv) !== null && _a !== void 0 ? _a : {},
+        processDefineEnv: (0, util_1.createDefineEnv)({
+            config: bundleOptions.config,
+            dev: true,
+            optionDefineEnv: bundleOptions.processDefineEnv,
+        }),
+        watch: {
+            enable: true,
+        },
+        dev: true,
+        buildId: (0, nanoid_1.nanoid)(),
+        config: {
+            ...bundleOptions.config,
+            mode: "development",
+            optimization: {
+                ...bundleOptions.config.optimization,
+                minify: false,
+                moduleIds: "named",
+            },
+        },
+        projectPath: projectPath || process.cwd(),
+        rootPath: rootPath || projectPath || process.cwd(),
+    }, {
+        persistentCaching: true,
+    });
+    const entrypointsSubscription = project.entrypointsSubscribe();
+    let currentEntriesHandlingResolve;
+    let currentEntriesHandling = new Promise((resolve) => (currentEntriesHandlingResolve = resolve));
+    let hmrEventHappened = false;
+    let hmrHash = 0;
+    const clients = new Set();
+    const clientStates = new WeakMap();
+    function sendToClient(client, payload) {
+        client.send(JSON.stringify(payload));
+    }
+    function sendEnqueuedMessages() {
+        for (const client of clients) {
+            const state = clientStates.get(client);
+            if (!state) {
+                continue;
+            }
+            for (const payload of state.hmrPayloads.values()) {
+                sendToClient(client, payload);
+            }
+            state.hmrPayloads.clear();
+            if (state.turbopackUpdates.length > 0) {
+                sendToClient(client, {
+                    action: "turbopack-message" /* HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_MESSAGE */,
+                    data: state.turbopackUpdates,
+                });
+                state.turbopackUpdates.length = 0;
+            }
+        }
+    }
+    const sendEnqueuedMessagesDebounce = (0, util_1.debounce)(sendEnqueuedMessages, 2);
+    function sendTurbopackMessage(payload) {
+        var _a;
+        payload.diagnostics = [];
+        payload.issues = [];
+        for (const client of clients) {
+            (_a = clientStates.get(client)) === null || _a === void 0 ? void 0 : _a.turbopackUpdates.push(payload);
+        }
+        hmrEventHappened = true;
+        sendEnqueuedMessagesDebounce();
+    }
+    async function subscribeToHmrEvents(client, id) {
+        const state = clientStates.get(client);
+        if (!state || state.subscriptions.has(id)) {
+            return;
+        }
+        const subscription = project.hmrEvents(id);
+        state.subscriptions.set(id, subscription);
+        // The subscription will always emit once, which is the initial
+        // computation. This is not a change, so swallow it.
+        try {
+            await subscription.next();
+            for await (const data of subscription) {
+                (0, util_1.processIssues)(data, true, true);
+                if (data.type !== "issues") {
+                    sendTurbopackMessage(data);
+                }
+            }
+        }
+        catch (e) {
+            // The client might be using an HMR session from a previous server, tell them
+            // to fully reload the page to resolve the issue. We can't use
+            // `hotReloader.send` since that would force every connected client to
+            // reload, only this client is out of date.
+            const reloadAction = {
+                action: "reload" /* HMR_ACTIONS_SENT_TO_BROWSER.RELOAD */,
+                data: `error in HMR event subscription for ${id}: ${e}`,
+            };
+            sendToClient(client, reloadAction);
+            client.close();
+            return;
+        }
+    }
+    function unsubscribeFromHmrEvents(client, id) {
+        const state = clientStates.get(client);
+        if (!state) {
+            return;
+        }
+        const subscription = state.subscriptions.get(id);
+        subscription === null || subscription === void 0 ? void 0 : subscription.return();
+    }
+    async function handleEntrypointsSubscription() {
+        for await (const entrypoints of entrypointsSubscription) {
+            if (!currentEntriesHandlingResolve) {
+                currentEntriesHandling = new Promise(
+                // eslint-disable-next-line no-loop-func
+                (resolve) => (currentEntriesHandlingResolve = resolve));
+            }
+            await Promise.all(entrypoints.apps.map((l) => l.writeToDisk().then((res) => (0, util_1.processIssues)(res, true, true))));
+            currentEntriesHandlingResolve();
+            currentEntriesHandlingResolve = undefined;
+        }
+    }
+    const hotReloader = {
+        turbopackProject: project,
+        serverStats: null,
+        onHMR(req, socket, head, onUpgrade) {
+            wsServer.handleUpgrade(req, socket, head, (client) => {
+                onUpgrade === null || onUpgrade === void 0 ? void 0 : onUpgrade(client);
+                const subscriptions = new Map();
+                clients.add(client);
+                clientStates.set(client, {
+                    hmrPayloads: new Map(),
+                    turbopackUpdates: [],
+                    subscriptions,
+                });
+                client.on("close", () => {
+                    var _a;
+                    // Remove active subscriptions
+                    for (const subscription of subscriptions.values()) {
+                        (_a = subscription.return) === null || _a === void 0 ? void 0 : _a.call(subscription);
+                    }
+                    clientStates.delete(client);
+                    clients.delete(client);
+                });
+                client.addEventListener("message", ({ data }) => {
+                    const parsedData = JSON.parse(typeof data !== "string" ? data.toString() : data);
+                    // messages
+                    switch (parsedData.event) {
+                        case "client-error": // { errorCount, clientId }
+                        case "client-warning": // { warningCount, clientId }
+                        case "client-success": // { clientId }
+                        case "client-full-reload": // { stackTrace, hadRuntimeError }
+                            const { hadRuntimeError, dependencyChain } = parsedData;
+                            if (hadRuntimeError) {
+                                console.warn(exports.FAST_REFRESH_RUNTIME_RELOAD);
+                            }
+                            if (Array.isArray(dependencyChain) &&
+                                typeof dependencyChain[0] === "string") {
+                                const cleanedModulePath = dependencyChain[0]
+                                    .replace(/^\[project\]/, ".")
+                                    .replace(/ \[.*\] \(.*\)$/, "");
+                                console.warn(`Fast Refresh had to perform a full reload when ${cleanedModulePath} changed.`);
+                            }
+                            break;
+                        default:
+                            // Might be a Turbopack message...
+                            if (!parsedData.type) {
+                                throw new Error(`unrecognized HMR message "${data}"`);
+                            }
+                    }
+                    // Turbopack messages
+                    switch (parsedData.type) {
+                        case "turbopack-subscribe":
+                            subscribeToHmrEvents(client, parsedData.path);
+                            break;
+                        case "turbopack-unsubscribe":
+                            unsubscribeFromHmrEvents(client, parsedData.path);
+                            break;
+                        default:
+                            if (!parsedData.event) {
+                                throw new Error(`unrecognized Turbopack HMR message "${data}"`);
+                            }
+                    }
+                });
+                const turbopackConnected = {
+                    action: "turbopack-connected" /* HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_CONNECTED */,
+                    data: { sessionId },
+                };
+                sendToClient(client, turbopackConnected);
+                const errors = [];
+                (async function () {
+                    const sync = {
+                        action: "sync" /* HMR_ACTIONS_SENT_TO_BROWSER.SYNC */,
+                        errors,
+                        warnings: [],
+                        hash: "",
+                    };
+                    sendToClient(client, sync);
+                })();
+            });
+        },
+        send(action) {
+            const payload = JSON.stringify(action);
+            for (const client of clients) {
+                client.send(payload);
+            }
+        },
+        setHmrServerError(_error) {
+            // Not implemented yet.
+        },
+        clearHmrServerError() {
+            // Not implemented yet.
+        },
+        async start() { },
+        async buildFallbackError() {
+            // Not implemented yet.
+        },
+        close() {
+            for (const wsClient of clients) {
+                // it's okay to not cleanly close these websocket connections, this is dev
+                wsClient.terminate();
+            }
+            clients.clear();
+        },
+    };
+    handleEntrypointsSubscription().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+    // Write empty manifests
+    await currentEntriesHandling;
+    async function handleProjectUpdates() {
+        for await (const updateMessage of project.updateInfoSubscribe(30)) {
+            switch (updateMessage.updateType) {
+                case "start": {
+                    hotReloader.send({ action: "building" /* HMR_ACTIONS_SENT_TO_BROWSER.BUILDING */ });
+                    break;
+                }
+                case "end": {
+                    sendEnqueuedMessages();
+                    const errors = new Map();
+                    for (const client of clients) {
+                        const state = clientStates.get(client);
+                        if (!state) {
+                            continue;
+                        }
+                        const clientErrors = new Map(errors);
+                        sendToClient(client, {
+                            action: "built" /* HMR_ACTIONS_SENT_TO_BROWSER.BUILT */,
+                            hash: String(++hmrHash),
+                            errors: [...clientErrors.values()],
+                            warnings: [],
+                        });
+                    }
+                    if (hmrEventHappened) {
+                        const time = updateMessage.value.duration;
+                        const timeMessage = time > 2000 ? `${Math.round(time / 100) / 10}s` : `${time}ms`;
+                        console.log(`Compiled in ${timeMessage}`);
+                        hmrEventHappened = false;
+                    }
+                    break;
+                }
+                default:
+            }
+        }
+    }
+    handleProjectUpdates().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+    return hotReloader;
+}

package/cjs/index.d.ts

@@ -1 +1,2 @@
-export declare function build(dir?: string): Promise<void>;
+export { build } from "./build";
+export { serve } from "./dev";

package/cjs/index.js

@@ -1,75 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.build = build;
-const nanoid_1 = require("nanoid");
-const project_1 = require("./project");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const util_1 = require("./util");
-const xcodeProfile_1 = require("./xcodeProfile");
-// ref:
-// https://github.com/vercel/next.js/pull/51883
-function blockStdout() {
-    // rust needs stdout to be blocking, otherwise it will throw an error (on macOS at least) when writing a lot of data (logs) to it
-    // see https://github.com/napi-rs/napi-rs/issues/1630
-    // and https://github.com/nodejs/node/blob/main/doc/api/process.md#a-note-on-process-io
-    if (process.stdout._handle != null) {
-        process.stdout._handle.setBlocking(true);
-    }
-    if (process.stderr._handle != null) {
-        process.stderr._handle.setBlocking(true);
-    }
-}
-async function build(dir) {
-    var _a, _b, _c, _d;
-    blockStdout();
-    if (process.env.XCODE_PROFILE) {
-        await (0, xcodeProfile_1.xcodeProfilingReady)();
-    }
-    const cwd = dir || process.cwd();
-    const projectOptions = JSON.parse(fs_1.default.readFileSync(path_1.default.join(cwd, "project_options.json"), {
-        encoding: "utf-8",
-    }));
-    const createProject = (0, project_1.projectFactory)();
-    const project = await createProject({
-        processEnv: (_a = projectOptions.processEnv) !== null && _a !== void 0 ? _a : {},
-        processDefineEnv: (_b = projectOptions.processDefineEnv) !== null && _b !== void 0 ? _b : {
-            client: [],
-            nodejs: [],
-            edge: [],
-        },
-        watch: (_c = projectOptions.watch) !== null && _c !== void 0 ? _c : {
-            enable: false,
-        },
-        dev: (_d = projectOptions.dev) !== null && _d !== void 0 ? _d : false,
-        buildId: (0, nanoid_1.nanoid)(),
-        config: projectOptions.config,
-        rootPath: path_1.default.resolve(cwd, projectOptions.rootPath),
-        projectPath: path_1.default.resolve(cwd, projectOptions.projectPath),
-    }, {
-        persistentCaching: false,
-    });
-    const entrypoints = await project.writeAllEntrypointsToDisk();
-    const topLevelErrors = [];
-    const topLevelWarnings = [];
-    for (const issue of entrypoints.issues) {
-        if (issue.severity === "error" || issue.severity === "fatal") {
-            topLevelErrors.push((0, util_1.formatIssue)(issue));
-        }
-        else if ((0, util_1.isRelevantWarning)(issue)) {
-            topLevelWarnings.push((0, util_1.formatIssue)(issue));
-        }
-    }
-    if (topLevelWarnings.length > 0) {
-        console.warn(`Turbopack build encountered ${topLevelWarnings.length} warnings:\n${topLevelWarnings.join("\n")}`);
-    }
-    if (topLevelErrors.length > 0) {
-        throw new Error(`Turbopack build failed with ${topLevelErrors.length} errors:\n${topLevelErrors.join("\n")}`);
-    }
-    await project.shutdown();
-    // TODO: Maybe run tasks in worker is a better way, see
-    // https://github.com/vercel/next.js/blob/512d8283054407ab92b2583ecce3b253c3be7b85/packages/next/src/lib/worker.ts
-}
+exports.serve = exports.build = void 0;
+var build_1 = require("./build");
+Object.defineProperty(exports, "build", { enumerable: true, get: function () { return build_1.build; } });
+var dev_1 = require("./dev");
+Object.defineProperty(exports, "serve", { enumerable: true, get: function () { return dev_1.serve; } });

package/cjs/mkcert.d.ts

@@ -0,0 +1,7 @@
+export interface SelfSignedCertificate {
+    key: string;
+    cert: string;
+    rootCA?: string;
+}
+export declare function createSelfSignedCertificate(host?: string, certDir?: string): Promise<SelfSignedCertificate | undefined>;
+export declare function getCacheDirectory(fileDirectory: string, envPath?: string): string;

package/cjs/mkcert.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSelfSignedCertificate = createSelfSignedCertificate;
+exports.getCacheDirectory = getCacheDirectory;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const os_1 = __importDefault(require("os"));
+const { WritableStream } = require("node:stream/web");
+const MKCERT_VERSION = "v1.4.4";
+function getBinaryName() {
+    const platform = process.platform;
+    const arch = process.arch === "x64" ? "amd64" : process.arch;
+    if (platform === "win32") {
+        return `mkcert-${MKCERT_VERSION}-windows-${arch}.exe`;
+    }
+    if (platform === "darwin") {
+        return `mkcert-${MKCERT_VERSION}-darwin-${arch}`;
+    }
+    if (platform === "linux") {
+        return `mkcert-${MKCERT_VERSION}-linux-${arch}`;
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}
+async function downloadBinary() {
+    try {
+        const binaryName = getBinaryName();
+        const cacheDirectory = getCacheDirectory("mkcert");
+        const binaryPath = node_path_1.default.join(cacheDirectory, binaryName);
+        if (node_fs_1.default.existsSync(binaryPath)) {
+            return binaryPath;
+        }
+        const downloadUrl = `https://github.com/FiloSottile/mkcert/releases/download/${MKCERT_VERSION}/${binaryName}`;
+        await node_fs_1.default.promises.mkdir(cacheDirectory, { recursive: true });
+        console.log(`Downloading mkcert package...`);
+        const response = await fetch(downloadUrl);
+        if (!response.ok || !response.body) {
+            throw new Error(`request failed with status ${response.status}`);
+        }
+        console.log(`Download response was successful, writing to disk`);
+        const binaryWriteStream = node_fs_1.default.createWriteStream(binaryPath);
+        await response.body.pipeTo(new WritableStream({
+            write(chunk) {
+                return new Promise((resolve, reject) => {
+                    binaryWriteStream.write(chunk, (error) => {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+            },
+            close() {
+                return new Promise((resolve, reject) => {
+                    binaryWriteStream.close((error) => {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+            },
+        }));
+        await node_fs_1.default.promises.chmod(binaryPath, 0o755);
+        return binaryPath;
+    }
+    catch (err) {
+        console.error("Error downloading mkcert:", err);
+    }
+}
+async function createSelfSignedCertificate(host, certDir = "certificates") {
+    try {
+        const binaryPath = await downloadBinary();
+        if (!binaryPath)
+            throw new Error("missing mkcert binary");
+        const resolvedCertDir = node_path_1.default.resolve(process.cwd(), `./${certDir}`);
+        await node_fs_1.default.promises.mkdir(resolvedCertDir, {
+            recursive: true,
+        });
+        const keyPath = node_path_1.default.resolve(resolvedCertDir, "localhost-key.pem");
+        const certPath = node_path_1.default.resolve(resolvedCertDir, "localhost.pem");
+        if (node_fs_1.default.existsSync(keyPath) && node_fs_1.default.existsSync(certPath)) {
+            const cert = new node_crypto_1.X509Certificate(node_fs_1.default.readFileSync(certPath));
+            const key = node_fs_1.default.readFileSync(keyPath);
+            if (cert.checkHost(host !== null && host !== void 0 ? host : "localhost") &&
+                cert.checkPrivateKey((0, node_crypto_1.createPrivateKey)(key))) {
+                console.log("Using already generated self signed certificate");
+                const caLocation = (0, node_child_process_1.execSync)(`"${binaryPath}" -CAROOT`)
+                    .toString()
+                    .trim();
+                return {
+                    key: keyPath,
+                    cert: certPath,
+                    rootCA: `${caLocation}/rootCA.pem`,
+                };
+            }
+        }
+        console.log("Attempting to generate self signed certificate. This may prompt for your password");
+        const defaultHosts = ["localhost", "127.0.0.1", "::1"];
+        const hosts = host && !defaultHosts.includes(host)
+            ? [...defaultHosts, host]
+            : defaultHosts;
+        (0, node_child_process_1.execSync)(`"${binaryPath}" -install -key-file "${keyPath}" -cert-file "${certPath}" ${hosts.join(" ")}`, { stdio: "ignore" });
+        const caLocation = (0, node_child_process_1.execSync)(`"${binaryPath}" -CAROOT`).toString().trim();
+        if (!node_fs_1.default.existsSync(keyPath) || !node_fs_1.default.existsSync(certPath)) {
+            throw new Error("Certificate files not found");
+        }
+        console.log(`CA Root certificate created in ${caLocation}`);
+        console.log(`Certificates created in ${resolvedCertDir}`);
+        const gitignorePath = node_path_1.default.resolve(process.cwd(), "./.gitignore");
+        if (node_fs_1.default.existsSync(gitignorePath)) {
+            const gitignore = await node_fs_1.default.promises.readFile(gitignorePath, "utf8");
+            if (!gitignore.includes(certDir)) {
+                console.log("Adding certificates to .gitignore");
+                await node_fs_1.default.promises.appendFile(gitignorePath, `\n${certDir}`);
+            }
+        }
+        return {
+            key: keyPath,
+            cert: certPath,
+            rootCA: `${caLocation}/rootCA.pem`,
+        };
+    }
+    catch (err) {
+        console.error("Failed to generate self-signed certificate. Falling back to http.", err);
+    }
+}
+// get platform specific cache directory adapted from playwright's handling
+// https://github.com/microsoft/playwright/blob/7d924470d397975a74a19184c136b3573a974e13/packages/playwright-core/src/utils/registry.ts#L141
+function getCacheDirectory(fileDirectory, envPath) {
+    let result;
+    if (envPath) {
+        result = envPath;
+    }
+    else {
+        let systemCacheDirectory;
+        if (process.platform === "linux") {
+            systemCacheDirectory =
+                process.env.XDG_CACHE_HOME || node_path_1.default.join(os_1.default.homedir(), ".cache");
+        }
+        else if (process.platform === "darwin") {
+            systemCacheDirectory = node_path_1.default.join(os_1.default.homedir(), "Library", "Caches");
+        }
+        else if (process.platform === "win32") {
+            systemCacheDirectory =
+                process.env.LOCALAPPDATA || node_path_1.default.join(os_1.default.homedir(), "AppData", "Local");
+        }
+        else {
+            /// Attempt to use generic tmp location for un-handled platform
+            if (!systemCacheDirectory) {
+                for (const dir of [
+                    node_path_1.default.join(os_1.default.homedir(), ".cache"),
+                    node_path_1.default.join(os_1.default.tmpdir()),
+                ]) {
+                    if (node_fs_1.default.existsSync(dir)) {
+                        systemCacheDirectory = dir;
+                        break;
+                    }
+                }
+            }
+            if (!systemCacheDirectory) {
+                console.error(new Error("Unsupported platform: " + process.platform));
+                process.exit(0);
+            }
+        }
+        result = node_path_1.default.join(systemCacheDirectory, fileDirectory);
+    }
+    if (!node_path_1.default.isAbsolute(result)) {
+        // It is important to resolve to the absolute path:
+        //   - for unzipping to work correctly;
+        //   - so that registry directory matches between installation and execution.
+        // INIT_CWD points to the root of `npm/yarn install` and is probably what
+        // the user meant when typing the relative path.
+        result = node_path_1.default.resolve(process.env["INIT_CWD"] || process.cwd(), result);
+    }
+    return result;
+}

package/cjs/project.d.ts

@@ -1,5 +1,5 @@
+import type { HmrIdentifiers, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
 import * as binding from "./binding";
-import type { NapiWrittenEndpoint, StackFrame } from "./binding";
 import { ProjectOptions, RawEntrypoints, Update } from "./types";
 export declare class TurbopackInternalError extends Error {
     name: string;
@@ -32,12 +32,12 @@ export declare function projectFactory(): (options: ProjectOptions, turboEngineO
         diagnostics: binding.NapiDiagnostic[];
     }, void, unknown>;
     hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
-    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<binding.HmrIdentifiers>>;
+    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<HmrIdentifiers>>;
     traceSource(stackFrame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>;
     getSourceForAsset(filePath: string): Promise<string | null>;
     getSourceMap(filePath: string): Promise<string | null>;
     getSourceMapSync(filePath: string): string | null;
-    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<binding.NapiUpdateMessage>>;
+    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<NapiUpdateMessage>>;
     shutdown(): Promise<void>;
     onExit(): Promise<void>;
 }>;

package/cjs/project.js

@@ -35,9 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurbopackInternalError = void 0;
 exports.projectFactory = projectFactory;
+const nanoid_1 = require("nanoid");
 const util_1 = require("util");
 const binding = __importStar(require("./binding"));
-const nanoid_1 = require("nanoid");
+const util_2 = require("./util");
 class TurbopackInternalError extends Error {
     constructor(cause) {
         super(cause.message);
@@ -114,19 +115,11 @@ async function serializeConfig(config) {
     }
     return JSON.stringify(configSerializable, null, 2);
 }
-function rustifyEnv(env) {
-    return Object.entries(env)
-        .filter(([_, value]) => value != null)
-        .map(([name, value]) => ({
-        name,
-        value,
-    }));
-}
 async function rustifyPartialProjectOptions(options) {
     return {
         ...options,
         config: options.config && (await serializeConfig(options.config)),
-        processEnv: options.processEnv && rustifyEnv(options.processEnv),
+        processEnv: options.processEnv && (0, util_2.rustifyEnv)(options.processEnv),
     };
 }
 async function rustifyProjectOptions(options) {
@@ -134,7 +127,7 @@ async function rustifyProjectOptions(options) {
     return {
         ...options,
         config: await serializeConfig(options.config),
-        processEnv: rustifyEnv((_a = options.processEnv) !== null && _a !== void 0 ? _a : {}),
+        processEnv: (0, util_2.rustifyEnv)((_a = options.processEnv) !== null && _a !== void 0 ? _a : {}),
     };
 }
 function projectFactory() {

package/cjs/types.d.ts

@@ -1,4 +1,16 @@
-import { HmrIdentifiers, NapiIssue, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
+import { HmrIdentifiers, NapiDiagnostic, NapiIssue, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
+declare global {
+    export type TurbopackResult<T = {}> = T & {
+        issues: NapiIssue[];
+        diagnostics: NapiDiagnostic[];
+    };
+    export type RefCell = {
+        readonly __tag: unique symbol;
+    };
+    export type ExternalEndpoint = {
+        readonly __tag: unique symbol;
+    };
+}
 export interface BaseUpdate {
     resource: {
         headers: unknown;
@@ -93,6 +105,7 @@ export interface ConfigComplete {
         type?: "standalone" | "export";
         filename?: string;
         chunkFilename?: string;
+        clean?: boolean;
     };
     target?: string;
     sourceMaps?: boolean;
@@ -202,7 +215,7 @@ export interface ProjectOptions {
         pollIntervalMs?: number;
     };
     /**
-     * The mode in which Next.js is running.
+     * The mode of utoo-pack.
      */
     dev: boolean;
     /**
@@ -210,6 +223,7 @@ export interface ProjectOptions {
      */
     buildId: string;
 }
+export type BundleOptions = Omit<ProjectOptions, "rootPath" | "projectPath">;
 export interface Project {
     update(options: Partial<ProjectOptions>): Promise<void>;
     entrypointsSubscribe(): AsyncIterableIterator<TurbopackResult<RawEntrypoints>>;