@ai-ecoverse/slicc-kernel 1.41.0 → 1.41.1

package/dist/kernel-worker.js

@@ -106,15 +106,15 @@ var IndexedDbMeta = class {
   async update(path, change) {
     const [transaction, store] = this.transaction("readwrite");
     const request2 = store.get(path);
-    let next;
+    let next2;
     request2.onsuccess = () => {
-      next = change(request2.result);
-      if (next) store.put(next);
+      next2 = change(request2.result);
+      if (next2) store.put(next2);
       else store.delete(path);
     };
     await settle(transaction, () => void 0);
     this.changed({ paths: [path] });
-    this.cache.set(path, next ?? null);
+    this.cache.set(path, next2 ?? null);
   }
   async move(from, to, root) {
     const [transaction, store] = this.transaction("readwrite");
@@ -341,8 +341,8 @@ var OpfsFs = class {
   resolvePath(base, path) {
     return resolvePath(base, path);
   }
-  async walk(parts, from, start) {
-    let dir = start;
+  async walk(parts, from, start2) {
+    let dir = start2;
     for (let at = from; at < parts.length; at++) {
       dir = await dir.getDirectoryHandle(parts[at]);
       this.dirs.set(`/${parts.slice(0, at + 1).join("/")}`, dir);
@@ -428,7 +428,7 @@ var OpfsFs = class {
     }
     return void 0;
   }
-  async locate(path, follow) {
+  async locate(path, follow2) {
     let current = path;
     for (let hops = 0; hops <= MAX_LINKS; hops++) {
       try {
@@ -437,9 +437,9 @@ var OpfsFs = class {
         if (!missing(err)) throw err;
         const link2 = await this.linkAlong(current);
         if (!link2) throw err;
-        if (link2.path === current && !follow) return { path: current, link: link2 };
-        const rest = current.slice(link2.path.length);
-        current = resolvePath(parentOf2(link2.path), `${link2.link}${rest}`);
+        if (link2.path === current && !follow2) return { path: current, link: link2 };
+        const rest2 = current.slice(link2.path.length);
+        current = resolvePath(parentOf2(link2.path), `${link2.link}${rest2}`);
       }
     }
     throw fsError("ELOOP", path);
@@ -755,9 +755,9 @@ var OpfsFs = class {
     return timed;
   }
   async restamp(path, timed) {
-    for (const rest of timed) {
-      const mtimeFor = await this.modified(path + rest);
-      await this.meta.update(path + rest, (entry) => entry && { ...entry, mtimeFor });
+    for (const rest2 of timed) {
+      const mtimeFor = await this.modified(path + rest2);
+      await this.meta.update(path + rest2, (entry) => entry && { ...entry, mtimeFor });
     }
   }
   async place(handle, dir, name2) {
@@ -805,8 +805,8 @@ var OpfsFs = class {
     }));
     this.touch(parent.path);
   }
-  async realpath(path, follow) {
-    return (await this.locate(path, follow)).path;
+  async realpath(path, follow2) {
+    return (await this.locate(path, follow2)).path;
   }
   async readlink(path) {
     const found = await this.locate(path, false);
@@ -1659,8 +1659,8 @@ var KernelSocket = class _KernelSocket {
   async accept(signal, nonblock = false) {
     for (; ; ) {
       if (this.state !== "listening") throw new KernelError("EINVAL");
-      const next = this.queue.shift();
-      if (next) return next;
+      const next2 = this.queue.shift();
+      if (next2) return next2;
       if (nonblock) throw new KernelError("EAGAIN");
       await this.changes.wait(signal);
     }
@@ -1841,8 +1841,8 @@ var LoopbackNet = class {
     if (reserve) this.internal.add(port);
     return this.internal.has(port);
   }
-  activate(addr, start) {
-    this.activators.set(keyOf(addr), start);
+  activate(addr, start2) {
+    this.activators.set(keyOf(addr), start2);
   }
   socket(domain) {
     return new KernelSocket(this, domain);
@@ -2084,12 +2084,12 @@ var MessageQueue = class {
   }
   async *[Symbol.asyncIterator]() {
     for (; ; ) {
-      const next = this.items.shift();
-      if (next !== void 0) {
-        const n = payloadSize(next);
+      const next2 = this.items.shift();
+      if (next2 !== void 0) {
+        const n = payloadSize(next2);
         this.size -= n;
         this.taken?.(n);
-        yield next;
+        yield next2;
         continue;
       }
       if (this.ended) return;
@@ -2118,7 +2118,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
       ...typeof code === "string" ? { code } : {}
     });
   };
-  const start = async (call) => {
+  const start2 = async (call) => {
     const abort = new AbortController();
     const entry = { abort };
     open.set(call.nid, entry);
@@ -2197,9 +2197,9 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
     try {
       const messages = socket.messages[Symbol.asyncIterator]();
       for (; ; ) {
-        const next = await Promise.race([messages.next(), unanswered]);
-        if (next === "late" || next.done) break;
-        const data = next.value;
+        const next2 = await Promise.race([messages.next(), unanswered]);
+        if (next2 === "late" || next2.done) break;
+        const data = next2.value;
         if (flow.closing) continue;
         if (payloadSize(data) > MESSAGE_LIMIT) {
           oversize = true;
@@ -2240,12 +2240,12 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
     const body = open.get(nid)?.body;
     if (!body) return;
     try {
-      const next = await body.next();
-      if (next.done) {
+      const next2 = await body.next();
+      if (next2.done) {
         open.delete(nid);
         peer.postMessage({ net: "end", nid });
       } else {
-        const bytes = next.value.slice();
+        const bytes = next2.value.slice();
         peer.postMessage({ net: "chunk", nid, bytes }, [bytes.buffer]);
       }
     } catch (e) {
@@ -2262,7 +2262,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
   };
   return {
     answer(call) {
-      if (call.net === "fetch") void start(call);
+      if (call.net === "fetch") void start2(call);
       else if (call.net === "read") void read(call.nid);
       else if (call.net === "ws-open") void openSocket(call);
       else if (call.net === "ws-send") void sendOn(call);
@@ -2290,17 +2290,17 @@ async function realpath(fs, path) {
   let parts = fs.resolvePath("/", path).split("/").filter(Boolean);
   let resolved = "";
   for (let hops = 0; parts.length > 0; ) {
-    const [name2, ...rest] = parts;
-    const next = `${resolved}/${name2}`;
-    if (!(await fs.lstat(next)).isSymbolicLink) {
-      resolved = next;
-      parts = rest;
+    const [name2, ...rest2] = parts;
+    const next2 = `${resolved}/${name2}`;
+    if (!(await fs.lstat(next2)).isSymbolicLink) {
+      resolved = next2;
+      parts = rest2;
       continue;
     }
     if (++hops > MAX_LINKS2) throw fsError("ELOOP", path);
-    const target = await fs.readlink(next);
+    const target = await fs.readlink(next2);
     const base = target.startsWith("/") ? "/" : resolved || "/";
-    parts = [...fs.resolvePath(base, target).split("/").filter(Boolean), ...rest];
+    parts = [...fs.resolvePath(base, target).split("/").filter(Boolean), ...rest2];
     resolved = "";
   }
   return resolved || "/";
@@ -2652,10 +2652,10 @@ var Incoming = class {
       this.eof = true;
       return false;
     }
-    const next = new Uint8Array(this.buf.length + chunk2.length);
-    next.set(this.buf);
-    next.set(chunk2, this.buf.length);
-    this.buf = next;
+    const next2 = new Uint8Array(this.buf.length + chunk2.length);
+    next2.set(this.buf);
+    next2.set(chunk2, this.buf.length);
+    this.buf = next2;
     return true;
   }
   take(n) {
@@ -3629,15 +3629,15 @@ var octets = (bytes) => tlv(4, bytes);
 var bits = (bytes, unused = 0) => tlv(3, Uint8Array.of(unused), bytes);
 var TRUE = tlv(1, Uint8Array.of(255));
 function integer(magnitude) {
-  let start = 0;
-  while (start < magnitude.length - 1 && magnitude[start] === 0) start++;
-  const trimmed = magnitude.subarray(start);
+  let start2 = 0;
+  while (start2 < magnitude.length - 1 && magnitude[start2] === 0) start2++;
+  const trimmed = magnitude.subarray(start2);
   return tlv(2, trimmed[0] & 128 ? concat2([Uint8Array.of(0), trimmed]) : trimmed);
 }
 function oid(dotted) {
-  const [a, b, ...rest] = dotted.split(".").map(Number);
+  const [a, b, ...rest2] = dotted.split(".").map(Number);
   const out = [40 * a + b];
-  for (const arc of rest) {
+  for (const arc of rest2) {
     const groups = [];
     for (let v = arc; ; v = Math.floor(v / 128)) {
       groups.unshift(v & 127);
@@ -3677,19 +3677,19 @@ function children(der) {
 function header(der, at) {
   const tag = der[at];
   let len = der[at + 1];
-  let start = at + 2;
+  let start2 = at + 2;
   if (len & 128) {
     const count = len & 127;
     len = 0;
-    for (let i = 0; i < count; i++) len = len * 256 + der[start + i];
-    start += count;
+    for (let i = 0; i < count; i++) len = len * 256 + der[start2 + i];
+    start2 += count;
   }
-  if (start + len > der.length) throw new Error("truncated DER");
-  return [tag, start, start + len];
+  if (start2 + len > der.length) throw new Error("truncated DER");
+  return [tag, start2, start2 + len];
 }
 function contents(element) {
-  const [, start, end] = header(element, 0);
-  return element.subarray(start, end);
+  const [, start2, end] = header(element, 0);
+  return element.subarray(start2, end);
 }
 function publicKeyBits(spki) {
   const key = children(spki)[1];
@@ -5288,6 +5288,53 @@ function withCommandDirs(fs, names) {
   };
 }
 
+// src/fs/physical-path.ts
+var MAX_HOPS = 40;
+function start(path) {
+  return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
+}
+function next(walk) {
+  while (walk.todo.length > 0) {
+    const part = walk.todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      walk.done.pop();
+      continue;
+    }
+    return part;
+  }
+  return void 0;
+}
+function lexical(path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
+  return `/${walk.done.join("/")}`;
+}
+function rest(walk, part) {
+  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
+}
+function follow(walk, target) {
+  if (++walk.hops > MAX_HOPS) return false;
+  if (target.startsWith("/")) walk.done.length = 0;
+  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
+  return true;
+}
+async function physicalPathAsync(fs, path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) {
+    const at = `/${[...walk.done, part].join("/")}`;
+    let target;
+    try {
+      target = (await fs.lstat(at)).isSymbolicLink ? await fs.readlink(at) : void 0;
+    } catch {
+      return rest(walk, part);
+    }
+    if (target === void 0) walk.done.push(part);
+    else if (!follow(walk, target)) return lexical(path);
+  }
+  return `/${walk.done.join("/")}`;
+}
+
 // src/fs/unlinked.ts
 var UNLINKED_DIR = ".slicc-unlinked";
 function webLocks() {
@@ -5343,9 +5390,9 @@ var UnlinkedKeeper = class {
     void locks?.request(lockName(this.instance), () => new Promise(() => void 0));
   }
   serial(op) {
-    const next = this.queue.then(op);
-    this.queue = next.catch(() => void 0);
-    return next;
+    const next2 = this.queue.then(op);
+    this.queue = next2.catch(() => void 0);
+    return next2;
   }
   wrap(fs = this.fs) {
     const keeper = this;
@@ -5642,10 +5689,10 @@ var ChildTable = class {
     }
     return this.track(req, fds, captured, this.spawner);
   }
-  async track(req, fds, captured, start) {
+  async track(req, fds, captured, start2) {
     let handle;
     try {
-      handle = await start(req, fds);
+      handle = await start2(req, fds);
     } catch (e) {
       await fds.closeAll();
       throw e;
@@ -6644,9 +6691,9 @@ var MountFs = class {
     this.table.forget(found.mount, normalizePath(path));
     await found.mount.conn.call({ op: "symlink", target, path: found.rel });
   }
-  async realpath(path, follow) {
+  async realpath(path, follow2) {
     if (this.at(path) || !this.base.realpath) throw errnoError("ENOSYS", path);
-    const real = await this.base.realpath(path, follow);
+    const real = await this.base.realpath(path, follow2);
     if (this.at(real)) throw errnoError("ENOSYS", path);
     return real;
   }
@@ -7210,9 +7257,9 @@ var HttpHandles = class {
     return this.close(req.handle);
   }
   traits() {
-    const { unavailable, crossOrigin = "any", ...rest } = this.transport.traits;
+    const { unavailable, crossOrigin = "any", ...rest2 } = this.transport.traits;
     if (unavailable) return { ok: false, errno: "ENETUNREACH", message: NO_TRANSPORT };
-    return { ok: true, kind: "json", json: { ...rest, crossOrigin } };
+    return { ok: true, kind: "json", json: { ...rest2, crossOrigin } };
   }
   add(abort, body, cancel) {
     const handle = ++this.nextHandle;
@@ -7274,9 +7321,9 @@ var HttpHandles = class {
   async take(entry, max) {
     if (entry.left.length === 0 && !entry.done) {
       try {
-        const next = await entry.body.next();
-        if (next.done) entry.done = true;
-        else entry.left = next.value;
+        const next2 = await entry.body.next();
+        if (next2.done) entry.done = true;
+        else entry.left = next2.value;
       } catch (e) {
         entry.done = true;
         const timedOut = e?.code === "ETIMEDOUT";
@@ -7638,12 +7685,12 @@ var KernelTty = class {
     const chunks = [];
     let n = 0;
     while (this.readable.length > 0 && n < max) {
-      const next = this.readable[0];
-      if (next === null || next === void 0) break;
-      const take = next.subarray(0, max - n);
+      const next2 = this.readable[0];
+      if (next2 === null || next2 === void 0) break;
+      const take = next2.subarray(0, max - n);
       chunks.push(take);
       n += take.length;
-      if (take.length < next.length) this.readable[0] = next.subarray(take.length);
+      if (take.length < next2.length) this.readable[0] = next2.subarray(take.length);
       else this.readable.shift();
       if (this.canonical) break;
     }
@@ -7740,11 +7787,11 @@ var PtyPair = class {
     const chunks = [];
     let n = 0;
     while (this.queue.length > 0 && n < max - status) {
-      const next = this.queue[0];
-      const take = next.subarray(0, max - status - n);
+      const next2 = this.queue[0];
+      const take = next2.subarray(0, max - status - n);
       chunks.push(take);
       n += take.length;
-      if (take.length < next.length) this.queue[0] = next.subarray(take.length);
+      if (take.length < next2.length) this.queue[0] = next2.subarray(take.length);
       else this.queue.shift();
     }
     const out = new Uint8Array(status + n);
@@ -8050,7 +8097,7 @@ var Pages = class {
     }
     const last = runs[runs.length - 1];
     if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
-    return runs.map(([start, n]) => [start, Math.min(n, this.stored - start)]);
+    return runs.map(([start2, n]) => [start2, Math.min(n, this.stored - start2)]);
   }
   partial(at, length2) {
     if (length2 === 0) return [];
@@ -8058,16 +8105,16 @@ var Pages = class {
     const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length2 - 1) / PAGE)]);
     const runs = [];
     for (const page of edges) {
-      const start = page * PAGE;
-      const covered = at <= start && at + length2 >= start + PAGE;
-      if (covered || this.pages.has(page) || start >= this.stored) continue;
-      runs.push([start, Math.min(PAGE, this.stored - start)]);
+      const start2 = page * PAGE;
+      const covered = at <= start2 && at + length2 >= start2 + PAGE;
+      if (covered || this.pages.has(page) || start2 >= this.stored) continue;
+      runs.push([start2, Math.min(PAGE, this.stored - start2)]);
     }
     return runs;
   }
-  fill(start, bytes) {
+  fill(start2, bytes) {
     for (let at = 0; at < bytes.length; at += PAGE) {
-      const page = (start + at) / PAGE;
+      const page = (start2 + at) / PAGE;
       if (this.pages.has(page)) continue;
       const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
       const fresh = this.take(part.length);
@@ -8133,14 +8180,14 @@ var Pages = class {
       while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
         j++;
       }
-      const start = first * PAGE;
+      const start2 = first * PAGE;
       const end = Math.min(this.length, (first + (j - i)) * PAGE);
-      const bytes = new Uint8Array(end - start);
+      const bytes = new Uint8Array(end - start2);
       for (let k = i; k < j; k++) {
         const page = this.pages.get(sorted[k]);
-        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start)), (k - i) * PAGE);
+        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start2)), (k - i) * PAGE);
       }
-      runs.push({ offset: start, bytes });
+      runs.push({ offset: start2, bytes });
       i = j;
     }
     const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
@@ -8207,8 +8254,8 @@ var AsyncRangedFile = class {
     return this.pages.length;
   }
   async fetch(runs) {
-    for (const [start, n] of runs) {
-      this.pages.fill(start, await this.io.pread(this.path, start, n, this.version));
+    for (const [start2, n] of runs) {
+      this.pages.fill(start2, await this.io.pread(this.path, start2, n, this.version));
     }
   }
   async read(at, length2) {
@@ -8283,9 +8330,9 @@ var VfsNode = class {
     if (dirty && contents2 !== void 0) this.markDirty();
   }
   serial(op) {
-    const next = this.queue.then(op);
-    this.queue = next.catch(() => void 0);
-    return next;
+    const next2 = this.queue.then(op);
+    this.queue = next2.catch(() => void 0);
+    return next2;
   }
   revoke() {
     this.revoked = true;
@@ -8467,10 +8514,10 @@ var VfsNodes = class {
   targetKey(path) {
     return this.real(path, true, () => realTarget(this.fs, path));
   }
-  async real(path, follow, walk) {
+  async real(path, follow2, walk) {
     if (this.fs.realpath) {
       try {
-        return await this.fs.realpath(path, follow);
+        return await this.fs.realpath(path, follow2);
       } catch (err) {
         if (errCode(err) === "ELOOP") throw err;
       }
@@ -8598,8 +8645,8 @@ var VfsNodes = class {
     }
   }
 };
-async function present(fs, path, follow = false) {
-  const look = (follow ? void 0 : fs.lstat) ?? fs.stat;
+async function present(fs, path, follow2 = false) {
+  const look = (follow2 ? void 0 : fs.lstat) ?? fs.stat;
   try {
     await (look ? look.call(fs, path) : fs.readFileBuffer(path));
     return true;
@@ -8625,10 +8672,10 @@ async function realDir(fs, dir, budget = { hops: 0 }) {
       at = parentOf6(at);
       continue;
     }
-    const next = at === "/" ? `/${part}` : `${at}/${part}`;
-    const link2 = await linkOf(fs, next);
+    const next2 = at === "/" ? `/${part}` : `${at}/${part}`;
+    const link2 = await linkOf(fs, next2);
     if (link2 === void 0) {
-      at = next;
+      at = next2;
       continue;
     }
     if (budget.hops >= MAX_LINKS5) throw fsError("ELOOP", dir);
@@ -10880,9 +10927,9 @@ function tmpfs() {
     let node = root;
     for (const name2 of parts(path)) {
       if (node.kind !== "directory") throw fsError2("ENOTDIR", path);
-      const next = node.children.get(name2);
-      if (!next) throw fsError2("ENOENT", path);
-      node = next;
+      const next2 = node.children.get(name2);
+      if (!next2) throw fsError2("ENOENT", path);
+      node = next2;
     }
     return node;
   }
@@ -11446,8 +11493,8 @@ var Launcher = class {
     const words = shebang(head) ?? (binfmt ? [binfmt] : void 0);
     if (!words) return void 0;
     if (baseName(words[0]) === "env") words.shift();
-    const [interp, ...rest] = words;
-    const arg = rest.join(" ");
+    const [interp, ...rest2] = words;
+    const arg = rest2.join(" ");
     const passed = [...arg ? [arg] : [], command ? script : file, ...argv.slice(1)];
     const found = interp ? await this.resolve(interp, interp, cwd) : void 0;
     if (!found) {
@@ -11528,7 +11575,8 @@ var Launcher = class {
   }
   async launch(planned, req) {
     const { target, args } = planned;
-    const seen = { ...req.env, HOSTNAME: this.hostname, cwd: req.cwd };
+    const cwd = await physicalPathAsync(this.base, req.cwd);
+    const seen = { ...req.env, HOSTNAME: this.hostname, cwd };
     const env = { ...expandDefaults(target.env, seen), ...req.env };
     for (const key of target.unset ?? []) delete env[key];
     env.HOSTNAME = this.hostname;
@@ -11539,7 +11587,7 @@ var Launcher = class {
       await req.fds.closeAll();
       throw err;
     }
-    return this.start({ ...req, program, argv0: target.argv0, args, env });
+    return this.start({ ...req, cwd, program, argv0: target.argv0, args, env });
   }
   groupSession(pgid) {
     return this.jobs.sessionOf(pgid);
@@ -11946,7 +11994,8 @@ var Launcher = class {
   async starting(argv, dir) {
     this.catalog = void 0;
     this.binfmts = void 0;
-    const cwd = this.fs.resolvePath("/", dir ?? "/");
+    const start2 = dir ?? "/";
+    const cwd = await physicalPathAsync(this.base, start2.startsWith("/") ? start2 : `/${start2}`);
     const [file = ""] = argv;
     await this.base.mkdir(cwd, { recursive: true });
     return { cwd, file, planned: await this.plan(file, argv, cwd) };