@ai-ecoverse/slicc-kernel 1.8.1 → 1.8.3

package/README.md

@@ -208,6 +208,8 @@ Unit tests live in `test/unit/`, which stays out of git. They run real wasm bash
 
 The Biome, TypeScript, lefthook, Renovate and CI configuration comes from [slicc-shared-web](https://github.com/ai-ecoverse/slicc-shared-web), which also provides the `slicc-lint-comments` (no comments anywhere), `slicc-no-unit-tests` (no unit tests in git) and `slicc-diff-cover` (100% coverage of changed lines) commands that `npm run lint` and the pre-commit hook use.
 
+Releases are cut by semantic-release on every push to `main`. A failure after the version is tagged (a rejected push, a failed `npm publish`) doesn't strand that version: `tools/release-recover.mjs` runs next. For any version tagged at HEAD, it first pushes the tag if origin lacks it, then publishes the version if npm lacks it, with retries, and creates its GitHub release if that is missing too. Re-running the Release workflow completes such a version the same way.
+
 ## License
 
 Apache-2.0

package/dist/node-process-worker.js

@@ -1703,6 +1703,61 @@ function syncFsync(imports, fs) {
     };
   }
 }
+function offsetOf(rest) {
+  const at = rest.length >= 3 ? Number(rest[1]) * 2 ** 32 + (Number(rest[0]) >>> 0) : Number(BigInt.asIntN(64, BigInt(rest[0])));
+  return at >= 0 && Number.isSafeInteger(at) ? at : void 0;
+}
+function readInto(sys, kfd, target, at) {
+  let done = 0;
+  while (done < target.length) {
+    const got = sys.pread?.(kfd, target.length - done, at + done) ?? new Uint8Array(0);
+    if (got.length === 0) break;
+    target.set(got, done);
+    done += got.length;
+  }
+  return done;
+}
+function positioned(original, write, deps) {
+  return (fd, iov, iovcnt, ...rest) => {
+    const stream = deps.fs()?.getStream(Number(fd));
+    const memory = deps.memory();
+    const kfd = stream?.sliccKernelFile ? stream.sliccKernelFd : void 0;
+    if (kfd === void 0 || !memory || !(write ? deps.sys.pwrite : deps.sys.pread)) {
+      return original(fd, iov, iovcnt, ...rest);
+    }
+    const at = offsetOf(rest);
+    if (at === void 0) return wasiErrno("EINVAL");
+    const view = new DataView(memory.buffer);
+    let done = 0;
+    try {
+      for (let i = 0; i < Number(iovcnt); i++) {
+        const ptr = view.getUint32(Number(iov) + i * 8, true);
+        const len = view.getUint32(Number(iov) + i * 8 + 4, true);
+        const part = new Uint8Array(memory.buffer, ptr, len);
+        const moved = write ? deps.sys.pwrite?.(kfd, part.slice(), at + done) ?? 0 : readInto(deps.sys, kfd, part, at + done);
+        done += moved;
+        if (moved < len) break;
+      }
+    } catch (err) {
+      return wasiErrno(String(err.code));
+    }
+    view.setUint32(Number(rest[rest.length - 1]), done, true);
+    return 0;
+  };
+}
+function positionalIo(imports, deps) {
+  for (const namespace of Object.values(imports)) {
+    for (const [name, write] of [
+      ["fd_pread", false],
+      ["fd_pwrite", true]
+    ]) {
+      const original = namespace?.[name];
+      if (typeof original === "function") {
+        namespace[name] = positioned(original, write, deps);
+      }
+    }
+  }
+}
 function wasmMemory(instance, imports) {
   const isMemory = (v) => v instanceof WebAssembly.Memory;
   const exported = Object.values(instance.exports).find(isMemory);
@@ -2344,6 +2399,11 @@ function kernelSys(transport) {
       const r = call2({ op: "fd-pread", fd, max, offset: at }, `fd-pread ${fd}`);
       return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
     },
+    pwrite(fd, bytes, at) {
+      return json(
+        call2({ op: "fd-pwrite", fd, offset: at, body: bytes }, `fd-pwrite ${fd}`)
+      );
+    },
     isatty(fd) {
       return json(call2({ op: "fd-info", fd }, `fd-info ${fd}`))?.tty === true;
     },
@@ -2482,6 +2542,11 @@ async function runWasmProcess(init, port2, deps = {}) {
           }
         });
         syncFsync(imports, () => ownValue(module, "FS"));
+        positionalIo(imports, {
+          fs: () => ownValue(module, "FS"),
+          sys,
+          memory: () => memory
+        });
         return WebAssembly.instantiate(init.program.module, imports);
       }).then((instance) => {
         memory = wasmMemory(instance, imports);