@utoo/web 1.2.0-rc.8 → 1.2.0

package/esm/webpackLoaders/cjs.js

@@ -7,35 +7,6 @@ const statCache = {};
 const pkgJsonCache = {};
 const resolutionCache = {};
 const searchPathsCache = {};
-const statSync = (p) => {
-    if (p.includes("node_modules") &&
-        Object.prototype.hasOwnProperty.call(statCache, p)) {
-        if (statCache[p] === false) {
-            throw new Error("ENOENT");
-        }
-        return statCache[p];
-    }
-    try {
-        const res = fs.statSync(p);
-        if (p.includes("node_modules"))
-            statCache[p] = res;
-        return res;
-    }
-    catch (e) {
-        if (p.includes("node_modules"))
-            statCache[p] = false;
-        throw e;
-    }
-};
-const existsSync = (p) => {
-    try {
-        statSync(p);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
 const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     if (installedModules[moduleId]) {
         return installedModules[moduleId].exports;
@@ -108,7 +79,7 @@ const loadModule = (id, context, importMaps, entrypoint) => {
     // 1. Resolve
     let resolvedId = id;
     if (id.startsWith(".")) {
-        resolvedId = path.resolve(context, id);
+        resolvedId = path.join(context, id);
     }
     // 2. Check Cache (SystemJS)
     let dependency = System.get(resolvedId);
@@ -259,8 +230,9 @@ 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. Context: ${context}`);
-    return {};
+    const error = new Error(`Worker: Dependency ${id} (resolved: ${resolvedId}) not found. Context: ${context}`);
+    console.error(error);
+    throw error;
 };
 export async function cjs(entrypoint, importMaps) {
     // Clear caches to avoid stale data across runs

package/esm/webpackLoaders/loaderWorkerPool.d.ts

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

package/esm/webpackLoaders/loaderWorkerPool.js

@@ -1,5 +1,4 @@
-import * as sabcom from "../sabcom";
-import initWasm, { Project as ProjectInternal, registerWorkerScheduler, workerCreated, } from "../utoo";
+import initWasm, { registerWorkerScheduler, workerCreated, } from "../utoo";
 let nextWorkerId = 0;
 const loaderWorkers = {};
 export const runLoaderWorkerPool = async (binding, projectCwd, loaderWorkerUrl, loadersImportMap) => {
@@ -7,24 +6,7 @@ export const runLoaderWorkerPool = async (binding, projectCwd, loaderWorkerUrl,
         const { options: { filename, cwd }, } = creation;
         nextWorkerId += 1;
         const workerId = nextWorkerId;
-        const sab = new SharedArrayBuffer(1024 * 1024 * 10); // 10MB
-        const sabHost = new sabcom.SabComHost(sab);
         const worker = new Worker(loaderWorkerUrl, { name: filename });
-        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),
-                });
-            }
-        };
         let finalCwd = cwd;
         let finalFilename = filename;
         if (projectCwd) {
@@ -69,7 +51,6 @@ export const runLoaderWorkerPool = async (binding, projectCwd, loaderWorkerUrl,
                     importMaps: { ...loadersImportMap },
                     entrypoint: finalFilename,
                 },
-                sab,
             },
         ]);
         const workers = loaderWorkers[filename] || (loaderWorkers[filename] = new Map());

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

@@ -1,5 +1,5 @@
 import { Buffer } from "buffer";
-import { Stats } from "../../type";
+import { Stats } from "../../types";
 import { promises } from "./fsPromisesPolyfill";
 export declare function readFileSync(path: string, options: any): string | Buffer<any>;
 export declare function readdirSync(path: string, options?: any): any;

package/esm/webpackLoaders/polyfills/fsPolyfill.js

@@ -1,7 +1,6 @@
 import { Buffer } from "buffer";
 import path from "path";
-import * as sabcom from "../../sabcom";
-import { Stats } from "../../type";
+import { Stats } from "../../types";
 import { promises } from "./fsPromisesPolyfill";
 function resolvePath(p) {
     var _a, _b, _c;
@@ -9,14 +8,6 @@ function resolvePath(p) {
     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;
@@ -25,22 +16,21 @@ function getFs() {
     }
     return fs;
 }
-// --- Synchronous API (via sabcom) ---
+// --- Synchronous API (via WASM Project Sync APIs) ---
+const textDecoder = new TextDecoder();
 export function readFileSync(path, options) {
-    const client = getSabClient();
-    const result = client.call(sabcom.SAB_OP_READ_FILE, resolvePath(path));
+    const fs = getFs();
+    const result = fs.readSync(resolvePath(path));
     if (options === "utf8" ||
         options === "utf-8" ||
         (options && (options.encoding === "utf8" || options.encoding === "utf-8"))) {
-        return new TextDecoder().decode(result);
+        return 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);
+    const fs = getFs();
+    const entries = fs.readDirSync(resolvePath(path));
     if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
         return entries.map((e) => ({
             name: e.name,
@@ -52,48 +42,69 @@ export function readdirSync(path, options) {
     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);
+    const fs = getFs();
+    let content;
+    if (typeof data === "string") {
+        content = new TextEncoder().encode(data);
+    }
+    else {
+        content = data;
+    }
+    fs.writeSync(resolvePath(path), content);
 }
 export function mkdirSync(path, options) {
-    const client = getSabClient();
+    const fs = getFs();
     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);
+    if (recursive) {
+        fs.createDirAllSync(resolvePath(path));
+    }
+    else {
+        fs.createDirSync(resolvePath(path));
+    }
 }
 export function rmSync(path, options) {
-    const client = getSabClient();
+    const fs = getFs();
     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);
+    if (recursive) {
+        fs.removeDirSync(resolvePath(path), true);
+    }
+    else {
+        fs.removeFileSync(resolvePath(path));
+    }
 }
 export function rmdirSync(path, options) {
-    const client = getSabClient();
+    const fs = getFs();
     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);
+    fs.removeDirSync(resolvePath(path), recursive);
 }
 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);
+    const fs = getFs();
+    fs.copyFileSync(resolvePath(src), resolvePath(dst));
 }
 export function statSync(p) {
-    const client = getSabClient();
-    const struct = client.callStat(resolvePath(p));
+    const fs = getFs();
+    const metadata = fs.metadataSync(resolvePath(p));
+    let type, size;
+    // @ts-ignore
+    if (typeof metadata.toJSON === "function") {
+        // @ts-ignore
+        const json = metadata.toJSON();
+        type = json.type;
+        size = json.file_size;
+    }
+    else {
+        // @ts-ignore
+        type = metadata.type;
+        // @ts-ignore
+        size = metadata.file_size;
+    }
     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,
+        type: type === "directory" ? "directory" : "file",
+        size: Number(size || 0),
+        atimeMs: Date.now(),
+        mtimeMs: Date.now(),
+        ctimeMs: Date.now(),
+        birthtimeMs: Date.now(),
     });
 }
 export function lstatSync(p) {

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

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

package/esm/webpackLoaders/polyfills/fsPromisesPolyfill.js

@@ -1,6 +1,6 @@
 import { Buffer } from "buffer";
 import path from "path";
-import { Stats } from "../../type";
+import { Stats } from "../../types";
 function resolvePath(p) {
     var _a, _b, _c;
     // @ts-ignore

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

@@ -8,5 +8,4 @@ export interface LoaderRunnerMeta {
         importMaps: Record<string, string>;
         entrypoint: string;
     };
-    sab?: SharedArrayBuffer;
 }

package/esm/webpackLoaders/worker.js

@@ -1,4 +1,3 @@
-import { SabComClient } from "../sabcom";
 import initWasm, { Project, recvTaskMessageInWorker, sendTaskMessage, workerCreated, } from "../utoo";
 import { cjs } from "./cjs";
 const binding = {
@@ -13,11 +12,6 @@ export function startLoaderWorker() {
             console.log(err);
             throw err;
         });
-        const sabClient = meta.sab
-            ? new SabComClient(meta.sab, () => {
-                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("");
@@ -27,7 +21,6 @@ export function startLoaderWorker() {
             cwd: meta.workerData.cwd,
             projectRoot: meta.workerData.projectRoot,
             binding,
-            sabClient,
             fs: Project,
         };
         self.process = {

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];

package/package.json

@@ -1,35 +1,36 @@
 {
   "name": "@utoo/web",
-  "version": "1.2.0-rc.8",
+  "version": "1.2.0",
   "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "files": [
-    "esm/*"
+    "esm"
   ],
   "scripts": {
-    "install-toolchain": "cargo install wasm-bindgen-cli@0.2.104 && brew install binaryen",
+    "install-toolchain": "cargo install wasm-bindgen-cli@0.2.104 && brew install binaryen llvm",
     "build-wasm": "cargo build -p utoo-wasm --target wasm32-unknown-unknown -Z build-std=panic_abort,std",
     "build-wasm:pm": "cargo build -p utoo-wasm --target wasm32-unknown-unknown --no-default-features -Z build-std=panic_abort,std",
     "bindgen-dev": "wasm-bindgen ../../target/wasm32-unknown-unknown/wasm-dev/utoo_wasm.wasm --out-dir src/utoo --out-name index --target web --debug --keep-debug --no-demangle",
     "bindgen-build": "wasm-bindgen ../../target/wasm32-unknown-unknown/release/utoo_wasm.wasm --out-dir src/utoo --out-name index --target web",
     "bindgen-build:local": "wasm-bindgen ../../target/wasm32-unknown-unknown/release-local/utoo_wasm.wasm --out-dir src/utoo --out-name index --target web",
     "tsc": "rm -rf esm && tsc -p ./tsconfig.build.json",
-    "dev": "npm run build-wasm -- --profile wasm-dev && npm run bindgen-dev && npx turbo run tsc --filter=@utoo/web  && npm run build-loaderWorker && cp src/utoo/index_bg.wasm esm/utoo",
-    "dev:pm": "npm run build-wasm:pm -- --profile wasm-dev && npm run bindgen-dev && npm run tsc && cp src/utoo/index_bg.wasm esm/utoo",
+    "copy-wasm": "cp src/utoo/index_bg.wasm esm/utoo",
+    "build:shared": "npx turbo run build --filter=@utoo/pack-shared",
+    "dev": "npm run build-wasm -- --profile wasm-dev && npm run bindgen-dev && npx turbo run tsc --filter=@utoo/web  && npm run build-loaderWorker && npm run copy-wasm",
+    "dev:pm": "npm run build-wasm:pm -- --profile wasm-dev && npm run bindgen-dev && npm run tsc && npm run copy-wasm",
     "wasm-opt": "wasm-opt src/utoo/index_bg.wasm -o esm/utoo/index_bg.wasm --enable-threads --enable-bulk-memory --enable-nontrapping-float-to-int -Oz",
     "build": "npm run build-wasm -- --release && npm run bindgen-build && npm run tsc && npm run build-loaderWorker && npm run wasm-opt",
-    "build:local": "npm run build-wasm -- --profile release-local && npm run bindgen-build:local && npm run tsc && npm run build-loaderWorker && cp src/utoo/index_bg.wasm esm/utoo",
+    "build:local": "CC=$(brew --prefix llvm)/bin/clang CXX=$(brew --prefix llvm)/bin/clang++ npm run build-wasm -- --profile release-local && npm run bindgen-build:local && npm run build:shared && npm run tsc && npm run build-loaderWorker && npm run copy-wasm",
     "build-loaderWorker": "node cli/umd.js -e ./src/webpackLoaders/worker.ts -o ./esm/loaderWorker.js -t webworker",
+    "clean": "rm -rf esm src/utoo",
     "prepublishOnly": "turbo run build --filter=@utoo/web"
   },
   "dependencies": {
-    "@utoo/pack-shared": "^0.0.7",
+    "@utoo/pack-shared": "^0.0.8",
     "comlink": "^4.4.2",
-    "micromatch": "^4.0.8",
     "systemjs": "^6.15.1"
   },
   "devDependencies": {
-    "@types/micromatch": "^4.0.8",
     "@types/systemjs": "^6.15.1",
     "binaryen": "^125.0.0",
     "node-stdlib-browser": "^1.3.1",

package/esm/sabcom.d.ts

@@ -1,61 +0,0 @@
-export declare const SAB_STATE_IDLE = 0;
-export declare const SAB_STATE_REQUEST = 1;
-export declare const SAB_STATE_RESPONSE = 2;
-export declare const SAB_STATE_ERROR = 3;
-export declare const SAB_OP_READ_FILE = 1;
-export declare const SAB_OP_READ_DIR = 2;
-export declare const SAB_OP_WRITE_FILE = 3;
-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 const STAT_TYPE_FILE = 0;
-export declare const STAT_TYPE_DIR = 1;
-export declare const SAB_INDEX_STATE = 0;
-export declare const SAB_INDEX_OP = 1;
-export declare const SAB_INDEX_DATA_LEN = 2;
-export declare const SAB_DATA_OFFSET = 12;
-export declare class SabComHost {
-    private sab;
-    private int32;
-    private uint8;
-    private dataView;
-    constructor(sab: SharedArrayBuffer);
-    readRequest(): {
-        op: number;
-        data: string;
-    };
-    writeResponse(data: Uint8Array | string): void;
-    writeError(message: string): void;
-    writeStat(type: number, size: bigint, atimeMs: number, mtimeMs: number, ctimeMs: number, birthtimeMs: number): void;
-}
-export declare class SabComClient {
-    private sab;
-    private notifyHost;
-    private int32;
-    private uint8;
-    private dataView;
-    constructor(sab: SharedArrayBuffer, notifyHost: () => void);
-    call(op: number, data: string): Uint8Array<ArrayBuffer>;
-    callStat(path: string): {
-        type: number;
-        size: bigint;
-        atimeMs: number;
-        mtimeMs: number;
-        ctimeMs: number;
-        birthtimeMs: number;
-    };
-}
-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

@@ -1,203 +0,0 @@
-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);
-    }
-};