@ai-ecoverse/slicc-kernel 1.154.1 → 1.154.3

package/dist/node-process-worker.js

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

package/dist/node.js

@@ -186,6 +186,7 @@ function embedderAsker(port) {
       void asked.body.cancel(message3.error.message).catch(() => void 0);
       push(asked, message3.error);
     } else if ("progress" in message3) asked.progress(message3.progress);
+    else if ("bodyCancel" in message3) void asked.body.cancel("the page").catch(() => void 0);
     else void sendBody(message3.id, asked);
   };
   return { hookFor, answer: answer2 };
@@ -213,7 +214,8 @@ function bodyStream(id2, state, post) {
         const next3 = state.body.shift();
         if (next3) controller.enqueue(next3);
         else controller.close();
-      }
+      },
+      cancel: () => post({ id: id2, bodyCancel: true })
     },
     { highWaterMark: 0 }
   );
@@ -234,14 +236,16 @@ function embedderAnswerer(port, hookFor) {
         throw Object.assign(new Error(`this page does not answer ${ask.kind}`), {
           name: "NotSupportedError"
         });
+      const body = bodyStream(ask.id, state, post);
       const reply = await hook.handle({
         kind: ask.kind,
         options: ask.options,
-        body: bodyStream(ask.id, state, post),
+        body,
         stamp: ask.stamp,
         signal: state.abort.signal,
         progress: (line) => post({ id: ask.id, progress: String(line) })
       });
+      if (!(reply instanceof ReadableStream)) post({ id: ask.id, bodyCancel: true });
       state.reader = bytesOf(reply).getReader();
       post({ id: ask.id, ready: true });
     } catch (err) {
@@ -3562,7 +3566,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.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
@@ -6410,6 +6414,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),
@@ -6646,6 +6651,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) => {
@@ -6844,6 +6858,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);
@@ -7425,6 +7445,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"]);
@@ -7928,6 +7961,7 @@ var BodyPipe = class {
   queue = [];
   size = 0;
   ended = false;
+  dropped = false;
   wake;
   room;
   stream;
@@ -7946,7 +7980,8 @@ var BodyPipe = class {
             this.room?.();
             controller.enqueue(next3);
           } else controller.close();
-        }
+        },
+        cancel: () => this.drop()
       },
       { highWaterMark: 0 }
     );
@@ -7954,8 +7989,14 @@ var BodyPipe = class {
   get full() {
     return this.size >= EMBEDDER_WINDOW;
   }
+  drop() {
+    this.dropped = true;
+    this.queue = [];
+    this.size = 0;
+    this.end();
+  }
   push(bytes) {
-    if (bytes.length === 0) return;
+    if (bytes.length === 0 || this.dropped) return;
     this.queue.push(bytes.slice());
     this.size += bytes.length;
     this.wake?.();
@@ -7971,6 +8012,30 @@ var BodyPipe = class {
     this.room?.();
   }
 };
+function endsWith(stream2, ended) {
+  const reader = stream2.getReader();
+  return new ReadableStream(
+    {
+      pull: async (controller) => {
+        let got;
+        try {
+          got = await reader.read();
+        } catch (err) {
+          ended();
+          throw err;
+        }
+        if (!got.done) return controller.enqueue(got.value);
+        ended();
+        controller.close();
+      },
+      cancel: (reason) => {
+        ended();
+        return reader.cancel(reason);
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
 function replyStream(reply) {
   if (reply instanceof ReadableStream) return reply;
   const bytes = typeof reply === "string" ? new TextEncoder().encode(reply) : reply instanceof Uint8Array ? reply : new Uint8Array(0);
@@ -8045,7 +8110,10 @@ var EmbedderChannel = class {
         signal: this.abort.signal,
         progress
       })
-    ).then((reply) => replyStream(reply).getReader());
+    ).then((reply) => {
+      if (!(reply instanceof ReadableStream)) body.drop();
+      return endsWith(replyStream(reply), () => body.drop()).getReader();
+    });
     this.replied = asked.catch((err) => {
       body.end();
       throw this.fail(err);
@@ -9291,6 +9359,7 @@ var RELINKED = [
   ["writeFile", [0]],
   ["pread", [0]],
   ["pwrite", [0]],
+  ["append", [0]],
   ["truncate", [0]],
   ["lstat", [0]],
   ["stat", [0]],
@@ -9596,6 +9665,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);
@@ -19400,6 +19482,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;
@@ -19595,6 +19678,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();
@@ -19683,6 +19794,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();
@@ -19787,6 +19901,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;
   }
@@ -20039,12 +20156,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 {
@@ -20193,8 +20311,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 () => {
@@ -24812,6 +24930,7 @@ var OpfsFs = class {
   mounts = {};
   locks;
   lockPrefix;
+  appendPrefix;
   rootName;
   renamePrefix;
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
@@ -24820,6 +24939,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);
@@ -25713,11 +25833,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);
@@ -31684,7 +31836,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,