@ai-ecoverse/slicc-kernel 1.167.1 → 1.167.3

package/dist/node.js

@@ -3684,7 +3684,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.167.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.167.3" : "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);
@@ -30595,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);
@@ -32808,7 +32862,7 @@ var Launcher = class {
       kept: async (tab, items, paths) => {
         for (const { path, hidden, fid } of items) {
           if (hidden !== void 0 && sharedKept(hidden)) await this.adoptShared(path, hidden, fid);
-          else this.adoptKept(path, hidden, fid, ours);
+          else await this.adoptKept(path, hidden, fid, ours);
         }
         await open(tab, paths);
       },
@@ -32818,14 +32872,33 @@ var Launcher = class {
       }
     };
   }
-  async adoptShared(path, hidden, fid) {
-    const bound3 = [...this.held].map(
-      (holds2) => [holds2, [...holds2.boundAt(path, fid), ...holds2.boundAt(hidden, fid)]]
-    );
-    const keeping = bound3.filter(([, ids]) => ids.length > 0);
+  async keptIds(hidden, fid) {
+    if (fid !== void 0) return [fid];
+    const st = await this.rootFs.lstat(hidden).catch(() => void 0);
+    return st?.fid === void 0 ? [void 0] : [void 0, st.fid];
+  }
+  boundTo(path, hidden, fids) {
+    const keeping = [...this.held].map(
+      (holds2) => [
+        holds2,
+        fids.flatMap((fid) => [...holds2.boundAt(path, fid), ...holds2.boundAt(hidden, fid)])
+      ]
+    ).filter(([, ids]) => ids.length > 0);
     const nodes = [...this.openFiles].filter(
       (open) => [path, hidden].some((at) => open.holdsAt(at))
     );
+    const keep2 = (file) => {
+      const kept = nodes.filter(
+        (open) => fids.some((fid) => open.keepBound([hidden, path], fid, file))
+      ).length;
+      for (let i = kept; i < nodes.length; i++) file.release();
+      for (const [holds2, ids] of keeping) holds2.keepBound(ids, path, file);
+      void this.rootFs.announceHolds?.([], [path, hidden], false);
+    };
+    return { keeping, nodes, keep: keep2 };
+  }
+  async adoptShared(path, hidden, fid) {
+    const { keeping, nodes, keep: keep2 } = this.boundTo(path, hidden, await this.keptIds(hidden, fid));
     const refs = keeping.length + nodes.length;
     if (refs === 0) {
       this.held.doubt([path]);
@@ -32840,33 +32913,22 @@ var Launcher = class {
       this.held.doubt([path]);
       return;
     }
-    const kept = nodes.filter((open) => open.keepBound([hidden, path], fid, file)).length;
-    for (let i = kept; i < nodes.length; i++) file.release();
-    for (const [holds2, ids] of keeping) holds2.keepBound(ids, path, file);
-    void this.rootFs.announceHolds?.([], [path, hidden], false);
+    keep2(file);
   }
-  adoptKept(path, hidden, fid, ours) {
+  async adoptKept(path, hidden, fid, ours) {
     if (hidden === void 0 || !ours(hidden)) {
       this.held.doubt([path]);
       return;
     }
-    const bound3 = [...this.held].map(
-      (holds2) => [holds2, [...holds2.boundAt(path, fid), ...holds2.boundAt(hidden, fid)]]
-    );
-    const keeping = bound3.filter(([, ids]) => ids.length > 0);
-    const nodes = [...this.openFiles].filter(
-      (open) => [path, hidden].some((at) => open.holdsAt(at))
-    );
+    const { keeping, nodes, keep: keep2 } = this.boundTo(path, hidden, await this.keptIds(hidden, fid));
     const file = this.unlinked.adopt(hidden, Math.max(keeping.length + nodes.length, 1));
-    const kept = nodes.filter((open) => open.keepBound([hidden, path], fid, file)).length;
-    for (let i = kept; i < nodes.length; i++) file.release();
     if (keeping.length === 0 && nodes.length === 0) file.release();
-    for (const [holds2, ids] of keeping) holds2.keepBound(ids, path, file);
-    void this.rootFs.announceHolds?.([], [path, hidden], false);
+    keep2(file);
   }
   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) {
@@ -32888,13 +32950,17 @@ 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) => {
       this.changes.flush();
       this.changes.foreign(crowded);
       if (crowded) {
+        void this.announceHeld();
         void this.held.bindIds((path) => this.rootFileId(path)).then(
           () => Promise.all([...this.openFiles].map((open) => open.bindIds((p) => this.rootFileId(p))))
         ).then(() => this.announceHeld());