@utoo/web 1.2.0-rc.5 → 1.2.0-rc.6

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

@@ -10,8 +10,9 @@ const searchPathsCache = {};
 const statSync = (p) => {
     if (p.includes("node_modules") &&
         Object.prototype.hasOwnProperty.call(statCache, p)) {
-        if (statCache[p] === false)
+        if (statCache[p] === false) {
             throw new Error("ENOENT");
+        }
         return statCache[p];
     }
     try {
@@ -31,7 +32,7 @@ const existsSync = (p) => {
         statSync(p);
         return true;
     }
-    catch (_a) {
+    catch (e) {
         return false;
     }
 };
@@ -89,7 +90,6 @@ const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     return finalExports;
 };
 const loadModule = (id, context, importMaps, entrypoint) => {
-    var _a, _b, _c;
     const cacheKey = `${context}:${id}`;
     if (resolutionCache[cacheKey]) {
         const cachedId = resolutionCache[cacheKey];
@@ -149,22 +149,29 @@ const loadModule = (id, context, importMaps, entrypoint) => {
                     break;
                 currentDir = parent;
             }
+            // Ensure cwd/node_modules is always included
+            const cwd = nodePolyFills.process.cwd();
+            const cwdNodeModules = path.join(cwd, "node_modules");
+            if (!searchPaths.includes(cwdNodeModules)) {
+                searchPaths.push(cwdNodeModules);
+            }
             searchPathsCache[context] = searchPaths;
         }
         for (const nodeModulesDir of searchPaths) {
             const nodeModulesPath = path.join(nodeModulesDir, id);
             // Check package.json first
             const pkgJsonPath = path.join(nodeModulesPath, "package.json");
-            if (existsSync(pkgJsonPath)) {
+            let pkg;
+            try {
+                const content = fs.readFileSync(pkgJsonPath, "utf8");
+                pkg = JSON.parse(content);
+                pkgJsonCache[pkgJsonPath] = pkg;
+            }
+            catch (e) {
+                // ignore
+            }
+            if (pkg) {
                 try {
-                    let pkg;
-                    if (pkgJsonCache[pkgJsonPath]) {
-                        pkg = pkgJsonCache[pkgJsonPath];
-                    }
-                    else {
-                        pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
-                        pkgJsonCache[pkgJsonPath] = pkg;
-                    }
                     const mainField = pkg.main;
                     if (mainField) {
                         const candidates = [
@@ -174,36 +181,36 @@ const loadModule = (id, context, importMaps, entrypoint) => {
                             path.resolve(nodeModulesPath, mainField, "index.js"),
                         ];
                         for (const candidate of candidates) {
-                            if (existsSync(candidate) && !statSync(candidate).isDirectory()) {
-                                try {
-                                    resolvedId = candidate;
-                                    moduleCode = fs.readFileSync(candidate, "utf8");
-                                    moduleId = candidate;
-                                    break;
-                                }
-                                catch (e) {
-                                    // ignore
-                                }
+                            try {
+                                // Try reading directly to bypass potential statSync issues
+                                moduleCode = fs.readFileSync(candidate, "utf8");
+                                resolvedId = candidate;
+                                moduleId = candidate;
+                                break;
+                            }
+                            catch (e) {
+                                // ignore
                             }
                         }
                     }
                 }
-                catch (_d) { }
+                catch (e) {
+                    // ignore
+                }
             }
             if (!moduleCode) {
                 const extensions = ["", ".js", ".json", "/index.js"];
                 for (const ext of extensions) {
                     const p = nodeModulesPath + ext;
-                    if (existsSync(p) && !statSync(p).isDirectory()) {
-                        try {
-                            resolvedId = p;
-                            moduleCode = fs.readFileSync(p, "utf8");
-                            moduleId = p;
-                            break;
-                        }
-                        catch (e) {
-                            // ignore
-                        }
+                    try {
+                        // Try reading directly
+                        moduleCode = fs.readFileSync(p, "utf8");
+                        resolvedId = p;
+                        moduleId = p;
+                        break;
+                    }
+                    catch (e) {
+                        // ignore
                     }
                 }
             }
@@ -211,29 +218,21 @@ const loadModule = (id, context, importMaps, entrypoint) => {
                 break;
         }
     }
-    // Fallback: Try resolving absolute path (handling CWD stripping)
+    // Fallback: Try resolving absolute path
     if (!moduleCode && id.startsWith("/")) {
-        // @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) || "/";
-        let relativeId = id;
-        if (id.startsWith(cwd)) {
-            relativeId = id.slice(cwd.length);
-            if (relativeId.startsWith("/"))
-                relativeId = relativeId.slice(1);
-        }
         const extensions = ["", ".js", ".json", "/index.js"];
         for (const ext of extensions) {
-            const p = relativeId + ext;
-            if (existsSync(p) && !statSync(p).isDirectory()) {
-                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
-                }
+            if (ext === "/index.js" && id.endsWith(".js"))
+                continue;
+            const p = id + ext;
+            try {
+                moduleCode = fs.readFileSync(p, "utf8");
+                resolvedId = p;
+                moduleId = id;
+                break;
+            }
+            catch (e) {
+                // ignore
             }
         }
     }
@@ -241,18 +240,17 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         // Try extensions
         const extensions = ["", ".js", ".json", "/index.js"];
         for (const ext of extensions) {
+            if (ext === "/index.js" && id.endsWith(".js"))
+                continue;
             const p = resolvedId + ext;
-            if (existsSync(p) && !statSync(p).isDirectory()) {
-                try {
-                    resolvedId = p;
-                    moduleCode = fs.readFileSync(p, "utf8");
-                    moduleId = p;
-                    break;
-                }
-                catch (e) {
-                    console.error(`[Debug] Failed to read file ${p}:`, e);
-                    // ignore
-                }
+            try {
+                moduleCode = fs.readFileSync(p, "utf8");
+                resolvedId = p;
+                moduleId = p;
+                break;
+            }
+            catch (e) {
+                // ignore
             }
         }
     }
@@ -265,6 +263,15 @@ const loadModule = (id, context, importMaps, entrypoint) => {
     return {};
 };
 export async function cjs(entrypoint, importMaps) {
+    // Clear caches to avoid stale data across runs
+    for (const key in statCache)
+        delete statCache[key];
+    for (const key in pkgJsonCache)
+        delete pkgJsonCache[key];
+    for (const key in resolutionCache)
+        delete resolutionCache[key];
+    for (const key in searchPathsCache)
+        delete searchPathsCache[key];
     await Promise.all(Object.entries(importMaps).map(async ([k, v]) => {
         if (v.startsWith("https://")) {
             try {

package/esm/webpackLoaders/loaderWorkerPool.d.ts

@@ -0,0 +1,2 @@
+import { Binding } from "../type";
+export declare const runLoaderWorkerPool: (binding: Binding, projectCwd: string, loaderWorkerUrl: string, loadersImportMap?: Record<string, string>) => Promise<void>;

package/esm/{loaderWorkerPool.js → webpackLoaders/loaderWorkerPool.js}

@@ -1,8 +1,8 @@
-import * as sabcom from "./sabcom";
-import initWasm, { registerWorkerScheduler, workerCreated, } from "./utoo";
+import * as sabcom from "../sabcom";
+import initWasm, { Project as ProjectInternal, registerWorkerScheduler, workerCreated, } from "../utoo";
 let nextWorkerId = 0;
 const loaderWorkers = {};
-export const runLoaderWorkerPool = async (binding, projectCwd, projectInternal, loaderWorkerUrl, loadersImportMap) => {
+export const runLoaderWorkerPool = async (binding, projectCwd, loaderWorkerUrl, loadersImportMap) => {
     registerWorkerScheduler(async (creation) => {
         const { options: { filename, cwd }, } = creation;
         nextWorkerId += 1;
@@ -13,15 +13,15 @@ export const runLoaderWorkerPool = async (binding, projectCwd, projectInternal,
         worker.onmessage = async (event) => {
             if (event.data === "sab_request") {
                 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),
+                    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),
                 });
             }
         };
@@ -29,15 +29,26 @@ export const runLoaderWorkerPool = async (binding, projectCwd, projectInternal,
         let finalFilename = filename;
         if (projectCwd) {
             const sep = "/";
-            const pCwd = projectCwd.endsWith(sep)
+            let pCwd = projectCwd.endsWith(sep)
                 ? projectCwd.slice(0, -1)
                 : projectCwd;
-            let cCwd = cwd.startsWith(sep) ? cwd.slice(1) : cwd;
-            if (cCwd === "." || cCwd === "./") {
-                cCwd = "";
+            if (!pCwd.startsWith(sep)) {
+                pCwd = sep + pCwd;
             }
-            finalCwd = cCwd ? `${pCwd}${sep}${cCwd}` : pCwd;
-            if (!filename.startsWith("/")) {
+            if (cwd.startsWith(sep)) {
+                finalCwd = cwd;
+            }
+            else {
+                let cCwd = cwd;
+                if (cCwd === "." || cCwd === "./") {
+                    cCwd = "";
+                }
+                finalCwd = cCwd ? `${pCwd}${sep}${cCwd}` : pCwd;
+            }
+            if (filename.startsWith(sep)) {
+                finalFilename = filename;
+            }
+            else {
                 let fName = filename;
                 if (fName.startsWith("./"))
                     fName = fName.slice(2);
@@ -51,6 +62,7 @@ export const runLoaderWorkerPool = async (binding, projectCwd, projectInternal,
             {
                 workerData: {
                     cwd: finalCwd,
+                    projectRoot: projectCwd,
                     workerId: workerId,
                 },
                 loaderAssets: {

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

@@ -0,0 +1,78 @@
+import { Buffer } from "buffer";
+import { Stats } from "../../type";
+import { promises } from "./fsPromisesPolyfill";
+export declare function readFileSync(path: string, options: any): string | Buffer<any>;
+export declare function readdirSync(path: string, options?: any): any;
+export declare function writeFileSync(path: string, data: string | Uint8Array, options?: any): void;
+export declare function mkdirSync(path: string, options?: any): void;
+export declare function rmSync(path: string, options?: any): void;
+export declare function rmdirSync(path: string, options?: any): void;
+export declare function copyFileSync(src: string, dst: string): void;
+export declare function statSync(p: string): Stats;
+export declare function lstatSync(p: string): Stats;
+export declare function realpathSync(p: string): string;
+export declare function accessSync(path: string, mode?: number): void;
+export declare function existsSync(path: string): boolean;
+export declare function readFile(path: string, options: any, cb: Function): void;
+export declare function readdir(path: string, options: any, cb: Function): void;
+export declare function writeFile(path: string, data: string | Uint8Array, options: any, cb: Function): void;
+export declare function mkdir(path: string, options: any, cb: Function): void;
+export declare function rm(path: string, options: any, cb: Function): void;
+export declare function rmdir(path: string, options: any, cb: Function): void;
+export declare function copyFile(src: string, dst: string, cb: Function): void;
+export declare function stat(p: string, cb: Function): void;
+export declare function lstat(p: string, cb: Function): void;
+export declare function realpath(p: string, cb: Function): void;
+export declare function access(p: string, mode: number | Function, cb?: Function): void;
+export declare const constants: {
+    F_OK: number;
+    R_OK: number;
+    W_OK: number;
+    X_OK: number;
+};
+declare const _default: {
+    readFile: typeof readFile;
+    readFileSync: typeof readFileSync;
+    readdir: typeof readdir;
+    readdirSync: typeof readdirSync;
+    writeFile: typeof writeFile;
+    writeFileSync: typeof writeFileSync;
+    mkdir: typeof mkdir;
+    mkdirSync: typeof mkdirSync;
+    rm: typeof rm;
+    rmSync: typeof rmSync;
+    rmdir: typeof rmdir;
+    rmdirSync: typeof rmdirSync;
+    copyFile: typeof copyFile;
+    copyFileSync: typeof copyFileSync;
+    stat: typeof stat;
+    statSync: typeof statSync;
+    lstat: typeof lstat;
+    lstatSync: typeof lstatSync;
+    realpath: typeof realpath;
+    realpathSync: typeof realpathSync;
+    access: typeof access;
+    accessSync: typeof accessSync;
+    existsSync: typeof existsSync;
+    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>;
+    };
+    constants: {
+        F_OK: number;
+        R_OK: number;
+        W_OK: number;
+        X_OK: number;
+    };
+};
+export default _default;
+export { promises };

package/esm/webpackLoaders/polyfills/fsPolyfill.js

@@ -0,0 +1,279 @@
+import { Buffer } from "buffer";
+import path from "path";
+import * as sabcom from "../../sabcom";
+import { Stats } from "../../type";
+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) || "/";
+    return path.resolve(cwd, p);
+}
+function getSabClient() {
+    // @ts-ignore
+    const client = self.workerData.sabClient;
+    if (!client) {
+        throw new Error("Sync fs not supported (no sabClient)");
+    }
+    return client;
+}
+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(sabcom.SAB_OP_READ_FILE, resolvePath(path));
+    if (options === "utf8" ||
+        options === "utf-8" ||
+        (options && (options.encoding === "utf8" || options.encoding === "utf-8"))) {
+        return new TextDecoder().decode(result);
+    }
+    return Buffer.from(result);
+}
+export function readdirSync(path, options) {
+    const client = getSabClient();
+    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) {
+        return entries.map((e) => ({
+            name: e.name,
+            isFile: () => e.type === "file",
+            isDirectory: () => e.type === "directory",
+            isSymbolicLink: () => false,
+        }));
+    }
+    return entries.map((e) => e.name);
+}
+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(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(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(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(sabcom.SAB_OP_RMDIR, payload);
+}
+export function copyFileSync(src, dst) {
+    const client = getSabClient();
+    const payload = JSON.stringify({
+        src: resolvePath(src),
+        dst: resolvePath(dst),
+    });
+    client.call(sabcom.SAB_OP_COPY_FILE, payload);
+}
+export function statSync(p) {
+    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 realpathSync(p) {
+    return p;
+}
+export function accessSync(path, mode) {
+    statSync(path);
+}
+export function existsSync(path) {
+    try {
+        statSync(path);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+// --- Asynchronous API (via WASM Project) ---
+export function readFile(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        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 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 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 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 rm(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    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 realpath(p, cb) {
+    cb(null, p);
+}
+export function access(p, mode, cb) {
+    if (typeof mode === "function") {
+        cb = mode;
+        mode = 0;
+    }
+    stat(p, (err) => {
+        if (cb)
+            cb(err);
+    });
+}
+export const constants = {
+    F_OK: 0,
+    R_OK: 4,
+    W_OK: 2,
+    X_OK: 1,
+};
+export default {
+    readFile,
+    readFileSync,
+    readdir,
+    readdirSync,
+    writeFile,
+    writeFileSync,
+    mkdir,
+    mkdirSync,
+    rm,
+    rmSync,
+    rmdir,
+    rmdirSync,
+    copyFile,
+    copyFileSync,
+    stat,
+    statSync,
+    lstat,
+    lstatSync,
+    realpath,
+    realpathSync,
+    access,
+    accessSync,
+    existsSync,
+    promises,
+    constants,
+};
+export { promises };

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

@@ -0,0 +1,26 @@
+import { Stats } from "../../type";
+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;