@utoo/web 1.2.0-rc.1 → 1.2.0-rc.10

package/esm/webpackLoaders/{worker/polyfills → polyfills}/fsPolyfill.js

@@ -1,29 +1,13 @@
 import { Buffer } from "buffer";
 import path from "path";
-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, } from "../../../sabcom";
+import { Stats } from "../../types";
+import * as sabcom from "../../utils/sabcom";
+import { promises } from "./fsPromisesPolyfill";
 function resolvePath(p) {
     var _a, _b, _c;
     // @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) || "/";
-    if (cwd === "/") {
-        if (p.startsWith("/")) {
-            return p.slice(1);
-        }
-        return p;
-    }
-    if (p.startsWith(cwd)) {
-        // Check if it's an exact match or followed by separator
-        if (p.length === cwd.length) {
-            return ".";
-        }
-        if (p[cwd.length] === path.sep || p[cwd.length] === "/") {
-            let relative = p.slice(cwd.length);
-            if (relative.startsWith("/"))
-                relative = relative.slice(1);
-            return relative || ".";
-        }
-    }
-    return p;
+    return path.resolve(cwd, p);
 }
 function getSabClient() {
     // @ts-ignore
@@ -33,22 +17,18 @@ function getSabClient() {
     }
     return client;
 }
-export function readFile(path, options, cb) {
-    if (typeof options === "function") {
-        cb = options;
-        options = {};
-    }
-    try {
-        const data = readFileSync(path, options);
-        cb(null, data);
-    }
-    catch (e) {
-        cb(e);
+function getFs() {
+    // @ts-ignore
+    const fs = self.workerData.fs;
+    if (!fs) {
+        throw new Error("FS not initialized");
     }
+    return fs;
 }
+// --- Synchronous API (via sabcom) ---
 export function readFileSync(path, options) {
     const client = getSabClient();
-    const result = client.call(SAB_OP_READ_FILE, resolvePath(path));
+    const result = client.call(sabcom.SAB_OP_READ_FILE, resolvePath(path));
     if (options === "utf8" ||
         options === "utf-8" ||
         (options && (options.encoding === "utf8" || options.encoding === "utf-8"))) {
@@ -58,7 +38,7 @@ export function readFileSync(path, options) {
 }
 export function readdirSync(path, options) {
     const client = getSabClient();
-    const result = client.call(SAB_OP_READ_DIR, resolvePath(path));
+    const result = client.call(sabcom.SAB_OP_READ_DIR, resolvePath(path));
     const json = new TextDecoder().decode(result);
     const entries = JSON.parse(json);
     if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
@@ -71,95 +51,30 @@ export function readdirSync(path, options) {
     }
     return entries.map((e) => e.name);
 }
-export function readdir(path, options, cb) {
-    if (typeof options === "function") {
-        cb = options;
-        options = {};
-    }
-    try {
-        const files = readdirSync(path, options);
-        cb(null, files);
-    }
-    catch (e) {
-        cb(e);
-    }
-}
 export function writeFileSync(path, data, options) {
     const client = getSabClient();
     // TODO: handle binary data properly
     const content = typeof data === "string" ? data : new TextDecoder().decode(data);
     const payload = JSON.stringify({ path: resolvePath(path), data: content });
-    client.call(SAB_OP_WRITE_FILE, payload);
-}
-export function writeFile(path, data, options, cb) {
-    if (typeof options === "function") {
-        cb = options;
-        options = {};
-    }
-    try {
-        writeFileSync(path, data, options);
-        cb(null);
-    }
-    catch (e) {
-        cb(e);
-    }
+    client.call(sabcom.SAB_OP_WRITE_FILE, payload);
 }
 export function mkdirSync(path, options) {
     const client = getSabClient();
     const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
     const payload = JSON.stringify({ path: resolvePath(path), recursive });
-    client.call(SAB_OP_MKDIR, payload);
-}
-export function mkdir(path, options, cb) {
-    if (typeof options === "function") {
-        cb = options;
-        options = {};
-    }
-    try {
-        mkdirSync(path, options);
-        cb(null);
-    }
-    catch (e) {
-        cb(e);
-    }
+    client.call(sabcom.SAB_OP_MKDIR, payload);
 }
 export function rmSync(path, options) {
     const client = getSabClient();
     const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
     const payload = JSON.stringify({ path: resolvePath(path), recursive });
-    client.call(SAB_OP_RM, payload);
-}
-export function rm(path, options, cb) {
-    if (typeof options === "function") {
-        cb = options;
-        options = {};
-    }
-    try {
-        rmSync(path, options);
-        cb(null);
-    }
-    catch (e) {
-        cb(e);
-    }
+    client.call(sabcom.SAB_OP_RM, payload);
 }
 export function rmdirSync(path, options) {
     const client = getSabClient();
     const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
     const payload = JSON.stringify({ path: resolvePath(path), recursive });
-    client.call(SAB_OP_RMDIR, payload);
-}
-export function rmdir(path, options, cb) {
-    if (typeof options === "function") {
-        cb = options;
-        options = {};
-    }
-    try {
-        rmdirSync(path, options);
-        cb(null);
-    }
-    catch (e) {
-        cb(e);
-    }
+    client.call(sabcom.SAB_OP_RMDIR, payload);
 }
 export function copyFileSync(src, dst) {
     const client = getSabClient();
@@ -167,120 +82,167 @@ export function copyFileSync(src, dst) {
         src: resolvePath(src),
         dst: resolvePath(dst),
     });
-    client.call(SAB_OP_COPY_FILE, payload);
-}
-export function copyFile(src, dst, cb) {
-    try {
-        copyFileSync(src, dst);
-        cb(null);
-    }
-    catch (e) {
-        cb(e);
-    }
+    client.call(sabcom.SAB_OP_COPY_FILE, payload);
 }
 export function statSync(p) {
-    const parent = path.dirname(p);
-    const name = path.basename(p);
-    // Root check
-    if (p === "/" || p === ".") {
-        return {
-            isDirectory: () => true,
-            isFile: () => false,
-            isSymbolicLink: () => false,
-            size: 0,
-            mtime: new Date(),
-        };
-    }
-    try {
-        const entries = readdirSync(parent, { withFileTypes: true });
-        const entry = entries.find((e) => e.name === name);
-        if (!entry) {
-            throw new Error(`ENOENT: no such file or directory, stat '${p}'`);
-        }
-        return {
-            isDirectory: () => entry.isDirectory(),
-            isFile: () => entry.isFile(),
-            isSymbolicLink: () => entry.isSymbolicLink(),
-            size: 0,
-            mtime: new Date(),
-        };
-    }
-    catch (e) {
-        throw e;
-    }
+    const client = getSabClient();
+    const struct = client.callStat(resolvePath(p));
+    return new Stats({
+        type: struct.type === sabcom.STAT_TYPE_DIR ? "directory" : "file",
+        size: Number(struct.size),
+        atimeMs: struct.atimeMs,
+        mtimeMs: struct.mtimeMs,
+        ctimeMs: struct.ctimeMs,
+        birthtimeMs: struct.birthtimeMs,
+    });
 }
 export function lstatSync(p) {
     return statSync(p);
 }
-export function stat(path, cb) {
+export function realpathSync(p) {
+    return p;
+}
+export function accessSync(path, mode) {
+    statSync(path);
+}
+export function existsSync(path) {
     try {
-        const stats = statSync(path);
-        cb(null, stats);
+        statSync(path);
+        return true;
     }
     catch (e) {
-        cb(e);
+        return false;
     }
 }
-export function lstat(path, cb) {
-    try {
-        const stats = lstatSync(path);
-        cb(null, stats);
+// --- Asynchronous API (via WASM Project) ---
+export function readFile(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
     }
-    catch (e) {
-        cb(e);
+    const encoding = options === "utf8" ||
+        options === "utf-8" ||
+        (options === null || options === void 0 ? void 0 : options.encoding) === "utf8" ||
+        (options === null || options === void 0 ? void 0 : options.encoding) === "utf-8"
+        ? "utf8"
+        : undefined;
+    const p = resolvePath(path);
+    const fs = getFs();
+    const promise = encoding ? fs.readToString(p) : fs.read(p);
+    promise
+        .then((data) => {
+        cb(null, encoding ? data : Buffer.from(data));
+    })
+        .catch((e) => cb(e));
+}
+export function readdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
     }
+    getFs()
+        .readDir(resolvePath(path))
+        .then((entries) => {
+        const result = entries.map((e) => {
+            const json = e.toJSON();
+            if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
+                return {
+                    name: json.name,
+                    isFile: () => json.type === "file",
+                    isDirectory: () => json.type === "directory",
+                    isSymbolicLink: () => false,
+                };
+            }
+            return json.name;
+        });
+        cb(null, result);
+    })
+        .catch((e) => cb(e));
 }
-export function realpathSync(p) {
-    return p;
+export function writeFile(path, data, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const p = resolvePath(path);
+    const fs = getFs();
+    const promise = typeof data === "string" ? fs.writeString(p, data) : fs.write(p, data);
+    promise.then(() => cb(null)).catch((e) => cb(e));
 }
-export function realpath(p, cb) {
-    cb(null, p);
+export function mkdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const p = resolvePath(path);
+    const fs = getFs();
+    const promise = (options === null || options === void 0 ? void 0 : options.recursive) ? fs.createDirAll(p) : fs.createDir(p);
+    promise.then(() => cb(null)).catch((e) => cb(e));
 }
-export function accessSync(path, mode) {
-    try {
-        statSync(path);
+export function rm(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
     }
-    catch (e) {
-        throw e;
+    const p = resolvePath(path);
+    const fs = getFs();
+    fs.metadata(p)
+        .then((metadata) => {
+        const type = metadata.toJSON().type;
+        if (type === "file") {
+            return fs.removeFile(p);
+        }
+        else {
+            return fs.removeDir(p, !!(options === null || options === void 0 ? void 0 : options.recursive));
+        }
+    })
+        .then(() => cb(null))
+        .catch((e) => cb(e));
+}
+export function rmdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
     }
+    getFs()
+        .removeDir(resolvePath(path), !!(options === null || options === void 0 ? void 0 : options.recursive))
+        .then(() => cb(null))
+        .catch((e) => cb(e));
+}
+export function copyFile(src, dst, cb) {
+    getFs()
+        .copyFile(resolvePath(src), resolvePath(dst))
+        .then(() => cb(null))
+        .catch((e) => cb(e));
+}
+export function stat(p, cb) {
+    getFs()
+        .metadata(resolvePath(p))
+        .then((metadata) => {
+        const json = metadata.toJSON();
+        cb(null, new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        }));
+    })
+        .catch((e) => cb(e));
+}
+export function lstat(p, cb) {
+    stat(p, cb);
 }
-export function access(path, mode, cb) {
+export function realpath(p, cb) {
+    cb(null, p);
+}
+export function access(p, mode, cb) {
     if (typeof mode === "function") {
         cb = mode;
         mode = 0;
     }
-    try {
-        accessSync(path, mode);
-        if (cb)
-            cb(null);
-    }
-    catch (e) {
+    stat(p, (err) => {
         if (cb)
-            cb(e);
-    }
-}
-export function existsSync(path) {
-    try {
-        statSync(path);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
+            cb(err);
+    });
 }
-export const promises = {
-    readFile: async (path, options) => readFileSync(path, options),
-    writeFile: async (path, data, options) => writeFileSync(path, data, options),
-    readdir: async (path, options) => readdirSync(path, options),
-    mkdir: async (path, options) => mkdirSync(path, options),
-    rm: async (path, options) => rmSync(path, options),
-    rmdir: async (path, options) => rmdirSync(path, options),
-    copyFile: async (src, dst) => copyFileSync(src, dst),
-    stat: async (p) => statSync(p),
-    lstat: async (p) => lstatSync(p),
-    realpath: async (p) => realpathSync(p),
-    access: async (path, mode) => accessSync(path, mode),
-};
 export const constants = {
     F_OK: 0,
     R_OK: 4,
@@ -314,3 +276,4 @@ export default {
     promises,
     constants,
 };
+export { promises };

package/esm/webpackLoaders/polyfills/fsPromisesPolyfill.d.ts

@@ -0,0 +1,26 @@
+import { Stats } from "../../types";
+export declare const promises: {
+    readFile: (p: string, options?: any) => Promise<any>;
+    writeFile: (p: string, data: string | Uint8Array, options?: any) => Promise<void>;
+    readdir: (p: string, options?: any) => Promise<any>;
+    mkdir: (p: string, options?: any) => Promise<void>;
+    rm: (p: string, options?: any) => Promise<void>;
+    rmdir: (p: string, options?: any) => Promise<any>;
+    copyFile: (src: string, dst: string) => Promise<any>;
+    stat: (p: string) => Promise<Stats>;
+    lstat: (p: string) => Promise<Stats>;
+    realpath: (p: string) => Promise<string>;
+    access: (p: string, mode?: number) => Promise<void>;
+};
+export declare const readFile: (p: string, options?: any) => Promise<any>;
+export declare const writeFile: (p: string, data: string | Uint8Array, options?: any) => Promise<void>;
+export declare const readdir: (p: string, options?: any) => Promise<any>;
+export declare const mkdir: (p: string, options?: any) => Promise<void>;
+export declare const rm: (p: string, options?: any) => Promise<void>;
+export declare const rmdir: (p: string, options?: any) => Promise<any>;
+export declare const copyFile: (src: string, dst: string) => Promise<any>;
+export declare const stat: (p: string) => Promise<Stats>;
+export declare const lstat: (p: string) => Promise<Stats>;
+export declare const realpath: (p: string) => Promise<string>;
+export declare const access: (p: string, mode?: number) => Promise<void>;
+export default promises;

package/esm/webpackLoaders/polyfills/fsPromisesPolyfill.js

@@ -0,0 +1,112 @@
+import { Buffer } from "buffer";
+import path from "path";
+import { Stats } from "../../types";
+function resolvePath(p) {
+    var _a, _b, _c;
+    // @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) || "/";
+    return path.resolve(cwd, p);
+}
+function getFs() {
+    // @ts-ignore
+    const fs = self.workerData.fs;
+    if (!fs) {
+        throw new Error("FS not initialized");
+    }
+    return fs;
+}
+export const promises = {
+    readFile: async (p, options) => {
+        const encoding = options === "utf8" ||
+            options === "utf-8" ||
+            (options === null || options === void 0 ? void 0 : options.encoding) === "utf8" ||
+            (options === null || options === void 0 ? void 0 : options.encoding) === "utf-8"
+            ? "utf8"
+            : undefined;
+        const fs = getFs();
+        const path = resolvePath(p);
+        const data = await (encoding ? fs.readToString(path) : fs.read(path));
+        return encoding ? data : Buffer.from(data);
+    },
+    writeFile: async (p, data, options) => {
+        const fs = getFs();
+        const path = resolvePath(p);
+        if (typeof data === "string") {
+            await fs.writeString(path, data);
+        }
+        else {
+            await fs.write(path, data);
+        }
+    },
+    readdir: async (p, options) => {
+        const entries = await getFs().readDir(resolvePath(p));
+        return entries.map((e) => {
+            const json = e.toJSON();
+            if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
+                return {
+                    name: json.name,
+                    isFile: () => json.type === "file",
+                    isDirectory: () => json.type === "directory",
+                    isSymbolicLink: () => false,
+                };
+            }
+            return json.name;
+        });
+    },
+    mkdir: async (p, options) => {
+        const fs = getFs();
+        const path = resolvePath(p);
+        if (options === null || options === void 0 ? void 0 : options.recursive) {
+            await fs.createDirAll(path);
+        }
+        else {
+            await fs.createDir(path);
+        }
+    },
+    rm: async (p, options) => {
+        const fs = getFs();
+        const path = resolvePath(p);
+        const metadata = await fs.metadata(path);
+        const type = metadata.toJSON().type;
+        if (type === "file") {
+            await fs.removeFile(path);
+        }
+        else {
+            await fs.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+        }
+    },
+    rmdir: async (p, options) => getFs().removeDir(resolvePath(p), !!(options === null || options === void 0 ? void 0 : options.recursive)),
+    copyFile: async (src, dst) => getFs().copyFile(resolvePath(src), resolvePath(dst)),
+    stat: async (p) => {
+        const metadata = await getFs().metadata(resolvePath(p));
+        const json = metadata.toJSON();
+        return new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        });
+    },
+    lstat: async (p) => {
+        const metadata = await getFs().metadata(resolvePath(p));
+        const json = metadata.toJSON();
+        return new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        });
+    },
+    realpath: async (p) => p,
+    access: async (p, mode) => {
+        await getFs().metadata(resolvePath(p));
+    },
+};
+export const readFile = promises.readFile;
+export const writeFile = promises.writeFile;
+export const readdir = promises.readdir;
+export const mkdir = promises.mkdir;
+export const rm = promises.rm;
+export const rmdir = promises.rmdir;
+export const copyFile = promises.copyFile;
+export const stat = promises.stat;
+export const lstat = promises.lstat;
+export const realpath = promises.realpath;
+export const access = promises.access;
+export default promises;

package/esm/webpackLoaders/{worker/polyfills → polyfills}/nodePolyFills.d.ts

@@ -22,7 +22,6 @@ declare const _default: {
     readonly "node:domain": any;
     readonly events: any;
     readonly "node:events": any;
-    "fast-glob": any;
     readonly http: any;
     readonly "node:http": any;
     readonly http2: any;
@@ -61,7 +60,6 @@ declare const _default: {
     readonly "node:zlib": any;
     fs: typeof fs;
     "node:fs": typeof fs;
-    "graceful-fs": typeof fs;
     path: any;
     "node:path": any;
     process: any;

package/esm/webpackLoaders/{worker/polyfills → polyfills}/nodePolyFills.js

@@ -7,6 +7,10 @@ process.cwd = () => {
     // @ts-ignore
     return ((_a = self.workerData) === null || _a === void 0 ? void 0 : _a.cwd) || (originalCwd === null || originalCwd === void 0 ? void 0 : originalCwd()) || "/";
 };
+if (!process.versions)
+    process.versions = {};
+if (!process.versions.node)
+    process.versions.node = "24.0.0";
 self.process = process;
 self.global = self;
 const path = require("path");
@@ -17,7 +21,6 @@ path.resolve = (...args) => {
     const cwd = ((_a = self.workerData) === null || _a === void 0 ? void 0 : _a.cwd) || "/";
     return originalResolve(cwd, ...args);
 };
-import fastGlob from "./fastGlobPolyfill";
 import * as fs from "./fsPolyfill";
 import * as workerThreads from "./workerThreadsPolyfill";
 const workerThreadsWithLiveWorkerData = {
@@ -96,7 +99,6 @@ export default {
     get "node:events"() {
         return require("events");
     },
-    "fast-glob": fastGlob,
     get http() {
         return require("http");
     },
@@ -207,7 +209,6 @@ export default {
     },
     fs,
     "node:fs": fs,
-    "graceful-fs": fs,
     path,
     "node:path": path,
     process,

package/esm/webpackLoaders/{worker/type.d.ts → types.d.ts}

@@ -2,6 +2,7 @@ export interface LoaderRunnerMeta {
     workerData: {
         workerId: number;
         cwd: string;
+        projectRoot: string;
     };
     loaderAssets: {
         importMaps: Record<string, string>;

package/esm/webpackLoaders/{worker/index.js → worker.js}

@@ -1,5 +1,5 @@
-import { SabComClient } from "../../sabcom";
-import initWasm, { recvTaskMessageInWorker, sendTaskMessage, workerCreated, } from "../../utoo";
+import { SabComClient } from "../utils/sabcom";
+import initWasm, { Project, recvTaskMessageInWorker, sendTaskMessage, workerCreated, } from "../utoo";
 import { cjs } from "./cjs";
 const binding = {
     recvTaskMessageInWorker,
@@ -18,17 +18,22 @@ export function startLoaderWorker() {
                 self.postMessage("sab_request");
             })
             : undefined;
+        // Initialize the thread-local state (tokio runtime).
+        // We don't need to pass threadWorkerUrl here because it's already stored in a global static in Rust.
+        Project.init("");
+        Project.setCwd(meta.workerData.cwd);
         self.workerData = {
             workerId: meta.workerData.workerId,
             cwd: meta.workerData.cwd,
+            projectRoot: meta.workerData.projectRoot,
             binding,
             sabClient,
+            fs: Project,
         };
         self.process = {
             env: {},
             cwd: () => self.workerData.cwd,
         };
-        console.log("Worker CWD:", self.process.cwd());
         cjs(meta.loaderAssets.entrypoint, meta.loaderAssets.importMaps);
     };
 }

package/esm/worker.js

@@ -1,6 +1,6 @@
 import * as comlink from "comlink";
-import { internalEndpoint } from "./internalProject";
-import { HandShake } from "./message";
+import { internalEndpoint } from "./project/InternalProject";
+import { HandShake } from "./utils/message";
 const ConnectedPorts = new Set();
 self.addEventListener("message", (e) => {
     const port = e.ports[0];