@ai-ecoverse/slicc-kernel 1.154.1 → 1.154.2

package/dist/kernel-worker.js

@@ -942,6 +942,12 @@ var ProtectedFs = class {
           return fs.pwrite?.(...args);
         }
       } : {},
+      ...fs.append ? {
+        async append(path, bytes) {
+          await check(path, true);
+          return fs.append.call(fs, path, bytes);
+        }
+      } : {},
       ...fs.truncate ? {
         async truncate(path, size) {
           await check(path, true);
@@ -1512,6 +1518,7 @@ var OpfsFs = class {
   mounts = {};
   locks;
   lockPrefix;
+  appendPrefix;
   rootName;
   renamePrefix;
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
@@ -1520,6 +1527,7 @@ var OpfsFs = class {
     this.ranged = options.ranged === true;
     this.locks = options.locks === void 0 ? lockManager() : options.locks ?? void 0;
     this.lockPrefix = `slicc-excl:${channel ?? ""}:`;
+    this.appendPrefix = `slicc-append:${escapeRoot(channel ?? "")}:`;
     this.rootName = channel;
     this.renamePrefix = `${RENAME_LOCK}${escapeRoot(channel ?? "")}:`;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
@@ -2413,11 +2421,43 @@ var OpfsFs = class {
     if (this.renamesInFlight()) await this.writeWaits(at);
     this.fileWrites.set(at, (this.fileWrites.get(at) ?? 0) + 1);
     try {
-      await this.truncated(path, size);
+      await this.ending(path, () => this.truncated(path, size));
+    } finally {
+      this.writeEnded(at);
+    }
+  }
+  async append(path, bytes) {
+    if (!this.locks || !this.remote || !this.shared()) {
+      throw fsError("ENOTSUP", `${path}: appended by position while no other tab shares the root`);
+    }
+    const at = normalizePath(path);
+    if (this.renamesInFlight()) await this.writeWaits(at);
+    this.fileWrites.set(at, (this.fileWrites.get(at) ?? 0) + 1);
+    try {
+      const found = await this.locate(path, true);
+      if (found.handle?.kind !== "file") throw fsError(found.handle ? "EISDIR" : "ENOENT", path);
+      this.refuse(found.path);
+      const [entry] = await this.meta.get([found.path]);
+      if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
+      const handle = found.handle;
+      return await this.ending(found.path, async () => {
+        const end = (await this.io(handle.getFile())).size;
+        await this.writeAt(handle, found.path, path, end, bytes);
+        return end + bytes.length;
+      });
     } finally {
       this.writeEnded(at);
     }
   }
+  async ending(path, op) {
+    if (!this.locks || !this.remote || !this.shared()) return op();
+    const physical = (await this.locate(path, true)).path;
+    let result;
+    await this.locks.request(`${this.appendPrefix}${physical}`, async () => {
+      result = await op();
+    });
+    return result;
+  }
   async truncated(path, size) {
     const handle = await this.existing(path, true);
     await this.refuseNode(path, (await this.io(handle.getFile())).size === 0);
@@ -8049,7 +8089,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.154.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.154.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
@@ -10719,6 +10759,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     ...fs.chown ? { chown: fs.chown.bind(fs) } : {},
     ...fs.createExclusive ? { createExclusive: fs.createExclusive.bind(fs) } : {},
     ...fs.copyFile ? { copyFile: fs.copyFile.bind(fs) } : {},
+    ...fs.append ? { append: fs.append.bind(fs) } : {},
     ...fs.ancestry ? { ancestry: fs.ancestry.bind(fs) } : {},
     ...fs.hasOwner ? { hasOwner: fs.hasOwner.bind(fs) } : {},
     chmod: (path, mode) => fs.chmod(path, mode),
@@ -10955,6 +10996,15 @@ var FreshModules = class {
         if (fresh3) this.fresh.set(normalizePath(to), fresh3);
       }
     };
+    const { append } = fs;
+    if (append) {
+      overrides.append = async (path, bytes) => {
+        const fresh3 = this.fresh.has(normalizePath(path));
+        const end = await append.call(fs, path, bytes);
+        if (fresh3 && end - bytes.length < MAGIC.length) await decide(path);
+        return end;
+      };
+    }
     const ranged2 = rangedOps(fs);
     if (ranged2) {
       overrides.pwrite = async (path, at, bytes, transfer, options) => {
@@ -11348,6 +11398,19 @@ var FsWatchers = class {
         "change"
       )
     };
+    const { append } = fs;
+    if (append) {
+      overrides.append = async (path, bytes) => {
+        let end = 0;
+        await content(
+          async (_path) => {
+            end = await append.call(fs, path, bytes);
+          },
+          () => ["change"]
+        )(path);
+        return end;
+      };
+    }
     const ranged2 = rangedOps(fs);
     if (ranged2) {
       overrides.pwrite = content(ranged2.pwrite, () => ["change"]);
@@ -13184,6 +13247,7 @@ var RELINKED = [
   ["writeFile", [0]],
   ["pread", [0]],
   ["pwrite", [0]],
+  ["append", [0]],
   ["truncate", [0]],
   ["lstat", [0]],
   ["stat", [0]],
@@ -13489,6 +13553,19 @@ var MountFs = class _MountFs {
       );
     }
   }
+  async append(path, bytes, redirects = 0) {
+    const real = await this.follow(path, 0, true);
+    const { append } = this.base;
+    if (!this.at(real) && append) {
+      return this.based(
+        [real],
+        redirects,
+        () => append.call(this.base, real, bytes),
+        ([to], n) => this.append(to, bytes, n)
+      );
+    }
+    throw errnoError("ENOTSUP", `${real}: appended by position on a mount`);
+  }
   async pwrite(path, offset, bytes, transfer = false, options, redirects = 0) {
     const real = await this.follow(path, 0, true);
     const found = this.at(real);
@@ -23453,6 +23530,7 @@ var O_ACCMODE = 3;
 var O_WRONLY = 1;
 var O_RDWR = 2;
 var O_APPEND = 1024;
+var POSITIONAL_MS = 100;
 var SEEK_SET = 0;
 var SEEK_CUR = 1;
 var SEEK_END = 2;
@@ -23648,6 +23726,34 @@ var VfsNode = class {
     if (this.ranged) this.ranged.path = path;
     this.cap = void 0;
   }
+  async append(bytes) {
+    const { append } = this.fs;
+    const recently = performance.now() - this.positionalAt < POSITIONAL_MS;
+    if (!append || this.orphaned || this.revoked || bytes.length === 0 || recently) {
+      const at = await this.size();
+      return at + await this.pwrite(bytes, at);
+    }
+    await this.settled();
+    await this.fits(await this.size() + bytes.length);
+    await this.flush();
+    const end = await this.followed(() => append.call(this.fs, this.path, bytes)).catch(
+      (err) => {
+        if (!positional(err)) throw err;
+        return void 0;
+      }
+    );
+    if (end === void 0) {
+      this.positionalAt = performance.now();
+      const at = await this.size();
+      return at + await this.pwrite(bytes, at);
+    }
+    this.reread();
+    return end;
+  }
+  positionalAt = Number.NEGATIVE_INFINITY;
+  shared() {
+    this.positionalAt = Number.NEGATIVE_INFINITY;
+  }
   async pwrite(bytes, at) {
     if (bytes.length === 0) return 0;
     await this.settled();
@@ -23736,6 +23842,9 @@ var VfsNode = class {
     this.writeBackCost = performance.now() - started;
   }
 };
+function positional(err) {
+  return err?.code === "ENOTSUP";
+}
 var VfsNodes = class {
   byPath = /* @__PURE__ */ new Map();
   kept = /* @__PURE__ */ new Map();
@@ -23840,6 +23949,9 @@ var VfsNodes = class {
     if (node.path === path) node.renamedTo(others[0]);
     return true;
   }
+  shared() {
+    for (const node of new Set(this.byPath.values())) node.shared();
+  }
   holdsAny() {
     return this.byPath.size > 0;
   }
@@ -24092,12 +24204,13 @@ function heldIo(fs, nodes, changed) {
   return {
     append: (path, bytes) => write(
       path,
-      async (held) => {
-        const at = await held.size();
-        await held.pwrite(bytes, at);
-        return at + bytes.length;
-      },
+      (held) => held.append(bytes),
       async () => {
+        const end = await fs.append?.(path, bytes).catch((err) => {
+          if (!positional(err)) throw err;
+          return void 0;
+        });
+        if (end !== void 0) return end;
         const at = (await fs.stat(path)).size;
         if (ranged2) await ranged2.pwrite(path, at, bytes, true);
         else {
@@ -24246,8 +24359,8 @@ function vfsFile(fs, opts, nodes) {
       return out;
     }) : void 0,
     write: writable2 ? (bytes) => serial(async () => {
-      if (opts.flags & O_APPEND) offset = await node.size();
-      offset += await node.pwrite(bytes, offset);
+      if (opts.flags & O_APPEND) offset = await node.append(bytes);
+      else offset += await node.pwrite(bytes, offset);
       return bytes.length;
     }) : void 0,
     seek: (to, whence) => serial(async () => {
@@ -32583,7 +32696,10 @@ var Launcher = class {
     peers.watch((crowded) => {
       this.changes.flush();
       this.changes.foreign(crowded);
-      if (crowded) void this.held?.bindIds((path) => this.rootFileId(path));
+      if (crowded) {
+        void this.held?.bindIds((path) => this.rootFileId(path));
+        for (const nodes of this.openFiles) nodes.shared();
+      }
     });
     return {
       ...peers,