@utoo/web 1.1.0 → 1.2.0-rc.10

package/esm/utils/sabcom.js

@@ -0,0 +1,203 @@
+export const SAB_STATE_IDLE = 0;
+export const SAB_STATE_REQUEST = 1;
+export const SAB_STATE_RESPONSE = 2;
+export const SAB_STATE_ERROR = 3;
+export const SAB_OP_READ_FILE = 1;
+export const SAB_OP_READ_DIR = 2;
+export const SAB_OP_WRITE_FILE = 3;
+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;
+export const STAT_TYPE_FILE = 0;
+export const STAT_TYPE_DIR = 1;
+export const SAB_INDEX_STATE = 0;
+export const SAB_INDEX_OP = 1;
+export const SAB_INDEX_DATA_LEN = 2;
+export const SAB_DATA_OFFSET = 12;
+// Stat struct layout (starts at byte 12)
+// type: Uint8 (1 byte) -> offset 0
+// padding: 7 bytes
+// size: BigUint64 (8 bytes) -> offset 8
+// atimeMs: Float64 (8 bytes) -> offset 16
+// mtimeMs: Float64 (8 bytes) -> offset 24
+// ctimeMs: Float64 (8 bytes) -> offset 32
+// birthtimeMs: Float64 (8 bytes) -> offset 40
+const STAT_OFFSET_TYPE = 0;
+const STAT_OFFSET_SIZE = 8;
+const STAT_OFFSET_ATIME = 16;
+const STAT_OFFSET_MTIME = 24;
+const STAT_OFFSET_CTIME = 32;
+const STAT_OFFSET_BIRTHTIME = 40;
+// Layout:
+// 0: State (Int32)
+// 1: Op (Int32)
+// 2: Data Length (Int32)
+// 12...: Data (Uint8) - Start at byte 12 (3 * 4 bytes)
+export class SabComHost {
+    constructor(sab) {
+        this.sab = sab;
+        this.int32 = new Int32Array(sab);
+        this.uint8 = new Uint8Array(sab);
+        this.dataView = new DataView(sab);
+    }
+    readRequest() {
+        const op = this.int32[SAB_INDEX_OP];
+        const len = this.int32[SAB_INDEX_DATA_LEN];
+        const data = new TextDecoder().decode(this.uint8.slice(SAB_DATA_OFFSET, SAB_DATA_OFFSET + len));
+        return { op, data };
+    }
+    writeResponse(data) {
+        if (typeof data === "string") {
+            data = new TextEncoder().encode(data);
+        }
+        // TODO: Check size overflow
+        this.int32[SAB_INDEX_DATA_LEN] = data.length;
+        this.uint8.set(data, SAB_DATA_OFFSET);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_RESPONSE);
+        Atomics.notify(this.int32, SAB_INDEX_STATE);
+    }
+    writeError(message) {
+        const data = new TextEncoder().encode(message);
+        this.int32[SAB_INDEX_DATA_LEN] = data.length;
+        this.uint8.set(data, SAB_DATA_OFFSET);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_ERROR);
+        Atomics.notify(this.int32, SAB_INDEX_STATE);
+    }
+    writeStat(type, size, atimeMs, mtimeMs, ctimeMs, birthtimeMs) {
+        const base = SAB_DATA_OFFSET;
+        this.dataView.setUint8(base + STAT_OFFSET_TYPE, type);
+        this.dataView.setBigUint64(base + STAT_OFFSET_SIZE, size, true);
+        this.dataView.setFloat64(base + STAT_OFFSET_ATIME, atimeMs, true);
+        this.dataView.setFloat64(base + STAT_OFFSET_MTIME, mtimeMs, true);
+        this.dataView.setFloat64(base + STAT_OFFSET_CTIME, ctimeMs, true);
+        this.dataView.setFloat64(base + STAT_OFFSET_BIRTHTIME, birthtimeMs, true);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_RESPONSE);
+        Atomics.notify(this.int32, SAB_INDEX_STATE);
+    }
+}
+export class SabComClient {
+    constructor(sab, notifyHost) {
+        this.sab = sab;
+        this.notifyHost = notifyHost;
+        this.int32 = new Int32Array(sab);
+        this.uint8 = new Uint8Array(sab);
+        this.dataView = new DataView(sab);
+    }
+    call(op, data) {
+        const encoded = new TextEncoder().encode(data);
+        this.int32[SAB_INDEX_OP] = op;
+        this.int32[SAB_INDEX_DATA_LEN] = encoded.length;
+        this.uint8.set(encoded, SAB_DATA_OFFSET);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_REQUEST);
+        this.notifyHost();
+        Atomics.wait(this.int32, SAB_INDEX_STATE, SAB_STATE_REQUEST);
+        const state = Atomics.load(this.int32, SAB_INDEX_STATE);
+        if (state === SAB_STATE_ERROR) {
+            const len = this.int32[SAB_INDEX_DATA_LEN];
+            const msg = new TextDecoder().decode(this.uint8.slice(SAB_DATA_OFFSET, SAB_DATA_OFFSET + len));
+            throw new Error(msg);
+        }
+        const len = this.int32[SAB_INDEX_DATA_LEN];
+        return this.uint8.slice(SAB_DATA_OFFSET, SAB_DATA_OFFSET + len);
+    }
+    callStat(path) {
+        const encoded = new TextEncoder().encode(path);
+        this.int32[SAB_INDEX_OP] = SAB_OP_STAT;
+        this.int32[SAB_INDEX_DATA_LEN] = encoded.length;
+        this.uint8.set(encoded, SAB_DATA_OFFSET);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_REQUEST);
+        this.notifyHost();
+        Atomics.wait(this.int32, SAB_INDEX_STATE, SAB_STATE_REQUEST);
+        const state = Atomics.load(this.int32, SAB_INDEX_STATE);
+        if (state === SAB_STATE_ERROR) {
+            const len = this.int32[SAB_INDEX_DATA_LEN];
+            const msg = new TextDecoder().decode(this.uint8.slice(SAB_DATA_OFFSET, SAB_DATA_OFFSET + len));
+            throw new Error(msg);
+        }
+        const base = SAB_DATA_OFFSET;
+        return {
+            type: this.dataView.getUint8(base + STAT_OFFSET_TYPE),
+            size: this.dataView.getBigUint64(base + STAT_OFFSET_SIZE, true),
+            atimeMs: this.dataView.getFloat64(base + STAT_OFFSET_ATIME, true),
+            mtimeMs: this.dataView.getFloat64(base + STAT_OFFSET_MTIME, true),
+            ctimeMs: this.dataView.getFloat64(base + STAT_OFFSET_CTIME, true),
+            birthtimeMs: this.dataView.getFloat64(base + STAT_OFFSET_BIRTHTIME, true),
+        };
+    }
+}
+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 { path: filePath, data: fileContent } = JSON.parse(path);
+            // 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 json = metadata.toJSON
+                ? metadata.toJSON()
+                : metadata;
+            const type = json.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);
+            const json = metadata.toJSON
+                ? metadata.toJSON()
+                : metadata;
+            const type = json.type === "directory" ? STAT_TYPE_DIR : STAT_TYPE_FILE;
+            const size = BigInt(json.file_size || 0);
+            const atimeMs = Number(json.atimeMs || 0);
+            const mtimeMs = Number(json.mtimeMs || 0);
+            const ctimeMs = Number(json.ctimeMs || 0);
+            const birthtimeMs = Number(json.birthtimeMs || 0);
+            sabHost.writeStat(type, size, atimeMs, mtimeMs, ctimeMs, birthtimeMs);
+        }
+        else {
+            sabHost.writeError("Unknown op");
+        }
+    }
+    catch (e) {
+        sabHost.writeError(e.message);
+    }
+};

package/esm/utoo/index.d.ts

@@ -1,38 +1,27 @@
 /**
  * @param {number} worker_id
- * @returns {Promise<string>}
+ * @returns {Promise<WasmTaskMessage>}
  */
-export function recvMessageInWorker(worker_id: number): Promise<string>;
+export function recvTaskMessageInWorker(worker_id: number): Promise<WasmTaskMessage>;
 /**
- * @returns {Promise<WorkerTermination>}
- */
-export function recvWorkerTermination(): Promise<WorkerTermination>;
-/**
- * @param {number} task_id
- * @param {number} worker_id
- * @returns {Promise<void>}
- */
-export function notifyWorkerAck(task_id: number, worker_id: number): Promise<void>;
-/**
- * @param {number} task_id
- * @param {string} message
+ * @param {any} message
  * @returns {Promise<void>}
  */
-export function sendTaskMessage(task_id: number, message: string): Promise<void>;
+export function sendTaskMessage(message: any): Promise<void>;
+export function init_pack(): void;
 /**
- * @param {string} pool_id
- * @returns {Promise<number>}
+ * @param {string} filter
  */
-export function recvWorkerRequest(pool_id: string): Promise<number>;
+export function initLogFilter(filter: string): void;
 /**
- * @returns {Promise<PoolOptions>}
+ * @param {Function} creator
+ * @param {Function} terminator
  */
-export function recvPoolRequest(): Promise<PoolOptions>;
-export function init_pack(): void;
+export function registerWorkerScheduler(creator: Function, terminator: Function): void;
 /**
- * @param {string} filter
+ * @param {number} worker_id
  */
-export function init_log_filter(filter: string): void;
+export function workerCreated(worker_id: number): void;
 /**
  * Entry point for web workers
  * @param {number} ptr
@@ -73,131 +62,180 @@ 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;
-}
-export class PoolOptions {
-    static __wrap(ptr: any): any;
-    __destroy_into_raw(): number | undefined;
-    __wbg_ptr: number | undefined;
-    free(): void;
     /**
-     * @param {string} arg0
+     * @param {DirEntryType} arg0
      */
-    set filename(arg0: string);
+    set type(arg0: DirEntryType);
     /**
-     * @returns {string}
+     * @returns {DirEntryType}
      */
-    get filename(): string;
+    get type(): DirEntryType;
     /**
-     * @param {number} arg0
+     * @param {bigint} arg0
      */
-    set maxConcurrency(arg0: number);
+    set file_size(arg0: bigint);
     /**
-     * @returns {number}
+     * @returns {bigint}
      */
-    get maxConcurrency(): number;
+    get file_size(): bigint;
 }
 export class Project {
-    /**
-     * @param {string} cwd
-     * @param {string} thread_url
-     */
-    constructor(cwd: string, thread_url: string);
-    __destroy_into_raw(): number;
-    __wbg_ptr: number;
-    free(): void;
     /**
      * @param {string} path
      * @returns {Promise<void>}
      */
-    createDir(path: string): Promise<void>;
+    static createDir(path: string): Promise<void>;
     /**
      * @param {string} path
      * @param {boolean} recursive
      * @returns {Promise<void>}
      */
-    removeDir(path: string, recursive: boolean): Promise<void>;
+    static removeDir(path: string, recursive: boolean): Promise<void>;
     /**
      * @param {string} path
      * @returns {Promise<void>}
      */
-    removeFile(path: string): Promise<void>;
+    static removeFile(path: string): Promise<void>;
     /**
      * @param {string} path
      * @param {string} content
      * @returns {Promise<void>}
      */
-    writeString(path: string, content: string): Promise<void>;
+    static writeString(path: string, content: string): Promise<void>;
     /**
      * @param {string} path
      * @returns {Promise<void>}
      */
-    createDirAll(path: string): Promise<void>;
+    static createDirAll(path: string): Promise<void>;
     /**
      * @param {string} path
      * @returns {Promise<string>}
      */
-    readToString(path: string): Promise<string>;
+    static readToString(path: string): Promise<string>;
     /**
      * @returns {string}
      */
-    get cwd(): string;
+    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>;
     /**
      * 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 {Uint8Array}
+     * @returns {Promise<Uint8Array>}
+     */
+    static gzip(files: any): Promise<Uint8Array>;
+    /**
+     * @param {string} thread_url
      */
-    gzip(files: any): Uint8Array;
+    static init(thread_url: string): void;
     /**
      * @param {string} path
      * @returns {Promise<Uint8Array>}
      */
-    read(path: string): Promise<Uint8Array>;
+    static read(path: string): Promise<Uint8Array>;
     /**
      * @returns {Promise<any>}
      */
-    build(): Promise<any>;
+    static build(): Promise<any>;
     /**
      * @param {string} path
      * @param {Uint8Array} content
      * @returns {Promise<void>}
      */
-    write(path: string, content: Uint8Array): Promise<void>;
+    static write(path: string, content: Uint8Array): Promise<void>;
     /**
      * @param {string} package_lock
      * @param {number | null} [max_concurrent_downloads]
      * @returns {Promise<void>}
      */
-    install(package_lock: string, max_concurrent_downloads?: number | null): Promise<void>;
+    static install(package_lock: string, max_concurrent_downloads?: number | null): Promise<void>;
     /**
-     * Calculate MD5 hash of byte content
+     * @param {string} path
+     */
+    static setCwd(path: string): void;
+    /**
+     * Calculate MD5 hash of byte content (async for better thread scheduling)
      * @param {Uint8Array} content
-     * @returns {string}
+     * @returns {Promise<string>}
      */
-    sigMd5(content: Uint8Array): string;
+    static sigMd5(content: Uint8Array): Promise<string>;
     /**
      * @param {string} path
      * @returns {Promise<Metadata>}
      */
-    metadata(path: string): Promise<Metadata>;
+    static metadata(path: string): Promise<Metadata>;
     /**
      * @param {string} path
      * @returns {Promise<DirEntry[]>}
      */
-    readDir(path: string): Promise<DirEntry[]>;
+    static readDir(path: string): Promise<DirEntry[]>;
     /**
      * @param {string} src
      * @param {string} dst
      * @returns {Promise<void>}
      */
-    copyFile(src: string, dst: string): Promise<void>;
+    static copyFile(src: string, dst: string): Promise<void>;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
 }
-export class WorkerTermination {
+export class WasmTaskMessage {
+    static __wrap(ptr: any): any;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+    /**
+     * @param {number} arg0
+     */
+    set taskId(arg0: number);
+    /**
+     * @returns {number}
+     */
+    get taskId(): number;
+    /**
+     * @param {string} arg0
+     */
+    set data(arg0: string);
+    /**
+     * @returns {string}
+     */
+    get data(): string;
+}
+export class WebWorkerCreation {
+    static __wrap(ptr: any): any;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+    /**
+     * @param {WebWorkerOptions} arg0
+     */
+    set options(arg0: WebWorkerOptions);
+    /**
+     * @returns {WebWorkerOptions}
+     */
+    get options(): WebWorkerOptions;
+}
+export class WebWorkerOptions {
     static __wrap(ptr: any): any;
     __destroy_into_raw(): number | undefined;
     __wbg_ptr: number | undefined;
@@ -210,6 +248,28 @@ export class WorkerTermination {
      * @returns {string}
      */
     get filename(): string;
+    /**
+     * @param {string} arg0
+     */
+    set cwd(arg0: string);
+    /**
+     * @returns {string}
+     */
+    get cwd(): string;
+}
+export class WebWorkerTermination {
+    static __wrap(ptr: any): any;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+    /**
+     * @param {WebWorkerOptions} arg0
+     */
+    set options(arg0: WebWorkerOptions);
+    /**
+     * @returns {WebWorkerOptions}
+     */
+    get options(): WebWorkerOptions;
     /**
      * @param {number} arg0
      */