@ai-ecoverse/slicc-kernel 1.32.0 → 1.32.2

package/README.md

@@ -410,7 +410,7 @@ OPFS stores names, bytes, sizes and modification times, nothing else. Everything
 - mode bits (`chmod`);
 - access and change times, and a modification time set explicitly with `utime` (it holds until the file is written again);
 - inode numbers that stay stable across renames;
-- symbolic links (`symlink`, `readlink`, `lstat`, and following them in paths), which exist only in the sidecar, with their own times: `touch -h`, `lutimes` and `utimensat` with `AT_SYMLINK_NOFOLLOW` set the link's, never the target's.
+- symbolic links (`symlink`, `readlink`, `lstat`, and following them in paths), which exist only in the sidecar, with their own times: `touch -h`, `lutimes` and `utimensat` with `AT_SYMLINK_NOFOLLOW` set the link's, never the target's. A link's own mode can't be changed, as on Linux: `chmod -h`, `lchmod` and `fchmodat` with `AT_SYMLINK_NOFOLLOW` fail with `EOPNOTSUPP` (which `chmod -h` and `tar` ignore for links) and never follow it, and `open` with `O_PATH | O_NOFOLLOW` gives a descriptor for the link itself.
 
 OPFS stays authoritative: an entry is consulted only for a path that exists in OPFS (symlinks only for paths that don't), so files written straight to OPFS, for example by the BIOS installer or a page, get the defaults: directories `0755`, files `0644`, and files under `node_modules/*/bin/` `0755`. A file deleted through the OPFS API disappears at once; its leftover entry is ignored and removed when the next kernel starts. Changes go to OPFS first and then to the sidecar, so a crash in between at worst loses the metadata of that one change. Each change is a read-modify-write inside one IndexedDB transaction, so two kernels (two tabs) on the same origin don't lose each other's updates.
 

package/dist/kernel-worker.js

@@ -1152,6 +1152,10 @@ function nullFile() {
     }
   });
 }
+function written(device, bytes) {
+  if (device === "full" && bytes.length > 0) throw new KernelError("ENOSPC");
+  return bytes.length;
+}
 function deviceFile(device, access) {
   const read = async (max) => {
     if (device === "null") return new Uint8Array(0);
@@ -1165,7 +1169,7 @@ function deviceFile(device, access) {
   };
   return new OpenFile({
     ...access !== "write" ? { read } : {},
-    ...access !== "read" ? { write: async (bytes) => bytes.length } : {},
+    ...access !== "read" ? { write: async (bytes) => written(device, bytes) } : {},
     seek: async () => 0,
     heldMeta: { device, ...access ? { access } : {} },
     close: () => {
@@ -4979,6 +4983,7 @@ var ChildTable = class {
   openSlot(slot, n, captured) {
     if ("fd" in slot) return this.parentFds.get(slot.fd).retain();
     if ("input" in slot) return bytesSource(slot.input);
+    if ("device" in slot) return deviceFile(slot.device, slot.access);
     if ("capture" in slot) {
       const chunks = [];
       captured.set(n, chunks);
@@ -7210,11 +7215,11 @@ var Pages = class {
       runs.push({ offset: start, bytes });
       i = j;
     }
-    const written = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
+    const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
     return {
       ...this.shrink !== void 0 ? { shrink: this.shrink } : {},
       runs,
-      ...this.length > written ? { extend: this.length } : {}
+      ...this.length > written2 ? { extend: this.length } : {}
     };
   }
   flushed() {