@ai-ecoverse/slicc-kernel 1.166.3 → 1.166.5

package/dist/process-worker.js

@@ -174,19 +174,22 @@ var init_lockdown = __esm({
 });
 
 // src/realm/sync-sab-wire.ts
+function copyWindow(out, window, chunk, at) {
+  setBytes.call(out, bytesPart.call(window, 0, chunk), at);
+}
 function loadBlocked(header) {
-  return [capturedAtomics.load(header, SAB_I_BLOCKED), capturedAtomics.load(header, SAB_I_BLOCKED_HI)];
+  return [sabLoad(header, SAB_I_BLOCKED), sabLoad(header, SAB_I_BLOCKED_HI)];
 }
 function storeBlocked(header, [low, high]) {
-  capturedAtomics.store(header, SAB_I_BLOCKED_HI, high);
-  capturedAtomics.store(header, SAB_I_BLOCKED, low);
+  sabStore(header, SAB_I_BLOCKED_HI, high);
+  sabStore(header, SAB_I_BLOCKED, low);
 }
 function loadU53(header, lo, hi) {
-  return (capturedAtomics.load(header, lo) >>> 0) + capturedAtomics.load(header, hi) * U32;
+  return (sabLoad(header, lo) >>> 0) + sabLoad(header, hi) * U32;
 }
 function publishMemory(sab, bytes) {
   if (bytes > 0)
-    capturedAtomics.store(new capturedInt32Array(sab, 0, SAB_HEADER_I32), SAB_I_MEMORY, capturedMath.ceil(bytes / 65536));
+    sabStore(new capturedInt32Array(sab, 0, SAB_HEADER_I32), SAB_I_MEMORY, capturedMath.ceil(bytes / 65536));
 }
 function decodeSabResult(status2, payload) {
   switch (status2) {
@@ -196,14 +199,14 @@ function decodeSabResult(status2, payload) {
       return { ok: true, kind: "void" };
     case SAB_STATUS_JSON: {
       try {
-        return { ok: true, kind: "json", json: capturedJSON.parse(decoder.decode(payload)) };
+        return { ok: true, kind: "json", json: capturedJSON.parse(decodeText.call(decoder, payload)) };
       } catch {
         return { ok: false, errno: "EIO", message: "sync-sab: malformed json payload" };
       }
     }
     case SAB_STATUS_ERRNO: {
       try {
-        const parsed = capturedJSON.parse(decoder.decode(payload));
+        const parsed = capturedJSON.parse(decodeText.call(decoder, payload));
         const errno2 = typeof parsed.errno === "string" && /^E[A-Z]+$|^EAI_[A-Z]+$/.test(parsed.errno) ? parsed.errno : "EIO";
         const message2 = capturedString(parsed.message ?? errno2);
         return {
@@ -230,11 +233,20 @@ function sabViews(sab) {
     window: new capturedUint8Array(sab, SAB_HEADER_BYTES)
   };
 }
-var SAB_HEADER_I32, SAB_CLOCK_OFFSET, SAB_CLOCK_I64, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_I_TOTAL_HI, SAB_I_OFFSET_HI, SAB_I_KILLED, SAB_I_ASYNC, SAB_I_STOP, SAB_I_BLOCKED, SAB_I_BLOCKED_HI, anyBlocked, U32, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
+var atomicLoad, atomicStore, atomicWaitAsync, setBytes, bytesPart, decodeText, sabLoad, sabStore, sabWaitAsync, SAB_HEADER_I32, SAB_CLOCK_OFFSET, SAB_CLOCK_I64, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_I_TOTAL_HI, SAB_I_OFFSET_HI, SAB_I_KILLED, SAB_I_ASYNC, SAB_I_STOP, SAB_I_BLOCKED, SAB_I_BLOCKED_HI, anyBlocked, U32, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
 var init_sync_sab_wire = __esm({
   "src/realm/sync-sab-wire.ts"() {
     "use strict";
     init_captured_globals();
+    atomicLoad = capturedAtomics.load;
+    atomicStore = capturedAtomics.store;
+    atomicWaitAsync = capturedAtomics.waitAsync;
+    setBytes = capturedUint8Array.prototype.set;
+    bytesPart = capturedUint8Array.prototype.subarray;
+    decodeText = capturedTextDecoder.prototype.decode;
+    sabLoad = (a, i) => atomicLoad(a, i);
+    sabStore = (a, i, v) => atomicStore(a, i, v);
+    sabWaitAsync = atomicWaitAsync;
     SAB_HEADER_I32 = 18;
     SAB_CLOCK_OFFSET = SAB_HEADER_I32 * 4;
     SAB_CLOCK_I64 = 3;
@@ -287,9 +299,9 @@ function useLocalClock(sab) {
   if (!local) return;
   localSab = sab;
   localStart = epochMicros();
-  const wait2 = (typed, index3, value2, timeout) => localWait(
-    () => rawWait(typed, index3, value2, timeout),
-    timeout !== 0 && capturedAtomics.load(typed, index3) === value2
+  const wait2 = (typed3, index3, value2, timeout) => localWait(
+    () => rawWait(typed3, index3, value2, timeout),
+    timeout !== 0 && capturedAtomics.load(typed3, index3) === value2
   );
   capturedAtomics.wait = wait2;
 }
@@ -1344,7 +1356,7 @@ function createSyncSabTransport(sab, port2, deps = {}) {
   const now = deps.now ?? (() => capturedperformance.now());
   let seq = 0;
   let typical = 0;
-  const ready = (id) => capturedAtomics.load(header, SAB_I_STATE) === SAB_STATE_READY && capturedAtomics.load(header, SAB_I_SEQ) === id;
+  const ready = (id) => sabLoad(header, SAB_I_STATE) === SAB_STATE_READY && sabLoad(header, SAB_I_SEQ) === id;
   function spinUntil(id, until) {
     for (let stride = 0; stride < SPIN_STRIDES; stride++) {
       for (let i = 0; i < SPIN_STRIDE; i++) if (ready(id)) return true;
@@ -1362,7 +1374,7 @@ function createSyncSabTransport(sab, port2, deps = {}) {
       return;
     }
     for (; ; ) {
-      const published = capturedAtomics.load(header, SAB_I_PUB);
+      const published = sabLoad(header, SAB_I_PUB);
       if (ready(id)) {
         settled2(start2);
         return;
@@ -1373,7 +1385,7 @@ function createSyncSabTransport(sab, port2, deps = {}) {
     }
   }
   return {
-    call(asked, timeoutMs2, label, given = []) {
+    call(asked, timeoutMs2, label, given = [], sink) {
       if (deps.memory) publishMemory(sab, deps.memory());
       const { req, transfer } = exactBody(asked, given);
       const id = ++seq;
@@ -1381,10 +1393,10 @@ function createSyncSabTransport(sab, port2, deps = {}) {
       let out = null;
       let status2 = 0;
       let offset = 0;
-      capturedAtomics.store(header, SAB_I_REQ, id);
+      sabStore(header, SAB_I_REQ, id);
       try {
         for (; ; ) {
-          capturedAtomics.store(header, SAB_I_STATE, SAB_STATE_PENDING);
+          sabStore(header, SAB_I_STATE, SAB_STATE_PENDING);
           const msg = offset === 0 ? { type: SYNC_SAB_REQ_MSG, id, req } : { type: SYNC_SAB_NEXT_MSG, id, offset };
           try {
             if (offset === 0 && transfer.length > 0) port2.postMessage(msg, transfer);
@@ -1394,28 +1406,34 @@ function createSyncSabTransport(sab, port2, deps = {}) {
           }
           awaitReady(id, now() + timeoutMs2, label);
           const total = loadU53(header, SAB_I_TOTAL, SAB_I_TOTAL_HI);
-          const chunk = capturedAtomics.load(header, SAB_I_CHUNK);
+          const chunk = sabLoad(header, SAB_I_CHUNK);
           const at = loadU53(header, SAB_I_OFFSET, SAB_I_OFFSET_HI);
           if (at !== offset || chunk < 0 || total < 0 || offset + chunk > total) {
             throw syncError("EIO", label);
           }
           if (out === null) {
-            status2 = capturedAtomics.load(header, SAB_I_STATUS);
-            out = new capturedUint8Array(total);
+            status2 = sabLoad(header, SAB_I_STATUS);
+            out = landing(status2, total, sink);
           }
-          out.set(window.subarray(0, chunk), offset);
+          copyWindow(out, window, chunk, offset);
           offset += chunk;
           if (offset >= total) break;
           if (chunk === 0) throw syncError("EIO", label);
         }
       } finally {
-        capturedAtomics.store(header, SAB_I_REQ, 0);
-        capturedAtomics.store(header, SAB_I_STATE, SAB_STATE_IDLE);
+        sabStore(header, SAB_I_REQ, 0);
+        sabStore(header, SAB_I_STATE, SAB_STATE_IDLE);
       }
       return decodeSabResult(status2, out);
     }
   };
 }
+function landing(status2, total, sink) {
+  if (!sink || status2 !== SAB_STATUS_BYTES || total > lengthOf.call(sink)) {
+    return new capturedUint8Array(total);
+  }
+  return new capturedUint8Array(bufferOf.call(sink), offsetOf.call(sink), total);
+}
 function errnoError(code2, path, direct) {
   const err = syncError(code2, `sync-sab bridge, '${path}'`);
   return direct ? capturedObject.assign(err, { direct }) : err;
@@ -1607,7 +1625,7 @@ function createSyncFsSabBridge(transport, opts = {}) {
     )
   };
 }
-var UNCOUNTED_OPS, calls, looks, SPIN_MS, SPIN_STRIDE, SPIN_STRIDES, SPIN_CORES, spinning, SPIN_CAP_MS;
+var UNCOUNTED_OPS, calls, looks, SPIN_MS, SPIN_STRIDE, SPIN_STRIDES, SPIN_CORES, spinning, SPIN_CAP_MS, typed, getter, bufferOf, offsetOf, lengthOf;
 var init_sync_sab_bridge = __esm({
   "src/realm/sync-sab-bridge.ts"() {
     "use strict";
@@ -1625,6 +1643,11 @@ var init_sync_sab_bridge = __esm({
     SPIN_CORES = 4;
     spinning = (capturedGlobalThis.navigator?.hardwareConcurrency ?? 0) >= SPIN_CORES;
     SPIN_CAP_MS = 1;
+    typed = capturedObject.getPrototypeOf(capturedUint8Array.prototype);
+    getter = (name2) => capturedObject.getOwnPropertyDescriptor(typed, name2)?.get;
+    bufferOf = getter("buffer");
+    offsetOf = getter("byteOffset");
+    lengthOf = getter("length");
   }
 });
 
@@ -3083,7 +3106,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_captured_globals();
-    KERNEL_VERSION = true ? "1.166.3" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.166.5" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -3556,7 +3579,7 @@ function syncFsync(imports, fs, glue) {
     };
   }
 }
-function offsetOf(rest2) {
+function offsetOf2(rest2) {
   const at = rest2.length >= 3 ? capturedNumber(rest2[1]) * 2 ** 32 + (capturedNumber(rest2[0]) >>> 0) : capturedNumber(capturedBigInt.asIntN(64, capturedBigInt(rest2[0])));
   return at >= 0 && capturedNumber.isSafeInteger(at) ? at : void 0;
 }
@@ -3578,7 +3601,7 @@ function positioned(original, write2, deps) {
     if (kfd === void 0 || !memory || !(write2 ? deps.sys.pwrite : deps.sys.pread)) {
       return original(fd, iov, iovcnt, ...rest2);
     }
-    const at = offsetOf(rest2);
+    const at = offsetOf2(rest2);
     if (at === void 0) return wasiErrno("EINVAL");
     const view = new capturedDataView(memory.buffer);
     let done = 0;
@@ -8025,8 +8048,8 @@ function createAsyncSabTransport(sab, port2, waitAsync = defaultWaitAsync) {
   let tail = capturedPromise.resolve();
   async function ready(id) {
     for (; ; ) {
-      const published = capturedAtomics.load(header, SAB_I_PUB);
-      if (capturedAtomics.load(header, SAB_I_STATE) === SAB_STATE_READY && capturedAtomics.load(header, SAB_I_SEQ) === id) {
+      const published = sabLoad(header, SAB_I_PUB);
+      if (sabLoad(header, SAB_I_STATE) === SAB_STATE_READY && sabLoad(header, SAB_I_SEQ) === id) {
         return;
       }
       await changed(header, SAB_I_PUB, published, waitAsync);
@@ -8038,31 +8061,31 @@ function createAsyncSabTransport(sab, port2, waitAsync = defaultWaitAsync) {
     let out = null;
     let status2 = 0;
     let offset = 0;
-    capturedAtomics.store(header, SAB_I_REQ, id);
+    sabStore(header, SAB_I_REQ, id);
     try {
       for (; ; ) {
-        capturedAtomics.store(header, SAB_I_STATE, SAB_STATE_PENDING);
+        sabStore(header, SAB_I_STATE, SAB_STATE_PENDING);
         if (offset === 0) port2.postMessage({ type: SYNC_SAB_REQ_MSG, id, req }, transfer);
         else port2.postMessage({ type: SYNC_SAB_NEXT_MSG, id, offset });
         await ready(id);
         const total = loadU53(header, SAB_I_TOTAL, SAB_I_TOTAL_HI);
-        const chunk = capturedAtomics.load(header, SAB_I_CHUNK);
+        const chunk = sabLoad(header, SAB_I_CHUNK);
         const at = loadU53(header, SAB_I_OFFSET, SAB_I_OFFSET_HI);
         if (at !== offset || chunk < 0 || total < 0 || offset + chunk > total) {
           return { ok: false, errno: "EIO", message: "sync-sab: torn reply" };
         }
         if (out === null) {
-          status2 = capturedAtomics.load(header, SAB_I_STATUS);
+          status2 = sabLoad(header, SAB_I_STATUS);
           out = new capturedUint8Array(total);
         }
-        out.set(window.subarray(0, chunk), offset);
+        copyWindow(out, window, chunk, offset);
         offset += chunk;
         if (offset >= total) break;
         if (chunk === 0) return { ok: false, errno: "EIO", message: "sync-sab: empty chunk" };
       }
     } finally {
-      capturedAtomics.store(header, SAB_I_REQ, 0);
-      capturedAtomics.store(header, SAB_I_STATE, SAB_STATE_IDLE);
+      sabStore(header, SAB_I_REQ, 0);
+      sabStore(header, SAB_I_STATE, SAB_STATE_IDLE);
     }
     return decodeSabResult(status2, out);
   }
@@ -8081,7 +8104,7 @@ var init_async_sab = __esm({
     init_captured_globals();
     init_sync_sab_bridge();
     init_sync_sab_wire();
-    defaultWaitAsync = (a, i, v) => capturedAtomics.waitAsync(a, i, v);
+    defaultWaitAsync = (a, i, v) => sabWaitAsync(a, i, v);
   }
 });
 
@@ -17734,13 +17757,17 @@ var init_js_run = __esm({
 });
 
 // src/process/js/js-sync.ts
+function viewOf(into, at, length) {
+  return new capturedUint8Array(bufferOf2.call(into), offsetOf3.call(into) + at, length);
+}
 function laneOf(lane, silence = SYNC_FS_REQUEST_TIMEOUT_MS, open = createSyncSabTransport) {
   if (!lane) return noLane;
   const transport = open(lane.sab, lane.port);
-  return (req) => {
-    if (!READ_ONLY.has(req.op)) return transport.call(req, capturedNumber.POSITIVE_INFINITY, req.op);
+  return (req, sink) => {
+    if (!READ_ONLY.has(req.op))
+      return transport.call(req, capturedNumber.POSITIVE_INFINITY, req.op, void 0, sink);
     try {
-      return transport.call(req, silence, req.op);
+      return transport.call(req, silence, req.op, void 0, sink);
     } catch (err) {
       const errno2 = err?.code;
       return {
@@ -17906,10 +17933,17 @@ function syncFile(kernel, fd, path, append, forget) {
       live();
       const max = capturedMath.min(length - got, MAX_PREAD);
       if (max <= 0) break;
-      const chunk = kernel.bytes({ op: "fd-pread", fd, offset: position + got, max });
+      const req = { op: "fd-pread", fd, offset: position + got, max };
+      if (target) {
+        const at = target.at + got;
+        const n = kernel.bytesInto(req, viewOf(target.into, at, max));
+        if (n === 0) break;
+        got += n;
+        continue;
+      }
+      const chunk = kernel.bytes(req);
       if (chunk.length === 0) break;
-      if (target) target.into.set(chunk, target.at + got);
-      else parts.push(chunk);
+      parts.push(chunk);
       got += chunk.length;
     } while (got < length);
     return target ? got : joined(parts, got);
@@ -18038,7 +18072,7 @@ function syncPathOps(kernel, resolve, statOf, open, clean) {
     }
   };
 }
-var encoder4, noLane, READ_ONLY, JsSyncKernel;
+var encoder4, typed2, getter2, bufferOf2, offsetOf3, setInto, noLane, READ_ONLY, JsSyncKernel;
 var init_js_sync = __esm({
   "src/process/js/js-sync.ts"() {
     "use strict";
@@ -18053,6 +18087,11 @@ var init_js_sync = __esm({
     init_js_proc();
     init_js_rights();
     encoder4 = new capturedTextEncoder();
+    typed2 = capturedObject.getPrototypeOf(capturedUint8Array.prototype);
+    getter2 = (name2) => capturedObject.getOwnPropertyDescriptor(typed2, name2)?.get;
+    bufferOf2 = getter2("buffer");
+    offsetOf3 = getter2("byteOffset");
+    setInto = capturedUint8Array.prototype.set;
     noLane = () => ({ ok: false, errno: "ENOSYS", message: "no sync lane" });
     READ_ONLY = new capturedSet([...SYNC_FS_READ_ONLY, "fd-path-flush"]);
     JsSyncKernel = class {
@@ -18065,9 +18104,9 @@ var init_js_sync = __esm({
         this.kernel = kernel;
         this.unwind = unwind;
       }
-      raw(req) {
+      raw(req, sink) {
         this.unwind();
-        const result = this.lane(req);
+        const result = this.lane(req, sink);
         this.kernel.deliver();
         this.unwind();
         return result;
@@ -18085,6 +18124,15 @@ var init_js_sync = __esm({
         const result = this.call(req);
         return result.ok && result.kind === "bytes" ? result.bytes : new capturedUint8Array(0);
       }
+      bytesInto(req, sink) {
+        const result = this.raw(req, sink);
+        if (!result.ok) throw callError(result, req.op);
+        if (result.kind !== "bytes") return 0;
+        const { bytes } = result;
+        if (bufferOf2.call(bytes) !== bufferOf2.call(sink) || offsetOf3.call(bytes) !== offsetOf3.call(sink))
+          setInto.call(sink, bytes);
+        return bytes.length;
+      }
       blocking(req) {
         for (; ; ) {
           const result = this.raw(req);