@utoo/web 1.2.0-rc.3 → 1.2.0-rc.4

package/esm/loaderWorkerPool.d.ts

@@ -1,3 +1,3 @@
 import { Binding } from "./type";
 import { Project as ProjectInternal } from "./utoo";
-export declare const runLoaderWorkerPool: (binding: Binding, projectCwd: string, projectInternal: ProjectInternal, workerUrl: string, loadersImportMap?: Record<string, string>) => Promise<void>;
+export declare const runLoaderWorkerPool: (binding: Binding, projectCwd: string, projectInternal: ProjectInternal, loaderWorkerUrl: string, loadersImportMap?: Record<string, string>) => Promise<void>;

package/esm/loaderWorkerPool.js

@@ -1,75 +1,28 @@
-import { SAB_OP_COPY_FILE, SAB_OP_MKDIR, SAB_OP_READ_DIR, SAB_OP_READ_FILE, SAB_OP_RM, SAB_OP_RMDIR, SAB_OP_WRITE_FILE, SabComHost, } from "./sabcom";
+import * as sabcom from "./sabcom";
 import initWasm, { registerWorkerScheduler, workerCreated, } from "./utoo";
 let nextWorkerId = 0;
 const loaderWorkers = {};
-export const runLoaderWorkerPool = async (binding, projectCwd, projectInternal, workerUrl, loadersImportMap) => {
+export const runLoaderWorkerPool = async (binding, projectCwd, projectInternal, loaderWorkerUrl, loadersImportMap) => {
     registerWorkerScheduler(async (creation) => {
         const { options: { filename, cwd }, } = creation;
         nextWorkerId += 1;
         const workerId = nextWorkerId;
         const sab = new SharedArrayBuffer(1024 * 1024 * 10); // 10MB
-        const sabHost = new SabComHost(sab);
-        const worker = new Worker(workerUrl, { name: filename });
+        const sabHost = new sabcom.SabComHost(sab);
+        const worker = new Worker(loaderWorkerUrl, { name: filename });
         worker.onmessage = async (event) => {
             if (event.data === "sab_request") {
-                const { op, data: path } = sabHost.readRequest();
-                try {
-                    if (op === SAB_OP_READ_FILE) {
-                        const bytes = await projectInternal.read(path);
-                        sabHost.writeResponse(bytes);
-                    }
-                    else if (op === SAB_OP_READ_DIR) {
-                        const entries = await projectInternal.readDir(path);
-                        sabHost.writeResponse(JSON.stringify(entries.map((e) => e.toJSON())));
-                    }
-                    else if (op === SAB_OP_WRITE_FILE) {
-                        const { content, encoding } = JSON.parse(path);
-                        const filePath = content.path;
-                        const fileContent = content.data;
-                        // TODO: handle binary content (base64?)
-                        await projectInternal.writeString(filePath, fileContent);
-                        sabHost.writeResponse("ok");
-                    }
-                    else if (op === SAB_OP_MKDIR) {
-                        const { path: dirPath, recursive } = JSON.parse(path);
-                        if (recursive) {
-                            await projectInternal.createDirAll(dirPath);
-                        }
-                        else {
-                            await projectInternal.createDir(dirPath);
-                        }
-                        sabHost.writeResponse("ok");
-                    }
-                    else if (op === SAB_OP_RM) {
-                        const { path: rmPath, recursive } = JSON.parse(path);
-                        // Mimic internalProject.rm logic
-                        const metadata = await projectInternal.metadata(rmPath);
-                        const type = metadata.toJSON().type;
-                        if (type === "file") {
-                            await projectInternal.removeFile(rmPath);
-                        }
-                        else if (type === "directory") {
-                            await projectInternal.removeDir(rmPath, !!recursive);
-                        }
-                        sabHost.writeResponse("ok");
-                    }
-                    else if (op === SAB_OP_RMDIR) {
-                        const { path: rmPath, recursive } = JSON.parse(path);
-                        await projectInternal.removeDir(rmPath, !!recursive);
-                        sabHost.writeResponse("ok");
-                    }
-                    else if (op === SAB_OP_COPY_FILE) {
-                        const { src, dst } = JSON.parse(path);
-                        await projectInternal.copyFile(src, dst);
-                        sabHost.writeResponse("ok");
-                    }
-                    else {
-                        sabHost.writeError("Unknown op");
-                    }
-                }
-                catch (e) {
-                    sabHost.writeError(e.message);
-                }
+                await sabcom.handleSabRequest(sabHost, {
+                    read: (path) => projectInternal.read(path),
+                    readDir: (path) => projectInternal.readDir(path),
+                    writeString: (path, content) => projectInternal.writeString(path, content),
+                    createDirAll: (path) => projectInternal.createDirAll(path),
+                    createDir: (path) => projectInternal.createDir(path),
+                    metadata: (path) => projectInternal.metadata(path),
+                    removeFile: (path) => projectInternal.removeFile(path),
+                    removeDir: (path, recursive) => projectInternal.removeDir(path, recursive),
+                    copyFile: (src, dst) => projectInternal.copyFile(src, dst),
+                });
             }
         };
         let finalCwd = cwd;

package/esm/sabcom.d.ts

@@ -9,6 +9,7 @@ export declare const SAB_OP_MKDIR = 4;
 export declare const SAB_OP_RM = 5;
 export declare const SAB_OP_RMDIR = 6;
 export declare const SAB_OP_COPY_FILE = 7;
+export declare const SAB_OP_STAT = 8;
 export declare class SabComHost {
     private sab;
     private int32;
@@ -29,3 +30,15 @@ export declare class SabComClient {
     constructor(sab: SharedArrayBuffer, notifyHost: () => void);
     call(op: number, data: string): Uint8Array<ArrayBuffer>;
 }
+export interface SabFileSystem {
+    read(path: string): Promise<Uint8Array>;
+    readDir(path: string): Promise<any[]>;
+    writeString(path: string, content: string): Promise<void>;
+    createDirAll(path: string): Promise<void>;
+    createDir(path: string): Promise<void>;
+    metadata(path: string): Promise<any>;
+    removeFile(path: string): Promise<void>;
+    removeDir(path: string, recursive: boolean): Promise<void>;
+    copyFile(src: string, dst: string): Promise<void>;
+}
+export declare const handleSabRequest: (sabHost: SabComHost, fs: SabFileSystem) => Promise<void>;

package/esm/sabcom.js

@@ -9,6 +9,7 @@ export const SAB_OP_MKDIR = 4;
 export const SAB_OP_RM = 5;
 export const SAB_OP_RMDIR = 6;
 export const SAB_OP_COPY_FILE = 7;
+export const SAB_OP_STAT = 8;
 // Layout:
 // 0: State (Int32)
 // 1: Op (Int32)
@@ -69,3 +70,67 @@ export class SabComClient {
         return this.uint8.slice(12, 12 + len);
     }
 }
+export const handleSabRequest = async (sabHost, fs) => {
+    const { op, data: path } = sabHost.readRequest();
+    try {
+        if (op === SAB_OP_READ_FILE) {
+            const bytes = await fs.read(path);
+            sabHost.writeResponse(bytes);
+        }
+        else if (op === SAB_OP_READ_DIR) {
+            const entries = await fs.readDir(path);
+            sabHost.writeResponse(JSON.stringify(entries.map((e) => e.toJSON())));
+        }
+        else if (op === SAB_OP_WRITE_FILE) {
+            const { content, encoding } = JSON.parse(path);
+            const filePath = content.path;
+            const fileContent = content.data;
+            // TODO: handle binary content (base64?)
+            await fs.writeString(filePath, fileContent);
+            sabHost.writeResponse("ok");
+        }
+        else if (op === SAB_OP_MKDIR) {
+            const { path: dirPath, recursive } = JSON.parse(path);
+            if (recursive) {
+                await fs.createDirAll(dirPath);
+            }
+            else {
+                await fs.createDir(dirPath);
+            }
+            sabHost.writeResponse("ok");
+        }
+        else if (op === SAB_OP_RM) {
+            const { path: rmPath, recursive } = JSON.parse(path);
+            // Mimic internalProject.rm logic
+            const metadata = await fs.metadata(rmPath);
+            const type = metadata.toJSON().type;
+            if (type === "file") {
+                await fs.removeFile(rmPath);
+            }
+            else if (type === "directory") {
+                await fs.removeDir(rmPath, !!recursive);
+            }
+            sabHost.writeResponse("ok");
+        }
+        else if (op === SAB_OP_RMDIR) {
+            const { path: rmPath, recursive } = JSON.parse(path);
+            await fs.removeDir(rmPath, !!recursive);
+            sabHost.writeResponse("ok");
+        }
+        else if (op === SAB_OP_COPY_FILE) {
+            const { src, dst } = JSON.parse(path);
+            await fs.copyFile(src, dst);
+            sabHost.writeResponse("ok");
+        }
+        else if (op === SAB_OP_STAT) {
+            const metadata = await fs.metadata(path);
+            sabHost.writeResponse(JSON.stringify(metadata));
+        }
+        else {
+            sabHost.writeError("Unknown op");
+        }
+    }
+    catch (e) {
+        sabHost.writeError(e.message);
+    }
+};

package/esm/serviceWorker.js

@@ -54,7 +54,7 @@ async function readFileFromProject(projectPath) {
             headers: {
                 "Content-Type": mimeType,
                 ...(mimeType === "text/html"
-                    ? { "Cross-Origin-Embedder-Policy": "require-corp" }
+                    ? { "Cross-Origin-Embedder-Policy": "credentialless" }
                     : {}),
             },
         });

package/esm/utoo/index.d.ts

@@ -62,11 +62,30 @@ export class DirEntry {
 }
 export class Metadata {
     static __wrap(ptr: any): any;
-    toJSON(): {};
+    toJSON(): {
+        type: DirEntryType;
+        file_size: bigint;
+    };
     toString(): string;
     __destroy_into_raw(): number | undefined;
     __wbg_ptr: number | undefined;
     free(): void;
+    /**
+     * @param {DirEntryType} arg0
+     */
+    set type(arg0: DirEntryType);
+    /**
+     * @returns {DirEntryType}
+     */
+    get type(): DirEntryType;
+    /**
+     * @param {bigint} arg0
+     */
+    set file_size(arg0: bigint);
+    /**
+     * @returns {bigint}
+     */
+    get file_size(): bigint;
 }
 export class Project {
     /**

package/esm/utoo/index.js

@@ -182,63 +182,63 @@ const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(state => {
         wasm.__wbindgen_export_5.get(state.dtor)(state.a, state.b);
     });
-function makeMutClosure(arg0, arg1, dtor, f) {
+function makeClosure(arg0, arg1, dtor, f) {
     const state = { a: arg0, b: arg1, cnt: 1, dtor };
     const real = (...args) => {
         // First up with a closure we increment the internal reference
         // count. This ensures that the Rust closure environment won't
         // be deallocated while we're invoking it.
         state.cnt++;
-        const a = state.a;
-        state.a = 0;
         try {
-            return f(a, state.b, ...args);
+            return f(state.a, state.b, ...args);
         }
         finally {
             if (--state.cnt === 0) {
-                wasm.__wbindgen_export_5.get(state.dtor)(a, state.b);
+                wasm.__wbindgen_export_5.get(state.dtor)(state.a, state.b);
+                state.a = 0;
                 CLOSURE_DTORS.unregister(state);
             }
-            else {
-                state.a = a;
-            }
         }
     };
     real.original = state;
     CLOSURE_DTORS.register(real, state, state);
     return real;
 }
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(takeObject(mem.getUint32(i, true)));
-    }
-    return result;
-}
-function makeClosure(arg0, arg1, dtor, f) {
+function makeMutClosure(arg0, arg1, dtor, f) {
     const state = { a: arg0, b: arg1, cnt: 1, dtor };
     const real = (...args) => {
         // First up with a closure we increment the internal reference
         // count. This ensures that the Rust closure environment won't
         // be deallocated while we're invoking it.
         state.cnt++;
+        const a = state.a;
+        state.a = 0;
         try {
-            return f(state.a, state.b, ...args);
+            return f(a, state.b, ...args);
         }
         finally {
             if (--state.cnt === 0) {
-                wasm.__wbindgen_export_5.get(state.dtor)(state.a, state.b);
-                state.a = 0;
+                wasm.__wbindgen_export_5.get(state.dtor)(a, state.b);
                 CLOSURE_DTORS.unregister(state);
             }
+            else {
+                state.a = a;
+            }
         }
     };
     real.original = state;
     CLOSURE_DTORS.register(real, state, state);
     return real;
 }
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
@@ -271,12 +271,6 @@ export function init_log_filter(filter) {
     const len0 = WASM_VECTOR_LEN;
     wasm.init_log_filter(ptr0, len0);
 }
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
 /**
  * @param {number} worker_id
  */
@@ -290,6 +284,12 @@ export function workerCreated(worker_id) {
 export function registerWorkerScheduler(creator, terminator) {
     wasm.registerWorkerScheduler(addHeapObject(creator), addHeapObject(terminator));
 }
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
  * Entry point for web workers
  * @param {number} ptr
@@ -297,13 +297,13 @@ export function registerWorkerScheduler(creator, terminator) {
 export function wasm_thread_entry_point(ptr) {
     wasm.wasm_thread_entry_point(ptr);
 }
-function __wbg_adapter_4(arg0, arg1, arg2) {
+function __wbg_adapter_6(arg0, arg1, arg2) {
     wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2));
 }
-function __wbg_adapter_13(arg0, arg1) {
+function __wbg_adapter_15(arg0, arg1) {
     wasm.__wbindgen_export_7(arg0, arg1);
 }
-function __wbg_adapter_26(arg0, arg1, arg2) {
+function __wbg_adapter_18(arg0, arg1, arg2) {
     wasm.__wbindgen_export_8(arg0, arg1, addHeapObject(arg2));
 }
 let stack_pointer = 128;
@@ -441,7 +441,10 @@ export class Metadata {
         return obj;
     }
     toJSON() {
-        return {};
+        return {
+            type: this.type,
+            file_size: this.file_size,
+        };
     }
     toString() {
         return JSON.stringify(this);
@@ -456,6 +459,32 @@ export class Metadata {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_metadata_free(ptr, 0);
     }
+    /**
+     * @returns {DirEntryType}
+     */
+    get type() {
+        const ret = wasm.__wbg_get_metadata_type(this.__wbg_ptr);
+        return __wbindgen_enum_DirEntryType[ret];
+    }
+    /**
+     * @param {DirEntryType} arg0
+     */
+    set type(arg0) {
+        wasm.__wbg_set_metadata_type(this.__wbg_ptr, (__wbindgen_enum_DirEntryType.indexOf(arg0) + 1 || 3) - 1);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get file_size() {
+        const ret = wasm.__wbg_get_metadata_file_size(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set file_size(arg0) {
+        wasm.__wbg_set_metadata_file_size(this.__wbg_ptr, arg0);
+    }
 }
 if (Symbol.dispose)
     Metadata.prototype[Symbol.dispose] = Metadata.prototype.free;
@@ -1712,9 +1741,9 @@ function __wbg_get_imports() {
             return ret;
         }, arguments);
     };
-    imports.wbg.__wbindgen_cast_1113a938f979d88a = function (arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 603, function: Function { arguments: [], shim_idx: 604, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, 603, __wbg_adapter_13);
+    imports.wbg.__wbindgen_cast_147f62ca53704375 = function (arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 8608, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 8609, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+        const ret = makeClosure(arg0, arg1, 8608, __wbg_adapter_18);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function (arg0, arg1) {
@@ -1722,14 +1751,19 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_320e55bca3a693f6 = function (arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 8608, function: Function { arguments: [Ref(NamedExternref("MessageEvent"))], shim_idx: 8631, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, 8608, __wbg_adapter_29);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function (arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_59550fe77af0bf03 = function (arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 8609, function: Function { arguments: [Ref(NamedExternref("MessageEvent"))], shim_idx: 8630, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, 8609, __wbg_adapter_29);
+    imports.wbg.__wbindgen_cast_6c005a14a1fbf1c5 = function (arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 595, function: Function { arguments: [], shim_idx: 596, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, 595, __wbg_adapter_15);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_76322aab70622876 = function (arg0, arg1) {
@@ -1739,11 +1773,6 @@ function __wbg_get_imports() {
         const ret = v0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_77984da3a91be2e9 = function (arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 8625, function: Function { arguments: [Externref], shim_idx: 8626, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, 8625, __wbg_adapter_4);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_77bc3e92745e9a35 = function (arg0, arg1) {
         var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
         wasm.__wbindgen_export_4(arg0, arg1 * 1, 1);
@@ -1751,9 +1780,14 @@ function __wbg_get_imports() {
         const ret = v0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_8ecade4ce8b126db = function (arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 8625, function: Function { arguments: [], shim_idx: 604, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, 8625, __wbg_adapter_13);
+    imports.wbg.__wbindgen_cast_7b3678bd8e0fb80b = function (arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 8626, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 8627, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, 8626, __wbg_adapter_6);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_884165a22f3e9702 = function (arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 8626, function: Function { arguments: [Externref], shim_idx: 8627, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, 8626, __wbg_adapter_6);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_9ae0607507abb057 = function (arg0) {
@@ -1761,14 +1795,9 @@ function __wbg_get_imports() {
         const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_bb0fb35a7180d55b = function (arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 8625, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 8626, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, 8625, __wbg_adapter_4);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_cdaa362fcf12456c = function (arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 8609, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 8610, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
-        const ret = makeClosure(arg0, arg1, 8609, __wbg_adapter_26);
+    imports.wbg.__wbindgen_cast_c112ec0eb88c0f62 = function (arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 8626, function: Function { arguments: [], shim_idx: 596, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, 8626, __wbg_adapter_15);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function (arg0) {

package/esm/webpackLoaders/worker/cjs.js

@@ -89,7 +89,7 @@ const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     return finalExports;
 };
 const loadModule = (id, context, importMaps, entrypoint) => {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c;
     const cacheKey = `${context}:${id}`;
     if (resolutionCache[cacheKey]) {
         const cachedId = resolutionCache[cacheKey];
@@ -136,13 +136,6 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         let searchPaths = searchPathsCache[context];
         if (!searchPaths) {
             searchPaths = [];
-            // @ts-ignore
-            const cwd = ((_b = (_a = self.process) === null || _a === void 0 ? void 0 : _a.cwd) === null || _b === void 0 ? void 0 : _b.call(_a)) || ((_c = self.workerData) === null || _c === void 0 ? void 0 : _c.cwd) || "/";
-            const isInsideNodeModules = context.includes("/node_modules/") ||
-                context.includes("\\node_modules\\");
-            if (isInsideNodeModules) {
-                searchPaths.push(path.join(cwd, "node_modules"));
-            }
             let currentDir = context;
             while (true) {
                 if (path.basename(currentDir) !== "node_modules") {
@@ -182,25 +175,35 @@ const loadModule = (id, context, importMaps, entrypoint) => {
                         ];
                         for (const candidate of candidates) {
                             if (existsSync(candidate) && !statSync(candidate).isDirectory()) {
-                                resolvedId = candidate;
-                                moduleCode = fs.readFileSync(candidate, "utf8");
-                                moduleId = candidate;
-                                break;
+                                try {
+                                    resolvedId = candidate;
+                                    moduleCode = fs.readFileSync(candidate, "utf8");
+                                    moduleId = candidate;
+                                    break;
+                                }
+                                catch (e) {
+                                    // ignore
+                                }
                             }
                         }
                     }
                 }
-                catch (_g) { }
+                catch (_d) { }
             }
             if (!moduleCode) {
                 const extensions = ["", ".js", ".json", "/index.js"];
                 for (const ext of extensions) {
                     const p = nodeModulesPath + ext;
                     if (existsSync(p) && !statSync(p).isDirectory()) {
-                        resolvedId = p;
-                        moduleCode = fs.readFileSync(p, "utf8");
-                        moduleId = p;
-                        break;
+                        try {
+                            resolvedId = p;
+                            moduleCode = fs.readFileSync(p, "utf8");
+                            moduleId = p;
+                            break;
+                        }
+                        catch (e) {
+                            // ignore
+                        }
                     }
                 }
             }
@@ -211,7 +214,7 @@ const loadModule = (id, context, importMaps, entrypoint) => {
     // Fallback: Try resolving absolute path (handling CWD stripping)
     if (!moduleCode && id.startsWith("/")) {
         // @ts-ignore
-        const cwd = ((_e = (_d = self.process) === null || _d === void 0 ? void 0 : _d.cwd) === null || _e === void 0 ? void 0 : _e.call(_d)) || ((_f = self.workerData) === null || _f === void 0 ? void 0 : _f.cwd) || "/";
+        const cwd = ((_b = (_a = self.process) === null || _a === void 0 ? void 0 : _a.cwd) === null || _b === void 0 ? void 0 : _b.call(_a)) || ((_c = self.workerData) === null || _c === void 0 ? void 0 : _c.cwd) || "/";
         let relativeId = id;
         if (id.startsWith(cwd)) {
             relativeId = id.slice(cwd.length);
@@ -222,10 +225,15 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         for (const ext of extensions) {
             const p = relativeId + ext;
             if (existsSync(p) && !statSync(p).isDirectory()) {
-                resolvedId = p; // Use relative path for FS ops
-                moduleCode = fs.readFileSync(p, "utf8");
-                moduleId = id; // Keep original absolute path as module ID
-                break;
+                try {
+                    resolvedId = p; // Use relative path for FS ops
+                    moduleCode = fs.readFileSync(p, "utf8");
+                    moduleId = id; // Keep original absolute path as module ID
+                    break;
+                }
+                catch (e) {
+                    // ignore
+                }
             }
         }
     }
@@ -235,10 +243,16 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         for (const ext of extensions) {
             const p = resolvedId + ext;
             if (existsSync(p) && !statSync(p).isDirectory()) {
-                resolvedId = p;
-                moduleCode = fs.readFileSync(p, "utf8");
-                moduleId = p;
-                break;
+                try {
+                    resolvedId = p;
+                    moduleCode = fs.readFileSync(p, "utf8");
+                    moduleId = p;
+                    break;
+                }
+                catch (e) {
+                    console.error(`[Debug] Failed to read file ${p}:`, e);
+                    // ignore
+                }
             }
         }
     }
@@ -247,7 +261,7 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         resolutionCache[cacheKey] = moduleId;
         return executeModule(moduleCode, moduleId, id, importMaps, entrypoint);
     }
-    console.error(`Worker: Dependency ${id} (resolved: ${resolvedId}) not found.`);
+    console.error(`Worker: Dependency ${id} (resolved: ${resolvedId}) not found. Context: ${context}`);
     return {};
 };
 export async function cjs(entrypoint, importMaps) {