@ai-ecoverse/slicc-kernel 1.167.0 → 1.167.2

package/dist/node.js

@@ -3684,7 +3684,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.167.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.167.2" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -11064,7 +11064,7 @@ async function heldOpen(entry, path, real, req, fid) {
   const handle = entry.hold?.(path, true, true, real, void 0, req.ino, fid);
   if (handle === void 0) return null;
   await entry.announceHold?.(real ?? path, fid, ((req.mode ?? 0) & HOLD_CREATED) !== 0);
-  return handle;
+  return real !== void 0 && real !== path ? { handle, real } : handle;
 }
 async function idOf(entry, path) {
   return await entry.fileId?.(path)?.catch(() => void 0) ?? void 0;
@@ -12025,6 +12025,10 @@ var AsyncRangedFile = class {
   truncate(size) {
     this.pages.truncate(size);
   }
+  wrote(at, length2) {
+    this.pages.landed(at, length2);
+    this.version = void 0;
+  }
   async flush() {
     if (this.pinned || !this.pages.changed) return;
     const plan = this.pages.plan();
@@ -20150,6 +20154,7 @@ var VfsNode = class {
   ino;
   onDirty;
   onDirtyState;
+  crowded;
   counted = false;
   recount() {
     if (!this.onDirtyState) return;
@@ -20267,9 +20272,48 @@ var VfsNode = class {
     if (!this.dirty) this.data = void 0;
   }
   async size() {
+    if (this.peerHeld()) {
+      const known = await this.exact();
+      if (known !== void 0) return known;
+    }
     const ranged2 = await this.prepare();
     return ranged2 ? ranged2.size() : this.length;
   }
+  peered = false;
+  peerHeld() {
+    if (this.orphaned || this.revoked || this.pin) return false;
+    if (this.crowded?.(this.path) === true) this.peered = true;
+    return this.peered;
+  }
+  async exact() {
+    await this.flush();
+    const { stat } = this.fs;
+    const io = rangedOps(this.fs);
+    if (!stat || !io) return void 0;
+    const st = await this.followed(() => stat.call(this.fs, this.path));
+    this.peered = this.crowded?.(this.path) === true;
+    const size = st.size ?? 0;
+    if (this.ranged) {
+      if (size !== this.ranged.size()) {
+        this.ranged = new AsyncRangedFile(io, this.path, size, st.version);
+      }
+      return void 0;
+    }
+    if (this.data && size !== this.length) this.data = void 0;
+    return this.data ? void 0 : size;
+  }
+  landed(at, bytes) {
+    if (this.ranged) {
+      this.ranged.wrote(at, bytes.length);
+      return;
+    }
+    if (!this.data) return;
+    const end = at + bytes.length;
+    const buf = this.ensure(end);
+    if (at > this.length) buf.fill(0, this.length, at);
+    buf.set(bytes, at);
+    this.length = Math.max(this.length, end);
+  }
   async pread(max, at) {
     const ranged2 = await this.prepare();
     if (ranged2) return this.followed(() => ranged2.read(at, max));
@@ -20341,6 +20385,13 @@ var VfsNode = class {
     if (bytes.length === 0) return 0;
     await this.settled();
     await this.fits(at + bytes.length);
+    const io = this.peerHeld() ? rangedOps(this.fs) : void 0;
+    if (io && at + bytes.length > await this.size()) {
+      const copy = bytes.slice();
+      await this.followed(() => io.pwrite(this.path, at, copy, true));
+      this.landed(at, bytes);
+      return bytes.length;
+    }
     const ranged2 = await this.prepare();
     if (ranged2) {
       await this.followed(() => ranged2.write(at, bytes));
@@ -20437,6 +20488,7 @@ var VfsNodes = class {
   movedAway;
   opened;
   dirtied;
+  crowded;
   fs;
   entries;
   onClosed;
@@ -20582,6 +20634,7 @@ var VfsNodes = class {
     this.reshaped();
     node.onDirty = () => this.changed?.(node.path);
     node.onDirtyState = (on) => this.dirtied?.(on ? 1 : -1);
+    node.crowded = (at) => this.crowded?.(at) === true;
     node.recount();
     this.byPath.set(path, node);
     if (id2 !== void 0) this.know(node, id2);
@@ -26618,6 +26671,15 @@ var OpfsFs = class {
   }
   async pread(path, offset, length2) {
     return this.reading(path, async (handle) => {
+      const seen = this.glanced(handle);
+      if (seen && length2 > 0 && offset + length2 <= seen.size) {
+        const bytes = await this.io(seen.slice(offset, offset + length2).arrayBuffer()).then(
+          (buffer) => new Uint8Array(buffer),
+          () => void 0
+        );
+        if (bytes?.length === length2) return bytes;
+        this.glances.delete(handle);
+      }
       const file = await this.io(handle.getFile());
       await this.refuseNode(path, file.size === 0);
       return new Uint8Array(await file.slice(offset, offset + length2).arrayBuffer());
@@ -30586,6 +30648,7 @@ var Launcher = class {
   hostname;
   watchers = new FsWatchers();
   changes = new FileChanges();
+  peerHeldPaths = /* @__PURE__ */ new Set();
   renameLog = new RenameLog(this.changes);
   cwds = new CwdTable(async (path) => {
     const { dev, ino } = await this.base.stat(path);
@@ -32858,6 +32921,7 @@ var Launcher = class {
   openNodes(fs, entries) {
     const nodes = new VfsNodes(fs, (path) => this.released(path), entries);
     nodes.opened = (node) => this.nodeOpened(node);
+    nodes.crowded = (path) => this.peerHeldPaths.has(path);
     return nodes;
   }
   nodeOpened(node) {
@@ -32879,7 +32943,10 @@ var Launcher = class {
     return this.mounts.locate(path) === void 0 ? this.rootFs.bindId?.(path) : void 0;
   }
   flushingPeers(fs) {
-    fs.peerHolds?.((paths) => this.changes.peerHeld(paths));
+    fs.peerHolds?.((paths) => {
+      this.peerHeldPaths = new Set(paths);
+      this.changes.peerHeld(paths);
+    });
     const peers = fs.peers?.();
     if (!peers) return void 0;
     peers.watch((crowded) => {