@ai-ecoverse/slicc-kernel 1.133.2 → 1.133.4

package/dist/node.js

@@ -4161,6 +4161,7 @@ var RemoteWatch = class {
   settled = false;
   quiet;
   crowd;
+  gone;
   told;
   counted = 0;
   recount() {
@@ -4250,6 +4251,7 @@ var RemoteWatch = class {
       this.peers.delete(peer);
       this.rebuild();
       this.recount();
+      this.gone?.();
       for (const wait2 of this.waiting.values()) {
         if (wait2.left.delete(peer) && wait2.left.size === 0) wait2.done();
       }
@@ -4285,14 +4287,16 @@ var RemoteWatch = class {
   async prune() {
     if (!this.locks) return;
     const held = new Set(((await this.locks.query()).held ?? []).map((lock) => lock.name));
+    let left = false;
     for (const tab of /* @__PURE__ */ new Set([...this.others.keys(), ...this.peers])) {
       if (!held.has(this.lockOf(tab))) {
+        if (this.peers.delete(tab)) left = true;
         this.others.delete(tab);
-        this.peers.delete(tab);
       }
     }
     this.rebuild();
     this.recount();
+    if (left) this.gone?.();
   }
   watched() {
     return this.union.size > 0;
@@ -4382,6 +4386,7 @@ var REPLACED_ATTEMPTS = 4;
 var RECONCILE_LISTINGS = 8;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
 var RENAMES = "/.slicc-renames";
+var RENAME_LOCK = "slicc-rename:";
 function movable(handle) {
   return typeof handle.move === "function";
 }
@@ -4544,8 +4549,11 @@ var OpfsFs = class {
     this.lockPrefix = `slicc-excl:${channel ?? ""}:`;
     this.rootName = channel;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
-    this.remote = channel === void 0 ? void 0 : new RemoteWatch(`${channel}:watch`);
-    if (this.remote) this.remote.quiet = () => this.quiet().then(() => this.settle?.());
+    this.remote = channel === void 0 ? void 0 : new RemoteWatch(`${channel}:watch`, { locks: this.locks ?? null });
+    if (this.remote) {
+      this.remote.quiet = () => this.quiet().then(() => this.settle?.());
+      this.remote.gone = () => void this.orphans();
+    }
     if (this.channel) {
       const remote = this.remote;
       meta.listen?.((c) => {
@@ -5618,14 +5626,17 @@ var OpfsFs = class {
     const dir = parent.handle;
     const name2 = baseOf(destination);
     const swap = targetStat?.isDirectory === true;
+    let lock;
     const staging = swap ? `.${name2}.${crypto.randomUUID()}` : name2;
     const copying = sourceStat.isDirectory && !movable(source.handle);
     const staged = resolvePath(parent.path, staging);
     const place = async () => {
       this.forget(destination);
       const timed2 = await this.explicitTimes(source.path);
-      const first = copying ? await this.intend({ from: source.path, to: staged }) : void 0;
-      const second = copying && swap ? await this.intend({ from: staged, to: destination, replace: true }) : void 0;
+      const root = { ino: inodeOf(source.path), ...moving };
+      const owned4 = lock ? { lock } : {};
+      const first = copying ? await this.intend({ from: source.path, to: staged, root, ...owned4 }) : void 0;
+      const second = copying && swap ? await this.intend({ from: staged, to: destination, replace: true, root, ...owned4 }) : void 0;
       const moved2 = await this.replacingTarget(
         targetStat !== null,
         () => this.place(source.handle, dir, staging)
@@ -5634,7 +5645,7 @@ var OpfsFs = class {
         throw err;
       });
       if (swap) await this.rm(destination, { recursive: true });
-      if (second) await this.intend({ from: staged, to: destination }, second);
+      if (second) await this.intend({ from: staged, to: destination, root, ...owned4 }, second);
       await this.meta.move(source.path, destination, carry, left);
       this.movePending(source.path, destination);
       if (!moved2) {
@@ -5659,7 +5670,11 @@ var OpfsFs = class {
     const entry = { from: source.path, to: destination, done: promise };
     this.renamingDirs.add(entry);
     try {
-      await place();
+      const locks = this.locks;
+      if (locks) {
+        lock = `${RENAME_LOCK}${crypto.randomUUID()}`;
+        await locks.request(lock, place);
+      } else await place();
     } finally {
       this.renamingDirs.delete(entry);
       resolve2();
@@ -5691,12 +5706,40 @@ var OpfsFs = class {
     } catch {
     }
   }
-  async finishRenames() {
-    const intents = (await this.meta.under(RENAMES)).filter((entry) => entry.rename !== void 0).sort(
+  replaying = Promise.resolve();
+  orphans() {
+    this.replaying = this.replaying.then(() => this.finishRenames(true)).catch(() => 0);
+    return this.replaying;
+  }
+  async finishRenames(orphaned = false) {
+    const locks = this.locks;
+    const held = /* @__PURE__ */ new Set();
+    if (orphaned && locks) {
+      const { held: h = [], pending = [] } = await locks.query();
+      for (const lock of [...h, ...pending]) held.add(lock.name);
+    }
+    const intents = (await this.meta.under(RENAMES)).filter(
+      (entry) => entry.rename !== void 0 && (!orphaned || locks !== void 0 && entry.rename.lock !== void 0 && !held.has(entry.rename.lock))
+    ).sort(
       (a, b) => a.rename.at - b.rename.at
     );
     for (const entry of intents) {
-      const { from, to, replace } = entry.rename;
+      const lock = entry.rename.lock;
+      if (!orphaned || !locks || !lock) await this.finishRename(entry);
+      else await locks.request(lock, () => this.finishRename(entry));
+    }
+    return intents.length;
+  }
+  async finishRename(entry) {
+    const [current] = await this.meta.under(entry.path);
+    if (current?.rename === void 0) return;
+    const { from, to, replace, root } = current.rename;
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    const barrier = { from, to, done: promise };
+    this.renamingDirs.add(barrier);
+    this.forget(from);
+    this.forget(to);
+    try {
       const left = await this.real(from);
       if (left && replace && await this.real(to)) await this.rm(to, { recursive: true });
       if (left) {
@@ -5713,11 +5756,23 @@ var OpfsFs = class {
         this.forget(to);
       }
       if ((await this.meta.under(from)).length > 0) {
-        await this.meta.move(from, to, (moved2) => ({ ...occupied(moved2), path: to }));
+        await this.meta.move(
+          from,
+          to,
+          (moved2) => ({
+            ...occupied(moved2),
+            ...root,
+            ino: occupied(moved2).ino ?? root?.ino ?? inodeOf(from),
+            path: to
+          }),
+          void 0
+        );
       }
       await this.meta.update(entry.path, () => void 0);
+    } finally {
+      this.renamingDirs.delete(barrier);
+      resolve2();
     }
-    return intents.length;
   }
   async settledRename(path) {
     if (this.renamingDirs.size === 0 && this.copying.size === 0 || typeof path !== "string")
@@ -6001,7 +6056,10 @@ var OpfsFs = class {
     };
   }
   async reconcile() {
-    if (this.remote && await this.remote.peered()) return 0;
+    if (this.remote && await this.remote.peered()) {
+      await this.orphans();
+      return 0;
+    }
     await this.finishRenames();
     let removed = 0;
     const entries = await this.meta.all();
@@ -7403,7 +7461,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.133.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.133.4" : "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
@@ -19342,10 +19400,32 @@ var KEY_ERRORS = [
   [-15232, "ERR_OSSL_BAD_DECRYPT"],
   [-15360, "ERR_OSSL_CRYPTO_INTERRUPTED_OR_CANCELLED"]
 ];
-function keyRefused(err) {
-  const code = err instanceof TlsError ? err.code : 0;
+var PBE_OIDS = [
+  [42, 134, 72, 134, 247, 13, 1, 5],
+  [42, 134, 72, 134, 247, 13, 1, 12, 1]
+];
+function hasBytes(hay, needle) {
+  for (let i = 0; i + needle.length <= hay.length; i++) {
+    if (needle.every((b, j) => hay[i + j] === b)) return true;
+  }
+  return false;
+}
+function encryptedKey(key) {
+  if (key[0] === 48) return PBE_OIDS.some((oid2) => hasBytes(key, oid2));
+  return new TextDecoder().decode(key).includes("ENCRYPTED");
+}
+var KEY_PARSE_RANGES = [
+  [-16383, -14336],
+  [-5375, -4096],
+  [-28671, -24576],
+  [-127, -96]
+];
+var keyParse = (code) => code !== -15360 && KEY_PARSE_RANGES.some(([lo, hi]) => code >= lo && code <= hi);
+function keyRefused(err, locked) {
+  const raw2 = err instanceof TlsError ? err.code : 0;
+  const code = locked && keyParse(raw2) ? -15232 : raw2;
   const name2 = KEY_ERRORS.find(([n]) => n === code)?.[1] ?? "ERR_OSSL_UNSUPPORTED";
-  const text = code === -3 ? "the key does not match the certificate" : err.message;
+  const text = code === -3 ? "the key does not match the certificate" : code === raw2 ? err.message : "bad decrypt";
   return new KernelError("EPROTO", `${name2}: ${text}`);
 }
 function takeCert(req) {
@@ -19376,7 +19456,7 @@ function withCert(session, cert) {
   try {
     session.ownCert(cert.chain, cert.key, cert.pass);
   } catch (err) {
-    throw keyRefused(err);
+    throw keyRefused(err, cert.pass.length > 0 && encryptedKey(cert.key));
   }
 }
 function wipe(cert) {