@ai-ecoverse/slicc-kernel 1.23.0 → 1.25.0

package/dist/node.js

@@ -1499,6 +1499,56 @@ function prefixes(path) {
 function within(path, root) {
   return path === root || path.startsWith(`${root}/`);
 }
+var LOCKED = /* @__PURE__ */ new Set(["NotReadableError", "NoModificationAllowedError", "InvalidStateError"]);
+var SYNC_BACKOFF_MS = [5, 10, 20, 40, 80];
+async function openSync(handle) {
+  const sync = handle.createSyncAccessHandle;
+  if (!sync) return void 0;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await sync.call(handle, { mode: "readwrite-unsafe" });
+    } catch (err) {
+      const delay = SYNC_BACKOFF_MS[attempt];
+      if (!LOCKED.has(err?.name)) throw err;
+      if (delay === void 0) return void 0;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+}
+function writeAll(access, at, bytes) {
+  for (let done4 = 0; done4 < bytes.length; ) {
+    const n = access.write(bytes.subarray(done4), { at: at + done4 });
+    if (!(n > 0))
+      throw Object.assign(new Error("the file system took no more bytes"), { code: "ENOSPC" });
+    done4 += n;
+  }
+}
+async function positioned(handle, op) {
+  const access = await openSync(handle);
+  if (access) {
+    try {
+      op({
+        write: (at, bytes) => writeAll(access, at, bytes),
+        truncate: (n) => access.truncate(n)
+      });
+      access.flush();
+    } finally {
+      access.close();
+    }
+    return;
+  }
+  const writable = await handle.createWritable({ keepExistingData: true });
+  try {
+    await op({
+      write: (at, bytes) => writable.write({ type: "write", position: at, data: bytes }),
+      truncate: (n) => writable.truncate(n)
+    });
+  } catch (err) {
+    await writable.abort();
+    throw err;
+  }
+  await writable.close();
+}
 function isHandle(child) {
   return "kind" in child;
 }
@@ -1508,9 +1558,11 @@ var OpfsFs = class {
   dirs = /* @__PURE__ */ new Map();
   checked = /* @__PURE__ */ new WeakMap();
   channel;
-  constructor(root, meta = new MemoryMeta(), channel) {
+  ranged;
+  constructor(root, meta = new MemoryMeta(), channel, options = {}) {
     this.root = root;
     this.meta = meta;
+    this.ranged = options.ranged === true;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
     if (this.channel) {
       this.channel.onmessage = ({ data }) => {
@@ -1647,7 +1699,8 @@ var OpfsFs = class {
       mtime: new Date(mtime),
       atime: new Date(meta?.atimeMs ?? mtime),
       ctime: new Date(Math.max(meta?.ctimeMs ?? mtime, modified)),
-      ino: meta?.ino ?? inodeOf(path)
+      ino: meta?.ino ?? inodeOf(path),
+      ...this.ranged && !directory ? { ranged: true } : {}
     };
   }
   linkStat(entry) {
@@ -1681,20 +1734,47 @@ var OpfsFs = class {
       () => false
     );
   }
-  async readFileBuffer(path) {
-    const handle = (await this.locate(path, true)).handle;
-    if (handle.kind === "directory") throw fsError("EISDIR", path);
+  async retrying(path, op, locks) {
     for (let attempt = 1; ; attempt++) {
       try {
-        return new Uint8Array(await (await handle.getFile()).arrayBuffer());
+        return await op();
       } catch (err) {
-        if (err?.name !== "NotReadableError" || attempt >= READ_ATTEMPTS) {
-          throw translate(err, path);
-        }
+        const name2 = err?.name;
+        const again = name2 === "NotReadableError" || locks && LOCKED.has(name2);
+        if (!again || attempt >= READ_ATTEMPTS) throw translate(err, path);
         await new Promise((resolve) => setTimeout(resolve, attempt * 10));
       }
     }
   }
+  async existing(path) {
+    const handle = (await this.locate(path, true)).handle;
+    if (handle.kind === "directory") throw fsError("EISDIR", path);
+    return handle;
+  }
+  async readFileBuffer(path) {
+    const handle = await this.existing(path);
+    return this.retrying(
+      path,
+      async () => new Uint8Array(await (await handle.getFile()).arrayBuffer()),
+      false
+    );
+  }
+  async pread(path, offset, length2) {
+    const handle = await this.existing(path);
+    return this.retrying(
+      path,
+      async () => new Uint8Array(await (await handle.getFile()).slice(offset, offset + length2).arrayBuffer()),
+      false
+    );
+  }
+  async pwrite(path, offset, bytes) {
+    const handle = (await this.fileFor(path))[0];
+    await this.retrying(path, () => positioned(handle, (io) => io.write(offset, bytes)), true);
+  }
+  async truncate(path, size) {
+    const handle = await this.existing(path);
+    await this.retrying(path, () => positioned(handle, (io) => io.truncate(size)), true);
+  }
   async readFile(path) {
     return new TextDecoder().decode(await this.readFileBuffer(path));
   }
@@ -1708,16 +1788,21 @@ var OpfsFs = class {
     const wanted = entry?.link === void 0 ? path : resolvePath(parentOf2(path), entry.link);
     return [resolvePath((await this.locate(parentOf2(wanted), true)).path, baseOf(wanted)), false];
   }
-  async writeFile(path, content) {
+  async fileFor(path) {
     const [target, existed] = await this.writeTarget(path);
     const [dir, name2] = await this.parent(target);
-    let file;
     try {
-      file = await this.inDir(dir, (parent) => parent.getFileHandle(name2, { create: true }));
+      return [
+        await this.inDir(dir, (parent) => parent.getFileHandle(name2, { create: true })),
+        existed
+      ];
     } catch (err) {
       const code = err?.name === "TypeMismatchError" ? "EISDIR" : null;
       throw code ? fsError(code, path) : translate(err, path);
     }
+  }
+  async writeFile(path, content) {
+    const [file, existed] = await this.fileFor(path);
     if (!existed && content.length === 0) return;
     const writable = await file.createWritable();
     await writable.write(content);
@@ -3694,6 +3779,7 @@ var MountFs = class {
   async pread(path, offset, length2) {
     const real = await this.follow(path);
     const found = this.at(real);
+    if (!found && this.base.pread) return this.base.pread(real, offset, length2);
     if (!found) return (await this.base.readFileBuffer(real)).slice(offset, offset + length2);
     const { mount, rel: rel2 } = found;
     if ((await this.table.getattr(mount, real, rel2)).kind === "directory") {
@@ -3731,6 +3817,7 @@ var MountFs = class {
   async pwrite(path, offset, bytes, transfer = false) {
     const real = await this.follow(path, 0, true);
     const found = this.at(real);
+    if (!found && this.base.pwrite) return this.base.pwrite(real, offset, bytes);
     if (!found)
       return this.base.writeFile(
         real,
@@ -3762,6 +3849,7 @@ var MountFs = class {
   async truncate(path, size) {
     const real = await this.follow(path);
     const found = this.at(real);
+    if (!found && this.base.truncate) return this.base.truncate(real, size);
     if (!found?.mount.caps.ranges) {
       return this.writeFile(real, resized(await this.readFileBuffer(real), size));
     }
@@ -9491,40 +9579,106 @@ function valid(name2) {
     throw new TypeError(`invalid name: ${name2}`);
   }
 }
+var CHUNK3 = 1024 * 1024;
 function bytesOf(data) {
   if (typeof data === "string") return new TextEncoder().encode(data);
   if (data instanceof Blob) return data.arrayBuffer().then((buffer) => new Uint8Array(buffer));
   if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength).slice();
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
   }
-  return new Uint8Array(data).slice();
+  return new Uint8Array(data);
 }
+var isParams = (data) => ["write", "seek", "truncate"].includes(data?.type) && !(data instanceof Blob);
+var Chunks = class {
+  blobs;
+  size;
+  constructor(blobs = [], size = 0) {
+    this.blobs = blobs;
+    this.size = size;
+  }
+  pad(index, length2) {
+    const blob = this.blobs[index] ?? new Blob([]);
+    if (blob.size < length2)
+      this.blobs[index] = new Blob([blob, new Uint8Array(length2 - blob.size)]);
+  }
+  grow(end) {
+    if (end <= this.size) return;
+    const last = Math.floor((end - 1) / CHUNK3);
+    for (let i = 0; i < last; i++) this.pad(i, CHUNK3);
+    this.pad(last, end - last * CHUNK3);
+    this.size = end;
+  }
+  async write(at, bytes) {
+    if (bytes.length === 0) return;
+    const first = Math.floor(at / CHUNK3);
+    for (let i = 0; i < first; i++) this.pad(i, CHUNK3);
+    for (let done4 = 0; done4 < bytes.length; ) {
+      const index = Math.floor((at + done4) / CHUNK3);
+      const from = at + done4 - index * CHUNK3;
+      const n = Math.min(CHUNK3 - from, bytes.length - done4);
+      const view = bytes.subarray(done4, done4 + n);
+      const part = view.buffer instanceof ArrayBuffer ? view : view.slice();
+      const old = this.blobs[index];
+      if (from === 0 && n >= (old?.size ?? 0)) this.blobs[index] = new Blob([part]);
+      else {
+        const merged = new Uint8Array(Math.max(old?.size ?? 0, from + n));
+        if (old) merged.set(new Uint8Array(await old.arrayBuffer()));
+        merged.set(part, from);
+        this.blobs[index] = new Blob([merged]);
+      }
+      done4 += n;
+    }
+    this.size = Math.max(this.size, at + bytes.length);
+  }
+  truncate(size) {
+    if (size >= this.size) {
+      this.grow(size);
+      return;
+    }
+    const keep = Math.ceil(size / CHUNK3);
+    this.blobs.length = keep;
+    if (keep > 0)
+      this.blobs[keep - 1] = this.blobs[keep - 1].slice(0, size - (keep - 1) * CHUNK3);
+    this.size = size;
+  }
+};
 var MemoryFile = class {
   kind = "file";
   name;
   parent;
-  bytes = new Uint8Array(0);
+  data = new Chunks();
   lastModified = Date.now();
   constructor(name2, parent) {
     this.name = name2;
     this.parent = parent;
   }
   async getFile() {
-    return new File([this.bytes], this.name, { lastModified: this.lastModified });
-  }
-  async createWritable() {
-    const chunks2 = [];
+    return new File(this.data.blobs, this.name, { lastModified: this.lastModified });
+  }
+  async createWritable({ keepExistingData = false } = {}) {
+    const next = keepExistingData ? new Chunks([...this.data.blobs], this.data.size) : new Chunks();
+    let position = 0;
+    const put = async (data) => {
+      const bytes = await bytesOf(data);
+      await next.write(position, bytes);
+      position += bytes.length;
+    };
     return {
-      write: async (data) => void chunks2.push(await bytesOf(data)),
+      write: async (data) => {
+        if (!isParams(data)) return put(data);
+        if (data.type === "truncate") return next.truncate(data.size ?? 0);
+        position = data.position ?? position;
+        if (data.type === "write") await put(data.data);
+      },
+      seek: async (at) => {
+        position = at;
+      },
+      truncate: async (size) => next.truncate(size),
       close: async () => {
-        const out = new Uint8Array(chunks2.reduce((n, chunk2) => n + chunk2.length, 0));
-        let at = 0;
-        for (const chunk2 of chunks2) {
-          out.set(chunk2, at);
-          at += chunk2.length;
-        }
-        this.bytes = out;
+        this.data = next;
         this.lastModified = Date.now();
+      },
+      abort: async () => {
       }
     };
   }
@@ -9617,6 +9771,9 @@ var MemoryDirectory = class _MemoryDirectory {
 function memoryRoot() {
   return new MemoryDirectory("", null);
 }
+function isMemoryRoot(handle) {
+  return handle instanceof MemoryDirectory;
+}
 
 // src/kernel/net/remote-transport.ts
 var TransportError = class extends Error {
@@ -10388,7 +10545,7 @@ function textOf(on) {
 }
 async function createNodeKernel(options = {}) {
   const root = options.root ?? memoryRoot();
-  const fs = new OpfsFs(root);
+  const fs = new OpfsFs(root, void 0, void 0, { ranged: isMemoryRoot(root) });
   await fs.reconcile();
   const live = /* @__PURE__ */ new Set();
   const pending = /* @__PURE__ */ new Set();