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

package/esm/index.d.ts

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

package/esm/index.js

@@ -1,69 +1,2 @@
-import { nanoid } from "nanoid";
-import { projectFactory } from "./project";
-import fs from "fs";
-import path from "path";
-import { formatIssue, isRelevantWarning } from "./util";
-import { xcodeProfilingReady } from "./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);
-    }
-}
-export async function build(dir) {
-    var _a, _b, _c, _d;
-    blockStdout();
-    if (process.env.XCODE_PROFILE) {
-        await xcodeProfilingReady();
-    }
-    const cwd = dir || process.cwd();
-    const projectOptions = JSON.parse(fs.readFileSync(path.join(cwd, "project_options.json"), {
-        encoding: "utf-8",
-    }));
-    const createProject = 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: nanoid(),
-        config: projectOptions.config,
-        rootPath: path.resolve(cwd, projectOptions.rootPath),
-        projectPath: path.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(formatIssue(issue));
-        }
-        else if (isRelevantWarning(issue)) {
-            topLevelWarnings.push(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
-}
+export { build } from "./build";
+export { serve } from "./dev";

package/esm/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/esm/mkcert.js

@@ -0,0 +1,176 @@
+import { execSync } from "node:child_process";
+import { createPrivateKey, X509Certificate } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import os from "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 = path.join(cacheDirectory, binaryName);
+        if (fs.existsSync(binaryPath)) {
+            return binaryPath;
+        }
+        const downloadUrl = `https://github.com/FiloSottile/mkcert/releases/download/${MKCERT_VERSION}/${binaryName}`;
+        await fs.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 = fs.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 fs.promises.chmod(binaryPath, 0o755);
+        return binaryPath;
+    }
+    catch (err) {
+        console.error("Error downloading mkcert:", err);
+    }
+}
+export async function createSelfSignedCertificate(host, certDir = "certificates") {
+    try {
+        const binaryPath = await downloadBinary();
+        if (!binaryPath)
+            throw new Error("missing mkcert binary");
+        const resolvedCertDir = path.resolve(process.cwd(), `./${certDir}`);
+        await fs.promises.mkdir(resolvedCertDir, {
+            recursive: true,
+        });
+        const keyPath = path.resolve(resolvedCertDir, "localhost-key.pem");
+        const certPath = path.resolve(resolvedCertDir, "localhost.pem");
+        if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
+            const cert = new X509Certificate(fs.readFileSync(certPath));
+            const key = fs.readFileSync(keyPath);
+            if (cert.checkHost(host !== null && host !== void 0 ? host : "localhost") &&
+                cert.checkPrivateKey(createPrivateKey(key))) {
+                console.log("Using already generated self signed certificate");
+                const caLocation = 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;
+        execSync(`"${binaryPath}" -install -key-file "${keyPath}" -cert-file "${certPath}" ${hosts.join(" ")}`, { stdio: "ignore" });
+        const caLocation = execSync(`"${binaryPath}" -CAROOT`).toString().trim();
+        if (!fs.existsSync(keyPath) || !fs.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 = path.resolve(process.cwd(), "./.gitignore");
+        if (fs.existsSync(gitignorePath)) {
+            const gitignore = await fs.promises.readFile(gitignorePath, "utf8");
+            if (!gitignore.includes(certDir)) {
+                console.log("Adding certificates to .gitignore");
+                await fs.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
+export function getCacheDirectory(fileDirectory, envPath) {
+    let result;
+    if (envPath) {
+        result = envPath;
+    }
+    else {
+        let systemCacheDirectory;
+        if (process.platform === "linux") {
+            systemCacheDirectory =
+                process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+        }
+        else if (process.platform === "darwin") {
+            systemCacheDirectory = path.join(os.homedir(), "Library", "Caches");
+        }
+        else if (process.platform === "win32") {
+            systemCacheDirectory =
+                process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+        }
+        else {
+            /// Attempt to use generic tmp location for un-handled platform
+            if (!systemCacheDirectory) {
+                for (const dir of [
+                    path.join(os.homedir(), ".cache"),
+                    path.join(os.tmpdir()),
+                ]) {
+                    if (fs.existsSync(dir)) {
+                        systemCacheDirectory = dir;
+                        break;
+                    }
+                }
+            }
+            if (!systemCacheDirectory) {
+                console.error(new Error("Unsupported platform: " + process.platform));
+                process.exit(0);
+            }
+        }
+        result = path.join(systemCacheDirectory, fileDirectory);
+    }
+    if (!path.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 = path.resolve(process.env["INIT_CWD"] || process.cwd(), result);
+    }
+    return result;
+}

package/esm/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/esm/project.js

@@ -1,6 +1,7 @@
+import { nanoid } from "nanoid";
 import { isDeepStrictEqual } from "util";
 import * as binding from "./binding";
-import { nanoid } from "nanoid";
+import { rustifyEnv } from "./util";
 export class TurbopackInternalError extends Error {
     constructor(cause) {
         super(cause.message);
@@ -76,14 +77,6 @@ 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,

package/esm/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>>;

package/esm/util.d.ts

@@ -1,5 +1,5 @@
 import { NapiIssue } from "./binding";
-import { StyledString } from "./types";
+import { ConfigComplete, DefineEnv, RustifiedEnv, StyledString } from "./types";
 export declare class ModuleBuildError extends Error {
     name: string;
 }
@@ -8,3 +8,14 @@ export declare function isWellKnownError(issue: NapiIssue): boolean;
 export declare function formatIssue(issue: NapiIssue): string;
 export declare function renderStyledStringToErrorAnsi(string: StyledString): string;
 export declare function isRelevantWarning(issue: NapiIssue): boolean;
+export declare function rustifyEnv(env: Record<string, string>): RustifiedEnv;
+interface DefineEnvOptions {
+    config: ConfigComplete;
+    dev: boolean;
+    optionDefineEnv?: DefineEnv;
+}
+export declare function createDefineEnv(options: DefineEnvOptions): DefineEnv;
+type AnyFunc<T> = (this: T, ...args: any) => any;
+export declare function debounce<T, F extends AnyFunc<T>>(fn: F, ms: number, maxWait?: number): (this: T, ...passedArgs: Parameters<F>) => void;
+export declare function blockStdout(): void;
+export {};

package/esm/util.js

@@ -1,5 +1,5 @@
-import { bold, green, magenta, red } from "picocolors";
 import { codeFrameColumns } from "@babel/code-frame";
+import { bold, green, magenta, red } from "picocolors";
 import { decodeMagicIdentifier, MAGIC_IDENTIFIER_REGEX, } from "./magicIdentifier";
 export class ModuleBuildError extends Error {
     constructor() {
@@ -128,3 +128,100 @@ function isNodeModulesIssue(issue) {
         (issue.filePath.match(/^(?:.*[\\/])?node_modules(?:[\\/].*)?$/) !== null ||
             issue.filePath.includes("@utoo/pack")));
 }
+export function rustifyEnv(env) {
+    return Object.entries(env)
+        .filter(([_, value]) => value != null)
+        .map(([name, value]) => ({
+        name,
+        value,
+    }));
+}
+export function createDefineEnv(options) {
+    var _a;
+    let defineEnv = (_a = options.optionDefineEnv) !== null && _a !== void 0 ? _a : {
+        client: [],
+        edge: [],
+        nodejs: [],
+    };
+    function getDefineEnv() {
+        var _a;
+        const envs = {
+            "process.env.NODE_ENV": options.dev ? "development" : "production",
+        };
+        const userDefines = (_a = options.config.define) !== null && _a !== void 0 ? _a : {};
+        for (const key in userDefines) {
+            envs[key] = userDefines[key];
+        }
+        // serialize
+        const defineEnvStringified = {};
+        for (const key in defineEnv) {
+            const value = envs[key];
+            defineEnvStringified[key] = JSON.stringify(value);
+        }
+        return defineEnvStringified;
+    }
+    // TODO: future define envs need to extends for more compiler like server or edge.
+    for (const variant of Object.keys(defineEnv)) {
+        defineEnv[variant] = rustifyEnv(getDefineEnv());
+    }
+    return defineEnv;
+}
+export function debounce(fn, ms, maxWait = Infinity) {
+    let timeoutId;
+    // The time the debouncing function was first called during this debounce queue.
+    let startTime = 0;
+    // The time the debouncing function was last called.
+    let lastCall = 0;
+    // The arguments and this context of the last call to the debouncing function.
+    let args, context;
+    // A helper used to that either invokes the debounced function, or
+    // reschedules the timer if a more recent call was made.
+    function run() {
+        const now = Date.now();
+        const diff = lastCall + ms - now;
+        // If the diff is non-positive, then we've waited at least `ms`
+        // milliseconds since the last call. Or if we've waited for longer than the
+        // max wait time, we must call the debounced function.
+        if (diff <= 0 || startTime + maxWait >= now) {
+            // It's important to clear the timeout id before invoking the debounced
+            // function, in case the function calls the debouncing function again.
+            timeoutId = undefined;
+            fn.apply(context, args);
+        }
+        else {
+            // Else, a new call was made after the original timer was scheduled. We
+            // didn't clear the timeout (doing so is very slow), so now we need to
+            // reschedule the timer for the time difference.
+            timeoutId = setTimeout(run, diff);
+        }
+    }
+    return function (...passedArgs) {
+        // The arguments and this context of the most recent call are saved so the
+        // debounced function can be invoked with them later.
+        args = passedArgs;
+        context = this;
+        // Instead of constantly clearing and scheduling a timer, we record the
+        // time of the last call. If a second call comes in before the timer fires,
+        // then we'll reschedule in the run function. Doing this is considerably
+        // faster.
+        lastCall = Date.now();
+        // Only schedule a new timer if we're not currently waiting.
+        if (timeoutId === undefined) {
+            startTime = lastCall;
+            timeoutId = setTimeout(run, ms);
+        }
+    };
+}
+// ref:
+// https://github.com/vercel/next.js/pull/51883
+export 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);
+    }
+}

package/package.json

@@ -1,18 +1,24 @@
 {
   "name": "@utoo/pack",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-alpha.12",
   "main": "cjs/index.js",
   "module": "esm/index.js",
-  "bin": {
-    "utoo-pack": "./bin/cli.js"
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./cjs/*": "./cjs/*",
+    "./esm/*": "./esm/*",
+    "./config_schema.json": "./config_schema.json",
+    "./package.json": "./package.json"
   },
   "files": [
     "./cjs/*.js",
     "./cjs/*.d.ts",
     "./esm/*.js",
     "./esm/*.d.ts",
-    "./bin/cli.js",
-    "./global.d.ts"
+    "./config_schema.json"
   ],
   "napi": {
     "name": "pack",
@@ -31,23 +37,32 @@
   },
   "license": "MIT",
   "dependencies": {
-    "nanoid": "^3.3.11",
-    "picocolors": "^1.1.1",
+    "react-refresh": "^0.12.0",
     "@babel/code-frame": "7.22.5",
     "@utoo/loader-runner": "^1.0.0",
     "@utoo/style-loader": "^1.0.0",
+    "less": "^4.0.0",
+    "less-loader": "^12.0.0",
+    "nanoid": "^3.3.11",
+    "picocolors": "^1.1.1",
     "postcss": "8.4.31",
+    "resolve-url-loader": "^5.0.0",
     "sass": "1.54.0",
-    "less": "^4.0.0",
     "sass-loader": "^13.2.0",
-    "less-loader": "^12.0.0",
-    "resolve-url-loader": "^5.0.0"
+    "ws": "^8.18.1",
+    "send": "0.17.1"
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.18.0",
-    "@types/node": "^20.3.0",
+    "@swc/helpers": "^0.5.15",
     "@types/babel__code-frame": "7.0.2",
-    "typescript": "^5.8.3"
+    "@types/node": "^20.3.0",
+    "styled-jsx": "^5.1.6",
+    "typescript": "^5.8.3",
+    "@types/ws": "^8.18.1",
+    "@types/webpack": "^5.28.5",
+    "@types/send": "0.14.4",
+    "@types/mime-types": "3.0.1"
   },
   "engines": {
     "node": ">= 10"
@@ -55,21 +70,21 @@
   "scripts": {
     "build:cjs": "rm -rf cjs && tsc -p ./tsconfig.json --module commonjs --outDir cjs && cp src/*.d.ts cjs/",
     "build:esm": "rm -rf esm && tsc -p ./tsconfig.json --module esnext --outDir esm && cp src/*.d.ts esm/",
-    "build:local": "npm run build:binding && npm run build:cjs && cp src/*.node cjs/",
+    "build:local": "npm run build:binding:local && npm run build:cjs && npm run build:esm && cp src/*.node cjs/ && cp src/*.node esm/",
     "artifacts": "napi artifacts --dir ./src --dist npm",
-    "build:binding": "napi build src --platform --release -p pack-napi --cargo-cwd ../../ --cargo-name pack_napi --features plugin --js binding.js --dts binding.d.ts --strip",
-    "build:binding:debug": "napi build src --platform -p pack-napi --cargo-cwd ../../ --cargo-name pack_napi --features plugin --js binding.js --dts binding.d.ts",
-    "prepublishOnly": "npm run build:esm && npm run build:cjs && napi prepublish -t npm",
+    "build:binding": "napi build src --platform --release -p pack-napi --cargo-cwd ../../ --cargo-name pack_napi --features plugin --js binding.js --dts binding.d.ts",
+    "build:binding:local": "napi build src --platform --profile release-local -p pack-napi --cargo-cwd ../../ --cargo-name pack_napi --features plugin --js binding.js --dts binding.d.ts",
+    "prepublishOnly": "npm run build:esm && npm run build:cjs && napi prepublish -t npm --skip-gh-release",
     "version": "napi version"
   },
   "repository": "git@github.com:umijs/mako.git",
   "optionalDependencies": {
-    "@utoo/pack-darwin-arm64": "0.0.1-alpha.1",
-    "@utoo/pack-darwin-x64": "0.0.1-alpha.1",
-    "@utoo/pack-linux-arm64-gnu": "0.0.1-alpha.1",
-    "@utoo/pack-linux-arm64-musl": "0.0.1-alpha.1",
-    "@utoo/pack-linux-x64-gnu": "0.0.1-alpha.1",
-    "@utoo/pack-linux-x64-musl": "0.0.1-alpha.1",
-    "@utoo/pack-win32-x64-msvc": "0.0.1-alpha.1"
+    "@utoo/pack-darwin-arm64": "0.0.1-alpha.12",
+    "@utoo/pack-darwin-x64": "0.0.1-alpha.12",
+    "@utoo/pack-linux-arm64-gnu": "0.0.1-alpha.12",
+    "@utoo/pack-linux-arm64-musl": "0.0.1-alpha.12",
+    "@utoo/pack-linux-x64-gnu": "0.0.1-alpha.12",
+    "@utoo/pack-linux-x64-musl": "0.0.1-alpha.12",
+    "@utoo/pack-win32-x64-msvc": "0.0.1-alpha.12"
   }
 }

package/bin/cli.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-const { build } = require("../cjs/index.js");
-
-console.log(process.argv);
-
-// Get the directory argument, default to current directory
-const dir = process.argv[2] || process.cwd();
-
-build(dir);

package/global.d.ts

@@ -1,10 +0,0 @@
-import { NapiDiagnostic, NapiIssue } from "./src/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 };
-}