@ai-ecoverse/wasm-zip 3.0.0-1 → 3.0.0-2

package/LICENSE

@@ -1,3 +1,5 @@
+==> LICENSE <==
+
 This is version 2007-Mar-4 of the Info-ZIP license.
 The definitive version of this document should be available at
 ftp://ftp.info-zip.org/pub/infozip/license.html indefinitely and
@@ -23,6 +25,69 @@ or implied.  In no event shall Info-ZIP or its contributors be held liable
 for any direct, indirect, incidental, special or consequential damages
 arising out of the use of or inability to use this software.
 
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the above disclaimer and the following restrictions:
+
+    1. Redistributions of source code (in whole or in part) must retain
+       the above copyright notice, definition, disclaimer, and this list
+       of conditions.
+
+    2. Redistributions in binary form (compiled executables and libraries)
+       must reproduce the above copyright notice, definition, disclaimer,
+       and this list of conditions in documentation and/or other materials
+       provided with the distribution.  The sole exception to this condition
+       is redistribution of a standard UnZipSFX binary (including SFXWiz) as
+       part of a self-extracting archive; that is permitted without inclusion
+       of this license, as long as the normal SFX banner has not been removed
+       from the binary or disabled.
+
+    3. Altered versions--including, but not limited to, ports to new operating
+       systems, existing ports with new graphical interfaces, versions with
+       modified or added functionality, and dynamic, shared, or static library
+       versions not from Info-ZIP--must be plainly marked as such and must not
+       be misrepresented as being the original source or, if binaries,
+       compiled from the original source.  Such altered versions also must not
+       be misrepresented as being Info-ZIP releases--including, but not
+       limited to, labeling of the altered versions with the names "Info-ZIP"
+       (or any variation thereof, including, but not limited to, different
+       capitalizations), "Pocket UnZip," "WiZ" or "MacZip" without the
+       explicit permission of Info-ZIP.  Such altered versions are further
+       prohibited from misrepresentative use of the Zip-Bugs or Info-ZIP
+       e-mail addresses or the Info-ZIP URL(s), such as to imply Info-ZIP
+       will provide support for the altered versions.
+
+    4. Info-ZIP retains the right to use the names "Info-ZIP," "Zip," "UnZip,"
+       "UnZipSFX," "WiZ," "Pocket UnZip," "Pocket Zip," and "MacZip" for its
+       own source and binary releases.
+
+==> LICENSE <==
+
+This is version 2009-Jan-02 of the Info-ZIP license.
+The definitive version of this document should be available at
+ftp://ftp.info-zip.org/pub/infozip/license.html indefinitely and
+a copy at http://www.info-zip.org/pub/infozip/license.html.
+
+
+Copyright (c) 1990-2009 Info-ZIP.  All rights reserved.
+
+For the purposes of this copyright and license, "Info-ZIP" is defined as
+the following set of individuals:
+
+   Mark Adler, John Bush, Karl Davis, Harald Denker, Jean-Michel Dubois,
+   Jean-loup Gailly, Hunter Goatley, Ed Gordon, Ian Gorman, Chris Herborth,
+   Dirk Haase, Greg Hartwig, Robert Heath, Jonathan Hudson, Paul Kienitz,
+   David Kirschbaum, Johnny Lee, Onno van der Linden, Igor Mandrichenko,
+   Steve P. Miller, Sergio Monesi, Keith Owens, George Petrov, Greg Roelofs,
+   Kai Uwe Rommel, Steve Salisbury, Dave Smith, Steven M. Schweda,
+   Christian Spieler, Cosmin Truta, Antoine Verheijen, Paul von Behren,
+   Rich Wales, Mike White.
+
+This software is provided "as is," without warranty of any kind, express
+or implied.  In no event shall Info-ZIP or its contributors be held liable
+for any direct, indirect, incidental, special or consequential damages
+arising out of the use of or inability to use this software.
+
 Permission is granted to anyone to use this software for any purpose,
 including commercial applications, and to alter it and redistribute it
 freely, subject to the above disclaimer and the following restrictions:
@@ -36,8 +101,8 @@ freely, subject to the above disclaimer and the following restrictions:
        and this list of conditions in documentation and/or other materials
        provided with the distribution.  Additional documentation is not needed
        for executables where a command line license option provides these and
-       a note regarding this option is in the executable's startup banner.
-       The sole exception to this condition is redistribution of a standard
+       a note regarding this option is in the executable's startup banner.  The
+       sole exception to this condition is redistribution of a standard
        UnZipSFX binary (including SFXWiz) as part of a self-extracting archive;
        that is permitted without inclusion of this license, as long as the
        normal SFX banner has not been removed from the binary or disabled.

package/README.md

@@ -4,7 +4,14 @@
 slicc's wasm realm.
 
 ```bash
-ipk add -g @ai-ecoverse/wasm-zip
+pnpm add -g @ai-ecoverse/wasm-zip
 zip out.zip file.txt
 unzip -l out.zip
 ```
+
+- `zip -T` runs `unzip` itself, without a shell. A `-TT` command is a shell
+  command, so it needs one (`@ai-ecoverse/wasm-bash`).
+- Non-ASCII names are UTF-8. `zip` sets the UTF-8 flag on them, and `unzip`
+  shows them and reads Info-ZIP's Unicode path field.
+- `zip - … > file` and `zip - … | …` write valid archives, and `zip -s 0`
+  merges split archives (`zip -s 1m`) back with every byte.

package/bin/unzip

@@ -176,26 +176,7 @@ if (ENVIRONMENT_IS_WORKER) {
   }
 
   readAsync = async (url) => {
-    // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
-    // See https://github.com/github/fetch/pull/92#issuecomment-140665932
-    // Cordova or Electron apps are typically loaded from a file:// url.
-    // So use XHR on webview if URL is a file URL.
-    if (isFileURI(url)) {
-      return new Promise((resolve, reject) => {
-        var xhr = new XMLHttpRequest();
-        xhr.open('GET', url, true);
-        xhr.responseType = 'arraybuffer';
-        xhr.onload = () => {
-          if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
-            resolve(xhr.response);
-            return;
-          }
-          reject(xhr.status);
-        };
-        xhr.onerror = reject;
-        xhr.send(null);
-      });
-    }
+    assert(!isFileURI(url), "readAsync does not work with file:// URLs");
     var response = await fetch(url, { credentials: 'same-origin' });
     if (response.ok) {
       return response.arrayBuffer();
@@ -483,6 +464,8 @@ var
 
 var runtimeInitialized = false;
 
+var runtimeExited = false;
+
 
 
 function updateMemoryViews() {
@@ -541,6 +524,18 @@ function preMain() {
   // No ATMAINS hooks
 }
 
+function exitRuntime() {
+  assert(!runtimeExited);
+  checkStackCookie();
+   // PThreads reuse the runtime from the main thread.
+  ___funcs_on_exit(); // Native atexit() functions
+  // Begin ATEXITS hooks
+  FS.quit();
+TTY.shutdown();
+  // End ATEXITS hooks
+  runtimeExited = true;
+}
+
 function postRun() {
   checkStackCookie();
    // PThreads reuse the runtime from the main thread.
@@ -594,6 +589,7 @@ function abort(what) {
 function createExportWrapper(name, nargs) {
   return (...args) => {
     assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
+    assert(!runtimeExited, `native function \`${name}\` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)`);
     var f = wasmExports[name];
     assert(f, `exported native function \`${name}\` not found`);
     // Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled.
@@ -654,8 +650,6 @@ async function instantiateArrayBuffer(binaryFile, imports) {
 
 async function instantiateAsync(binary, binaryFile, imports) {
   if (!binary
-      // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
-      && !isFileURI(binaryFile)
       // Avoid instantiateStreaming() on Node.js environment for now, as while
       // Node.js v18.1.0 implements it, it does not have a full fetch()
       // implementation yet.
@@ -860,7 +854,7 @@ async function createWasm() {
     }
   }
 
-  var noExitRuntime = true;
+  var noExitRuntime = false;
 
   var ptrToString = (ptr) => {
       assert(typeof ptr === 'number', `ptrToString expects a number, got ${typeof ptr}`);
@@ -906,6 +900,21 @@ async function createWasm() {
 
   
 
+  var wasmTableMirror = [];
+  
+  
+  var getWasmTableEntry = (funcPtr) => {
+      var func = wasmTableMirror[funcPtr];
+      if (!func) {
+        /** @suppress {checkTypes} */
+        wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+      }
+      /** @suppress {checkTypes} */
+      assert(wasmTable.get(funcPtr) == func, 'JavaScript-side Wasm function table mirror is out of date!');
+      return func;
+    };
+  var ___call_sighandler = (fp, sig) => getWasmTableEntry(fp)(sig);
+
   var PATH = {
   isAbs:(path) => path.charAt(0) === '/',
   splitPath:(filename) => {
@@ -1588,6 +1597,13 @@ async function createWasm() {
   write(stream, buffer, offset, length, position, canOwn) {
           // The data buffer should be a typed array view
           assert(!(buffer instanceof ArrayBuffer));
+          // If the buffer is located in main memory (HEAP), and if
+          // memory can grow, we can't hold on to references of the
+          // memory buffer, as they may get invalidated. That means we
+          // need to copy its contents.
+          if (buffer.buffer === HEAP8.buffer) {
+            canOwn = false;
+          }
   
           if (!length) return 0;
           var node = stream.node;
@@ -4085,6 +4101,12 @@ async function createWasm() {
   var __abort_js = () =>
       abort('native code called abort()');
 
+  var runtimeKeepaliveCounter = 0;
+  var __emscripten_runtime_keepalive_clear = () => {
+      noExitRuntime = false;
+      runtimeKeepaliveCounter = 0;
+    };
+
   var INT53_MAX = 9007199254740992;
   
   var INT53_MIN = -9007199254740992;
@@ -4200,14 +4222,83 @@ async function createWasm() {
       }
     };
 
-  var abortOnCannotGrowMemory = (requestedSize) => {
-      abort(`Cannot enlarge memory arrays to size ${requestedSize} bytes (OOM). Either (1) compile with -sINITIAL_MEMORY=X with X higher than the current value ${HEAP8.length}, (2) compile with -sALLOW_MEMORY_GROWTH which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -sABORTING_MALLOC=0`);
+  var getHeapMax = () =>
+      // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+      // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+      // for any code that deals with heap sizes, which would require special
+      // casing all heap size related code to treat 0 specially.
+      2147483648;
+  
+  var alignMemory = (size, alignment) => {
+      assert(alignment, "alignment argument is required");
+      return Math.ceil(size / alignment) * alignment;
+    };
+  
+  var growMemory = (size) => {
+      var oldHeapSize = wasmMemory.buffer.byteLength;
+      var pages = ((size - oldHeapSize + 65535) / 65536) | 0;
+      try {
+        // round size grow request up to wasm page size (fixed 64KB per spec)
+        wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
+        updateMemoryViews();
+        return 1 /*success*/;
+      } catch(e) {
+        err(`growMemory: Attempted to grow heap from ${oldHeapSize} bytes to ${size} bytes, but got error: ${e}`);
+      }
+      // implicit 0 return to save code size (caller will cast "undefined" into 0
+      // anyhow)
     };
   var _emscripten_resize_heap = (requestedSize) => {
       var oldSize = HEAPU8.length;
       // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
       requestedSize >>>= 0;
-      abortOnCannotGrowMemory(requestedSize);
+      // With multithreaded builds, races can happen (another thread might increase the size
+      // in between), so return a failure, and let the caller retry.
+      assert(requestedSize > oldSize);
+  
+      // Memory resize rules:
+      // 1.  Always increase heap size to at least the requested size, rounded up
+      //     to next page multiple.
+      // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
+      //     geometrically: increase the heap size according to
+      //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
+      //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
+      // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
+      //     linearly: increase the heap size by at least
+      //     MEMORY_GROWTH_LINEAR_STEP bytes.
+      // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
+      //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
+      // 4.  If we were unable to allocate as much memory, it may be due to
+      //     over-eager decision to excessively reserve due to (3) above.
+      //     Hence if an allocation fails, cut down on the amount of excess
+      //     growth, in an attempt to succeed to perform a smaller allocation.
+  
+      // A limit is set for how much we can grow. We should not exceed that
+      // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
+        return false;
+      }
+  
+      // Loop through potential heap size increases. If we attempt a too eager
+      // reservation that fails, cut down on the attempted size and reserve a
+      // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
+        // but limit overreserving (default to capping at +96MB overgrowth at most)
+        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );
+  
+        var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+  
+        var replacement = growMemory(newSize);
+        if (replacement) {
+  
+          return true;
+        }
+      }
+      err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
+      return false;
     };
 
   var ENV = {
@@ -4270,7 +4361,6 @@ async function createWasm() {
     };
 
   
-  var runtimeKeepaliveCounter = 0;
   var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
   var _proc_exit = (code) => {
       EXITSTATUS = code;
@@ -4286,7 +4376,9 @@ async function createWasm() {
   var exitJS = (status, implicit) => {
       EXITSTATUS = status;
   
-      checkUnflushedContent();
+      if (!keepRuntimeAlive()) {
+        exitRuntime();
+      }
   
       // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down
       if (keepRuntimeAlive() && !implicit) {
@@ -4389,23 +4481,22 @@ async function createWasm() {
 
   /** @param {number=} offset */
   var doWritev = (stream, iov, iovcnt, offset) => {
-      var ret = 0;
-      for (var i = 0; i < iovcnt; i++) {
-        var ptr = HEAPU32[((iov)>>2)];
-        var len = HEAPU32[(((iov)+(4))>>2)];
-        iov += 8;
-        var curr = FS.write(stream, HEAP8, ptr, len, offset);
-        if (curr < 0) return -1;
-        ret += curr;
-        if (curr < len) {
-          // No more space to write.
-          break;
-        }
-        if (typeof offset != 'undefined') {
-          offset += curr;
-        }
+      if (iovcnt == 1) {
+        return FS.write(stream, HEAP8, HEAPU32[iov >> 2], HEAPU32[(iov + 4) >> 2], offset);
       }
-      return ret;
+      var total = 0;
+      for (var i = 0, p = iov; i < iovcnt; i++, p += 8) {
+        total += HEAPU32[(p + 4) >> 2];
+      }
+      var view = new Uint8Array(total);
+      var voff = 0;
+      for (var i = 0; i < iovcnt; i++, iov += 8) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[(iov + 4) >> 2];
+        view.set(HEAPU8.subarray(ptr, ptr + len), voff);
+        voff += len;
+      }
+      return FS.write(stream, view, 0, total, offset);
     };
   
   function _fd_write(fd, iov, iovcnt, pnum) {
@@ -4422,6 +4513,7 @@ async function createWasm() {
   }
 
 
+
   var handleException = (e) => {
       // Certain exception types we do not treat as errors since they are used for
       // internal control flow.
@@ -4434,7 +4526,7 @@ async function createWasm() {
       checkStackCookie();
       if (e instanceof WebAssembly.RuntimeError) {
         if (_emscripten_stack_get_current() <= 0) {
-          err('Stack overflow detected.  You can try increasing -sSTACK_SIZE (currently set to 65536)');
+          err('Stack overflow detected.  You can try increasing -sSTACK_SIZE (currently set to 524288)');
         }
       }
       quit_(1, e);
@@ -4450,6 +4542,20 @@ async function createWasm() {
       return ret;
     };
 
+
+
+  var FS_createPath = (...args) => FS.createPath(...args);
+
+
+
+  var FS_unlink = (...args) => FS.unlink(...args);
+
+  var FS_createLazyFile = (...args) => FS.createLazyFile(...args);
+
+  var FS_createDevice = (...args) => FS.createDevice(...args);
+
+
+
   FS.createPreloadedFile = FS_createPreloadedFile;
   FS.preloadFile = FS_preloadFile;
   FS.staticInit();;
@@ -4500,6 +4606,16 @@ if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
 }
 
 // Begin runtime exports
+  Module['callMain'] = callMain;
+  Module['addRunDependency'] = addRunDependency;
+  Module['removeRunDependency'] = removeRunDependency;
+  Module['FS_preloadFile'] = FS_preloadFile;
+  Module['FS_unlink'] = FS_unlink;
+  Module['FS_createPath'] = FS_createPath;
+  Module['FS_createDevice'] = FS_createDevice;
+  Module['FS'] = FS;
+  Module['FS_createDataFile'] = FS_createDataFile;
+  Module['FS_createLazyFile'] = FS_createLazyFile;
   var missingLibrarySymbols = [
   'writeI53ToI64',
   'writeI53ToI64Clamped',
@@ -4514,8 +4630,6 @@ if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
   'setTempRet0',
   'createNamedFunction',
   'zeroMemory',
-  'getHeapMax',
-  'growMemory',
   'withStackSave',
   'inetPton4',
   'inetNtop4',
@@ -4533,7 +4647,6 @@ if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
   'callUserCallback',
   'maybeExit',
   'asmjsMangle',
-  'alignMemory',
   'HandleAllocator',
   'addOnInit',
   'addOnPostCtor',
@@ -4666,7 +4779,6 @@ missingLibrarySymbols.forEach(missingLibrarySymbol)
   'run',
   'out',
   'err',
-  'callMain',
   'abort',
   'wasmExports',
   'HEAPF32',
@@ -4690,7 +4802,8 @@ missingLibrarySymbols.forEach(missingLibrarySymbol)
   'stackAlloc',
   'ptrToString',
   'exitJS',
-  'abortOnCannotGrowMemory',
+  'getHeapMax',
+  'growMemory',
   'ENV',
   'ERRNO_CODES',
   'strError',
@@ -4704,13 +4817,12 @@ missingLibrarySymbols.forEach(missingLibrarySymbol)
   'handleException',
   'keepRuntimeAlive',
   'asyncLoad',
+  'alignMemory',
   'mmapAlloc',
   'wasmTable',
   'wasmMemory',
   'getUniqueRunDependency',
   'noExitRuntime',
-  'addRunDependency',
-  'removeRunDependency',
   'addOnPreRun',
   'addOnPostRun',
   'freeTableIndexes',
@@ -4764,16 +4876,11 @@ missingLibrarySymbols.forEach(missingLibrarySymbol)
   'SYSCALLS',
   'preloadPlugins',
   'FS_createPreloadedFile',
-  'FS_preloadFile',
   'FS_modeStringToFlags',
   'FS_getMode',
   'FS_stdin_getChar_buffer',
   'FS_stdin_getChar',
-  'FS_unlink',
-  'FS_createPath',
-  'FS_createDevice',
   'FS_readFile',
-  'FS',
   'FS_root',
   'FS_mounts',
   'FS_devices',
@@ -4877,9 +4984,7 @@ missingLibrarySymbols.forEach(missingLibrarySymbol)
   'FS_findObject',
   'FS_analyzePath',
   'FS_createFile',
-  'FS_createDataFile',
   'FS_forceLoadFile',
-  'FS_createLazyFile',
   'FS_absolutePath',
   'FS_createFolder',
   'FS_createLink',
@@ -4916,11 +5021,25 @@ unexportedSymbols.forEach(unexportedRuntimeSymbol);
 function checkIncomingModuleAPI() {
   ignoredModuleProp('fetchSettings');
 }
+function slicc_sleep_ms(ms) { if (typeof SharedArrayBuffer === 'function' && typeof Atomics === 'object') { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); return; } const end = Date.now() + ms; while (Date.now() < end) {} }
+function slicc_default_getpid_js() { return (Module.sliccPid | 0) || 42; }
+function slicc_default_getppid_js() { return (Module.sliccPpid | 0) || 1; }
+function slicc_kill_js(pid,sig) { if (Module.sliccKernel && Module.sliccKernel.kill) return Module.sliccKernel.kill(pid, sig); return 1; }
+function slicc_pause_js() { if (Module.sliccKernel && Module.sliccKernel.pause) return Module.sliccKernel.pause(); return -52; }
+function slicc_cred_js(out) { const k = Module.sliccKernel; if (!k || !k.cred) return -52; const c = k.cred(); if (typeof c === 'number') return c; ['ruid', 'euid', 'suid', 'rgid', 'egid', 'sgid'].forEach((key, i) => { HEAPU32[(out >> 2) + i] = c[key] >>> 0; }); return 0; }
+function slicc_groups_js(list,cap) { const k = Module.sliccKernel; if (!k || !k.cred) return -52; const c = k.cred(); if (typeof c === 'number') return c; if (cap === 0) return c.groups.length; if (cap < c.groups.length) return -28; c.groups.forEach((g, i) => { HEAPU32[(list >> 2) + i] = g >>> 0; }); return c.groups.length; }
+function slicc_setcred_js(ruid,euid,suid,rgid,egid,sgid) { const k = Module.sliccKernel; if (!k || !k.setcred) return -52; const change = {}; const ids = { ruid, euid, suid, rgid, egid, sgid }; for (const key in ids) if (ids[key] !== -1) change[key] = ids[key] >>> 0; const r = k.setcred(change); return typeof r === 'number' ? r : 0; }
+function slicc_setgroups_js(list,n) { const k = Module.sliccKernel; if (!k || !k.setcred) return -52; const groups = []; for (let i = 0; i < n; i++) groups.push(HEAPU32[(list >> 2) + i]); const r = k.setcred({ groups }); return typeof r === 'number' ? r : 0; }
 
 // Imports from the Wasm binary.
 var _main = Module['_main'] = makeInvalidEarlyAccess('_main');
 var _strerror = makeInvalidEarlyAccess('_strerror');
 var _fflush = makeInvalidEarlyAccess('_fflush');
+var _slicc_sigpipe = Module['_slicc_sigpipe'] = makeInvalidEarlyAccess('_slicc_sigpipe');
+var _slicc_raise = Module['_slicc_raise'] = makeInvalidEarlyAccess('_slicc_raise');
+var _slicc_sig_mask = Module['_slicc_sig_mask'] = makeInvalidEarlyAccess('_slicc_sig_mask');
+var _slicc_cred_euid = Module['_slicc_cred_euid'] = makeInvalidEarlyAccess('_slicc_cred_euid');
+var ___funcs_on_exit = makeInvalidEarlyAccess('___funcs_on_exit');
 var _emscripten_stack_get_end = makeInvalidEarlyAccess('_emscripten_stack_get_end');
 var _emscripten_stack_get_base = makeInvalidEarlyAccess('_emscripten_stack_get_base');
 var _emscripten_stack_init = makeInvalidEarlyAccess('_emscripten_stack_init');
@@ -4931,11 +5050,17 @@ var _emscripten_stack_get_current = makeInvalidEarlyAccess('_emscripten_stack_ge
 var memory = makeInvalidEarlyAccess('memory');
 var __indirect_function_table = makeInvalidEarlyAccess('__indirect_function_table');
 var wasmMemory = makeInvalidEarlyAccess('wasmMemory');
+var wasmTable = makeInvalidEarlyAccess('wasmTable');
 
 function assignWasmExports(wasmExports) {
   assert(typeof wasmExports['__main_argc_argv'] != 'undefined', 'missing Wasm export: __main_argc_argv');
   assert(typeof wasmExports['strerror'] != 'undefined', 'missing Wasm export: strerror');
   assert(typeof wasmExports['fflush'] != 'undefined', 'missing Wasm export: fflush');
+  assert(typeof wasmExports['slicc_sigpipe'] != 'undefined', 'missing Wasm export: slicc_sigpipe');
+  assert(typeof wasmExports['slicc_raise'] != 'undefined', 'missing Wasm export: slicc_raise');
+  assert(typeof wasmExports['slicc_sig_mask'] != 'undefined', 'missing Wasm export: slicc_sig_mask');
+  assert(typeof wasmExports['slicc_cred_euid'] != 'undefined', 'missing Wasm export: slicc_cred_euid');
+  assert(typeof wasmExports['__funcs_on_exit'] != 'undefined', 'missing Wasm export: __funcs_on_exit');
   assert(typeof wasmExports['emscripten_stack_get_end'] != 'undefined', 'missing Wasm export: emscripten_stack_get_end');
   assert(typeof wasmExports['emscripten_stack_get_base'] != 'undefined', 'missing Wasm export: emscripten_stack_get_base');
   assert(typeof wasmExports['emscripten_stack_init'] != 'undefined', 'missing Wasm export: emscripten_stack_init');
@@ -4948,6 +5073,11 @@ function assignWasmExports(wasmExports) {
   _main = Module['_main'] = createExportWrapper('__main_argc_argv', 2);
   _strerror = createExportWrapper('strerror', 1);
   _fflush = createExportWrapper('fflush', 1);
+  _slicc_sigpipe = Module['_slicc_sigpipe'] = createExportWrapper('slicc_sigpipe', 0);
+  _slicc_raise = Module['_slicc_raise'] = createExportWrapper('slicc_raise', 1);
+  _slicc_sig_mask = Module['_slicc_sig_mask'] = createExportWrapper('slicc_sig_mask', 1);
+  _slicc_cred_euid = Module['_slicc_cred_euid'] = createExportWrapper('slicc_cred_euid', 0);
+  ___funcs_on_exit = createExportWrapper('__funcs_on_exit', 0);
   _emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'];
   _emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'];
   _emscripten_stack_init = wasmExports['emscripten_stack_init'];
@@ -4956,10 +5086,12 @@ function assignWasmExports(wasmExports) {
   __emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'];
   _emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'];
   memory = wasmMemory = wasmExports['memory'];
-  __indirect_function_table = wasmExports['__indirect_function_table'];
+  __indirect_function_table = wasmTable = wasmExports['__indirect_function_table'];
 }
 
 var wasmImports = {
+  /** @export */
+  __call_sighandler: ___call_sighandler,
   /** @export */
   __syscall_chmod: ___syscall_chmod,
   /** @export */
@@ -4997,6 +5129,8 @@ var wasmImports = {
   /** @export */
   _abort_js: __abort_js,
   /** @export */
+  _emscripten_runtime_keepalive_clear: __emscripten_runtime_keepalive_clear,
+  /** @export */
   _gmtime_js: __gmtime_js,
   /** @export */
   _localtime_js: __localtime_js,
@@ -5019,7 +5153,17 @@ var wasmImports = {
   /** @export */
   fd_seek: _fd_seek,
   /** @export */
-  fd_write: _fd_write
+  fd_write: _fd_write,
+  /** @export */
+  proc_exit: _proc_exit,
+  /** @export */
+  slicc_cred_js,
+  /** @export */
+  slicc_default_getpid_js,
+  /** @export */
+  slicc_kill_js,
+  /** @export */
+  slicc_pause_js
 };
 
 
@@ -5099,7 +5243,7 @@ function run(args = arguments_) {
     Module['onRuntimeInitialized']?.();
     consumedModuleProp('onRuntimeInitialized');
 
-    var noInitialRun = Module['noInitialRun'] || false;
+    var noInitialRun = Module['noInitialRun'] || true;
     if (!noInitialRun) callMain(args);
 
     postRun();
@@ -5118,45 +5262,6 @@ function run(args = arguments_) {
   checkStackCookie();
 }
 
-function checkUnflushedContent() {
-  // Compiler settings do not allow exiting the runtime, so flushing
-  // the streams is not possible. but in ASSERTIONS mode we check
-  // if there was something to flush, and if so tell the user they
-  // should request that the runtime be exitable.
-  // Normally we would not even include flush() at all, but in ASSERTIONS
-  // builds we do so just for this check, and here we see if there is any
-  // content to flush, that is, we check if there would have been
-  // something a non-ASSERTIONS build would have not seen.
-  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
-  // mode (which has its own special function for this; otherwise, all
-  // the code is inside libc)
-  var oldOut = out;
-  var oldErr = err;
-  var has = false;
-  out = err = (x) => {
-    has = true;
-  }
-  try { // it doesn't matter if it fails
-    _fflush(0);
-    // also flush in the JS FS layer
-    for (var name of ['stdout', 'stderr']) {
-      var info = FS.analyzePath('/dev/' + name);
-      if (!info) return;
-      var stream = info.object;
-      var rdev = stream.rdev;
-      var tty = TTY.ttys[rdev];
-      if (tty?.output?.length) {
-        has = true;
-      }
-    }
-  } catch(e) {}
-  out = oldOut;
-  err = oldErr;
-  if (has) {
-    warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.');
-  }
-}
-
 var wasmExports;
 
 // With async instantation wasmExports is assigned asynchronously when the

package/bin/zip

@@ -510,6 +510,7 @@ function initRuntime() {
   // Begin ATINITS hooks
   if (!Module['noFSInit'] && !FS.initialized) FS.init();
 TTY.init();
+PIPEFS.root = FS.mount(PIPEFS, {}, null);
   // End ATINITS hooks
 
   wasmExports['__wasm_call_ctors']();
@@ -3941,6 +3942,256 @@ async function createWasm() {
   }
   }
 
+  var PIPEFS = {
+  BUCKET_BUFFER_SIZE:8192,
+  mount(mount) {
+        // Do not pollute the real root directory or its child nodes with pipes
+        // Looks like it is OK to create another pseudo-root node not linked to the FS.root hierarchy this way
+        return FS.createNode(null, '/', 16384 | 0o777, 0);
+      },
+  createPipe() {
+        var pipe = {
+          buckets: [],
+          // refcnt 2 because pipe has a read end and a write end. We need to be
+          // able to read from the read end after write end is closed.
+          refcnt : 2,
+          timestamp: new Date(),
+        };
+  
+        pipe.buckets.push({
+          buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
+          offset: 0,
+          roffset: 0
+        });
+  
+        var rName = PIPEFS.nextname();
+        var wName = PIPEFS.nextname();
+        var rNode = FS.createNode(PIPEFS.root, rName, 4096, 0);
+        var wNode = FS.createNode(PIPEFS.root, wName, 4096, 0);
+  
+        rNode.pipe = pipe;
+        wNode.pipe = pipe;
+  
+        var readableStream = FS.createStream({
+          path: rName,
+          node: rNode,
+          flags: 0,
+          seekable: false,
+          stream_ops: PIPEFS.stream_ops
+        });
+        rNode.stream = readableStream;
+  
+        var writableStream = FS.createStream({
+          path: wName,
+          node: wNode,
+          flags: 1,
+          seekable: false,
+          stream_ops: PIPEFS.stream_ops
+        });
+        wNode.stream = writableStream;
+  
+        return {
+          readable_fd: readableStream.fd,
+          writable_fd: writableStream.fd
+        };
+      },
+  stream_ops:{
+  getattr(stream) {
+          var node = stream.node;
+          var timestamp = node.pipe.timestamp;
+          return {
+            dev: 14,
+            ino: node.id,
+            mode: 0o10600,
+            nlink: 1,
+            uid: 0,
+            gid: 0,
+            rdev: 0,
+            size: 0,
+            atime: timestamp,
+            mtime: timestamp,
+            ctime: timestamp,
+            blksize: 4096,
+            blocks: 0,
+          };
+        },
+  poll(stream, timeout, notifyCallback) {
+          var pipe = stream.node.pipe;
+  
+          if ((stream.flags & 2097155) === 1) {
+            return (256 | 4);
+          }
+          for (var bucket of pipe.buckets) {
+            if (bucket.offset - bucket.roffset > 0) {
+              return (64 | 1);
+            }
+          }
+  
+          return 0;
+        },
+  dup(stream) {
+          stream.node.pipe.refcnt++;
+        },
+  ioctl(stream, request, varargs) {
+          return 28;
+        },
+  fsync(stream) {
+          return 28;
+        },
+  read(stream, buffer, offset, length, position /* ignored */) {
+          var pipe = stream.node.pipe;
+          var currentLength = 0;
+  
+          for (var bucket of pipe.buckets) {
+            currentLength += bucket.offset - bucket.roffset;
+          }
+  
+          assert(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer));
+          var data = buffer.subarray(offset, offset + length);
+  
+          if (length <= 0) {
+            return 0;
+          }
+          if (currentLength == 0) {
+            // Behave as if the read end is always non-blocking
+            throw new FS.ErrnoError(6);
+          }
+          var toRead = Math.min(currentLength, length);
+  
+          var totalRead = toRead;
+          var toRemove = 0;
+  
+          for (var bucket of pipe.buckets) {
+            var bucketSize = bucket.offset - bucket.roffset;
+  
+            if (toRead <= bucketSize) {
+              var tmpSlice = bucket.buffer.subarray(bucket.roffset, bucket.offset);
+              if (toRead < bucketSize) {
+                tmpSlice = tmpSlice.subarray(0, toRead);
+                bucket.roffset += toRead;
+              } else {
+                toRemove++;
+              }
+              data.set(tmpSlice);
+              break;
+            } else {
+              var tmpSlice = bucket.buffer.subarray(bucket.roffset, bucket.offset);
+              data.set(tmpSlice);
+              data = data.subarray(tmpSlice.byteLength);
+              toRead -= tmpSlice.byteLength;
+              toRemove++;
+            }
+          }
+  
+          if (toRemove && toRemove == pipe.buckets.length) {
+            // Do not generate excessive garbage in use cases such as
+            // write several bytes, read everything, write several bytes, read everything...
+            toRemove--;
+            pipe.buckets[toRemove].offset = 0;
+            pipe.buckets[toRemove].roffset = 0;
+          }
+  
+          pipe.buckets.splice(0, toRemove);
+  
+          return totalRead;
+        },
+  write(stream, buffer, offset, length, position /* ignored */) {
+          var pipe = stream.node.pipe;
+  
+          assert(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer));
+          var data = buffer.subarray(offset, offset + length);
+  
+          var dataLen = data.byteLength;
+          if (dataLen <= 0) {
+            return 0;
+          }
+  
+          var currBucket = null;
+  
+          if (pipe.buckets.length == 0) {
+            currBucket = {
+              buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
+              offset: 0,
+              roffset: 0
+            };
+            pipe.buckets.push(currBucket);
+          } else {
+            currBucket = pipe.buckets[pipe.buckets.length - 1];
+          }
+  
+          assert(currBucket.offset <= PIPEFS.BUCKET_BUFFER_SIZE);
+  
+          var freeBytesInCurrBuffer = PIPEFS.BUCKET_BUFFER_SIZE - currBucket.offset;
+          if (freeBytesInCurrBuffer >= dataLen) {
+            currBucket.buffer.set(data, currBucket.offset);
+            currBucket.offset += dataLen;
+            return dataLen;
+          } else if (freeBytesInCurrBuffer > 0) {
+            currBucket.buffer.set(data.subarray(0, freeBytesInCurrBuffer), currBucket.offset);
+            currBucket.offset += freeBytesInCurrBuffer;
+            data = data.subarray(freeBytesInCurrBuffer, data.byteLength);
+          }
+  
+          var numBuckets = (data.byteLength / PIPEFS.BUCKET_BUFFER_SIZE) | 0;
+          var remElements = data.byteLength % PIPEFS.BUCKET_BUFFER_SIZE;
+  
+          for (var i = 0; i < numBuckets; i++) {
+            var newBucket = {
+              buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
+              offset: PIPEFS.BUCKET_BUFFER_SIZE,
+              roffset: 0
+            };
+            pipe.buckets.push(newBucket);
+            newBucket.buffer.set(data.subarray(0, PIPEFS.BUCKET_BUFFER_SIZE));
+            data = data.subarray(PIPEFS.BUCKET_BUFFER_SIZE, data.byteLength);
+          }
+  
+          if (remElements > 0) {
+            var newBucket = {
+              buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
+              offset: data.byteLength,
+              roffset: 0
+            };
+            pipe.buckets.push(newBucket);
+            newBucket.buffer.set(data);
+          }
+  
+          return dataLen;
+        },
+  close(stream) {
+          var pipe = stream.node.pipe;
+          pipe.refcnt--;
+          if (pipe.refcnt === 0) {
+            pipe.buckets = null;
+          }
+        },
+  },
+  nextname() {
+        if (!PIPEFS.nextname.current) {
+          PIPEFS.nextname.current = 0;
+        }
+        return 'pipe[' + (PIPEFS.nextname.current++) + ']';
+      },
+  };
+  function ___syscall_pipe(fdPtr) {
+  try {
+  
+      if (fdPtr == 0) {
+        throw new FS.ErrnoError(21);
+      }
+  
+      var res = PIPEFS.createPipe();
+  
+      HEAP32[((fdPtr)>>2)] = res.readable_fd;
+      HEAP32[(((fdPtr)+(4))>>2)] = res.writable_fd;
+  
+      return 0;
+    } catch (e) {
+    if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+    return -e.errno;
+  }
+  }
+
   
   
   function ___syscall_readlinkat(dirfd, path, buf, bufsize) {
@@ -4077,45 +4328,6 @@ async function createWasm() {
       runtimeKeepaliveCounter = 0;
     };
 
-  var __emscripten_system = (command) => {
-      if (ENVIRONMENT_IS_NODE) {
-        if (!command) return 1; // shell is available
-  
-        var cmdstr = UTF8ToString(command);
-        if (!cmdstr.length) return 0; // this is what glibc seems to do (shell works test?)
-  
-        var cp = require('child_process');
-        var ret = cp.spawnSync(cmdstr, [], {shell:true, stdio:'inherit'});
-  
-        var _W_EXITCODE = (ret, sig) => ((ret) << 8 | (sig));
-  
-        // this really only can happen if process is killed by signal
-        if (ret.status === null) {
-          // sadly node doesn't expose such function
-          var signalToNumber = (sig) => {
-            // implement only the most common ones, and fallback to SIGINT
-            switch (sig) {
-              case 'SIGHUP': return 1;
-              case 'SIGQUIT': return 3;
-              case 'SIGFPE': return 8;
-              case 'SIGKILL': return 9;
-              case 'SIGALRM': return 14;
-              case 'SIGTERM': return 15;
-              default: return 2;
-            }
-          }
-          return _W_EXITCODE(0, signalToNumber(ret.signal));
-        }
-  
-        return _W_EXITCODE(ret.status, 0);
-      }
-      // int system(const char *command);
-      // http://pubs.opengroup.org/onlinepubs/000095399/functions/system.html
-      // Can't call external programs.
-      if (!command) return 0; // no shell available
-      return -52;
-    };
-
   var isLeapYear = (year) => year%4 === 0 && (year%100 !== 0 || year%400 === 0);
   
   var MONTH_DAYS_LEAP_CUMULATIVE = [0,31,60,91,121,152,182,213,244,274,305,335];
@@ -4556,23 +4768,22 @@ async function createWasm() {
 
   /** @param {number=} offset */
   var doWritev = (stream, iov, iovcnt, offset) => {
-      var ret = 0;
-      for (var i = 0; i < iovcnt; i++) {
-        var ptr = HEAPU32[((iov)>>2)];
-        var len = HEAPU32[(((iov)+(4))>>2)];
-        iov += 8;
-        var curr = FS.write(stream, HEAP8, ptr, len, offset);
-        if (curr < 0) return -1;
-        ret += curr;
-        if (curr < len) {
-          // No more space to write.
-          break;
-        }
-        if (typeof offset != 'undefined') {
-          offset += curr;
-        }
+      if (iovcnt == 1) {
+        return FS.write(stream, HEAP8, HEAPU32[iov >> 2], HEAPU32[(iov + 4) >> 2], offset);
       }
-      return ret;
+      var total = 0;
+      for (var i = 0, p = iov; i < iovcnt; i++, p += 8) {
+        total += HEAPU32[(p + 4) >> 2];
+      }
+      var view = new Uint8Array(total);
+      var voff = 0;
+      for (var i = 0; i < iovcnt; i++, iov += 8) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[(iov + 4) >> 2];
+        view.set(HEAPU8.subarray(ptr, ptr + len), voff);
+        voff += len;
+      }
+      return FS.write(stream, view, 0, total, offset);
     };
   
   function _fd_write(fd, iov, iovcnt, pnum) {
@@ -5097,8 +5308,18 @@ unexportedSymbols.forEach(unexportedRuntimeSymbol);
 function checkIncomingModuleAPI() {
   ignoredModuleProp('fetchSettings');
 }
+function slicc_spawn_capture_js(path,argv,envp,cwd,in_fd,out_fd,err_fd,actions,nactions) { const strings = (ptr) => { const out = []; for (let i = 0; ptr; i++) { const s = HEAPU32[(ptr >> 2) + i]; if (!s) break; out.push(UTF8ToString(s)); } return out; }; const isTty = (st) => st && FS.isChrdev(st.node.mode); const file = UTF8ToString(path); if (!file) return -44; const args = strings(argv); const envList = strings(envp); const env = {}; for (const kv of envList) { const eq = kv.indexOf('='); if (eq > 0) env[kv.slice(0, eq)] = kv.slice(eq + 1); } if (Module.sliccKernel) { const pairs = []; for (let i = 0; i < nactions; i++) { pairs.push([HEAP32[(actions >> 2) + 2 * i], HEAP32[(actions >> 2) + 2 * i + 1]]); } return Module.sliccKernel.spawn(file, args, envList.length ? env : null, cwd ? UTF8ToString(cwd) : null, [in_fd === -2 ? 0 : in_fd, out_fd, err_fd], pairs); } let input; if (in_fd >= 0) { try { const st = FS.getStream(in_fd); if (st && !isTty(st)) { const chunks = []; const buf = new Uint8Array(65536); let n; while ((n = FS.read(st, buf, 0, buf.length)) > 0) chunks.push(buf.slice(0, n)); if (chunks.length) input = Buffer.concat(chunks); } } catch (e) { } } if (Module.sliccBeforeSpawn) Module.sliccBeforeSpawn(); let r; try { r = require('child_process').spawnSync(file, args.slice(1), { cwd: cwd ? UTF8ToString(cwd) : FS.cwd(), env: envList.length ? env : process.env, input, }); } catch (e) { return e && e.code === 'ENOENT' ? -44 : -29; } finally { if (Module.sliccAfterSpawn) Module.sliccAfterSpawn(); } if (r.error) return r.error.code === 'ENOENT' ? -44 : -29; const put = (fd, data) => { if (fd < 0 || !data || !data.length) return; const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data; let st; try { st = FS.getStream(fd); } catch (e) {} if ((fd === 1 || fd === 2) && (!st || isTty(st))) { (fd === 1 ? process.stdout : process.stderr).write(bytes); return; } if (st) FS.write(st, bytes, 0, bytes.length); }; put(out_fd, r.stdout); put(err_fd, r.stderr); Module.sliccExited = Module.sliccExited || new Map(); Module.sliccNextPid = Module.sliccNextPid || 1000; const pid = ++Module.sliccNextPid; Module.sliccExited.set(pid, r.signal ? 9 : ((r.status ?? 1) & 0xff) << 8); return pid; }
+function slicc_wait_js(pid,status,options) { const nohang = options & 1; const gone = (st) => (st & 0xff) !== 0x7f && st !== 0xffff; const done = Module.sliccExited; const kernel = Module.sliccKernel; if (kernel) { const put = (reaped, st) => { if (status && reaped > 0) HEAP32[status >> 2] = st; return reaped; }; const exitedKey = pid > 0 ? (done?.has(pid) ? pid : undefined) : done?.keys().next().value; if (exitedKey !== undefined) { const st = done.get(exitedKey); done.delete(exitedKey); return put(exitedKey, st); } const aliases = Module.sliccAliases; if (pid > 0 && aliases?.has(pid)) { const r = kernel.wait(aliases.get(pid), !!nohang, options); if (typeof r === 'number') return r; if (r[0] > 0 && gone(r[1])) aliases.delete(pid); return put(r[0] > 0 ? pid : 0, r[1]); } const r = kernel.wait(pid, !!nohang, options); if (typeof r === 'number') return r; for (const [forkPid, kernelPid] of aliases ?? []) { if (kernelPid !== r[0]) continue; if (gone(r[1])) aliases.delete(forkPid); return put(forkPid, r[1]); } return put(r[0], r[1]); } if (!done || done.size === 0) return -12; const key = pid > 0 ? pid : done.keys().next().value; if (!done.has(key)) return -12; if (status) HEAP32[status >> 2] = done.get(key); done.delete(key); return key; }
+function slicc_exec_detach(pid) { if (!Module.sliccKernel || typeof SliccFork === 'undefined' || !SliccFork.stack.length) return 0; SliccFork.execPid = pid; return 1; }
 function slicc_sleep_ms(ms) { if (typeof SharedArrayBuffer === 'function' && typeof Atomics === 'object') { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); return; } const end = Date.now() + ms; while (Date.now() < end) {} }
+function slicc_default_getpid_js() { return (Module.sliccPid | 0) || 42; }
+function slicc_default_getppid_js() { return (Module.sliccPpid | 0) || 1; }
 function slicc_kill_js(pid,sig) { if (Module.sliccKernel && Module.sliccKernel.kill) return Module.sliccKernel.kill(pid, sig); return 1; }
+function slicc_pause_js() { if (Module.sliccKernel && Module.sliccKernel.pause) return Module.sliccKernel.pause(); return -52; }
+function slicc_cred_js(out) { const k = Module.sliccKernel; if (!k || !k.cred) return -52; const c = k.cred(); if (typeof c === 'number') return c; ['ruid', 'euid', 'suid', 'rgid', 'egid', 'sgid'].forEach((key, i) => { HEAPU32[(out >> 2) + i] = c[key] >>> 0; }); return 0; }
+function slicc_groups_js(list,cap) { const k = Module.sliccKernel; if (!k || !k.cred) return -52; const c = k.cred(); if (typeof c === 'number') return c; if (cap === 0) return c.groups.length; if (cap < c.groups.length) return -28; c.groups.forEach((g, i) => { HEAPU32[(list >> 2) + i] = g >>> 0; }); return c.groups.length; }
+function slicc_setcred_js(ruid,euid,suid,rgid,egid,sgid) { const k = Module.sliccKernel; if (!k || !k.setcred) return -52; const change = {}; const ids = { ruid, euid, suid, rgid, egid, sgid }; for (const key in ids) if (ids[key] !== -1) change[key] = ids[key] >>> 0; const r = k.setcred(change); return typeof r === 'number' ? r : 0; }
+function slicc_setgroups_js(list,n) { const k = Module.sliccKernel; if (!k || !k.setcred) return -52; const groups = []; for (let i = 0; i < n; i++) groups.push(HEAPU32[(list >> 2) + i]); const r = k.setcred({ groups }); return typeof r === 'number' ? r : 0; }
 
 // Imports from the Wasm binary.
 var _strerror = makeInvalidEarlyAccess('_strerror');
@@ -5107,11 +5328,12 @@ var _main = Module['_main'] = makeInvalidEarlyAccess('_main');
 var _slicc_sigpipe = Module['_slicc_sigpipe'] = makeInvalidEarlyAccess('_slicc_sigpipe');
 var _slicc_raise = Module['_slicc_raise'] = makeInvalidEarlyAccess('_slicc_raise');
 var _slicc_sig_mask = Module['_slicc_sig_mask'] = makeInvalidEarlyAccess('_slicc_sig_mask');
+var _slicc_cred_euid = Module['_slicc_cred_euid'] = makeInvalidEarlyAccess('_slicc_cred_euid');
 var ___funcs_on_exit = makeInvalidEarlyAccess('___funcs_on_exit');
-var _emscripten_stack_get_end = makeInvalidEarlyAccess('_emscripten_stack_get_end');
-var _emscripten_stack_get_base = makeInvalidEarlyAccess('_emscripten_stack_get_base');
 var _emscripten_stack_init = makeInvalidEarlyAccess('_emscripten_stack_init');
 var _emscripten_stack_get_free = makeInvalidEarlyAccess('_emscripten_stack_get_free');
+var _emscripten_stack_get_base = makeInvalidEarlyAccess('_emscripten_stack_get_base');
+var _emscripten_stack_get_end = makeInvalidEarlyAccess('_emscripten_stack_get_end');
 var __emscripten_stack_restore = makeInvalidEarlyAccess('__emscripten_stack_restore');
 var __emscripten_stack_alloc = makeInvalidEarlyAccess('__emscripten_stack_alloc');
 var _emscripten_stack_get_current = makeInvalidEarlyAccess('_emscripten_stack_get_current');
@@ -5127,11 +5349,12 @@ function assignWasmExports(wasmExports) {
   assert(typeof wasmExports['slicc_sigpipe'] != 'undefined', 'missing Wasm export: slicc_sigpipe');
   assert(typeof wasmExports['slicc_raise'] != 'undefined', 'missing Wasm export: slicc_raise');
   assert(typeof wasmExports['slicc_sig_mask'] != 'undefined', 'missing Wasm export: slicc_sig_mask');
+  assert(typeof wasmExports['slicc_cred_euid'] != 'undefined', 'missing Wasm export: slicc_cred_euid');
   assert(typeof wasmExports['__funcs_on_exit'] != 'undefined', 'missing Wasm export: __funcs_on_exit');
-  assert(typeof wasmExports['emscripten_stack_get_end'] != 'undefined', 'missing Wasm export: emscripten_stack_get_end');
-  assert(typeof wasmExports['emscripten_stack_get_base'] != 'undefined', 'missing Wasm export: emscripten_stack_get_base');
   assert(typeof wasmExports['emscripten_stack_init'] != 'undefined', 'missing Wasm export: emscripten_stack_init');
   assert(typeof wasmExports['emscripten_stack_get_free'] != 'undefined', 'missing Wasm export: emscripten_stack_get_free');
+  assert(typeof wasmExports['emscripten_stack_get_base'] != 'undefined', 'missing Wasm export: emscripten_stack_get_base');
+  assert(typeof wasmExports['emscripten_stack_get_end'] != 'undefined', 'missing Wasm export: emscripten_stack_get_end');
   assert(typeof wasmExports['_emscripten_stack_restore'] != 'undefined', 'missing Wasm export: _emscripten_stack_restore');
   assert(typeof wasmExports['_emscripten_stack_alloc'] != 'undefined', 'missing Wasm export: _emscripten_stack_alloc');
   assert(typeof wasmExports['emscripten_stack_get_current'] != 'undefined', 'missing Wasm export: emscripten_stack_get_current');
@@ -5143,11 +5366,12 @@ function assignWasmExports(wasmExports) {
   _slicc_sigpipe = Module['_slicc_sigpipe'] = createExportWrapper('slicc_sigpipe', 0);
   _slicc_raise = Module['_slicc_raise'] = createExportWrapper('slicc_raise', 1);
   _slicc_sig_mask = Module['_slicc_sig_mask'] = createExportWrapper('slicc_sig_mask', 1);
+  _slicc_cred_euid = Module['_slicc_cred_euid'] = createExportWrapper('slicc_cred_euid', 0);
   ___funcs_on_exit = createExportWrapper('__funcs_on_exit', 0);
-  _emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'];
-  _emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'];
   _emscripten_stack_init = wasmExports['emscripten_stack_init'];
   _emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'];
+  _emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'];
+  _emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'];
   __emscripten_stack_restore = wasmExports['_emscripten_stack_restore'];
   __emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'];
   _emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'];
@@ -5175,6 +5399,8 @@ var wasmImports = {
   /** @export */
   __syscall_openat: ___syscall_openat,
   /** @export */
+  __syscall_pipe: ___syscall_pipe,
+  /** @export */
   __syscall_readlinkat: ___syscall_readlinkat,
   /** @export */
   __syscall_renameat: ___syscall_renameat,
@@ -5191,8 +5417,6 @@ var wasmImports = {
   /** @export */
   _emscripten_runtime_keepalive_clear: __emscripten_runtime_keepalive_clear,
   /** @export */
-  _emscripten_system: __emscripten_system,
-  /** @export */
   _localtime_js: __localtime_js,
   /** @export */
   _mktime_js: __mktime_js,
@@ -5221,7 +5445,19 @@ var wasmImports = {
   /** @export */
   fd_write: _fd_write,
   /** @export */
-  proc_exit: _proc_exit
+  proc_exit: _proc_exit,
+  /** @export */
+  slicc_cred_js,
+  /** @export */
+  slicc_default_getpid_js,
+  /** @export */
+  slicc_kill_js,
+  /** @export */
+  slicc_pause_js,
+  /** @export */
+  slicc_spawn_capture_js,
+  /** @export */
+  slicc_wait_js
 };
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/wasm-zip",
-  "version": "3.0.0-1",
+  "version": "3.0.0-2",
   "description": "Info-ZIP zip 3.0 + unzip 6.0 for wasm / slicc (emscripten)",
   "license": "Info-ZIP",
   "repository": {