@ai-ecoverse/slicc-kernel 1.117.1 → 1.117.2

package/dist/node-process-worker.js

@@ -5377,7 +5377,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.117.1" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.117.2" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });

package/dist/node.js

@@ -4122,6 +4122,7 @@ var ABSENT_MS = 2;
 var ABSENT_NAMES = 4096;
 var FILE_HANDLES = 4096;
 var STALE = /* @__PURE__ */ new Set(["NotFoundError", "TypeMismatchError"]);
+var REPLACED_ATTEMPTS = 4;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
 var ERRNO_BY_DOM_ERROR = {
   NotFoundError: "ENOENT",
@@ -4252,6 +4253,8 @@ var OpfsFs = class {
   files = new PathMap();
   absent = new PathMap();
   changes = 0;
+  replacing = Promise.resolve();
+  replacements = 0;
   snapshots = /* @__PURE__ */ new WeakMap();
   found = /* @__PURE__ */ new WeakMap();
   checked = /* @__PURE__ */ new WeakMap();
@@ -4586,7 +4589,22 @@ var OpfsFs = class {
     }
     return void 0;
   }
-  async locate(path, follow2) {
+  locate(path, follow2) {
+    return this.unreplaced(() => this.located(path, follow2));
+  }
+  async unreplaced(op) {
+    for (let attempt = 1; ; attempt++) {
+      const seen = this.replacements;
+      try {
+        return await op();
+      } catch (err) {
+        if (attempt >= REPLACED_ATTEMPTS || !missing2(err)) throw err;
+        await this.replacing;
+        if (this.replacements === seen) throw err;
+      }
+    }
+  }
+  async located(path, follow2) {
     let current = path;
     for (let hops = 0; hops <= MAX_LINKS5; hops++) {
       try {
@@ -4784,11 +4802,11 @@ var OpfsFs = class {
     const stat = await this.statOf(found.path, found.handle, meta, touched);
     return { ...stat, ...ownOf(meta) ?? inherit(entries) };
   }
-  async stat(path) {
-    return this.describe(await this.locate(path, true));
+  stat(path) {
+    return this.unreplaced(async () => this.describe(await this.located(path, true)));
   }
-  async lstat(path) {
-    return this.describe(await this.locate(path, false));
+  lstat(path) {
+    return this.unreplaced(async () => this.describe(await this.located(path, false)));
   }
   async exists(path) {
     return this.locate(path, true).then(
@@ -4812,6 +4830,12 @@ var OpfsFs = class {
       }
     }
   }
+  reading(path, op) {
+    return this.unreplaced(async () => {
+      const handle = await this.existing(path);
+      return this.retrying(path, () => op(handle), false);
+    });
+  }
   async existing(path, writing = false) {
     const found = await this.locate(path, true);
     if (writing) this.refuse(found.path);
@@ -4825,52 +4849,35 @@ var OpfsFs = class {
     if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
   }
   async readFileBuffer(path) {
-    const handle = await this.existing(path);
-    const bytes = await this.retrying(
+    const bytes = await this.reading(
       path,
-      async () => new Uint8Array(await (await handle.getFile()).arrayBuffer()),
-      false
+      async (handle) => new Uint8Array(await (await handle.getFile()).arrayBuffer())
     );
     await this.refuseNode(path, bytes.length === 0);
     return bytes;
   }
   async readVersioned(path, cached = false) {
-    const handle = await this.existing(path);
-    return this.retrying(
-      path,
-      async () => {
-        const stamp = await this.stamp(path, cached);
-        const file = await handle.getFile();
-        const bytes = new Uint8Array(await file.arrayBuffer());
-        await this.refuseNode(path, bytes.length === 0);
-        return { bytes, version: `${file.lastModified}:${file.size}:${stamp}` };
-      },
-      false
-    );
+    return this.reading(path, async (handle) => {
+      const stamp = await this.stamp(path, cached);
+      const file = await handle.getFile();
+      const bytes = new Uint8Array(await file.arrayBuffer());
+      await this.refuseNode(path, bytes.length === 0);
+      return { bytes, version: `${file.lastModified}:${file.size}:${stamp}` };
+    });
   }
   async version(path, cached = false) {
-    const handle = await this.existing(path);
-    return this.retrying(
-      path,
-      async () => {
-        const stamp = await this.stamp(path, cached);
-        const file = await handle.getFile();
-        return `${file.lastModified}:${file.size}:${stamp}`;
-      },
-      false
-    );
+    return this.reading(path, async (handle) => {
+      const stamp = await this.stamp(path, cached);
+      const file = await handle.getFile();
+      return `${file.lastModified}:${file.size}:${stamp}`;
+    });
   }
   async pread(path, offset, length2) {
-    const handle = await this.existing(path);
-    return this.retrying(
-      path,
-      async () => {
-        const file = await handle.getFile();
-        await this.refuseNode(path, file.size === 0);
-        return new Uint8Array(await file.slice(offset, offset + length2).arrayBuffer());
-      },
-      false
-    );
+    return this.reading(path, async (handle) => {
+      const file = await handle.getFile();
+      await this.refuseNode(path, file.size === 0);
+      return new Uint8Array(await file.slice(offset, offset + length2).arrayBuffer());
+    });
   }
   async pwrite(path, offset, bytes) {
     const [handle, , target] = await this.fileFor(path);
@@ -5183,7 +5190,10 @@ var OpfsFs = class {
     const staging = swap ? `.${name2}.${crypto.randomUUID()}` : name2;
     this.forget(destination);
     const timed2 = await this.explicitTimes(source.path);
-    const moved2 = await this.place(source.handle, dir, staging);
+    const moved2 = await this.replacingTarget(
+      targetStat !== null,
+      () => this.place(source.handle, dir, staging)
+    );
     if (swap) await this.rm(destination, { recursive: true });
     await this.meta.move(source.path, destination, carry);
     this.movePending(source.path, destination);
@@ -5199,6 +5209,21 @@ var OpfsFs = class {
     this.changed(source.path, destination);
     this.touch(Date.now(), parentOf4(source.path), parent.path);
   }
+  async replacingTarget(replaces, op) {
+    if (!replaces) return op();
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    const before = this.replacing;
+    this.replacing = Promise.all([before, promise]).then(() => void 0);
+    this.replacements++;
+    this.changes++;
+    try {
+      return await op();
+    } finally {
+      this.replacements++;
+      this.changes++;
+      resolve2();
+    }
+  }
   async modified(path) {
     const handle = await this.handle(path);
     return handle.kind === "file" ? (await handle.getFile()).lastModified : 0;
@@ -5401,6 +5426,16 @@ function pidOwner(proc) {
 function webLocks() {
   return globalThis.navigator?.locks;
 }
+var LOOKUP_OPS = [
+  "exists",
+  "readFile",
+  "readFileBuffer",
+  "readVersioned",
+  "version",
+  "pread",
+  "readlink",
+  "realpath"
+];
 var within4 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
 var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var lockName = (instance) => `slicc-unlinked:${instance}`;
@@ -5439,6 +5474,8 @@ var UnlinkedKeeper = class {
   gate = new PathGate();
   queue = Promise.resolve();
   count = 0;
+  replacing = /* @__PURE__ */ new Map();
+  replaced = 0;
   links = /* @__PURE__ */ new Map();
   linked = /* @__PURE__ */ new Map();
   dirOwner;
@@ -5461,6 +5498,44 @@ var UnlinkedKeeper = class {
   }
   wrap(fs = this.fs) {
     const keeper = this;
+    const { replacing } = this;
+    const replace = async (target, op) => {
+      const before = replacing.get(target);
+      const { promise, resolve: resolve2 } = Promise.withResolvers();
+      const mine = {
+        done: Promise.all([before?.done, promise]).then(() => void 0)
+      };
+      replacing.set(target, mine);
+      try {
+        await op();
+      } finally {
+        keeper.replaced += 1;
+        resolve2();
+        if (replacing.get(target) === mine) replacing.delete(target);
+      }
+    };
+    const unreplaced = async (path, op) => {
+      const at = fs.resolvePath("/", path);
+      for (let attempt = 1; ; attempt++) {
+        await replacing.get(at)?.done;
+        const seen = keeper.replaced;
+        try {
+          return await op();
+        } catch (err) {
+          const code = err?.code;
+          if (attempt >= 3 || code !== "ENOENT") throw err;
+          await replacing.get(at)?.done;
+          if (keeper.replaced === seen) throw err;
+        }
+      }
+    };
+    const looking = (name2) => {
+      const call = fs[name2];
+      if (!call) return {};
+      return {
+        [name2]: (path, ...rest2) => unreplaced(path, () => call.call(fs, path, ...rest2))
+      };
+    };
     const visible = (names) => names.filter((name2) => name2 !== UNLINKED_DIR);
     const counted3 = (st) => {
       const hidden = keeper.links.get(`${st.dev ?? 0}:${st.ino}`) ?? 0;
@@ -5468,9 +5543,10 @@ var UnlinkedKeeper = class {
     };
     return {
       ...fs,
+      ...LOOKUP_OPS.reduce((all, name2) => Object.assign(all, looking(name2)), {}),
       links: (path) => mayLink(fs, path),
-      stat: async (path) => counted3(await fs.stat(path)),
-      lstat: async (path) => counted3(await fs.lstat(path)),
+      stat: (path) => unreplaced(path, async () => counted3(await fs.stat(path))),
+      lstat: (path) => unreplaced(path, async () => counted3(await fs.lstat(path))),
       async rm(path, options) {
         const target = fs.resolvePath("/", path);
         const pinned = await keeper.pin(target);
@@ -5480,8 +5556,10 @@ var UnlinkedKeeper = class {
       async rename(from, to) {
         const target = fs.resolvePath("/", to);
         if (target === fs.resolvePath("/", from)) return fs.rename(from, to);
-        const pinned = await keeper.pin(target);
-        await keeper.settle(pinned, () => fs.rename(from, to));
+        await replace(target, async () => {
+          const pinned = await keeper.pin(target);
+          await keeper.settle(pinned, () => fs.rename(from, to));
+        });
       },
       readdir: async (path) => visible(await fs.readdir(path)),
       readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR).map(([name2, st]) => [name2, st && counted3(st)])
@@ -6578,7 +6656,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.117.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.117.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