@utoo/pack 1.1.3 → 1.1.4

package/esm/core/hmr.js

@@ -0,0 +1,334 @@
+import fs from "fs";
+import { nanoid } from "nanoid";
+import { join } from "path";
+import ws from "ws";
+import { HtmlPlugin } from "../plugins/HtmlPlugin";
+import { createDefineEnv, debounce, getPackPath, processIssues, } from "../utils/common";
+import { processHtmlEntry } from "../utils/html-entry";
+import { projectFactory } from "./project";
+const wsServer = new ws.Server({ noServer: true });
+const sessionId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random());
+export const FAST_REFRESH_RUNTIME_RELOAD = "Fast Refresh had to perform a full reload due to a runtime error.";
+export async function createHotReloader(bundleOptions, projectPath, rootPath) {
+    var _a;
+    processHtmlEntry(bundleOptions.config, projectPath || process.cwd());
+    const createProject = projectFactory();
+    const project = await createProject({
+        processEnv: (_a = bundleOptions.processEnv) !== null && _a !== void 0 ? _a : {},
+        defineEnv: createDefineEnv({
+            config: bundleOptions.config,
+            dev: true,
+            optionDefineEnv: bundleOptions.defineEnv,
+        }),
+        watch: {
+            enable: true,
+        },
+        dev: true,
+        buildId: bundleOptions.buildId || nanoid(),
+        config: {
+            ...bundleOptions.config,
+            mode: "development",
+            stats: Boolean(process.env.ANALYZE) ||
+                bundleOptions.config.stats ||
+                bundleOptions.config.entry.some((e) => !!e.html),
+            optimization: {
+                ...bundleOptions.config.optimization,
+                minify: false,
+                moduleIds: "named",
+            },
+        },
+        projectPath: projectPath || process.cwd(),
+        rootPath: rootPath || projectPath || process.cwd(),
+        packPath: getPackPath(),
+    }, {
+        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 = 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) {
+                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() {
+        var _a, _b;
+        for await (const entrypoints of entrypointsSubscription) {
+            if (!currentEntriesHandlingResolve) {
+                currentEntriesHandling = new Promise(
+                // eslint-disable-next-line no-loop-func
+                (resolve) => (currentEntriesHandlingResolve = resolve));
+            }
+            const assets = { js: [], css: [] };
+            await Promise.all(entrypoints.apps.map((l) => l.writeToDisk().then((res) => {
+                processIssues(res, true, true);
+                res.clientPaths.forEach((p) => {
+                    if (p.endsWith(".js"))
+                        assets.js.push(p);
+                    if (p.endsWith(".css"))
+                        assets.css.push(p);
+                });
+            })));
+            const htmlConfigs = [
+                ...(Array.isArray(bundleOptions.config.html)
+                    ? bundleOptions.config.html
+                    : bundleOptions.config.html
+                        ? [bundleOptions.config.html]
+                        : []),
+                ...bundleOptions.config.entry
+                    .filter((e) => !!e.html)
+                    .map((e) => e.html),
+            ];
+            if (htmlConfigs.length > 0) {
+                const outputDir = ((_a = bundleOptions.config.output) === null || _a === void 0 ? void 0 : _a.path) || join(process.cwd(), "dist");
+                const publicPath = (_b = bundleOptions.config.output) === null || _b === void 0 ? void 0 : _b.publicPath;
+                if (assets.js.length === 0 && assets.css.length === 0) {
+                    const statsPath = join(outputDir, "stats.json");
+                    if (fs.existsSync(statsPath)) {
+                        try {
+                            const stats = JSON.parse(fs.readFileSync(statsPath, "utf-8"));
+                            if (stats.assets) {
+                                stats.assets.forEach((asset) => {
+                                    if (asset.name.endsWith(".js"))
+                                        assets.js.push(asset.name);
+                                    if (asset.name.endsWith(".css"))
+                                        assets.css.push(asset.name);
+                                });
+                            }
+                        }
+                        catch (e) {
+                            console.warn("Failed to read stats.json for assets discovery", e);
+                        }
+                    }
+                }
+                for (const config of htmlConfigs) {
+                    const plugin = new HtmlPlugin(config);
+                    await plugin.generate(outputDir, assets, publicPath);
+                }
+            }
+            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(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/esm/core/loaderWorkerPool.d.ts

@@ -0,0 +1 @@
+export declare function runLoaderWorkerPool(binding: typeof import("../binding"), bindingPath: string): Promise<void>;

package/esm/core/loaderWorkerPool.js

@@ -0,0 +1,32 @@
+import { Worker } from "worker_threads";
+const loaderWorkers = {};
+function getPoolId(cwd, filename) {
+    return `${cwd}:${filename}`;
+}
+let workerSchedulerRegistered = false;
+export async function runLoaderWorkerPool(binding, bindingPath) {
+    if (workerSchedulerRegistered) {
+        return;
+    }
+    binding.registerWorkerScheduler((creation) => {
+        const { options: { filename, cwd }, } = creation;
+        let poolId = getPoolId(cwd, filename);
+        const worker = new Worker(filename, {
+            workerData: {
+                bindingPath,
+                cwd,
+            },
+        });
+        worker.unref();
+        const workers = loaderWorkers[poolId] || (loaderWorkers[poolId] = new Map());
+        workers.set(worker.threadId, worker);
+    }, (termination) => {
+        var _a;
+        const { options: { filename, cwd }, workerId, } = termination;
+        let poolId = getPoolId(cwd, filename);
+        const workers = loaderWorkers[poolId];
+        (_a = workers.get(workerId)) === null || _a === void 0 ? void 0 : _a.terminate();
+        workers.delete(workerId);
+    });
+    workerSchedulerRegistered = true;
+}

package/esm/core/project.d.ts

@@ -0,0 +1,43 @@
+import type { HmrIdentifiers, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "../binding";
+import * as binding from "../binding";
+import { ProjectOptions, RawEntrypoints, Update } from "./types";
+export declare class TurbopackInternalError extends Error {
+    name: string;
+    constructor(cause: Error);
+}
+export declare function projectFactory(): (options: Required<ProjectOptions>, turboEngineOptions: binding.NapiTurboEngineOptions) => Promise<{
+    readonly _nativeProject: {
+        __napiType: "Project";
+    };
+    update(options: Partial<ProjectOptions>): Promise<void>;
+    writeAllEntrypointsToDisk(): Promise<TurbopackResult<RawEntrypoints>>;
+    entrypointsSubscribe(): AsyncGenerator<{
+        apps: {
+            readonly _nativeEndpoint: {
+                __napiType: "Endpoint";
+            };
+            writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
+            clientChanged(): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+            serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+        }[];
+        libraries: {
+            readonly _nativeEndpoint: {
+                __napiType: "Endpoint";
+            };
+            writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
+            clientChanged(): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+            serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+        }[];
+        issues: binding.NapiIssue[];
+        diagnostics: binding.NapiDiagnostic[];
+    }, void, unknown>;
+    hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
+    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<NapiUpdateMessage>>;
+    shutdown(): Promise<void>;
+    onExit(): Promise<void>;
+}>;

package/esm/core/project.js

@@ -0,0 +1,253 @@
+import { isDeepStrictEqual } from "util";
+import * as binding from "../binding";
+import { rustifyEnv } from "../utils/common";
+import { runLoaderWorkerPool } from "./loaderWorkerPool";
+export class TurbopackInternalError extends Error {
+    constructor(cause) {
+        super(cause.message);
+        this.name = "TurbopackInternalError";
+        this.stack = cause.stack;
+    }
+}
+async function withErrorCause(fn) {
+    try {
+        return await fn();
+    }
+    catch (nativeError) {
+        throw new TurbopackInternalError(nativeError);
+    }
+}
+function ensureLoadersHaveSerializableOptions(turbopackRules) {
+    for (const [glob, rule] of Object.entries(turbopackRules)) {
+        if (Array.isArray(rule)) {
+            checkLoaderItems(rule, glob);
+        }
+        else {
+            checkConfigItem(rule, glob);
+        }
+    }
+    function checkConfigItem(rule, glob) {
+        if (!rule)
+            return;
+        if ("loaders" in rule) {
+            checkLoaderItems(rule.loaders, glob);
+        }
+        else {
+            for (const key in rule) {
+                const inner = rule[key];
+                if (typeof inner === "object" && inner) {
+                    checkConfigItem(inner, glob);
+                }
+            }
+        }
+    }
+    function checkLoaderItems(loaderItems, glob) {
+        for (const loaderItem of loaderItems) {
+            if (typeof loaderItem !== "string" &&
+                !isDeepStrictEqual(loaderItem, JSON.parse(JSON.stringify(loaderItem)))) {
+                throw new Error(`loader ${loaderItem.loader} for match "${glob}" does not have serializable options. Ensure that options passed are plain JavaScript objects and values.`);
+            }
+        }
+    }
+}
+async function serializeConfig(config) {
+    var _a;
+    const configSerializable = { ...config };
+    if (configSerializable.entry) {
+        configSerializable.entry = configSerializable.entry.map((entry) => {
+            const { html, ...rest } = entry;
+            return rest;
+        });
+    }
+    if ((_a = configSerializable.module) === null || _a === void 0 ? void 0 : _a.rules) {
+        ensureLoadersHaveSerializableOptions(configSerializable.module.rules);
+    }
+    if (configSerializable.optimization) {
+        configSerializable.optimization = { ...configSerializable.optimization };
+        const { modularizeImports } = configSerializable.optimization;
+        if (modularizeImports) {
+            configSerializable.optimization.modularizeImports = Object.fromEntries(Object.entries(modularizeImports).map(([mod, config]) => [
+                mod,
+                {
+                    ...config,
+                    transform: typeof config.transform === "string"
+                        ? config.transform
+                        : Object.entries(config.transform).map(([key, value]) => [
+                            key,
+                            value,
+                        ]),
+                },
+            ]));
+        }
+    }
+    return JSON.stringify(configSerializable, null, 2);
+}
+async function rustifyPartialProjectOptions(options) {
+    return {
+        ...options,
+        config: options.config && (await serializeConfig(options.config)),
+        processEnv: options.processEnv && rustifyEnv(options.processEnv),
+    };
+}
+async function rustifyProjectOptions(options) {
+    var _a;
+    return {
+        ...options,
+        config: await serializeConfig(options.config),
+        processEnv: rustifyEnv((_a = options.processEnv) !== null && _a !== void 0 ? _a : {}),
+    };
+}
+export function projectFactory() {
+    const cancel = new (class Cancel extends Error {
+    })();
+    function subscribe(useBuffer, nativeFunction) {
+        // A buffer of produced items. This will only contain values if the
+        // consumer is slower than the producer.
+        let buffer = [];
+        // A deferred value waiting for the next produced item. This will only
+        // exist if the consumer is faster than the producer.
+        let waiting;
+        let canceled = false;
+        // The native function will call this every time it emits a new result. We
+        // either need to notify a waiting consumer, or buffer the new result until
+        // the consumer catches up.
+        function emitResult(err, value) {
+            if (waiting) {
+                let { resolve, reject } = waiting;
+                waiting = undefined;
+                if (err)
+                    reject(err);
+                else
+                    resolve(value);
+            }
+            else {
+                const item = { err, value };
+                if (useBuffer)
+                    buffer.push(item);
+                else
+                    buffer[0] = item;
+            }
+        }
+        async function* createIterator() {
+            const task = await withErrorCause(() => nativeFunction(emitResult));
+            try {
+                while (!canceled) {
+                    if (buffer.length > 0) {
+                        const item = buffer.shift();
+                        if (item.err)
+                            throw item.err;
+                        yield item.value;
+                    }
+                    else {
+                        // eslint-disable-next-line no-loop-func
+                        yield new Promise((resolve, reject) => {
+                            waiting = { resolve, reject };
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                if (e === cancel)
+                    return;
+                if (e instanceof Error) {
+                    throw new TurbopackInternalError(e);
+                }
+                throw e;
+            }
+            finally {
+                if (task) {
+                    binding.rootTaskDispose(task);
+                }
+            }
+        }
+        const iterator = createIterator();
+        iterator.return = async () => {
+            canceled = true;
+            if (waiting)
+                waiting.reject(cancel);
+            return { value: undefined, done: true };
+        };
+        return iterator;
+    }
+    class ProjectImpl {
+        constructor(nativeProject) {
+            this._nativeProject = nativeProject;
+            if (typeof binding.registerWorkerScheduler === "function") {
+                runLoaderWorkerPool(binding, require.resolve("@utoo/pack/cjs/binding.js"));
+            }
+        }
+        async update(options) {
+            await withErrorCause(async () => binding.projectUpdate(this._nativeProject, await rustifyPartialProjectOptions(options)));
+        }
+        async writeAllEntrypointsToDisk() {
+            return await withErrorCause(async () => {
+                const napiEndpoints = (await binding.projectWriteAllEntrypointsToDisk(this._nativeProject));
+                return napiEntrypointsToRawEntrypoints(napiEndpoints);
+            });
+        }
+        entrypointsSubscribe() {
+            const subscription = subscribe(false, async (callback) => binding.projectEntrypointsSubscribe(this._nativeProject, callback));
+            return (async function* () {
+                for await (const entrypoints of subscription) {
+                    yield napiEntrypointsToRawEntrypoints(entrypoints);
+                }
+            })();
+        }
+        hmrEvents(identifier) {
+            return subscribe(true, async (callback) => binding.projectHmrEvents(this._nativeProject, identifier, callback));
+        }
+        hmrIdentifiersSubscribe() {
+            return subscribe(false, async (callback) => binding.projectHmrIdentifiersSubscribe(this._nativeProject, callback));
+        }
+        traceSource(stackFrame, currentDirectoryFileUrl) {
+            return binding.projectTraceSource(this._nativeProject, stackFrame, currentDirectoryFileUrl);
+        }
+        getSourceForAsset(filePath) {
+            return binding.projectGetSourceForAsset(this._nativeProject, filePath);
+        }
+        getSourceMap(filePath) {
+            return binding.projectGetSourceMap(this._nativeProject, filePath);
+        }
+        getSourceMapSync(filePath) {
+            return binding.projectGetSourceMapSync(this._nativeProject, filePath);
+        }
+        updateInfoSubscribe(aggregationMs) {
+            return subscribe(true, async (callback) => binding.projectUpdateInfoSubscribe(this._nativeProject, aggregationMs, callback));
+        }
+        shutdown() {
+            return binding.projectShutdown(this._nativeProject);
+        }
+        onExit() {
+            return binding.projectOnExit(this._nativeProject);
+        }
+    }
+    class EndpointImpl {
+        constructor(nativeEndpoint) {
+            this._nativeEndpoint = nativeEndpoint;
+        }
+        async writeToDisk() {
+            return await withErrorCause(() => binding.endpointWriteToDisk(this._nativeEndpoint));
+        }
+        async clientChanged() {
+            const clientSubscription = subscribe(false, async (callback) => binding.endpointClientChangedSubscribe(await this._nativeEndpoint, callback));
+            await clientSubscription.next();
+            return clientSubscription;
+        }
+        async serverChanged(includeIssues) {
+            const serverSubscription = subscribe(false, async (callback) => binding.endpointServerChangedSubscribe(await this._nativeEndpoint, includeIssues, callback));
+            await serverSubscription.next();
+            return serverSubscription;
+        }
+    }
+    function napiEntrypointsToRawEntrypoints(entrypoints) {
+        return {
+            apps: (entrypoints.apps || []).map((e) => new EndpointImpl(e)),
+            libraries: (entrypoints.libraries || []).map((e) => new EndpointImpl(e)),
+            issues: entrypoints.issues,
+            diagnostics: entrypoints.diagnostics,
+        };
+    }
+    return async function createProject(options, turboEngineOptions) {
+        return new ProjectImpl(await binding.projectNew(await rustifyProjectOptions(options), turboEngineOptions || {}));
+    };
+}