@ai-ecoverse/slicc-kernel 1.166.3 → 1.166.5

package/dist/node-process-worker.cjs

@@ -1690,19 +1690,22 @@ var init_wasi_files = __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) {
@@ -1712,14 +1715,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 {
@@ -1746,11 +1749,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;
@@ -1993,9 +2005,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;
 }
@@ -2186,7 +2198,7 @@ function createSyncSabTransport(sab, port3, 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;
@@ -2204,7 +2216,7 @@ function createSyncSabTransport(sab, port3, deps = {}) {
       return;
     }
     for (; ; ) {
-      const published = capturedAtomics.load(header, SAB_I_PUB);
+      const published = sabLoad(header, SAB_I_PUB);
       if (ready(id)) {
         settled2(start2);
         return;
@@ -2215,7 +2227,7 @@ function createSyncSabTransport(sab, port3, 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;
@@ -2223,10 +2235,10 @@ function createSyncSabTransport(sab, port3, 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) port3.postMessage(msg, transfer);
@@ -2236,28 +2248,34 @@ function createSyncSabTransport(sab, port3, 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;
@@ -2449,7 +2467,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";
@@ -2467,6 +2485,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");
   }
 });
 
@@ -2481,8 +2504,8 @@ function createAsyncSabTransport(sab, port3, 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);
@@ -2494,31 +2517,31 @@ function createAsyncSabTransport(sab, port3, 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) port3.postMessage({ type: SYNC_SAB_REQ_MSG, id, req }, transfer);
         else port3.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);
   }
@@ -2537,7 +2560,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);
   }
 });
 
@@ -7466,7 +7489,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";
   }
 });
@@ -10234,7 +10257,7 @@ function errnoOf(err) {
   const errno2 = err?.errno;
   return typeof errno2 === "number" ? errno2 : wasiErrno("EIO");
 }
-function sizeOf(Fs, stream) {
+function sizeOf2(Fs, stream) {
   const st = Fs.fstat?.(stream.fd);
   return st?.size ?? 0;
 }
@@ -10265,7 +10288,7 @@ function refused2(kind, flags) {
   return kind === "write" && access === O_RDONLY || kind === "read" && access === O_WRONLY4;
 }
 function baseOf2(Fs, stream) {
-  return (whence) => whence === SEEK_CUR3 ? stream.position : whence === SEEK_END3 ? sizeOf(Fs, stream) : 0;
+  return (whence) => whence === SEEK_CUR3 ? stream.position : whence === SEEK_END3 ? sizeOf2(Fs, stream) : 0;
 }
 function recordLock(fcntl, deps) {
   return (fd, cmd, varargs) => {
@@ -10688,7 +10711,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;
 }
@@ -10710,7 +10733,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;
@@ -12560,13 +12583,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 {
@@ -12732,10 +12759,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);
@@ -12864,7 +12898,7 @@ function syncPathOps(kernel, resolve2, 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";
@@ -12879,6 +12913,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 {
@@ -12891,9 +12930,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;
@@ -12911,6 +12950,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);
@@ -19098,7 +19146,7 @@ function fillMemory(memory, copy2) {
   if (pages2 > 0) memory.grow(pages2);
   new capturedUint8Array(memory.buffer).set(copy2);
 }
-function sizeOf2(main) {
+function sizeOf3(main) {
   return () => main.memory?.buffer.byteLength ?? 0;
 }
 function memoryOf(instance, imported2) {
@@ -19327,7 +19375,7 @@ async function runWasiProcess(init, port3) {
     call: kernelCall,
     say,
     gate
-  } = kernelOf(init, port3, signals, sizeOf2(main));
+  } = kernelOf(init, port3, signals, sizeOf3(main));
   const id = identify(transport, init);
   const stats = init.env.SLICC_WASI_STATS === "1" ? new WasiStats() : void 0;
   const call3 = stats ? timedCalls(stats, kernelCall) : kernelCall;
@@ -19389,7 +19437,7 @@ async function runWasiProcess(init, port3) {
   });
   restoreExportedMemory(instance, memory, init);
   main.memory = memoryOf(instance, memory);
-  publishMemory(init.sab, sizeOf2(main)());
+  publishMemory(init.sab, sizeOf3(main)());
   port3.postMessage({ type: WASM_PROCESS_READY });
   signals.bind(instance.exports);
   if (importsSigactionHook(module2)) signals.useHook();
@@ -19814,6 +19862,17 @@ function programScript(name2, hash) {
 }
 var SOURCE_NAMES = 4096;
 var sourceNames = new capturedSet();
+var setDelete = capturedSet.prototype.delete;
+var setValues = capturedSet.prototype.values;
+var sizeOf = capturedObject.getOwnPropertyDescriptor(capturedSet.prototype, "size")?.get;
+var nextOf = capturedObject.getPrototypeOf(new capturedSet().values()).next;
+function noteName(name2) {
+  if (apply(setDelete, sourceNames, [name2]) !== true && apply(sizeOf, sourceNames, []) >= SOURCE_NAMES) {
+    const oldest = apply(nextOf, apply(setValues, sourceNames, []), []);
+    apply(setDelete, sourceNames, [oldest.value]);
+  }
+  apply(setAdd, sourceNames, [name2]);
+}
 function programName(name2) {
   return apply(startsWith, name2, ["data:"]) === true || apply(setHas, programNames, [name2]) === true || apply(setHas, sourceNames, [name2]) === true;
 }
@@ -19825,7 +19884,7 @@ function noteSourceUrls(trace) {
     if (typeof origin !== "string" || evalAt(origin)) continue;
     const name2 = apply(nameOf, site, []);
     if (typeof name2 !== "string" || apply(setHas, ownNames, [name2]) === true) continue;
-    if (sourceNames.size < SOURCE_NAMES) apply(setAdd, sourceNames, [name2]);
+    noteName(name2);
   }
 }
 function rootOrigin(origin) {
@@ -20093,8 +20152,8 @@ function refuseModules() {
       const known = sources.get(url);
       if (known !== void 0) return { format: "module", source: known, shortCircuit: true };
       const payload = url.startsWith(BASE64_MODULE) ? url.slice(BASE64_MODULE.length) : "";
-      const typed = capturedObject.keys(context.importAttributes ?? {}).length > 0;
-      if (typed || payload.length % 4 !== 0 || !PLAIN_BASE64.test(payload))
+      const typed3 = capturedObject.keys(context.importAttributes ?? {}).length > 0;
+      if (typed3 || payload.length % 4 !== 0 || !PLAIN_BASE64.test(payload))
         return next2(url, context);
       const source = toText(fromBase64(payload, "base64"), "utf8");
       return { format: "module", source, shortCircuit: true };