@utoo/web 1.2.8 → 1.3.0-rc.2

package/esm/project/ForkedProject.d.ts

@@ -1,10 +1,13 @@
-import { DepsOptions, InstallOptions, PackFile, ProjectEndpoint, Stats } from "../types";
+import { DepsOptions, InstallOptions, PackFile, ProjectEndpoint, Stats, UpdateMessage } from "../types";
 export declare class ForkedProject implements ProjectEndpoint {
     private endpoint;
     constructor(port: MessagePort);
     deps(options?: DepsOptions): Promise<string>;
     install(packageLock: string, options?: InstallOptions): Promise<void>;
     build(): Promise<import("..").BuildOutput>;
+    dev(onUpdate?: (result: any) => void): void;
+    hmrSubscribe(identifier: string, callback: (update: unknown) => void): Promise<void>;
+    updateInfoSubscribe(aggregationMs: number, callback: (message: UpdateMessage) => void): void;
     readFile(path: string, encoding?: "utf8"): Promise<any>;
     writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;

package/esm/project/ForkedProject.js

@@ -6,14 +6,29 @@ export class ForkedProject {
         (_a = this.endpoint) !== null && _a !== void 0 ? _a : (this.endpoint = comlink.wrap(port));
     }
     async deps(options) {
-        return await this.endpoint.deps(options);
+        var _a, _b;
+        return await this.endpoint.deps({
+            registry: (_a = options === null || options === void 0 ? void 0 : options.registry) !== null && _a !== void 0 ? _a : undefined,
+            concurrency: (_b = options === null || options === void 0 ? void 0 : options.concurrency) !== null && _b !== void 0 ? _b : undefined,
+        });
     }
     async install(packageLock, options) {
-        return await this.endpoint.install(packageLock, options);
+        return await this.endpoint.install(packageLock, {
+            maxConcurrentDownloads: options === null || options === void 0 ? void 0 : options.maxConcurrentDownloads,
+        });
     }
     async build() {
         return await this.endpoint.build();
     }
+    dev(onUpdate) {
+        this.endpoint.dev(onUpdate ? comlink.proxy(onUpdate) : undefined);
+    }
+    async hmrSubscribe(identifier, callback) {
+        await this.endpoint.hmrSubscribe(identifier, comlink.proxy(callback));
+    }
+    updateInfoSubscribe(aggregationMs, callback) {
+        this.endpoint.updateInfoSubscribe(aggregationMs, comlink.proxy(callback));
+    }
     async readFile(path, encoding) {
         return (await this.endpoint.readFile(path, encoding));
     }

package/esm/project/InternalProject.d.ts

@@ -1,13 +1,17 @@
+import { type UpdateMessage } from "@utoo/pack-shared";
 import { DepsOptions, InstallOptions, PackFile, ProjectEndpoint, ProjectOptions, Stats } from "../types";
 import initWasm from "../utoo";
 declare class InternalEndpoint implements ProjectEndpoint {
     wasmInit?: ReturnType<typeof initWasm>;
     options?: Omit<ProjectOptions, "workerUrl" | "serviceWorker">;
     loaderWorkerPoolInitialized: boolean;
+    private rootTask?;
+    private hmrRootTasks;
     mount(opt: Omit<ProjectOptions, "workerUrl" | "serviceWorker">): Promise<void>;
     deps(options?: DepsOptions): Promise<string>;
     install(packageLock: string, options?: InstallOptions): Promise<void>;
     build(): Promise<any>;
+    dev(onUpdate?: (result: any) => void): Promise<void>;
     readFile(path: string, encoding?: "utf8"): Promise<any>;
     writeFile(path: string, content: string | Uint8Array, _encoding?: "utf8"): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
@@ -26,6 +30,8 @@ declare class InternalEndpoint implements ProjectEndpoint {
     }): Promise<void>;
     gzip(files: PackFile[]): Promise<Uint8Array<ArrayBufferLike>>;
     sigMd5(content: Uint8Array): Promise<string>;
+    hmrSubscribe(identifier: string, callback: (update: unknown) => void): Promise<void>;
+    updateInfoSubscribe(aggregationMs: number, callback: (message: UpdateMessage) => void): void;
 }
 declare const internalEndpoint: InternalEndpoint;
 export { internalEndpoint };

package/esm/project/InternalProject.js

@@ -3,6 +3,8 @@ import { runLoaderWorkerPool } from "../webpackLoaders/loaderWorkerPool";
 class InternalEndpoint {
     constructor() {
         this.loaderWorkerPoolInitialized = false;
+        // Keep HMR root tasks alive (keyed by identifier)
+        this.hmrRootTasks = new Map();
     }
     // This should be called only once
     async mount(opt) {
@@ -23,11 +25,16 @@ class InternalEndpoint {
     async deps(options) {
         var _a, _b;
         await this.wasmInit;
-        return await ProjectInternal.deps((_a = options === null || options === void 0 ? void 0 : options.registry) !== null && _a !== void 0 ? _a : undefined, (_b = options === null || options === void 0 ? void 0 : options.concurrency) !== null && _b !== void 0 ? _b : undefined);
+        // Ensure we pass undefined (not null) for missing values
+        const registry = (_a = options === null || options === void 0 ? void 0 : options.registry) !== null && _a !== void 0 ? _a : undefined;
+        const concurrency = (_b = options === null || options === void 0 ? void 0 : options.concurrency) !== null && _b !== void 0 ? _b : undefined;
+        return await ProjectInternal.deps(registry, concurrency);
     }
     async install(packageLock, options) {
+        var _a;
         await this.wasmInit;
-        await ProjectInternal.install(packageLock, options === null || options === void 0 ? void 0 : options.maxConcurrentDownloads);
+        const concurrency = (_a = options === null || options === void 0 ? void 0 : options.maxConcurrentDownloads) !== null && _a !== void 0 ? _a : undefined;
+        await ProjectInternal.install(packageLock, concurrency);
         return;
     }
     async build() {
@@ -39,6 +46,16 @@ class InternalEndpoint {
         }
         return await ProjectInternal.build();
     }
+    async dev(onUpdate) {
+        var _a, _b;
+        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.loaderWorkerUrl) && !this.loaderWorkerPoolInitialized) {
+            runLoaderWorkerPool(this.options.cwd, this.options.loaderWorkerUrl, (_b = this.options) === null || _b === void 0 ? void 0 : _b.loadersImportMap);
+            this.loaderWorkerPoolInitialized = true;
+        }
+        this.rootTask = await ProjectInternal.entrypointsSubscribe((result) => {
+            onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(result);
+        });
+    }
     async readFile(path, encoding) {
         await this.wasmInit;
         let ret;
@@ -124,6 +141,13 @@ class InternalEndpoint {
         await this.wasmInit;
         return await ProjectInternal.sigMd5(content);
     }
+    async hmrSubscribe(identifier, callback) {
+        const rootTask = await ProjectInternal.hmrEvents(identifier, callback);
+        this.hmrRootTasks.set(identifier, rootTask);
+    }
+    updateInfoSubscribe(aggregationMs, callback) {
+        ProjectInternal.updateInfoSubscribe(aggregationMs, callback);
+    }
 }
 const internalEndpoint = new InternalEndpoint();
 export { internalEndpoint };

package/esm/project/Project.d.ts

@@ -1,9 +1,13 @@
+import { type UpdateMessage } from "@utoo/pack-shared";
+import { HmrClient } from "../hmr";
 import { BuildOutput, DepsOptions, Dirent, InstallOptions, PackFile, ProjectEndpoint, ProjectOptions, ServiceWorkerOptions, Stats } from "../types";
 export declare class Project implements ProjectEndpoint {
     #private;
     private options;
     readonly cwd: string;
     readonly serviceWorkerOptions?: ServiceWorkerOptions;
+    /** HMR server for managing hot module replacement with preview iframes */
+    private hmrServer?;
     private remote;
     constructor(options: ProjectOptions);
     private connectWorker;
@@ -12,6 +16,9 @@ export declare class Project implements ProjectEndpoint {
     deps(options?: DepsOptions): Promise<string>;
     install(packageLock: string, options?: InstallOptions): Promise<void>;
     build(): Promise<BuildOutput>;
+    dev(onUpdate?: (result: BuildOutput) => void): void;
+    hmrSubscribe(identifier: string, callback: (update: unknown) => void): Promise<void>;
+    updateInfoSubscribe(aggregationMs: number, callback: (message: UpdateMessage) => void): void;
     readFile(path: string, encoding?: "utf8"): Promise<any>;
     writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
@@ -30,5 +37,14 @@ export declare class Project implements ProjectEndpoint {
     stat(path: string): Promise<Stats>;
     gzip(files: PackFile[]): Promise<Uint8Array>;
     sigMd5(content: Uint8Array): Promise<string>;
+    /**
+     * Connect an iframe to the HMR server for hot module replacement.
+     * Only works after dev() has been called.
+     *
+     * @param iframe The iframe element to connect
+     * @param origin Optional origin for postMessage (default: "*")
+     * @returns The HMR client instance, or null if connection failed or dev() not called
+     */
+    connectHmrIframe(iframe: HTMLIFrameElement, origin?: string): HmrClient | null;
     static fork(channel: MessageChannel, eventSource?: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;
 }

package/esm/project/Project.js

@@ -12,6 +12,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _Project_mount;
 import { handleIssues } from "@utoo/pack-shared";
 import * as comlink from "comlink";
+import { HmrServer } from "../hmr";
 import { WorkerMessageType } from "../message";
 import { installServiceWorker } from "../serviceWorker/install";
 import { Dirent, Stats, } from "../types";
@@ -79,6 +80,30 @@ export class Project {
         handleIssues(res.issues, false, false);
         return res;
     }
+    dev(onUpdate) {
+        // Create HmrServer lazily on first dev() call
+        if (!this.hmrServer) {
+            this.hmrServer = new HmrServer({
+                onSubscribe: async (path, client) => {
+                    await this.hmrSubscribe(path, (update) => {
+                        this.hmrServer.sendUpdate(path, update);
+                    });
+                },
+            });
+        }
+        this.remote.dev(onUpdate
+            ? comlink.proxy((result) => {
+                handleIssues(result.issues, false, false);
+                onUpdate(result);
+            })
+            : undefined);
+    }
+    async hmrSubscribe(identifier, callback) {
+        await this.remote.hmrSubscribe(identifier, comlink.proxy(callback));
+    }
+    updateInfoSubscribe(aggregationMs, callback) {
+        this.remote.updateInfoSubscribe(aggregationMs, comlink.proxy(callback));
+    }
     async readFile(path, encoding) {
         await __classPrivateFieldGet(this, _Project_mount, "f");
         return (await this.remote.readFile(path, encoding));
@@ -124,6 +149,20 @@ export class Project {
         await __classPrivateFieldGet(this, _Project_mount, "f");
         return await this.remote.sigMd5(content);
     }
+    /**
+     * Connect an iframe to the HMR server for hot module replacement.
+     * Only works after dev() has been called.
+     *
+     * @param iframe The iframe element to connect
+     * @param origin Optional origin for postMessage (default: "*")
+     * @returns The HMR client instance, or null if connection failed or dev() not called
+     */
+    connectHmrIframe(iframe, origin) {
+        if (!this.hmrServer) {
+            return null;
+        }
+        return this.hmrServer.connectIframe(iframe, origin);
+    }
     static fork(channel, eventSource) {
         (eventSource || self).postMessage(WorkerMessageType.RequestFork, {
             transfer: [channel.port2],

package/esm/types.d.ts

@@ -1,5 +1,6 @@
-import { Issue } from "@utoo/pack-shared";
+import { Issue, type UpdateMessage } from "@utoo/pack-shared";
 import initWasm, { DirEntryType } from "./utoo";
+export { type UpdateMessage } from "@utoo/pack-shared";
 export interface RawDirent {
     name: string;
     type: DirEntryType;
@@ -69,6 +70,17 @@ export interface ProjectEndpoint {
     deps: (options?: DepsOptions) => Promise<string>;
     install: (packageLock: string, options?: InstallOptions) => Promise<void>;
     build: () => Promise<BuildOutput>;
+    /** Start dev mode with file watching. onUpdate is called on each rebuild. */
+    dev: (onUpdate?: (result: BuildOutput) => void) => void;
+    /**
+     * Subscribe to HMR events for a specific identifier.
+     * Returns a Promise that resolves when the subscription is set up.
+     * Matches NAPI signature: project_hmr_events(project, identifier, func) -> RootTask
+     * Callback receives: { result: ClientUpdateInstruction, issues: Issue[], diagnostics: Diagnostic[] }
+     */
+    hmrSubscribe: (identifier: string, callback: (update: unknown) => void) => void | Promise<void>;
+    /** Subscribe to compilation lifecycle events (start/end). */
+    updateInfoSubscribe: (aggregationMs: number, callback: (message: UpdateMessage) => void) => void;
     readFile(path: string): Promise<Uint8Array>;
     readFile(path: string, encoding?: "utf8"): Promise<string>;
     writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;

package/esm/utoo/index.d.ts

@@ -212,24 +212,33 @@ export class Project {
     static get cwd(): string;
     /**
      * Generate package-lock.json by resolving dependencies.
-     *
-     * # Arguments
-     * * `registry` - Optional registry URL. If None, uses npmmirror.
-     *   - "https://registry.npmmirror.com" - supports semver queries (faster)
-     *   - "https://registry.npmjs.org" - official npm registry (slower, fetches full manifest)
-     * * `concurrency` - Optional concurrency limit (defaults to 20)
      * @param {string | null} [registry]
      * @param {number | null} [concurrency]
      * @returns {Promise<string>}
      */
     static deps(registry?: string | null, concurrency?: number | null): Promise<string>;
+    /**
+     * Subscribe to entrypoints changes with HMR support.
+     * This will watch for file changes and automatically rebuild.
+     * Returns a RootTask that must be held by JS to keep the subscription active.
+     * @param {Function} callback
+     * @returns {Promise<RootTask>}
+     */
+    static entrypointsSubscribe(callback: Function): Promise<RootTask>;
     /**
      * Create a tar.gz archive and return bytes (no file I/O)
-     * This is useful for main thread execution without OPFS access
      * @param {any} files
      * @returns {Promise<Uint8Array>}
      */
     static gzip(files: any): Promise<Uint8Array>;
+    /**
+     * Subscribe to HMR events for a specific identifier.
+     * Returns a RootTask that must be held by JS to keep the subscription active.
+     * @param {string} identifier
+     * @param {Function} callback
+     * @returns {Promise<RootTask>}
+     */
+    static hmrEvents(identifier: string, callback: Function): Promise<RootTask>;
     /**
      * @param {string} thread_url
      */
@@ -251,6 +260,28 @@ export class Project {
      * @returns {Promise<string>}
      */
     static sigMd5(content: Uint8Array): Promise<string>;
+    /**
+     * Subscribe to compilation lifecycle events.
+     * Emits "start" when computation begins, "end" when idle for aggregation_ms.
+     * @param {number} aggregation_ms
+     * @param {Function} callback
+     */
+    static updateInfoSubscribe(aggregation_ms: number, callback: Function): void;
+    /**
+     * Write all entrypoints to disk.
+     * @param {Function} callback
+     */
+    static writeAllToDisk(callback: Function): void;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+}
+/**
+ * A root task handle that keeps the turbo-tasks subscription alive.
+ * This must be held by JS to keep the subscription active.
+ */
+export class RootTask {
+    static __wrap(ptr: any): any;
     __destroy_into_raw(): number | undefined;
     __wbg_ptr: number | undefined;
     free(): void;

package/esm/utoo/index.js

@@ -507,12 +507,6 @@ export class Project {
     }
     /**
      * Generate package-lock.json by resolving dependencies.
-     *
-     * # Arguments
-     * * `registry` - Optional registry URL. If None, uses npmmirror.
-     *   - "https://registry.npmmirror.com" - supports semver queries (faster)
-     *   - "https://registry.npmjs.org" - official npm registry (slower, fetches full manifest)
-     * * `concurrency` - Optional concurrency limit (defaults to 20)
      * @param {string | null} [registry]
      * @param {number | null} [concurrency]
      * @returns {Promise<string>}
@@ -523,9 +517,19 @@ export class Project {
         const ret = wasm.project_deps(ptr0, len0, isLikeNone(concurrency) ? 0x100000001 : (concurrency) >>> 0);
         return takeObject(ret);
     }
+    /**
+     * Subscribe to entrypoints changes with HMR support.
+     * This will watch for file changes and automatically rebuild.
+     * Returns a RootTask that must be held by JS to keep the subscription active.
+     * @param {Function} callback
+     * @returns {Promise<RootTask>}
+     */
+    static entrypointsSubscribe(callback) {
+        const ret = wasm.project_entrypointsSubscribe(addHeapObject(callback));
+        return takeObject(ret);
+    }
     /**
      * Create a tar.gz archive and return bytes (no file I/O)
-     * This is useful for main thread execution without OPFS access
      * @param {any} files
      * @returns {Promise<Uint8Array>}
      */
@@ -533,6 +537,19 @@ export class Project {
         const ret = wasm.project_gzip(addHeapObject(files));
         return takeObject(ret);
     }
+    /**
+     * Subscribe to HMR events for a specific identifier.
+     * Returns a RootTask that must be held by JS to keep the subscription active.
+     * @param {string} identifier
+     * @param {Function} callback
+     * @returns {Promise<RootTask>}
+     */
+    static hmrEvents(identifier, callback) {
+        const ptr0 = passStringToWasm0(identifier, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_hmrEvents(ptr0, len0, addHeapObject(callback));
+        return takeObject(ret);
+    }
     /**
      * @param {string} thread_url
      */
@@ -570,9 +587,50 @@ export class Project {
         const ret = wasm.project_sigMd5(addHeapObject(content));
         return takeObject(ret);
     }
+    /**
+     * Subscribe to compilation lifecycle events.
+     * Emits "start" when computation begins, "end" when idle for aggregation_ms.
+     * @param {number} aggregation_ms
+     * @param {Function} callback
+     */
+    static updateInfoSubscribe(aggregation_ms, callback) {
+        wasm.project_updateInfoSubscribe(aggregation_ms, addHeapObject(callback));
+    }
+    /**
+     * Write all entrypoints to disk.
+     * @param {Function} callback
+     */
+    static writeAllToDisk(callback) {
+        wasm.project_writeAllToDisk(addHeapObject(callback));
+    }
 }
 if (Symbol.dispose)
     Project.prototype[Symbol.dispose] = Project.prototype.free;
+/**
+ * A root task handle that keeps the turbo-tasks subscription alive.
+ * This must be held by JS to keep the subscription active.
+ */
+export class RootTask {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RootTask.prototype);
+        obj.__wbg_ptr = ptr;
+        RootTaskFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RootTaskFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_roottask_free(ptr, 0);
+    }
+}
+if (Symbol.dispose)
+    RootTask.prototype[Symbol.dispose] = RootTask.prototype.free;
 export class WasmTaskMessage {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -844,13 +902,6 @@ function __wbg_get_imports(memory) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         },
-        __wbg_String_8f0eb39a4a4c2f66: function (arg0, arg1) {
-            const ret = String(getObject(arg1));
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
         __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function (arg0, arg1) {
             const ret = debugString(getObject(arg1));
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -867,10 +918,6 @@ function __wbg_get_imports(memory) {
             const ret = typeof (val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_string_cd444516edc5b180: function (arg0) {
-            const ret = typeof (getObject(arg0)) === 'string';
-            return ret;
-        },
         __wbg___wbindgen_is_undefined_9e4d92534c42d778: function (arg0) {
             const ret = getObject(arg0) === undefined;
             return ret;
@@ -1227,7 +1274,7 @@ function __wbg_get_imports(memory) {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_3447(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_3247(a, state0.b, arg0, arg1);
                     }
                     finally {
                         state0.a = a;
@@ -1250,10 +1297,6 @@ function __wbg_get_imports(memory) {
             const ret = new FileSystemObserver(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_new_dca287b076112a51: function () {
-            const ret = new Map();
-            return addHeapObject(ret);
-        },
         __wbg_new_dd2b680c8bf6ae29: function (arg0) {
             const ret = new Uint8Array(getObject(arg0));
             return addHeapObject(ret);
@@ -1320,6 +1363,12 @@ function __wbg_get_imports(memory) {
             const ret = Array.of(getObject(arg0), getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         },
+        __wbg_parse_708461a1feddfb38: function () {
+            return handleError(function (arg0, arg1) {
+                const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+                return addHeapObject(ret);
+            }, arguments);
+        },
         __wbg_performance_6adc3b899e448a23: function (arg0) {
             const ret = getObject(arg0).performance;
             return addHeapObject(ret);
@@ -1368,6 +1417,10 @@ function __wbg_get_imports(memory) {
             const ret = getObject(arg0).root;
             return addHeapObject(ret);
         },
+        __wbg_roottask_new: function (arg0) {
+            const ret = RootTask.__wrap(arg0);
+            return addHeapObject(ret);
+        },
         __wbg_setTimeout_63008613644b07af: function () {
             return handleError(function (arg0, arg1, arg2) {
                 const ret = getObject(arg0).setTimeout(getObject(arg1), arg2);
@@ -1378,13 +1431,6 @@ function __wbg_get_imports(memory) {
             const ret = setTimeout(getObject(arg0), arg1);
             return addHeapObject(ret);
         },
-        __wbg_set_1eb0999cf5d27fc8: function (arg0, arg1, arg2) {
-            const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-            return addHeapObject(ret);
-        },
-        __wbg_set_3f1d0b984ed272ed: function (arg0, arg1, arg2) {
-            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
-        },
         __wbg_set_body_9a7e00afe3cfe244: function (arg0, arg1) {
             getObject(arg0).body = getObject(arg1);
         },
@@ -1548,33 +1594,33 @@ function __wbg_get_imports(memory) {
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1878, function: Function { arguments: [Externref], shim_idx: 7388, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22681, __wasm_bindgen_func_elem_83554);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [Externref], shim_idx: 7400, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22596, __wasm_bindgen_func_elem_83828);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1878, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 7381, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
-            const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22681, __wasm_bindgen_func_elem_83231);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 7384, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22596, __wasm_bindgen_func_elem_83390);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1878, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 7388, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22681, __wasm_bindgen_func_elem_83554);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 7400, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22596, __wasm_bindgen_func_elem_83828);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1878, function: Function { arguments: [], shim_idx: 1879, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22681, __wasm_bindgen_func_elem_22682);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1845, function: Function { arguments: [], shim_idx: 1846, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_22596, __wasm_bindgen_func_elem_22597);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 7392, function: Function { arguments: [Ref(NamedExternref("MessageEvent"))], shim_idx: 7393, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_83606, __wasm_bindgen_func_elem_83607);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 7404, function: Function { arguments: [Ref(NamedExternref("MessageEvent"))], shim_idx: 7405, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_83880, __wasm_bindgen_func_elem_83881);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000006: function (arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 7392, function: Function { arguments: [], shim_idx: 1879, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_83606, __wasm_bindgen_func_elem_22682);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 7404, function: Function { arguments: [], shim_idx: 1846, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_83880, __wasm_bindgen_func_elem_22597);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000007: function (arg0) {
@@ -1582,22 +1628,12 @@ function __wbg_get_imports(memory) {
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000008: function (arg0) {
-            // Cast intrinsic for `I64 -> Externref`.
-            const ret = arg0;
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000009: function (arg0, arg1) {
+        __wbindgen_cast_0000000000000008: function (arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_000000000000000a: function (arg0) {
-            // Cast intrinsic for `U64 -> Externref`.
-            const ret = BigInt.asUintN(64, arg0);
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_000000000000000b: function (arg0, arg1) {
+        __wbindgen_cast_0000000000000009: function (arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("DirEntry")) -> Externref`.
@@ -1632,25 +1668,25 @@ function __wbg_get_imports(memory) {
         "./index_bg.js": import0,
     };
 }
-function __wasm_bindgen_func_elem_22682(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_22682(arg0, arg1);
+function __wasm_bindgen_func_elem_22597(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_22597(arg0, arg1);
 }
-function __wasm_bindgen_func_elem_83554(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_83554(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_83828(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_83828(arg0, arg1, addHeapObject(arg2));
 }
-function __wasm_bindgen_func_elem_83231(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_83231(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_83390(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_83390(arg0, arg1, addHeapObject(arg2));
 }
-function __wasm_bindgen_func_elem_83607(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_83881(arg0, arg1, arg2) {
     try {
-        wasm.__wasm_bindgen_func_elem_83607(arg0, arg1, addBorrowedObject(arg2));
+        wasm.__wasm_bindgen_func_elem_83881(arg0, arg1, addBorrowedObject(arg2));
     }
     finally {
         heap[stack_pointer++] = undefined;
     }
 }
-function __wasm_bindgen_func_elem_3447(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_3447(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_3247(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_3247(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 const __wbindgen_enum_DirEntryType = ["file", "directory"];
 const __wbindgen_enum_FileSystemChangeRecordType = ["appeared", "disappeared", "errored", "modified", "moved", "unknown"];
@@ -1674,6 +1710,9 @@ const MetadataFinalization = (typeof FinalizationRegistry === 'undefined')
 const ProjectFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => { }, unregister: () => { } }
     : new FinalizationRegistry(ptr => wasm.__wbg_project_free(ptr >>> 0, 1));
+const RootTaskFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_roottask_free(ptr >>> 0, 1));
 const WasmTaskMessageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => { }, unregister: () => { } }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmtaskmessage_free(ptr >>> 0, 1));

package/esm/webpackLoaders/worker.js

@@ -1,4 +1,4 @@
-import initWasm, { Fs, recvTaskMessageInWorker, sendTaskMessage, workerCreated, } from "../utoo";
+import { Fs, initSync, recvTaskMessageInWorker, sendTaskMessage, workerCreated, } from "../utoo";
 import { cjs } from "./cjs";
 const binding = {
     recvTaskMessageInWorker,
@@ -6,12 +6,15 @@ const binding = {
     workerCreated,
 };
 export function startLoaderWorker() {
-    self.onmessage = async (event) => {
+    self.onmessage = (event) => {
         let [module, memory, meta] = event.data;
-        await initWasm(module, memory).catch((err) => {
-            console.log(err);
+        try {
+            initSync({ module, memory });
+        }
+        catch (err) {
+            console.error(err);
             throw err;
-        });
+        }
         self.workerData = {
             threadId: meta.workerData.threadId,
             cwd: meta.workerData.cwd,