@vercel/python-analysis 0.9.1 → 0.10.0

package/dist/wasm/vercel_python_analysis.js

@@ -5,6 +5,22 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
   
   const toUint64 = val => BigInt.asUintN(64, BigInt(val));
   
+  function toUint16(val) {
+    val >>>= 0;
+    val %= 2 ** 16;
+    return val;
+  }
+  
+  function toUint32(val) {
+    return val >>> 0;
+  }
+  
+  function toUint8(val) {
+    val >>>= 0;
+    val %= 2 ** 8;
+    return val;
+  }
+  
   const utf8Decoder = new TextDecoder();
   
   const utf8Encoder = new TextEncoder();
@@ -790,6 +806,7 @@ const module0 = getCoreModule('vercel_python_analysis.core.wasm');
 const module1 = getCoreModule('vercel_python_analysis.core2.wasm');
 const module2 = getCoreModule('vercel_python_analysis.core3.wasm');
 
+const { domainToAscii, nfkcNormalize, readFile } = imports['vercel:python-analysis/host-utils'];
 const { getEnvironment } = imports['wasi:cli/environment'];
 const { exit } = imports['wasi:cli/exit'];
 const { getStderr } = imports['wasi:cli/stderr'];
@@ -800,6 +817,8 @@ const { TerminalOutput } = imports['wasi:cli/terminal-output'];
 const { getTerminalStderr } = imports['wasi:cli/terminal-stderr'];
 const { getTerminalStdin } = imports['wasi:cli/terminal-stdin'];
 const { getTerminalStdout } = imports['wasi:cli/terminal-stdout'];
+const { getDirectories } = imports['wasi:filesystem/preopens'];
+const { Descriptor } = imports['wasi:filesystem/types'];
 const { Error: Error$1 } = imports['wasi:io/error'];
 const { Pollable } = imports['wasi:io/poll'];
 const { InputStream, OutputStream } = imports['wasi:io/streams'];
@@ -807,7 +826,7 @@ const { insecureSeed } = imports['wasi:random/insecure-seed'];
 let gen = (function* _initGenerator () {
   let exports0;
   
-  function trampoline6(arg0) {
+  function trampoline7(arg0) {
     let variant0;
     switch (arg0) {
       case 0: {
@@ -846,7 +865,7 @@ let gen = (function* _initGenerator () {
   let captureCnt0 = 0;
   handleTables[0] = handleTable0;
   
-  function trampoline7(arg0) {
+  function trampoline8(arg0) {
     var handle1 = arg0;
     var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
     var rsc0 = captureTable0.get(rep2);
@@ -878,7 +897,7 @@ let gen = (function* _initGenerator () {
   let captureCnt3 = 0;
   handleTables[3] = handleTable3;
   
-  function trampoline8(arg0) {
+  function trampoline9(arg0) {
     var handle1 = arg0;
     var rep2 = handleTable3[(handle1 << 1) + 1] & ~T_FLAG;
     var rsc0 = captureTable3.get(rep2);
@@ -920,7 +939,7 @@ let gen = (function* _initGenerator () {
   let captureCnt2 = 0;
   handleTables[2] = handleTable2;
   
-  function trampoline9() {
+  function trampoline10() {
     _debugLog('[iface="wasi:cli/stdin@0.2.6", function="get-stdin"] [Instruction::CallInterface] (async? sync, @ enter)');
     const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stdin');
     const ret = getStdin();
@@ -945,7 +964,7 @@ let gen = (function* _initGenerator () {
   }
   
   
-  function trampoline10() {
+  function trampoline11() {
     _debugLog('[iface="wasi:cli/stdout@0.2.6", function="get-stdout"] [Instruction::CallInterface] (async? sync, @ enter)');
     const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stdout');
     const ret = getStdout();
@@ -970,7 +989,7 @@ let gen = (function* _initGenerator () {
   }
   
   
-  function trampoline11() {
+  function trampoline12() {
     _debugLog('[iface="wasi:cli/stderr@0.2.6", function="get-stderr"] [Instruction::CallInterface] (async? sync, @ enter)');
     const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stderr');
     const ret = getStderr();
@@ -998,7 +1017,123 @@ let gen = (function* _initGenerator () {
   let memory0;
   let realloc0;
   
-  function trampoline12(arg0) {
+  function trampoline13(arg0, arg1, arg2) {
+    var ptr0 = arg0;
+    var len0 = arg1;
+    var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="read-file"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'read-file');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: readFile(result0)};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="read-file"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var variant3 = ret;
+    switch (variant3.tag) {
+      case 'ok': {
+        const e = variant3.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        var ptr1 = utf8Encode(e, realloc0, memory0);
+        var len1 = utf8EncodedLen;
+        dataView(memory0).setUint32(arg2 + 8, len1, true);
+        dataView(memory0).setUint32(arg2 + 4, ptr1, true);
+        break;
+      }
+      case 'err': {
+        const e = variant3.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var ptr2 = utf8Encode(e, realloc0, memory0);
+        var len2 = utf8EncodedLen;
+        dataView(memory0).setUint32(arg2 + 8, len2, true);
+        dataView(memory0).setUint32(arg2 + 4, ptr2, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="read-file"][Instruction::Return]', {
+      funcName: 'read-file',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline14(arg0, arg1, arg2) {
+    var ptr0 = arg0;
+    var len0 = arg1;
+    var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="nfkc-normalize"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'nfkc-normalize');
+    const ret = nfkcNormalize(result0);
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="nfkc-normalize"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var ptr1 = utf8Encode(ret, realloc0, memory0);
+    var len1 = utf8EncodedLen;
+    dataView(memory0).setUint32(arg2 + 4, len1, true);
+    dataView(memory0).setUint32(arg2 + 0, ptr1, true);
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="nfkc-normalize"][Instruction::Return]', {
+      funcName: 'nfkc-normalize',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline15(arg0, arg1, arg2) {
+    var ptr0 = arg0;
+    var len0 = arg1;
+    var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="domain-to-ascii"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'domain-to-ascii');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: domainToAscii(result0)};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="domain-to-ascii"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var variant3 = ret;
+    switch (variant3.tag) {
+      case 'ok': {
+        const e = variant3.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        var ptr1 = utf8Encode(e, realloc0, memory0);
+        var len1 = utf8EncodedLen;
+        dataView(memory0).setUint32(arg2 + 8, len1, true);
+        dataView(memory0).setUint32(arg2 + 4, ptr1, true);
+        break;
+      }
+      case 'err': {
+        const e = variant3.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var ptr2 = utf8Encode(e, realloc0, memory0);
+        var len2 = utf8EncodedLen;
+        dataView(memory0).setUint32(arg2 + 8, len2, true);
+        dataView(memory0).setUint32(arg2 + 4, ptr2, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="vercel:python-analysis/host-utils", function="domain-to-ascii"][Instruction::Return]', {
+      funcName: 'domain-to-ascii',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline16(arg0) {
     _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"] [Instruction::CallInterface] (async? sync, @ enter)');
     const _interface_call_currentTaskID = startCurrentTask(0, false, 'insecure-seed');
     const ret = insecureSeed();
@@ -1020,7 +1155,7 @@ let gen = (function* _initGenerator () {
   let captureCnt1 = 0;
   handleTables[1] = handleTable1;
   
-  function trampoline13(arg0, arg1) {
+  function trampoline17(arg0, arg1) {
     var handle1 = arg0;
     var rep2 = handleTable3[(handle1 << 1) + 1] & ~T_FLAG;
     var rsc0 = captureTable3.get(rep2);
@@ -1095,7 +1230,7 @@ let gen = (function* _initGenerator () {
   }
   
   
-  function trampoline14(arg0, arg1, arg2, arg3) {
+  function trampoline18(arg0, arg1, arg2, arg3) {
     var handle1 = arg0;
     var rep2 = handleTable3[(handle1 << 1) + 1] & ~T_FLAG;
     var rsc0 = captureTable3.get(rep2);
@@ -1172,7 +1307,7 @@ let gen = (function* _initGenerator () {
   }
   
   
-  function trampoline15(arg0, arg1) {
+  function trampoline19(arg0, arg1) {
     var handle1 = arg0;
     var rep2 = handleTable3[(handle1 << 1) + 1] & ~T_FLAG;
     var rsc0 = captureTable3.get(rep2);
@@ -1245,86 +1380,1977 @@ let gen = (function* _initGenerator () {
     });
   }
   
+  const handleTable6 = [T_FLAG, 0];
+  const captureTable6= new Map();
+  let captureCnt6 = 0;
+  handleTables[6] = handleTable6;
   
-  function trampoline16(arg0) {
-    _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-environment');
-    const ret = getEnvironment();
-    _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    var vec3 = ret;
-    var len3 = vec3.length;
-    var result3 = realloc0(0, 0, 4, len3 * 16);
-    for (let i = 0; i < vec3.length; i++) {
-      const e = vec3[i];
-      const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
-      var ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
-      var len1 = utf8EncodedLen;
-      dataView(memory0).setUint32(base + 4, len1, true);
-      dataView(memory0).setUint32(base + 0, ptr1, true);
-      var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
-      var len2 = utf8EncodedLen;
-      dataView(memory0).setUint32(base + 12, len2, true);
-      dataView(memory0).setUint32(base + 8, ptr2, true);
+  function trampoline20(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable6.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
     }
-    dataView(memory0).setUint32(arg0 + 4, len3, true);
-    dataView(memory0).setUint32(arg0 + 0, result3, true);
-    _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"][Instruction::Return]', {
-      funcName: 'get-environment',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  const handleTable4 = [T_FLAG, 0];
-  const captureTable4= new Map();
-  let captureCnt4 = 0;
-  handleTables[4] = handleTable4;
-  
-  function trampoline17(arg0) {
-    _debugLog('[iface="wasi:cli/terminal-stdin@0.2.6", function="get-terminal-stdin"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-terminal-stdin');
-    const ret = getTerminalStdin();
-    _debugLog('[iface="wasi:cli/terminal-stdin@0.2.6", function="get-terminal-stdin"] [Instruction::CallInterface] (sync, @ post-call)');
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.read-via-stream"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.read-via-stream');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: rsc0.readViaStream(BigInt.asUintN(64, arg1))};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.read-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
     endCurrentTask(0);
-    var variant1 = ret;
-    if (variant1 === null || variant1=== undefined) {
-      dataView(memory0).setInt8(arg0 + 0, 0, true);
-    } else {
-      const e = variant1;
-      dataView(memory0).setInt8(arg0 + 0, 1, true);
-      if (!(e instanceof TerminalInput)) {
-        throw new TypeError('Resource error: Not a valid "TerminalInput" resource.');
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        if (!(e instanceof InputStream)) {
+          throw new TypeError('Resource error: Not a valid "InputStream" resource.');
+        }
+        var handle3 = e[symbolRscHandle];
+        if (!handle3) {
+          const rep = e[symbolRscRep] || ++captureCnt2;
+          captureTable2.set(rep, e);
+          handle3 = rscTableCreateOwn(handleTable2, rep);
+        }
+        dataView(memory0).setInt32(arg2 + 4, handle3, true);
+        break;
       }
-      var handle0 = e[symbolRscHandle];
-      if (!handle0) {
-        const rep = e[symbolRscRep] || ++captureCnt4;
-        captureTable4.set(rep, e);
-        handle0 = rscTableCreateOwn(handleTable4, rep);
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var val4 = e;
+        let enum4;
+        switch (val4) {
+          case 'access': {
+            enum4 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum4 = 1;
+            break;
+          }
+          case 'already': {
+            enum4 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum4 = 3;
+            break;
+          }
+          case 'busy': {
+            enum4 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum4 = 5;
+            break;
+          }
+          case 'quota': {
+            enum4 = 6;
+            break;
+          }
+          case 'exist': {
+            enum4 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum4 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum4 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum4 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum4 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum4 = 12;
+            break;
+          }
+          case 'io': {
+            enum4 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum4 = 14;
+            break;
+          }
+          case 'loop': {
+            enum4 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum4 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum4 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum4 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum4 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum4 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum4 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum4 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum4 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum4 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum4 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum4 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum4 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum4 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum4 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum4 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum4 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum4 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum4 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum4 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum4 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum4 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg2 + 4, enum4, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
       }
-      dataView(memory0).setInt32(arg0 + 4, handle0, true);
     }
-    _debugLog('[iface="wasi:cli/terminal-stdin@0.2.6", function="get-terminal-stdin"][Instruction::Return]', {
-      funcName: 'get-terminal-stdin',
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.read-via-stream"][Instruction::Return]', {
+      funcName: '[method]descriptor.read-via-stream',
       paramCount: 0,
       async: false,
       postReturn: false
     });
   }
   
-  const handleTable5 = [T_FLAG, 0];
-  const captureTable5= new Map();
-  let captureCnt5 = 0;
-  handleTables[5] = handleTable5;
   
-  function trampoline18(arg0) {
-    _debugLog('[iface="wasi:cli/terminal-stdout@0.2.6", function="get-terminal-stdout"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-terminal-stdout');
-    const ret = getTerminalStdout();
-    _debugLog('[iface="wasi:cli/terminal-stdout@0.2.6", function="get-terminal-stdout"] [Instruction::CallInterface] (sync, @ post-call)');
+  function trampoline21(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable6.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.write-via-stream');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: rsc0.writeViaStream(BigInt.asUintN(64, arg1))};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
     endCurrentTask(0);
-    var variant1 = ret;
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        if (!(e instanceof OutputStream)) {
+          throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+        }
+        var handle3 = e[symbolRscHandle];
+        if (!handle3) {
+          const rep = e[symbolRscRep] || ++captureCnt3;
+          captureTable3.set(rep, e);
+          handle3 = rscTableCreateOwn(handleTable3, rep);
+        }
+        dataView(memory0).setInt32(arg2 + 4, handle3, true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var val4 = e;
+        let enum4;
+        switch (val4) {
+          case 'access': {
+            enum4 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum4 = 1;
+            break;
+          }
+          case 'already': {
+            enum4 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum4 = 3;
+            break;
+          }
+          case 'busy': {
+            enum4 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum4 = 5;
+            break;
+          }
+          case 'quota': {
+            enum4 = 6;
+            break;
+          }
+          case 'exist': {
+            enum4 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum4 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum4 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum4 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum4 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum4 = 12;
+            break;
+          }
+          case 'io': {
+            enum4 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum4 = 14;
+            break;
+          }
+          case 'loop': {
+            enum4 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum4 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum4 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum4 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum4 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum4 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum4 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum4 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum4 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum4 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum4 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum4 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum4 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum4 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum4 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum4 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum4 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum4 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum4 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum4 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum4 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum4 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg2 + 4, enum4, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.write-via-stream"][Instruction::Return]', {
+      funcName: '[method]descriptor.write-via-stream',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline22(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable6.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.append-via-stream');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: rsc0.appendViaStream()};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        if (!(e instanceof OutputStream)) {
+          throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+        }
+        var handle3 = e[symbolRscHandle];
+        if (!handle3) {
+          const rep = e[symbolRscRep] || ++captureCnt3;
+          captureTable3.set(rep, e);
+          handle3 = rscTableCreateOwn(handleTable3, rep);
+        }
+        dataView(memory0).setInt32(arg1 + 4, handle3, true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val4 = e;
+        let enum4;
+        switch (val4) {
+          case 'access': {
+            enum4 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum4 = 1;
+            break;
+          }
+          case 'already': {
+            enum4 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum4 = 3;
+            break;
+          }
+          case 'busy': {
+            enum4 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum4 = 5;
+            break;
+          }
+          case 'quota': {
+            enum4 = 6;
+            break;
+          }
+          case 'exist': {
+            enum4 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum4 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum4 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum4 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum4 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum4 = 12;
+            break;
+          }
+          case 'io': {
+            enum4 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum4 = 14;
+            break;
+          }
+          case 'loop': {
+            enum4 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum4 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum4 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum4 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum4 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum4 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum4 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum4 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum4 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum4 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum4 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum4 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum4 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum4 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum4 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum4 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum4 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum4 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum4 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum4 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum4 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum4 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 4, enum4, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.append-via-stream"][Instruction::Return]', {
+      funcName: '[method]descriptor.append-via-stream',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline23(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable6.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.get-flags"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.get-flags');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: rsc0.getFlags()};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.get-flags"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        let flags3 = 0;
+        if (typeof e === 'object' && e !== null) {
+          flags3 = Boolean(e.read) << 0 | Boolean(e.write) << 1 | Boolean(e.fileIntegritySync) << 2 | Boolean(e.dataIntegritySync) << 3 | Boolean(e.requestedWriteSync) << 4 | Boolean(e.mutateDirectory) << 5;
+        } else if (e !== null && e!== undefined) {
+          throw new TypeError('only an object, undefined or null can be converted to flags');
+        }
+        dataView(memory0).setInt8(arg1 + 1, flags3, true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val4 = e;
+        let enum4;
+        switch (val4) {
+          case 'access': {
+            enum4 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum4 = 1;
+            break;
+          }
+          case 'already': {
+            enum4 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum4 = 3;
+            break;
+          }
+          case 'busy': {
+            enum4 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum4 = 5;
+            break;
+          }
+          case 'quota': {
+            enum4 = 6;
+            break;
+          }
+          case 'exist': {
+            enum4 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum4 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum4 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum4 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum4 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum4 = 12;
+            break;
+          }
+          case 'io': {
+            enum4 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum4 = 14;
+            break;
+          }
+          case 'loop': {
+            enum4 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum4 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum4 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum4 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum4 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum4 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum4 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum4 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum4 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum4 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum4 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum4 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum4 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum4 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum4 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum4 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum4 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum4 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum4 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum4 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum4 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum4 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 1, enum4, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.get-flags"][Instruction::Return]', {
+      funcName: '[method]descriptor.get-flags',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline24(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable6.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.stat"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.stat');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: rsc0.stat()};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.stat"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant12 = ret;
+    switch (variant12.tag) {
+      case 'ok': {
+        const e = variant12.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var {type: v3_0, linkCount: v3_1, size: v3_2, dataAccessTimestamp: v3_3, dataModificationTimestamp: v3_4, statusChangeTimestamp: v3_5 } = e;
+        var val4 = v3_0;
+        let enum4;
+        switch (val4) {
+          case 'unknown': {
+            enum4 = 0;
+            break;
+          }
+          case 'block-device': {
+            enum4 = 1;
+            break;
+          }
+          case 'character-device': {
+            enum4 = 2;
+            break;
+          }
+          case 'directory': {
+            enum4 = 3;
+            break;
+          }
+          case 'fifo': {
+            enum4 = 4;
+            break;
+          }
+          case 'symbolic-link': {
+            enum4 = 5;
+            break;
+          }
+          case 'regular-file': {
+            enum4 = 6;
+            break;
+          }
+          case 'socket': {
+            enum4 = 7;
+            break;
+          }
+          default: {
+            if ((v3_0) instanceof Error) {
+              console.error(v3_0);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum4, true);
+        dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
+        dataView(memory0).setBigInt64(arg1 + 24, toUint64(v3_2), true);
+        var variant6 = v3_3;
+        if (variant6 === null || variant6=== undefined) {
+          dataView(memory0).setInt8(arg1 + 32, 0, true);
+        } else {
+          const e = variant6;
+          dataView(memory0).setInt8(arg1 + 32, 1, true);
+          var {seconds: v5_0, nanoseconds: v5_1 } = e;
+          dataView(memory0).setBigInt64(arg1 + 40, toUint64(v5_0), true);
+          dataView(memory0).setInt32(arg1 + 48, toUint32(v5_1), true);
+        }
+        var variant8 = v3_4;
+        if (variant8 === null || variant8=== undefined) {
+          dataView(memory0).setInt8(arg1 + 56, 0, true);
+        } else {
+          const e = variant8;
+          dataView(memory0).setInt8(arg1 + 56, 1, true);
+          var {seconds: v7_0, nanoseconds: v7_1 } = e;
+          dataView(memory0).setBigInt64(arg1 + 64, toUint64(v7_0), true);
+          dataView(memory0).setInt32(arg1 + 72, toUint32(v7_1), true);
+        }
+        var variant10 = v3_5;
+        if (variant10 === null || variant10=== undefined) {
+          dataView(memory0).setInt8(arg1 + 80, 0, true);
+        } else {
+          const e = variant10;
+          dataView(memory0).setInt8(arg1 + 80, 1, true);
+          var {seconds: v9_0, nanoseconds: v9_1 } = e;
+          dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
+          dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
+        }
+        break;
+      }
+      case 'err': {
+        const e = variant12.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val11 = e;
+        let enum11;
+        switch (val11) {
+          case 'access': {
+            enum11 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum11 = 1;
+            break;
+          }
+          case 'already': {
+            enum11 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum11 = 3;
+            break;
+          }
+          case 'busy': {
+            enum11 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum11 = 5;
+            break;
+          }
+          case 'quota': {
+            enum11 = 6;
+            break;
+          }
+          case 'exist': {
+            enum11 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum11 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum11 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum11 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum11 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum11 = 12;
+            break;
+          }
+          case 'io': {
+            enum11 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum11 = 14;
+            break;
+          }
+          case 'loop': {
+            enum11 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum11 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum11 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum11 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum11 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum11 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum11 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum11 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum11 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum11 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum11 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum11 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum11 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum11 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum11 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum11 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum11 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum11 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum11 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum11 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum11 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum11 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val11}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum11, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.stat"][Instruction::Return]', {
+      funcName: '[method]descriptor.stat',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline25(arg0, arg1, arg2, arg3, arg4) {
+    var handle1 = arg0;
+    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable6.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    if ((arg1 & 4294967294) !== 0) {
+      throw new TypeError('flags have extraneous bits set');
+    }
+    var flags3 = {
+      symlinkFollow: Boolean(arg1 & 1),
+    };
+    var ptr4 = arg2;
+    var len4 = arg3;
+    var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.stat-at"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.stat-at');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: rsc0.statAt(flags3, result4)};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.stat-at"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant14 = ret;
+    switch (variant14.tag) {
+      case 'ok': {
+        const e = variant14.val;
+        dataView(memory0).setInt8(arg4 + 0, 0, true);
+        var {type: v5_0, linkCount: v5_1, size: v5_2, dataAccessTimestamp: v5_3, dataModificationTimestamp: v5_4, statusChangeTimestamp: v5_5 } = e;
+        var val6 = v5_0;
+        let enum6;
+        switch (val6) {
+          case 'unknown': {
+            enum6 = 0;
+            break;
+          }
+          case 'block-device': {
+            enum6 = 1;
+            break;
+          }
+          case 'character-device': {
+            enum6 = 2;
+            break;
+          }
+          case 'directory': {
+            enum6 = 3;
+            break;
+          }
+          case 'fifo': {
+            enum6 = 4;
+            break;
+          }
+          case 'symbolic-link': {
+            enum6 = 5;
+            break;
+          }
+          case 'regular-file': {
+            enum6 = 6;
+            break;
+          }
+          case 'socket': {
+            enum6 = 7;
+            break;
+          }
+          default: {
+            if ((v5_0) instanceof Error) {
+              console.error(v5_0);
+            }
+            
+            throw new TypeError(`"${val6}" is not one of the cases of descriptor-type`);
+          }
+        }
+        dataView(memory0).setInt8(arg4 + 8, enum6, true);
+        dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
+        dataView(memory0).setBigInt64(arg4 + 24, toUint64(v5_2), true);
+        var variant8 = v5_3;
+        if (variant8 === null || variant8=== undefined) {
+          dataView(memory0).setInt8(arg4 + 32, 0, true);
+        } else {
+          const e = variant8;
+          dataView(memory0).setInt8(arg4 + 32, 1, true);
+          var {seconds: v7_0, nanoseconds: v7_1 } = e;
+          dataView(memory0).setBigInt64(arg4 + 40, toUint64(v7_0), true);
+          dataView(memory0).setInt32(arg4 + 48, toUint32(v7_1), true);
+        }
+        var variant10 = v5_4;
+        if (variant10 === null || variant10=== undefined) {
+          dataView(memory0).setInt8(arg4 + 56, 0, true);
+        } else {
+          const e = variant10;
+          dataView(memory0).setInt8(arg4 + 56, 1, true);
+          var {seconds: v9_0, nanoseconds: v9_1 } = e;
+          dataView(memory0).setBigInt64(arg4 + 64, toUint64(v9_0), true);
+          dataView(memory0).setInt32(arg4 + 72, toUint32(v9_1), true);
+        }
+        var variant12 = v5_5;
+        if (variant12 === null || variant12=== undefined) {
+          dataView(memory0).setInt8(arg4 + 80, 0, true);
+        } else {
+          const e = variant12;
+          dataView(memory0).setInt8(arg4 + 80, 1, true);
+          var {seconds: v11_0, nanoseconds: v11_1 } = e;
+          dataView(memory0).setBigInt64(arg4 + 88, toUint64(v11_0), true);
+          dataView(memory0).setInt32(arg4 + 96, toUint32(v11_1), true);
+        }
+        break;
+      }
+      case 'err': {
+        const e = variant14.val;
+        dataView(memory0).setInt8(arg4 + 0, 1, true);
+        var val13 = e;
+        let enum13;
+        switch (val13) {
+          case 'access': {
+            enum13 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum13 = 1;
+            break;
+          }
+          case 'already': {
+            enum13 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum13 = 3;
+            break;
+          }
+          case 'busy': {
+            enum13 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum13 = 5;
+            break;
+          }
+          case 'quota': {
+            enum13 = 6;
+            break;
+          }
+          case 'exist': {
+            enum13 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum13 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum13 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum13 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum13 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum13 = 12;
+            break;
+          }
+          case 'io': {
+            enum13 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum13 = 14;
+            break;
+          }
+          case 'loop': {
+            enum13 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum13 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum13 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum13 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum13 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum13 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum13 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum13 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum13 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum13 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum13 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum13 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum13 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum13 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum13 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum13 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum13 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum13 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum13 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum13 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum13 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum13 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val13}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg4 + 8, enum13, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.stat-at"][Instruction::Return]', {
+      funcName: '[method]descriptor.stat-at',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline26(arg0, arg1) {
+    var handle1 = arg0;
+    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable6.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.metadata-hash"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.metadata-hash');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: rsc0.metadataHash()};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.metadata-hash"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case 'ok': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var {lower: v3_0, upper: v3_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 8, toUint64(v3_0), true);
+        dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
+        break;
+      }
+      case 'err': {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val4 = e;
+        let enum4;
+        switch (val4) {
+          case 'access': {
+            enum4 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum4 = 1;
+            break;
+          }
+          case 'already': {
+            enum4 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum4 = 3;
+            break;
+          }
+          case 'busy': {
+            enum4 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum4 = 5;
+            break;
+          }
+          case 'quota': {
+            enum4 = 6;
+            break;
+          }
+          case 'exist': {
+            enum4 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum4 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum4 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum4 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum4 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum4 = 12;
+            break;
+          }
+          case 'io': {
+            enum4 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum4 = 14;
+            break;
+          }
+          case 'loop': {
+            enum4 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum4 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum4 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum4 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum4 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum4 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum4 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum4 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum4 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum4 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum4 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum4 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum4 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum4 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum4 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum4 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum4 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum4 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum4 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum4 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum4 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum4 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum4, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.metadata-hash"][Instruction::Return]', {
+      funcName: '[method]descriptor.metadata-hash',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline27(arg0, arg1, arg2, arg3, arg4) {
+    var handle1 = arg0;
+    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+    var rsc0 = captureTable6.get(rep2);
+    if (!rsc0) {
+      rsc0 = Object.create(Descriptor.prototype);
+      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+    }
+    curResourceBorrows.push(rsc0);
+    if ((arg1 & 4294967294) !== 0) {
+      throw new TypeError('flags have extraneous bits set');
+    }
+    var flags3 = {
+      symlinkFollow: Boolean(arg1 & 1),
+    };
+    var ptr4 = arg2;
+    var len4 = arg3;
+    var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.metadata-hash-at"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.metadata-hash-at');
+    let ret;
+    try {
+      ret = { tag: 'ok', val: rsc0.metadataHashAt(flags3, result4)};
+    } catch (e) {
+      ret = { tag: 'err', val: getErrorPayload(e) };
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.metadata-hash-at"] [Instruction::CallInterface] (sync, @ post-call)');
+    for (const rsc of curResourceBorrows) {
+      rsc[symbolRscHandle] = undefined;
+    }
+    curResourceBorrows = [];
+    endCurrentTask(0);
+    var variant7 = ret;
+    switch (variant7.tag) {
+      case 'ok': {
+        const e = variant7.val;
+        dataView(memory0).setInt8(arg4 + 0, 0, true);
+        var {lower: v5_0, upper: v5_1 } = e;
+        dataView(memory0).setBigInt64(arg4 + 8, toUint64(v5_0), true);
+        dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
+        break;
+      }
+      case 'err': {
+        const e = variant7.val;
+        dataView(memory0).setInt8(arg4 + 0, 1, true);
+        var val6 = e;
+        let enum6;
+        switch (val6) {
+          case 'access': {
+            enum6 = 0;
+            break;
+          }
+          case 'would-block': {
+            enum6 = 1;
+            break;
+          }
+          case 'already': {
+            enum6 = 2;
+            break;
+          }
+          case 'bad-descriptor': {
+            enum6 = 3;
+            break;
+          }
+          case 'busy': {
+            enum6 = 4;
+            break;
+          }
+          case 'deadlock': {
+            enum6 = 5;
+            break;
+          }
+          case 'quota': {
+            enum6 = 6;
+            break;
+          }
+          case 'exist': {
+            enum6 = 7;
+            break;
+          }
+          case 'file-too-large': {
+            enum6 = 8;
+            break;
+          }
+          case 'illegal-byte-sequence': {
+            enum6 = 9;
+            break;
+          }
+          case 'in-progress': {
+            enum6 = 10;
+            break;
+          }
+          case 'interrupted': {
+            enum6 = 11;
+            break;
+          }
+          case 'invalid': {
+            enum6 = 12;
+            break;
+          }
+          case 'io': {
+            enum6 = 13;
+            break;
+          }
+          case 'is-directory': {
+            enum6 = 14;
+            break;
+          }
+          case 'loop': {
+            enum6 = 15;
+            break;
+          }
+          case 'too-many-links': {
+            enum6 = 16;
+            break;
+          }
+          case 'message-size': {
+            enum6 = 17;
+            break;
+          }
+          case 'name-too-long': {
+            enum6 = 18;
+            break;
+          }
+          case 'no-device': {
+            enum6 = 19;
+            break;
+          }
+          case 'no-entry': {
+            enum6 = 20;
+            break;
+          }
+          case 'no-lock': {
+            enum6 = 21;
+            break;
+          }
+          case 'insufficient-memory': {
+            enum6 = 22;
+            break;
+          }
+          case 'insufficient-space': {
+            enum6 = 23;
+            break;
+          }
+          case 'not-directory': {
+            enum6 = 24;
+            break;
+          }
+          case 'not-empty': {
+            enum6 = 25;
+            break;
+          }
+          case 'not-recoverable': {
+            enum6 = 26;
+            break;
+          }
+          case 'unsupported': {
+            enum6 = 27;
+            break;
+          }
+          case 'no-tty': {
+            enum6 = 28;
+            break;
+          }
+          case 'no-such-device': {
+            enum6 = 29;
+            break;
+          }
+          case 'overflow': {
+            enum6 = 30;
+            break;
+          }
+          case 'not-permitted': {
+            enum6 = 31;
+            break;
+          }
+          case 'pipe': {
+            enum6 = 32;
+            break;
+          }
+          case 'read-only': {
+            enum6 = 33;
+            break;
+          }
+          case 'invalid-seek': {
+            enum6 = 34;
+            break;
+          }
+          case 'text-file-busy': {
+            enum6 = 35;
+            break;
+          }
+          case 'cross-device': {
+            enum6 = 36;
+            break;
+          }
+          default: {
+            if ((e) instanceof Error) {
+              console.error(e);
+            }
+            
+            throw new TypeError(`"${val6}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg4 + 8, enum6, true);
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant specified for result');
+      }
+    }
+    _debugLog('[iface="wasi:filesystem/types@0.2.6", function="[method]descriptor.metadata-hash-at"][Instruction::Return]', {
+      funcName: '[method]descriptor.metadata-hash-at',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline28(arg0) {
+    _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-environment');
+    const ret = getEnvironment();
+    _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var vec3 = ret;
+    var len3 = vec3.length;
+    var result3 = realloc0(0, 0, 4, len3 * 16);
+    for (let i = 0; i < vec3.length; i++) {
+      const e = vec3[i];
+      const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
+      var ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
+      var len1 = utf8EncodedLen;
+      dataView(memory0).setUint32(base + 4, len1, true);
+      dataView(memory0).setUint32(base + 0, ptr1, true);
+      var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+      var len2 = utf8EncodedLen;
+      dataView(memory0).setUint32(base + 12, len2, true);
+      dataView(memory0).setUint32(base + 8, ptr2, true);
+    }
+    dataView(memory0).setUint32(arg0 + 4, len3, true);
+    dataView(memory0).setUint32(arg0 + 0, result3, true);
+    _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"][Instruction::Return]', {
+      funcName: 'get-environment',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  const handleTable4 = [T_FLAG, 0];
+  const captureTable4= new Map();
+  let captureCnt4 = 0;
+  handleTables[4] = handleTable4;
+  
+  function trampoline29(arg0) {
+    _debugLog('[iface="wasi:cli/terminal-stdin@0.2.6", function="get-terminal-stdin"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-terminal-stdin');
+    const ret = getTerminalStdin();
+    _debugLog('[iface="wasi:cli/terminal-stdin@0.2.6", function="get-terminal-stdin"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var variant1 = ret;
+    if (variant1 === null || variant1=== undefined) {
+      dataView(memory0).setInt8(arg0 + 0, 0, true);
+    } else {
+      const e = variant1;
+      dataView(memory0).setInt8(arg0 + 0, 1, true);
+      if (!(e instanceof TerminalInput)) {
+        throw new TypeError('Resource error: Not a valid "TerminalInput" resource.');
+      }
+      var handle0 = e[symbolRscHandle];
+      if (!handle0) {
+        const rep = e[symbolRscRep] || ++captureCnt4;
+        captureTable4.set(rep, e);
+        handle0 = rscTableCreateOwn(handleTable4, rep);
+      }
+      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+    }
+    _debugLog('[iface="wasi:cli/terminal-stdin@0.2.6", function="get-terminal-stdin"][Instruction::Return]', {
+      funcName: 'get-terminal-stdin',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  const handleTable5 = [T_FLAG, 0];
+  const captureTable5= new Map();
+  let captureCnt5 = 0;
+  handleTables[5] = handleTable5;
+  
+  function trampoline30(arg0) {
+    _debugLog('[iface="wasi:cli/terminal-stdout@0.2.6", function="get-terminal-stdout"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-terminal-stdout');
+    const ret = getTerminalStdout();
+    _debugLog('[iface="wasi:cli/terminal-stdout@0.2.6", function="get-terminal-stdout"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var variant1 = ret;
     if (variant1 === null || variant1=== undefined) {
       dataView(memory0).setInt8(arg0 + 0, 0, true);
     } else {
@@ -1350,7 +3376,7 @@ let gen = (function* _initGenerator () {
   }
   
   
-  function trampoline19(arg0) {
+  function trampoline31(arg0) {
     _debugLog('[iface="wasi:cli/terminal-stderr@0.2.6", function="get-terminal-stderr"] [Instruction::CallInterface] (async? sync, @ enter)');
     const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-terminal-stderr');
     const ret = getTerminalStderr();
@@ -1365,16 +3391,54 @@ let gen = (function* _initGenerator () {
       if (!(e instanceof TerminalOutput)) {
         throw new TypeError('Resource error: Not a valid "TerminalOutput" resource.');
       }
-      var handle0 = e[symbolRscHandle];
-      if (!handle0) {
-        const rep = e[symbolRscRep] || ++captureCnt5;
-        captureTable5.set(rep, e);
-        handle0 = rscTableCreateOwn(handleTable5, rep);
+      var handle0 = e[symbolRscHandle];
+      if (!handle0) {
+        const rep = e[symbolRscRep] || ++captureCnt5;
+        captureTable5.set(rep, e);
+        handle0 = rscTableCreateOwn(handleTable5, rep);
+      }
+      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+    }
+    _debugLog('[iface="wasi:cli/terminal-stderr@0.2.6", function="get-terminal-stderr"][Instruction::Return]', {
+      funcName: 'get-terminal-stderr',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
+  
+  function trampoline32(arg0) {
+    _debugLog('[iface="wasi:filesystem/preopens@0.2.6", function="get-directories"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-directories');
+    const ret = getDirectories();
+    _debugLog('[iface="wasi:filesystem/preopens@0.2.6", function="get-directories"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var vec3 = ret;
+    var len3 = vec3.length;
+    var result3 = realloc0(0, 0, 4, len3 * 12);
+    for (let i = 0; i < vec3.length; i++) {
+      const e = vec3[i];
+      const base = result3 + i * 12;var [tuple0_0, tuple0_1] = e;
+      if (!(tuple0_0 instanceof Descriptor)) {
+        throw new TypeError('Resource error: Not a valid "Descriptor" resource.');
+      }
+      var handle1 = tuple0_0[symbolRscHandle];
+      if (!handle1) {
+        const rep = tuple0_0[symbolRscRep] || ++captureCnt6;
+        captureTable6.set(rep, tuple0_0);
+        handle1 = rscTableCreateOwn(handleTable6, rep);
       }
-      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+      dataView(memory0).setInt32(base + 0, handle1, true);
+      var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+      var len2 = utf8EncodedLen;
+      dataView(memory0).setUint32(base + 8, len2, true);
+      dataView(memory0).setUint32(base + 4, ptr2, true);
     }
-    _debugLog('[iface="wasi:cli/terminal-stderr@0.2.6", function="get-terminal-stderr"][Instruction::Return]', {
-      funcName: 'get-terminal-stderr',
+    dataView(memory0).setUint32(arg0 + 4, len3, true);
+    dataView(memory0).setUint32(arg0 + 0, result3, true);
+    _debugLog('[iface="wasi:filesystem/preopens@0.2.6", function="get-directories"][Instruction::Return]', {
+      funcName: 'get-directories',
       paramCount: 0,
       async: false,
       postReturn: false
@@ -1387,6 +3451,7 @@ let gen = (function* _initGenerator () {
   let postReturn2;
   let postReturn3;
   let postReturn4;
+  let postReturn5;
   function trampoline0(handle) {
     const handleEntry = rscTableRemove(handleTable1, handle);
     if (handleEntry.own) {
@@ -1465,23 +3530,41 @@ let gen = (function* _initGenerator () {
       }
     }
   }
+  function trampoline6(handle) {
+    const handleEntry = rscTableRemove(handleTable6, handle);
+    if (handleEntry.own) {
+      
+      const rsc = captureTable6.get(handleEntry.rep);
+      if (rsc) {
+        if (rsc[symbolDispose]) rsc[symbolDispose]();
+        captureTable6.delete(handleEntry.rep);
+      } else if (Descriptor[symbolCabiDispose]) {
+        Descriptor[symbolCabiDispose](handleEntry.rep);
+      }
+    }
+  }
   Promise.all([module0, module1, module2]).catch(() => {});
   ({ exports: exports0 } = yield instantiateCore(yield module1));
   ({ exports: exports1 } = yield instantiateCore(yield module0, {
+    'vercel:python-analysis/host-utils': {
+      'domain-to-ascii': exports0['2'],
+      'nfkc-normalize': exports0['1'],
+      'read-file': exports0['0'],
+    },
     'wasi:cli/environment@0.2.0': {
-      'get-environment': exports0['4'],
+      'get-environment': exports0['15'],
     },
     'wasi:cli/exit@0.2.0': {
-      exit: trampoline6,
+      exit: trampoline7,
     },
     'wasi:cli/stderr@0.2.0': {
-      'get-stderr': trampoline11,
+      'get-stderr': trampoline12,
     },
     'wasi:cli/stdin@0.2.0': {
-      'get-stdin': trampoline9,
+      'get-stdin': trampoline10,
     },
     'wasi:cli/stdout@0.2.0': {
-      'get-stdout': trampoline10,
+      'get-stdout': trampoline11,
     },
     'wasi:cli/terminal-input@0.2.0': {
       '[resource-drop]terminal-input': trampoline4,
@@ -1490,31 +3573,45 @@ let gen = (function* _initGenerator () {
       '[resource-drop]terminal-output': trampoline5,
     },
     'wasi:cli/terminal-stderr@0.2.0': {
-      'get-terminal-stderr': exports0['7'],
+      'get-terminal-stderr': exports0['18'],
     },
     'wasi:cli/terminal-stdin@0.2.0': {
-      'get-terminal-stdin': exports0['5'],
+      'get-terminal-stdin': exports0['16'],
     },
     'wasi:cli/terminal-stdout@0.2.0': {
-      'get-terminal-stdout': exports0['6'],
+      'get-terminal-stdout': exports0['17'],
+    },
+    'wasi:filesystem/preopens@0.2.0': {
+      'get-directories': exports0['19'],
+    },
+    'wasi:filesystem/types@0.2.0': {
+      '[method]descriptor.append-via-stream': exports0['9'],
+      '[method]descriptor.get-flags': exports0['10'],
+      '[method]descriptor.metadata-hash': exports0['13'],
+      '[method]descriptor.metadata-hash-at': exports0['14'],
+      '[method]descriptor.read-via-stream': exports0['7'],
+      '[method]descriptor.stat': exports0['11'],
+      '[method]descriptor.stat-at': exports0['12'],
+      '[method]descriptor.write-via-stream': exports0['8'],
+      '[resource-drop]descriptor': trampoline6,
     },
     'wasi:io/error@0.2.0': {
       '[resource-drop]error': trampoline0,
     },
     'wasi:io/poll@0.2.0': {
-      '[method]pollable.block': trampoline7,
+      '[method]pollable.block': trampoline8,
       '[resource-drop]pollable': trampoline1,
     },
     'wasi:io/streams@0.2.0': {
-      '[method]output-stream.blocking-flush': exports0['3'],
-      '[method]output-stream.check-write': exports0['1'],
-      '[method]output-stream.subscribe': trampoline8,
-      '[method]output-stream.write': exports0['2'],
+      '[method]output-stream.blocking-flush': exports0['6'],
+      '[method]output-stream.check-write': exports0['4'],
+      '[method]output-stream.subscribe': trampoline9,
+      '[method]output-stream.write': exports0['5'],
       '[resource-drop]input-stream': trampoline2,
       '[resource-drop]output-stream': trampoline3,
     },
     'wasi:random/insecure-seed@0.2.4': {
-      'insecure-seed': exports0['0'],
+      'insecure-seed': exports0['3'],
     },
   }));
   memory0 = exports1.memory;
@@ -1522,14 +3619,26 @@ let gen = (function* _initGenerator () {
   ({ exports: exports2 } = yield instantiateCore(yield module2, {
     '': {
       $imports: exports0.$imports,
-      '0': trampoline12,
-      '1': trampoline13,
-      '2': trampoline14,
-      '3': trampoline15,
-      '4': trampoline16,
-      '5': trampoline17,
-      '6': trampoline18,
-      '7': trampoline19,
+      '0': trampoline13,
+      '1': trampoline14,
+      '10': trampoline23,
+      '11': trampoline24,
+      '12': trampoline25,
+      '13': trampoline26,
+      '14': trampoline27,
+      '15': trampoline28,
+      '16': trampoline29,
+      '17': trampoline30,
+      '18': trampoline31,
+      '19': trampoline32,
+      '2': trampoline15,
+      '3': trampoline16,
+      '4': trampoline17,
+      '5': trampoline18,
+      '6': trampoline19,
+      '7': trampoline20,
+      '8': trampoline21,
+      '9': trampoline22,
     },
   }));
   postReturn0 = exports1['cabi_post_get-string-constant'];
@@ -1537,6 +3646,7 @@ let gen = (function* _initGenerator () {
   postReturn2 = exports1['cabi_post_parse-record'];
   postReturn3 = exports1['cabi_post_parse-direct-url'];
   postReturn4 = exports1['cabi_post_normalize-package-name'];
+  postReturn5 = exports1['cabi_post_parse-requirements-txt'];
   let exports1ContainsAppOrHandler;
   
   function containsAppOrHandler(arg0) {
@@ -2268,6 +4378,532 @@ let gen = (function* _initGenerator () {
     cstate.mayLeave = true;
     return retCopy;
     
+  }
+  let exports1ParseRequirementsTxt;
+  
+  function parseRequirementsTxt(arg0, arg1, arg2) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    var variant2 = arg1;
+    let variant2_0;
+    let variant2_1;
+    let variant2_2;
+    if (variant2 === null || variant2=== undefined) {
+      variant2_0 = 0;
+      variant2_1 = 0;
+      variant2_2 = 0;
+    } else {
+      const e = variant2;
+      var ptr1 = utf8Encode(e, realloc0, memory0);
+      var len1 = utf8EncodedLen;
+      variant2_0 = 1;
+      variant2_1 = ptr1;
+      variant2_2 = len1;
+    }
+    var variant4 = arg2;
+    let variant4_0;
+    let variant4_1;
+    let variant4_2;
+    if (variant4 === null || variant4=== undefined) {
+      variant4_0 = 0;
+      variant4_1 = 0;
+      variant4_2 = 0;
+    } else {
+      const e = variant4;
+      var ptr3 = utf8Encode(e, realloc0, memory0);
+      var len3 = utf8EncodedLen;
+      variant4_0 = 1;
+      variant4_1 = ptr3;
+      variant4_2 = len3;
+    }
+    _debugLog('[iface="parse-requirements-txt", function="parse-requirements-txt"][Instruction::CallWasm] enter', {
+      funcName: 'parse-requirements-txt',
+      paramCount: 8,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1ParseRequirementsTxt');
+    const ret = exports1ParseRequirementsTxt(ptr0, len0, variant2_0, variant2_1, variant2_2, variant4_0, variant4_1, variant4_2);
+    endCurrentTask(0);
+    let variant55;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        var len25 = dataView(memory0).getUint32(ret + 8, true);
+        var base25 = dataView(memory0).getUint32(ret + 4, true);
+        var result25 = [];
+        for (let i = 0; i < len25; i++) {
+          const base = base25 + i * 112;
+          let variant6;
+          switch (dataView(memory0).getUint8(base + 0, true)) {
+            case 0: {
+              variant6 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr5 = dataView(memory0).getUint32(base + 4, true);
+              var len5 = dataView(memory0).getUint32(base + 8, true);
+              var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+              variant6 = result5;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          var ptr7 = dataView(memory0).getUint32(base + 12, true);
+          var len7 = dataView(memory0).getUint32(base + 16, true);
+          var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
+          var len9 = dataView(memory0).getUint32(base + 24, true);
+          var base9 = dataView(memory0).getUint32(base + 20, true);
+          var result9 = [];
+          for (let i = 0; i < len9; i++) {
+            const base = base9 + i * 8;
+            var ptr8 = dataView(memory0).getUint32(base + 0, true);
+            var len8 = dataView(memory0).getUint32(base + 4, true);
+            var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+            result9.push(result8);
+          }
+          let variant11;
+          switch (dataView(memory0).getUint8(base + 28, true)) {
+            case 0: {
+              variant11 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr10 = dataView(memory0).getUint32(base + 32, true);
+              var len10 = dataView(memory0).getUint32(base + 36, true);
+              var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+              variant11 = result10;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          let variant13;
+          switch (dataView(memory0).getUint8(base + 40, true)) {
+            case 0: {
+              variant13 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr12 = dataView(memory0).getUint32(base + 44, true);
+              var len12 = dataView(memory0).getUint32(base + 48, true);
+              var result12 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr12, len12));
+              variant13 = result12;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          let variant15;
+          switch (dataView(memory0).getUint8(base + 52, true)) {
+            case 0: {
+              variant15 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr14 = dataView(memory0).getUint32(base + 56, true);
+              var len14 = dataView(memory0).getUint32(base + 60, true);
+              var result14 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr14, len14));
+              variant15 = result14;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          var len17 = dataView(memory0).getUint32(base + 68, true);
+          var base17 = dataView(memory0).getUint32(base + 64, true);
+          var result17 = [];
+          for (let i = 0; i < len17; i++) {
+            const base = base17 + i * 8;
+            var ptr16 = dataView(memory0).getUint32(base + 0, true);
+            var len16 = dataView(memory0).getUint32(base + 4, true);
+            var result16 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr16, len16));
+            result17.push(result16);
+          }
+          var bool18 = dataView(memory0).getUint8(base + 72, true);
+          let variant22;
+          switch (dataView(memory0).getUint8(base + 76, true)) {
+            case 0: {
+              variant22 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr19 = dataView(memory0).getUint32(base + 80, true);
+              var len19 = dataView(memory0).getUint32(base + 84, true);
+              var result19 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr19, len19));
+              let variant21;
+              switch (dataView(memory0).getUint8(base + 88, true)) {
+                case 0: {
+                  variant21 = undefined;
+                  break;
+                }
+                case 1: {
+                  var ptr20 = dataView(memory0).getUint32(base + 92, true);
+                  var len20 = dataView(memory0).getUint32(base + 96, true);
+                  var result20 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr20, len20));
+                  variant21 = result20;
+                  break;
+                }
+                default: {
+                  throw new TypeError('invalid variant discriminant for option');
+                }
+              }
+              variant22 = {
+                url: result19,
+                rev: variant21,
+              };
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          let variant24;
+          switch (dataView(memory0).getUint8(base + 100, true)) {
+            case 0: {
+              variant24 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr23 = dataView(memory0).getUint32(base + 104, true);
+              var len23 = dataView(memory0).getUint32(base + 108, true);
+              var result23 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr23, len23));
+              variant24 = result23;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          result25.push({
+            name: variant6,
+            pep508: result7,
+            extras: result9,
+            markers: variant11,
+            versionSpec: variant13,
+            url: variant15,
+            hashes: result17,
+            editable: bool18 == 0 ? false : (bool18 == 1 ? true : throwInvalidBool()),
+            vcs: variant22,
+            givenUrl: variant24,
+          });
+        }
+        var len46 = dataView(memory0).getUint32(ret + 16, true);
+        var base46 = dataView(memory0).getUint32(ret + 12, true);
+        var result46 = [];
+        for (let i = 0; i < len46; i++) {
+          const base = base46 + i * 112;
+          let variant27;
+          switch (dataView(memory0).getUint8(base + 0, true)) {
+            case 0: {
+              variant27 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr26 = dataView(memory0).getUint32(base + 4, true);
+              var len26 = dataView(memory0).getUint32(base + 8, true);
+              var result26 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr26, len26));
+              variant27 = result26;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          var ptr28 = dataView(memory0).getUint32(base + 12, true);
+          var len28 = dataView(memory0).getUint32(base + 16, true);
+          var result28 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr28, len28));
+          var len30 = dataView(memory0).getUint32(base + 24, true);
+          var base30 = dataView(memory0).getUint32(base + 20, true);
+          var result30 = [];
+          for (let i = 0; i < len30; i++) {
+            const base = base30 + i * 8;
+            var ptr29 = dataView(memory0).getUint32(base + 0, true);
+            var len29 = dataView(memory0).getUint32(base + 4, true);
+            var result29 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr29, len29));
+            result30.push(result29);
+          }
+          let variant32;
+          switch (dataView(memory0).getUint8(base + 28, true)) {
+            case 0: {
+              variant32 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr31 = dataView(memory0).getUint32(base + 32, true);
+              var len31 = dataView(memory0).getUint32(base + 36, true);
+              var result31 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr31, len31));
+              variant32 = result31;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          let variant34;
+          switch (dataView(memory0).getUint8(base + 40, true)) {
+            case 0: {
+              variant34 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr33 = dataView(memory0).getUint32(base + 44, true);
+              var len33 = dataView(memory0).getUint32(base + 48, true);
+              var result33 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr33, len33));
+              variant34 = result33;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          let variant36;
+          switch (dataView(memory0).getUint8(base + 52, true)) {
+            case 0: {
+              variant36 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr35 = dataView(memory0).getUint32(base + 56, true);
+              var len35 = dataView(memory0).getUint32(base + 60, true);
+              var result35 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr35, len35));
+              variant36 = result35;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          var len38 = dataView(memory0).getUint32(base + 68, true);
+          var base38 = dataView(memory0).getUint32(base + 64, true);
+          var result38 = [];
+          for (let i = 0; i < len38; i++) {
+            const base = base38 + i * 8;
+            var ptr37 = dataView(memory0).getUint32(base + 0, true);
+            var len37 = dataView(memory0).getUint32(base + 4, true);
+            var result37 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr37, len37));
+            result38.push(result37);
+          }
+          var bool39 = dataView(memory0).getUint8(base + 72, true);
+          let variant43;
+          switch (dataView(memory0).getUint8(base + 76, true)) {
+            case 0: {
+              variant43 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr40 = dataView(memory0).getUint32(base + 80, true);
+              var len40 = dataView(memory0).getUint32(base + 84, true);
+              var result40 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr40, len40));
+              let variant42;
+              switch (dataView(memory0).getUint8(base + 88, true)) {
+                case 0: {
+                  variant42 = undefined;
+                  break;
+                }
+                case 1: {
+                  var ptr41 = dataView(memory0).getUint32(base + 92, true);
+                  var len41 = dataView(memory0).getUint32(base + 96, true);
+                  var result41 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr41, len41));
+                  variant42 = result41;
+                  break;
+                }
+                default: {
+                  throw new TypeError('invalid variant discriminant for option');
+                }
+              }
+              variant43 = {
+                url: result40,
+                rev: variant42,
+              };
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          let variant45;
+          switch (dataView(memory0).getUint8(base + 100, true)) {
+            case 0: {
+              variant45 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr44 = dataView(memory0).getUint32(base + 104, true);
+              var len44 = dataView(memory0).getUint32(base + 108, true);
+              var result44 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr44, len44));
+              variant45 = result44;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          result46.push({
+            name: variant27,
+            pep508: result28,
+            extras: result30,
+            markers: variant32,
+            versionSpec: variant34,
+            url: variant36,
+            hashes: result38,
+            editable: bool39 == 0 ? false : (bool39 == 1 ? true : throwInvalidBool()),
+            vcs: variant43,
+            givenUrl: variant45,
+          });
+        }
+        let variant48;
+        switch (dataView(memory0).getUint8(ret + 20, true)) {
+          case 0: {
+            variant48 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr47 = dataView(memory0).getUint32(ret + 24, true);
+            var len47 = dataView(memory0).getUint32(ret + 28, true);
+            var result47 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr47, len47));
+            variant48 = result47;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        var len50 = dataView(memory0).getUint32(ret + 36, true);
+        var base50 = dataView(memory0).getUint32(ret + 32, true);
+        var result50 = [];
+        for (let i = 0; i < len50; i++) {
+          const base = base50 + i * 8;
+          var ptr49 = dataView(memory0).getUint32(base + 0, true);
+          var len49 = dataView(memory0).getUint32(base + 4, true);
+          var result49 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr49, len49));
+          result50.push(result49);
+        }
+        var len52 = dataView(memory0).getUint32(ret + 44, true);
+        var base52 = dataView(memory0).getUint32(ret + 40, true);
+        var result52 = [];
+        for (let i = 0; i < len52; i++) {
+          const base = base52 + i * 8;
+          var ptr51 = dataView(memory0).getUint32(base + 0, true);
+          var len51 = dataView(memory0).getUint32(base + 4, true);
+          var result51 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr51, len51));
+          result52.push(result51);
+        }
+        var bool53 = dataView(memory0).getUint8(ret + 48, true);
+        variant55= {
+          tag: 'ok',
+          val: {
+            requirements: result25,
+            editables: result46,
+            indexUrl: variant48,
+            extraIndexUrls: result50,
+            findLinks: result52,
+            noIndex: bool53 == 0 ? false : (bool53 == 1 ? true : throwInvalidBool()),
+          }
+        };
+        break;
+      }
+      case 1: {
+        var ptr54 = dataView(memory0).getUint32(ret + 4, true);
+        var len54 = dataView(memory0).getUint32(ret + 8, true);
+        var result54 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr54, len54));
+        variant55= {
+          tag: 'err',
+          val: result54
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    _debugLog('[iface="parse-requirements-txt", function="parse-requirements-txt"][Instruction::Return]', {
+      funcName: 'parse-requirements-txt',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = variant55;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn5(ret);
+    cstate.mayLeave = true;
+    
+    
+    
+    if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+      throw new ComponentError(retCopy.val);
+    }
+    return retCopy.val;
+    
+  }
+  let exports1IsWheelCompatible;
+  
+  function isWheelCompatible(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    var ptr1 = utf8Encode(arg3, realloc0, memory0);
+    var len1 = utf8EncodedLen;
+    var ptr2 = utf8Encode(arg4, realloc0, memory0);
+    var len2 = utf8EncodedLen;
+    _debugLog('[iface="is-wheel-compatible", function="is-wheel-compatible"][Instruction::CallWasm] enter', {
+      funcName: 'is-wheel-compatible',
+      paramCount: 10,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1IsWheelCompatible');
+    const ret = exports1IsWheelCompatible(ptr0, len0, toUint8(arg1), toUint8(arg2), ptr1, len1, ptr2, len2, toUint16(arg5), toUint16(arg6));
+    endCurrentTask(0);
+    let variant5;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        var bool3 = dataView(memory0).getUint8(ret + 4, true);
+        variant5= {
+          tag: 'ok',
+          val: bool3 == 0 ? false : (bool3 == 1 ? true : throwInvalidBool())
+        };
+        break;
+      }
+      case 1: {
+        var ptr4 = dataView(memory0).getUint32(ret + 4, true);
+        var len4 = dataView(memory0).getUint32(ret + 8, true);
+        var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+        variant5= {
+          tag: 'err',
+          val: result4
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    _debugLog('[iface="is-wheel-compatible", function="is-wheel-compatible"][Instruction::Return]', {
+      funcName: 'is-wheel-compatible',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = variant5;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn0(ret);
+    cstate.mayLeave = true;
+    
+    
+    
+    if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+      throw new ComponentError(retCopy.val);
+    }
+    return retCopy.val;
+    
   }
   exports1ContainsAppOrHandler = exports1['contains-app-or-handler'];
   exports1GetStringConstant = exports1['get-string-constant'];
@@ -2276,8 +4912,10 @@ let gen = (function* _initGenerator () {
   exports1ParseRecord = exports1['parse-record'];
   exports1ParseDirectUrl = exports1['parse-direct-url'];
   exports1NormalizePackageName = exports1['normalize-package-name'];
+  exports1ParseRequirementsTxt = exports1['parse-requirements-txt'];
+  exports1IsWheelCompatible = exports1['is-wheel-compatible'];
   
-  return { containsAppOrHandler, containsTopLevelCallable, getStringConstant, normalizePackageName, parseDirectUrl, parseDistMetadata, parseRecord,  };
+  return { containsAppOrHandler, containsTopLevelCallable, getStringConstant, isWheelCompatible, normalizePackageName, parseDirectUrl, parseDistMetadata, parseRecord, parseRequirementsTxt,  };
 })();
 let promise, resolve, reject;
 function runNext (value) {