@ai-ecoverse/slicc-kernel 1.125.12 → 1.126.1

package/dist/node.js

@@ -4361,6 +4361,10 @@ var STALE = /* @__PURE__ */ new Set(["NotFoundError", "TypeMismatchError"]);
 var REPLACED_ATTEMPTS = 4;
 var RECONCILE_LISTINGS = 8;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
+var RENAMES = "/.slicc-renames";
+function movable(handle) {
+  return typeof handle.move === "function";
+}
 var ERRNO_BY_DOM_ERROR = {
   NotFoundError: "ENOENT",
   TypeMismatchError: "ENOTDIR",
@@ -5530,9 +5534,9 @@ var OpfsFs = class {
     }
     const now = Date.now();
     const moving = await this.movedOwner(source);
-    const carry = (entry) => ({
+    const carry = (entry2) => ({
       ino: inodeOf(source.path),
-      ...occupied(entry),
+      ...occupied(entry2),
       ...moving,
       path: destination,
       ctimeMs: now
@@ -5548,29 +5552,127 @@ var OpfsFs = class {
     const name2 = baseOf(destination);
     const swap = targetStat?.isDirectory === true;
     const staging = swap ? `.${name2}.${crypto.randomUUID()}` : name2;
-    this.forget(destination);
-    const timed2 = await this.explicitTimes(source.path);
-    const moved2 = await this.replacingTarget(
-      targetStat !== null,
-      () => this.place(source.handle, dir, staging)
+    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 moved2 = await this.replacingTarget(
+        targetStat !== null,
+        () => this.place(source.handle, dir, staging)
+      ).catch(async (err) => {
+        if (first) await this.rollBack(staged, source.path, [first, second]);
+        throw err;
+      });
+      if (swap) await this.rm(destination, { recursive: true });
+      if (second) await this.intend({ from: staged, to: destination }, second);
+      await this.meta.move(source.path, destination, carry, left);
+      this.movePending(source.path, destination);
+      if (!moved2) {
+        await this.rm(source.path, { recursive: true });
+        await this.meta.update(source.path, () => left);
+      }
+      if (first) await this.meta.update(first, () => void 0);
+      let copied = !moved2;
+      if (swap) {
+        const hidden = await dir.getDirectoryHandle(staging);
+        const placed = await this.place(hidden, dir, name2);
+        if (!placed) await dir.removeEntry(staging, { recursive: true });
+        copied ||= !placed;
+      }
+      if (second) await this.meta.update(second, () => void 0);
+      if (copied) await this.restamp(destination, timed2);
+      this.changed(source.path, destination);
+      this.touch(Date.now(), parentOf4(source.path), parent.path);
+    };
+    if (!copying) return place();
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    const entry = { from: source.path, to: destination, done: promise };
+    this.renamingDirs.add(entry);
+    try {
+      await place();
+    } finally {
+      this.renamingDirs.delete(entry);
+      resolve2();
+    }
+  }
+  renamingDirs = /* @__PURE__ */ new Set();
+  intents = 0;
+  async intend(rename, at = `${RENAMES}/${crypto.randomUUID()}`) {
+    const record = { ...rename, at: Date.now() * 1e3 + this.intents++ % 1e3 };
+    await this.meta.update(at, () => ({ path: at, rename: record }));
+    return at;
+  }
+  async rollBack(from, to, intents) {
+    try {
+      if (await this.real(from)) {
+        const moved2 = await this.locate(from, false);
+        const back = await this.locate(parentOf4(to), true);
+        await this.copy(
+          moved2.handle,
+          back.handle,
+          baseOf(to)
+        );
+        const [dir, name2] = await this.parent(from);
+        await this.inDir(dir, (parent) => parent.removeEntry(name2, { recursive: true }));
+      }
+      this.forget(from);
+      this.forget(to);
+      for (const intent of intents) if (intent) await this.meta.update(intent, () => void 0);
+    } catch {
+    }
+  }
+  async finishRenames() {
+    const intents = (await this.meta.under(RENAMES)).filter((entry) => entry.rename !== void 0).sort(
+      (a, b) => a.rename.at - b.rename.at
     );
-    if (swap) await this.rm(destination, { recursive: true });
-    await this.meta.move(source.path, destination, carry, left);
-    this.movePending(source.path, destination);
-    if (!moved2) {
-      await this.rm(source.path, { recursive: true });
-      await this.meta.update(source.path, () => left);
-    }
-    let copied = !moved2;
-    if (swap) {
-      const staged = await dir.getDirectoryHandle(staging);
-      const placed = await this.place(staged, dir, name2);
-      if (!placed) await dir.removeEntry(staging, { recursive: true });
-      copied ||= !placed;
-    }
-    if (copied) await this.restamp(destination, timed2);
-    this.changed(source.path, destination);
-    this.touch(Date.now(), parentOf4(source.path), parent.path);
+    for (const entry of intents) {
+      const { from, to, replace } = entry.rename;
+      const left = await this.real(from);
+      if (left && replace && await this.real(to)) await this.rm(to, { recursive: true });
+      if (left) {
+        const source = await this.locate(from, false);
+        const target = await this.locate(parentOf4(to), true);
+        await this.copy(
+          source.handle,
+          target.handle,
+          baseOf(to)
+        );
+        const [dir, name2] = await this.parent(from);
+        await this.inDir(dir, (parent) => parent.removeEntry(name2, { recursive: true }));
+        this.forget(from);
+        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.update(entry.path, () => void 0);
+    }
+    return intents.length;
+  }
+  async settledRename(path) {
+    if (this.renamingDirs.size === 0 || typeof path !== "string") return;
+    const at = normalizePath(path);
+    for (let real; ; ) {
+      const busy = this.renameAt(at) ?? (real === void 0 ? void 0 : this.renameAt(real));
+      if (busy) {
+        await busy.done;
+        continue;
+      }
+      if (real !== void 0 || at === "/") return;
+      const parent = await this.realpath(parentOf4(at), true).catch(() => parentOf4(at));
+      real = resolvePath(parent, baseOf(at));
+      if (real === at) return;
+    }
+  }
+  renameAt(at) {
+    for (const m of this.renamingDirs) {
+      if (within3(at, m.from) || within3(at, m.to) || at === parentOf4(m.from) || at === parentOf4(m.to))
+        return m;
+    }
+    return void 0;
   }
   async replacingTarget(replaces, op) {
     if (!replaces) return op();
@@ -5612,15 +5714,29 @@ var OpfsFs = class {
       () => false
     );
     if (moved2) return true;
+    const before = this.fileMoves;
     try {
       await this.copy(handle, dir, name2);
     } catch (err) {
-      if (handle.kind === "directory") await dir.removeEntry(name2, { recursive: true });
+      if (handle.kind === "directory" && this.fileMoves === before) {
+        await dir.removeEntry(name2, { recursive: true });
+      }
       throw translate(err, name2);
     }
     return false;
   }
+  fileMoves = 0;
   async copy(handle, dir, name2) {
+    if (handle.kind === "file" && movable(handle)) {
+      const moved2 = await handle.move?.(dir, name2).then(
+        () => true,
+        () => false
+      );
+      if (moved2) {
+        this.fileMoves++;
+        return;
+      }
+    }
     if (handle.kind === "file") {
       const writable2 = await (await dir.getFileHandle(name2, { create: true })).createWritable();
       await writable2.write(await handle.getFile());
@@ -5757,6 +5873,7 @@ var OpfsFs = class {
   }
   async reconcile() {
     if (this.remote && await this.remote.peered()) return 0;
+    await this.finishRenames();
     let removed = 0;
     const entries = await this.meta.all();
     const carried = new Set(entries.filter((e) => !e.vacated).map((e) => e.ino));
@@ -5787,7 +5904,9 @@ var READS = [
   "readdir",
   "readdirStat",
   "readlink",
-  "realpath"
+  "realpath",
+  "version",
+  "readVersioned"
 ];
 var WRITES = [
   "writeFile",
@@ -5813,6 +5932,7 @@ for (const [names2, op] of [
     const inner = proto[name2];
     proto[name2] = async function(...args) {
       try {
+        if (op === "read") await this.settledRename(args[0]);
         return await inner.apply(this, args);
       } catch (err) {
         throw translate(err, String(args[0]), op, false);
@@ -7153,7 +7273,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.125.12" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.126.1" : "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
@@ -8426,10 +8546,10 @@ function tunnelRequestUrl(req, origin) {
     throw new HttpError(400, "malformed request target");
   }
   const hosts = fieldValues(req.headers, "host");
-  const hostOk = hosts.every(
+  const hostOk2 = hosts.every(
     (h) => URL.canParse(`https://${h}`) && new URL(`https://${h}`).host === base.host
   );
-  if (url.origin !== base.origin || !hostOk) {
+  if (url.origin !== base.origin || !hostOk2) {
     throw new HttpError(421, `this tunnel is for ${base.host}`);
   }
   return url.href;
@@ -17599,6 +17719,10 @@ function controlsOf(o, session, protocol, chain2, shape) {
     ...o.insecure ? insecureOf(session, chain2, shape) : { hostnameMatches: checked || !session.nameMismatch }
   };
 }
+function verdictOf(o, session) {
+  if (o.bundled !== true || isIP(o.servername) || session.verifyResult !== 0) return false;
+  return o.checkHostname !== false || !session.nameMismatch;
+}
 async function infoOf(o, session) {
   const flags2 = session.verifyResult;
   const code = verifyCode(flags2);
@@ -17611,7 +17735,9 @@ async function infoOf(o, session) {
     authorized: code === void 0,
     ...code ? { authorizationError: code, authorizationText: o.engine.verifyInfo(flags2).trim() } : {},
     peerCertificates: chain2,
-    ...controlsOf(o, session, protocol, chain2, shape)
+    ...controlsOf(o, session, protocol, chain2, shape),
+    verified: verdictOf(o, session),
+    handshakeAt: Date.now()
   };
 }
 var FATAL_ALERT = -30592;
@@ -17729,6 +17855,7 @@ function sessionOf(info, servername) {
   return {
     path: "kernel",
     substitutes: false,
+    verified: info.verified,
     protocol: info.protocol,
     alpnProtocol: info.alpnProtocol,
     authorized: info.authorized,
@@ -17842,7 +17969,8 @@ async function prepareWith(support, req, servername, cert) {
     insecure: req.insecure === true,
     ...req.sni === false ? { sni: false } : {},
     ...req.checkHostname === false ? { checkHostname: false } : {},
-    clientCertificate: cert !== void 0
+    clientCertificate: cert !== void 0,
+    bundled: own === void 0
   };
   let session;
   try {
@@ -22582,6 +22710,79 @@ function scrubStdio(fds, scrubber) {
   }
 }
 
+// src/kernel/sealed-session.ts
+var SESSION_WINDOW_MS = 6e4;
+var SESSION_PLACEHOLDERS = 16;
+var SESSION_PLACEHOLDER = /^fnox_proxy_[0-9a-f]{24}$/;
+var SESSION_ID = /^[A-Za-z0-9_-]{16,128}$/;
+var TOKEN5 = "[!#$%&'*+.^_`|~0-9a-z-]+";
+var HEADER = new RegExp(`^header:${TOKEN5}$`);
+var METHOD = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var TARGET = /^[\x21-\x7e]+$/;
+var EXIT = /^(page|proxy|tailscale|device:[\x21-\x7e]+)$/;
+var HOST = /^[a-z0-9.:-]+$/;
+var UNSAFE = /[\r\n\0]/;
+var POSITIONS = {
+  http1: (position) => HEADER.test(position),
+  smtp: (position) => position === "auth-plain" || position === "auth-login",
+  pg: (position) => position === "password-cleartext"
+};
+function boundHost(servername) {
+  const lower = servername.toLowerCase();
+  return lower.endsWith(".") ? lower.slice(0, -1) : lower;
+}
+function headOk(f) {
+  if (f.protocol !== "http1") return f.head === void 0;
+  const head = f.head;
+  return head !== void 0 && typeof head.method === "string" && METHOD.test(head.method) && typeof head.path === "string" && TARGET.test(head.path);
+}
+function placeholdersOk(list) {
+  if (!Array.isArray(list) || list.length === 0 || list.length > SESSION_PLACEHOLDERS) return false;
+  return new Set(list).size === list.length && list.every((p) => typeof p === "string" && SESSION_PLACEHOLDER.test(p));
+}
+function hostOk(host) {
+  return typeof host === "string" && HOST.test(host) && boundHost(host) === host;
+}
+function sessionAskable(f, now) {
+  if (!Object.hasOwn(POSITIONS, f.protocol) || typeof f.position !== "string") return false;
+  if (!POSITIONS[f.protocol](f.position)) return false;
+  if (typeof f.session !== "string" || !SESSION_ID.test(f.session)) return false;
+  if (f.verified !== true || !hostOk(f.host) || typeof f.handshakeAt !== "number") return false;
+  if (!Number.isInteger(f.port) || f.port < 1 || f.port > 65535) return false;
+  const age = now - f.handshakeAt;
+  if (!Number.isFinite(age) || age < 0 || age > SESSION_WINDOW_MS) return false;
+  return typeof f.exit === "string" && EXIT.test(f.exit) && placeholdersOk(f.placeholders) && headOk(f);
+}
+function sessionRequest(f) {
+  return {
+    v: 1,
+    op: "sessionMaterialize",
+    caller: f.stamp,
+    stamp: f.stamp,
+    session: f.session,
+    host: f.host,
+    port: f.port,
+    protocol: f.protocol,
+    position: f.position,
+    verified: true,
+    handshakeAt: f.handshakeAt,
+    exit: f.exit,
+    placeholders: [...f.placeholders],
+    ...f.head ? { head: { method: f.head.method, path: f.head.path } } : {}
+  };
+}
+function sessionValues(reply, asked) {
+  if (typeof reply !== "object" || reply === null || Array.isArray(reply)) return void 0;
+  const { error, values } = reply;
+  if (error !== void 0 || typeof values !== "object" || values === null) return void 0;
+  const out = {};
+  for (const ph of asked) {
+    const value2 = values[ph];
+    if (typeof value2 === "string" && value2.length > 0 && !UNSAFE.test(value2)) out[ph] = value2;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+
 // src/kernel/sealed.ts
 var SEALED_MAX_BYTES = 64 * 1024;
 var SEALED_TIMEOUT_MS = 1e4;
@@ -22776,6 +22977,15 @@ var SealedBroker = class {
     };
   }
   async consume(fields) {
+    const req = { ...fields, v: 1, op: "materializeConsume", caller: fields.stamp };
+    return this.ask(req, swapOf);
+  }
+  async sessionMaterialize(fields, now = Date.now()) {
+    if (!sessionAskable(fields, now)) return void 0;
+    const req = sessionRequest(fields);
+    return this.ask(req, (reply) => sessionValues(reply, req.placeholders));
+  }
+  async ask(req, parse) {
     const { hook } = this;
     if (!hook) return void 0;
     const control = new AbortController();
@@ -22783,14 +22993,8 @@ var SealedBroker = class {
     const stopped = new Promise((resolve2) => {
       control.signal.addEventListener("abort", () => resolve2(void 0), { once: true });
     });
-    const req = {
-      ...fields,
-      v: 1,
-      op: "materializeConsume",
-      caller: fields.stamp
-    };
     try {
-      const asked = Promise.resolve().then(() => hook(req, { signal: control.signal })).then(swapOf, () => void 0);
+      const asked = Promise.resolve().then(() => hook(req, { signal: control.signal })).then(parse, () => void 0);
       return await Promise.race([asked, stopped]);
     } finally {
       clearTimeout(timer);