@bytecodealliance/jco 0.13.2 → 0.14.0

package/obj/wasm-tools.js

@@ -1,6 +1,6 @@
 import { environment, exit as exit$1, stderr, stdin, stdout, terminalInput, terminalOutput, terminalStderr, terminalStdin, terminalStdout } from '@bytecodealliance/preview2-shim/cli';
 import { preopens, types } from '@bytecodealliance/preview2-shim/filesystem';
-import { streams } from '@bytecodealliance/preview2-shim/io';
+import { error, streams } from '@bytecodealliance/preview2-shim/io';
 import { random } from '@bytecodealliance/preview2-shim/random';
 const { getEnvironment } = environment;
 const { exit } = exit$1;
@@ -16,8 +16,8 @@ const { getDirectories } = preopens;
 const { Descriptor,
   DirectoryEntryStream,
   filesystemErrorCode } = types;
-const { Error: Error$1,
-  InputStream,
+const { Error: Error$1 } = error;
+const { InputStream,
   OutputStream } = streams;
 const { getRandomBytes } = random;
 
@@ -53,13 +53,15 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 const instantiateCore = WebAssembly.instantiate;
 
-const resourceHandleSymbol = Symbol();
+const resourceHandleSymbol = Symbol('resource');
+
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
 
 function throwUninitialized() {
   throw new TypeError('Wasm uninitialized use `await $init` first');
 }
 
-const toUint64 = val => BigInt.asUintN(64, val);
+const toUint64 = val => BigInt.asUintN(64, BigInt(val));
 
 function toUint32(val) {
   return val >>> 0;
@@ -80,8 +82,7 @@ function utf8Encode(s, realloc, memory) {
   let ptr = 0;
   let writtenTotal = 0;
   while (s.length > 0) {
-    ptr = realloc(ptr, allocLen, 1, allocLen + s.length);
-    allocLen += s.length;
+    ptr = realloc(ptr, allocLen, 1, allocLen += s.length * 2);
     const { read, written } = utf8Encoder.encodeInto(
     s,
     new Uint8Array(memory.buffer, ptr + writtenTotal, allocLen - writtenTotal),
@@ -89,8 +90,6 @@ function utf8Encode(s, realloc, memory) {
     writtenTotal += written;
     s = s.slice(read);
   }
-  if (allocLen > writtenTotal)
-  ptr = realloc(ptr, allocLen, 1, writtenTotal);
   utf8EncodedLen = writtenTotal;
   return ptr;
 }
@@ -101,9 +100,9 @@ let exports1;
 function trampoline8() {
   const ret = getStderr();
   if (!(ret instanceof OutputStream)) {
-    throw new Error('Not a valid "OutputStream" resource.');
+    throw new Error('Resource error: Not a valid "OutputStream" resource.');
   }
-  const handle0 = handleCnt2++;
+  var handle0 = handleCnt2++;
   handleTable2.set(handle0, { rep: ret, own: true });
   return handle0;
 }
@@ -135,19 +134,19 @@ function trampoline9(arg0) {
 function trampoline10() {
   const ret = getStdin();
   if (!(ret instanceof InputStream)) {
-    throw new Error('Not a valid "InputStream" resource.');
+    throw new Error('Resource error: Not a valid "InputStream" resource.');
   }
-  const handle0 = handleCnt0++;
-  handleTable0.set(handle0, { rep: ret, own: true });
+  var handle0 = handleCnt1++;
+  handleTable1.set(handle0, { rep: ret, own: true });
   return handle0;
 }
 
 function trampoline11() {
   const ret = getStdout();
   if (!(ret instanceof OutputStream)) {
-    throw new Error('Not a valid "OutputStream" resource.');
+    throw new Error('Resource error: Not a valid "OutputStream" resource.');
   }
-  const handle0 = handleCnt2++;
+  var handle0 = handleCnt2++;
   handleTable2.set(handle0, { rep: ret, own: true });
   return handle0;
 }
@@ -155,20 +154,20 @@ let exports2;
 
 function trampoline12(arg0) {
   const ret = getDirectories();
-  const vec3 = ret;
-  const len3 = vec3.length;
-  const result3 = realloc0(0, 0, 4, len3 * 12);
+  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;const [tuple0_0, tuple0_1] = e;
+    const base = result3 + i * 12;var [tuple0_0, tuple0_1] = e;
     if (!(tuple0_0 instanceof Descriptor)) {
-      throw new Error('Not a valid "Descriptor" resource.');
+      throw new Error('Resource error: Not a valid "Descriptor" resource.');
     }
-    const handle1 = handleCnt3++;
+    var handle1 = handleCnt3++;
     handleTable3.set(handle1, { rep: tuple0_0, own: true });
     dataView(memory0).setInt32(base + 0, handle1, true);
-    const ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
-    const len2 = utf8EncodedLen;
+    var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+    var len2 = utf8EncodedLen;
     dataView(memory0).setInt32(base + 8, len2, true);
     dataView(memory0).setInt32(base + 4, ptr2, true);
   }
@@ -179,178 +178,179 @@ let memory0;
 let realloc0;
 
 function trampoline13(arg0, arg1, arg2) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.readViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  var variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
       if (!(e instanceof InputStream)) {
-        throw new Error('Not a valid "InputStream" resource.');
+        throw new Error('Resource error: Not a valid "InputStream" resource.');
       }
-      const handle1 = handleCnt0++;
-      handleTable0.set(handle1, { rep: e, own: true });
-      dataView(memory0).setInt32(arg2 + 4, handle1, true);
+      var handle2 = handleCnt1++;
+      handleTable1.set(handle2, { rep: e, own: true });
+      dataView(memory0).setInt32(arg2 + 4, handle2, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      var val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -358,10 +358,10 @@ function trampoline13(arg0, arg1, arg2) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg2 + 4, enum2, true);
+      dataView(memory0).setInt8(arg2 + 4, enum3, true);
       break;
     }
     default: {
@@ -371,178 +371,179 @@ function trampoline13(arg0, arg1, arg2) {
 }
 
 function trampoline14(arg0, arg1, arg2) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.writeViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  var variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
       if (!(e instanceof OutputStream)) {
-        throw new Error('Not a valid "OutputStream" resource.');
+        throw new Error('Resource error: Not a valid "OutputStream" resource.');
       }
-      const handle1 = handleCnt2++;
-      handleTable2.set(handle1, { rep: e, own: true });
-      dataView(memory0).setInt32(arg2 + 4, handle1, true);
+      var handle2 = handleCnt2++;
+      handleTable2.set(handle2, { rep: e, own: true });
+      dataView(memory0).setInt32(arg2 + 4, handle2, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      var val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -550,10 +551,10 @@ function trampoline14(arg0, arg1, arg2) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg2 + 4, enum2, true);
+      dataView(memory0).setInt8(arg2 + 4, enum3, true);
       break;
     }
     default: {
@@ -563,178 +564,179 @@ function trampoline14(arg0, arg1, arg2) {
 }
 
 function trampoline15(arg0, arg1) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.appendViaStream.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  var variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
       if (!(e instanceof OutputStream)) {
-        throw new Error('Not a valid "OutputStream" resource.');
+        throw new Error('Resource error: Not a valid "OutputStream" resource.');
       }
-      const handle1 = handleCnt2++;
-      handleTable2.set(handle1, { rep: e, own: true });
-      dataView(memory0).setInt32(arg1 + 4, handle1, true);
+      var handle2 = handleCnt2++;
+      handleTable2.set(handle2, { rep: e, own: true });
+      dataView(memory0).setInt32(arg1 + 4, handle2, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      var val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -742,10 +744,10 @@ function trampoline15(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 4, enum2, true);
+      dataView(memory0).setInt8(arg1 + 4, enum3, true);
       break;
     }
     default: {
@@ -755,51 +757,52 @@ function trampoline15(arg0, arg1) {
 }
 
 function trampoline16(arg0, arg1) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.getType.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  var variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const val1 = e;
-      let enum1;
-      switch (val1) {
+      var val2 = e;
+      let enum2;
+      switch (val2) {
         case 'unknown': {
-          enum1 = 0;
+          enum2 = 0;
           break;
         }
         case 'block-device': {
-          enum1 = 1;
+          enum2 = 1;
           break;
         }
         case 'character-device': {
-          enum1 = 2;
+          enum2 = 2;
           break;
         }
         case 'directory': {
-          enum1 = 3;
+          enum2 = 3;
           break;
         }
         case 'fifo': {
-          enum1 = 4;
+          enum2 = 4;
           break;
         }
         case 'symbolic-link': {
-          enum1 = 5;
+          enum2 = 5;
           break;
         }
         case 'regular-file': {
-          enum1 = 6;
+          enum2 = 6;
           break;
         }
         case 'socket': {
-          enum1 = 7;
+          enum2 = 7;
           break;
         }
         default: {
@@ -807,164 +810,164 @@ function trampoline16(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val1}" is not one of the cases of descriptor-type`);
+          throw new TypeError(`"${val2}" is not one of the cases of descriptor-type`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 1, enum1, true);
+      dataView(memory0).setInt8(arg1 + 1, enum2, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      var val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -972,10 +975,10 @@ function trampoline16(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 1, enum2, true);
+      dataView(memory0).setInt8(arg1 + 1, enum3, true);
       break;
     }
     default: {
@@ -985,249 +988,250 @@ function trampoline16(arg0, arg1) {
 }
 
 function trampoline17(arg0, arg1) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.stat.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant10 = ret;
-  switch (variant10.tag) {
+  var variant11 = ret;
+  switch (variant11.tag) {
     case 'ok': {
-      const e = variant10.val;
+      const e = variant11.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const {type: v1_0, linkCount: v1_1, size: v1_2, dataAccessTimestamp: v1_3, dataModificationTimestamp: v1_4, statusChangeTimestamp: v1_5 } = e;
-      const val2 = v1_0;
-      let enum2;
-      switch (val2) {
+      var {type: v2_0, linkCount: v2_1, size: v2_2, dataAccessTimestamp: v2_3, dataModificationTimestamp: v2_4, statusChangeTimestamp: v2_5 } = e;
+      var val3 = v2_0;
+      let enum3;
+      switch (val3) {
         case 'unknown': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'block-device': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'character-device': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'directory': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'fifo': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'symbolic-link': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'regular-file': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'socket': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         default: {
-          if ((v1_0) instanceof Error) {
-            console.error(v1_0);
+          if ((v2_0) instanceof Error) {
+            console.error(v2_0);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of descriptor-type`);
+          throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum2, true);
-      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v1_1), true);
-      dataView(memory0).setBigInt64(arg1 + 24, toUint64(v1_2), true);
-      const variant4 = v1_3;
-      if (variant4 === null || variant4=== undefined) {
+      dataView(memory0).setInt8(arg1 + 8, enum3, true);
+      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
+      dataView(memory0).setBigInt64(arg1 + 24, toUint64(v2_2), true);
+      var variant5 = v2_3;
+      if (variant5 === null || variant5=== undefined) {
         dataView(memory0).setInt8(arg1 + 32, 0, true);
       } else {
-        const e = variant4;
+        const e = variant5;
         dataView(memory0).setInt8(arg1 + 32, 1, true);
-        const {seconds: v3_0, nanoseconds: v3_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 40, toUint64(v3_0), true);
-        dataView(memory0).setInt32(arg1 + 48, toUint32(v3_1), true);
+        var {seconds: v4_0, nanoseconds: v4_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 40, toUint64(v4_0), true);
+        dataView(memory0).setInt32(arg1 + 48, toUint32(v4_1), true);
       }
-      const variant6 = v1_4;
-      if (variant6 === null || variant6=== undefined) {
+      var variant7 = v2_4;
+      if (variant7 === null || variant7=== undefined) {
         dataView(memory0).setInt8(arg1 + 56, 0, true);
       } else {
-        const e = variant6;
+        const e = variant7;
         dataView(memory0).setInt8(arg1 + 56, 1, true);
-        const {seconds: v5_0, nanoseconds: v5_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 64, toUint64(v5_0), true);
-        dataView(memory0).setInt32(arg1 + 72, toUint32(v5_1), true);
+        var {seconds: v6_0, nanoseconds: v6_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 64, toUint64(v6_0), true);
+        dataView(memory0).setInt32(arg1 + 72, toUint32(v6_1), true);
       }
-      const variant8 = v1_5;
-      if (variant8 === null || variant8=== undefined) {
+      var variant9 = v2_5;
+      if (variant9 === null || variant9=== undefined) {
         dataView(memory0).setInt8(arg1 + 80, 0, true);
       } else {
-        const e = variant8;
+        const e = variant9;
         dataView(memory0).setInt8(arg1 + 80, 1, true);
-        const {seconds: v7_0, nanoseconds: v7_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 88, toUint64(v7_0), true);
-        dataView(memory0).setInt32(arg1 + 96, toUint32(v7_1), true);
+        var {seconds: v8_0, nanoseconds: v8_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 88, toUint64(v8_0), true);
+        dataView(memory0).setInt32(arg1 + 96, toUint32(v8_1), true);
       }
       break;
     }
     case 'err': {
-      const e = variant10.val;
+      const e = variant11.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val9 = e;
-      let enum9;
-      switch (val9) {
+      var val10 = e;
+      let enum10;
+      switch (val10) {
         case 'access': {
-          enum9 = 0;
+          enum10 = 0;
           break;
         }
         case 'would-block': {
-          enum9 = 1;
+          enum10 = 1;
           break;
         }
         case 'already': {
-          enum9 = 2;
+          enum10 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum9 = 3;
+          enum10 = 3;
           break;
         }
         case 'busy': {
-          enum9 = 4;
+          enum10 = 4;
           break;
         }
         case 'deadlock': {
-          enum9 = 5;
+          enum10 = 5;
           break;
         }
         case 'quota': {
-          enum9 = 6;
+          enum10 = 6;
           break;
         }
         case 'exist': {
-          enum9 = 7;
+          enum10 = 7;
           break;
         }
         case 'file-too-large': {
-          enum9 = 8;
+          enum10 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum9 = 9;
+          enum10 = 9;
           break;
         }
         case 'in-progress': {
-          enum9 = 10;
+          enum10 = 10;
           break;
         }
         case 'interrupted': {
-          enum9 = 11;
+          enum10 = 11;
           break;
         }
         case 'invalid': {
-          enum9 = 12;
+          enum10 = 12;
           break;
         }
         case 'io': {
-          enum9 = 13;
+          enum10 = 13;
           break;
         }
         case 'is-directory': {
-          enum9 = 14;
+          enum10 = 14;
           break;
         }
         case 'loop': {
-          enum9 = 15;
+          enum10 = 15;
           break;
         }
         case 'too-many-links': {
-          enum9 = 16;
+          enum10 = 16;
           break;
         }
         case 'message-size': {
-          enum9 = 17;
+          enum10 = 17;
           break;
         }
         case 'name-too-long': {
-          enum9 = 18;
+          enum10 = 18;
           break;
         }
         case 'no-device': {
-          enum9 = 19;
+          enum10 = 19;
           break;
         }
         case 'no-entry': {
-          enum9 = 20;
+          enum10 = 20;
           break;
         }
         case 'no-lock': {
-          enum9 = 21;
+          enum10 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum9 = 22;
+          enum10 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum9 = 23;
+          enum10 = 23;
           break;
         }
         case 'not-directory': {
-          enum9 = 24;
+          enum10 = 24;
           break;
         }
         case 'not-empty': {
-          enum9 = 25;
+          enum10 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum9 = 26;
+          enum10 = 26;
           break;
         }
         case 'unsupported': {
-          enum9 = 27;
+          enum10 = 27;
           break;
         }
         case 'no-tty': {
-          enum9 = 28;
+          enum10 = 28;
           break;
         }
         case 'no-such-device': {
-          enum9 = 29;
+          enum10 = 29;
           break;
         }
         case 'overflow': {
-          enum9 = 30;
+          enum10 = 30;
           break;
         }
         case 'not-permitted': {
-          enum9 = 31;
+          enum10 = 31;
           break;
         }
         case 'pipe': {
-          enum9 = 32;
+          enum10 = 32;
           break;
         }
         case 'read-only': {
-          enum9 = 33;
+          enum10 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum9 = 34;
+          enum10 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum9 = 35;
+          enum10 = 35;
           break;
         }
         case 'cross-device': {
-          enum9 = 36;
+          enum10 = 36;
           break;
         }
         default: {
@@ -1235,10 +1239,10 @@ function trampoline17(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val9}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val10}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum9, true);
+      dataView(memory0).setInt8(arg1 + 8, enum10, true);
       break;
     }
     default: {
@@ -1247,21 +1251,22 @@ function trampoline17(arg0, arg1) {
   }
 }
 
-function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-  const rsc0 = handleTable3.get(arg0).rep;
+function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+  var handle1 = arg0;
+  var rsc0 = handleTable3.get(handle1).rep;
   if ((arg1 & 4294967294) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags1 = {
+  var flags2 = {
     symlinkFollow: Boolean(arg1 & 1),
   };
-  const ptr2 = arg2;
-  const len2 = arg3;
-  const result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+  var ptr3 = arg2;
+  var len3 = arg3;
+  var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
   if ((arg4 & 4294967280) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags3 = {
+  var flags4 = {
     create: Boolean(arg4 & 1),
     directory: Boolean(arg4 & 2),
     exclusive: Boolean(arg4 & 4),
@@ -1270,7 +1275,7 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
   if ((arg5 & 4294967232) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags4 = {
+  var flags5 = {
     read: Boolean(arg5 & 1),
     write: Boolean(arg5 & 2),
     fileIntegritySync: Boolean(arg5 & 4),
@@ -1278,37 +1283,29 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
     requestedWriteSync: Boolean(arg5 & 16),
     mutateDirectory: Boolean(arg5 & 32),
   };
-  if ((arg6 & 4294967288) !== 0) {
-    throw new TypeError('flags have extraneous bits set');
-  }
-  const flags5 = {
-    readable: Boolean(arg6 & 1),
-    writable: Boolean(arg6 & 2),
-    executable: Boolean(arg6 & 4),
-  };
   let ret;
   try {
-    ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags1, result2, flags3, flags4, flags5) };
+    ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags2, result3, flags4, flags5) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant8 = ret;
+  var variant8 = ret;
   switch (variant8.tag) {
     case 'ok': {
       const e = variant8.val;
-      dataView(memory0).setInt8(arg7 + 0, 0, true);
+      dataView(memory0).setInt8(arg6 + 0, 0, true);
       if (!(e instanceof Descriptor)) {
-        throw new Error('Not a valid "Descriptor" resource.');
+        throw new Error('Resource error: Not a valid "Descriptor" resource.');
       }
-      const handle6 = handleCnt3++;
+      var handle6 = handleCnt3++;
       handleTable3.set(handle6, { rep: e, own: true });
-      dataView(memory0).setInt32(arg7 + 4, handle6, true);
+      dataView(memory0).setInt32(arg6 + 4, handle6, true);
       break;
     }
     case 'err': {
       const e = variant8.val;
-      dataView(memory0).setInt8(arg7 + 0, 1, true);
-      const val7 = e;
+      dataView(memory0).setInt8(arg6 + 0, 1, true);
+      var val7 = e;
       let enum7;
       switch (val7) {
         case 'access': {
@@ -1467,7 +1464,7 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
           throw new TypeError(`"${val7}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg7 + 4, enum7, true);
+      dataView(memory0).setInt8(arg6 + 4, enum7, true);
       break;
     }
     default: {
@@ -1477,175 +1474,176 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
 }
 
 function trampoline19(arg0, arg1) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.metadataHash.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  var variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const {lower: v1_0, upper: v1_1 } = e;
-      dataView(memory0).setBigInt64(arg1 + 8, toUint64(v1_0), true);
-      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v1_1), true);
+      var {lower: v2_0, upper: v2_1 } = e;
+      dataView(memory0).setBigInt64(arg1 + 8, toUint64(v2_0), true);
+      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      var val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -1653,10 +1651,10 @@ function trampoline19(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum2, true);
+      dataView(memory0).setInt8(arg1 + 8, enum3, true);
       break;
     }
     default: {
@@ -1666,163 +1664,164 @@ function trampoline19(arg0, arg1) {
 }
 
 function trampoline20(arg0, arg1) {
-  const rsc0 = handleTable1.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable0.get(handle1).rep;
   const ret = filesystemErrorCode(rsc0);
-  const variant2 = ret;
-  if (variant2 === null || variant2=== undefined) {
+  var variant3 = ret;
+  if (variant3 === null || variant3=== undefined) {
     dataView(memory0).setInt8(arg1 + 0, 0, true);
   } else {
-    const e = variant2;
+    const e = variant3;
     dataView(memory0).setInt8(arg1 + 0, 1, true);
-    const val1 = e;
-    let enum1;
-    switch (val1) {
+    var val2 = e;
+    let enum2;
+    switch (val2) {
       case 'access': {
-        enum1 = 0;
+        enum2 = 0;
         break;
       }
       case 'would-block': {
-        enum1 = 1;
+        enum2 = 1;
         break;
       }
       case 'already': {
-        enum1 = 2;
+        enum2 = 2;
         break;
       }
       case 'bad-descriptor': {
-        enum1 = 3;
+        enum2 = 3;
         break;
       }
       case 'busy': {
-        enum1 = 4;
+        enum2 = 4;
         break;
       }
       case 'deadlock': {
-        enum1 = 5;
+        enum2 = 5;
         break;
       }
       case 'quota': {
-        enum1 = 6;
+        enum2 = 6;
         break;
       }
       case 'exist': {
-        enum1 = 7;
+        enum2 = 7;
         break;
       }
       case 'file-too-large': {
-        enum1 = 8;
+        enum2 = 8;
         break;
       }
       case 'illegal-byte-sequence': {
-        enum1 = 9;
+        enum2 = 9;
         break;
       }
       case 'in-progress': {
-        enum1 = 10;
+        enum2 = 10;
         break;
       }
       case 'interrupted': {
-        enum1 = 11;
+        enum2 = 11;
         break;
       }
       case 'invalid': {
-        enum1 = 12;
+        enum2 = 12;
         break;
       }
       case 'io': {
-        enum1 = 13;
+        enum2 = 13;
         break;
       }
       case 'is-directory': {
-        enum1 = 14;
+        enum2 = 14;
         break;
       }
       case 'loop': {
-        enum1 = 15;
+        enum2 = 15;
         break;
       }
       case 'too-many-links': {
-        enum1 = 16;
+        enum2 = 16;
         break;
       }
       case 'message-size': {
-        enum1 = 17;
+        enum2 = 17;
         break;
       }
       case 'name-too-long': {
-        enum1 = 18;
+        enum2 = 18;
         break;
       }
       case 'no-device': {
-        enum1 = 19;
+        enum2 = 19;
         break;
       }
       case 'no-entry': {
-        enum1 = 20;
+        enum2 = 20;
         break;
       }
       case 'no-lock': {
-        enum1 = 21;
+        enum2 = 21;
         break;
       }
       case 'insufficient-memory': {
-        enum1 = 22;
+        enum2 = 22;
         break;
       }
       case 'insufficient-space': {
-        enum1 = 23;
+        enum2 = 23;
         break;
       }
       case 'not-directory': {
-        enum1 = 24;
+        enum2 = 24;
         break;
       }
       case 'not-empty': {
-        enum1 = 25;
+        enum2 = 25;
         break;
       }
       case 'not-recoverable': {
-        enum1 = 26;
+        enum2 = 26;
         break;
       }
       case 'unsupported': {
-        enum1 = 27;
+        enum2 = 27;
         break;
       }
       case 'no-tty': {
-        enum1 = 28;
+        enum2 = 28;
         break;
       }
       case 'no-such-device': {
-        enum1 = 29;
+        enum2 = 29;
         break;
       }
       case 'overflow': {
-        enum1 = 30;
+        enum2 = 30;
         break;
       }
       case 'not-permitted': {
-        enum1 = 31;
+        enum2 = 31;
         break;
       }
       case 'pipe': {
-        enum1 = 32;
+        enum2 = 32;
         break;
       }
       case 'read-only': {
-        enum1 = 33;
+        enum2 = 33;
         break;
       }
       case 'invalid-seek': {
-        enum1 = 34;
+        enum2 = 34;
         break;
       }
       case 'text-file-busy': {
-        enum1 = 35;
+        enum2 = 35;
         break;
       }
       case 'cross-device': {
-        enum1 = 36;
+        enum2 = 36;
         break;
       }
       default: {
@@ -1830,49 +1829,50 @@ function trampoline20(arg0, arg1) {
           console.error(e);
         }
         
-        throw new TypeError(`"${val1}" is not one of the cases of error-code`);
+        throw new TypeError(`"${val2}" is not one of the cases of error-code`);
       }
     }
-    dataView(memory0).setInt8(arg1 + 1, enum1, true);
+    dataView(memory0).setInt8(arg1 + 1, enum2, true);
   }
 }
 
 function trampoline21(arg0, arg1, arg2) {
-  const rsc0 = handleTable0.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable1.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: InputStream.prototype.read.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant4 = ret;
-  switch (variant4.tag) {
+  var variant5 = ret;
+  switch (variant5.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
-      const val1 = e;
-      const len1 = val1.byteLength;
-      const ptr1 = realloc0(0, 0, 1, len1 * 1);
-      const src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
-      (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
-      dataView(memory0).setInt32(arg2 + 8, len1, true);
-      dataView(memory0).setInt32(arg2 + 4, ptr1, true);
+      var val2 = e;
+      var len2 = val2.byteLength;
+      var ptr2 = realloc0(0, 0, 1, len2 * 1);
+      var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+      (new Uint8Array(memory0.buffer, ptr2, len2 * 1)).set(src2);
+      dataView(memory0).setInt32(arg2 + 8, len2, true);
+      dataView(memory0).setInt32(arg2 + 4, ptr2, true);
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const variant3 = e;
-      switch (variant3.tag) {
+      var variant4 = e;
+      switch (variant4.tag) {
         case 'last-operation-failed': {
-          const e = variant3.val;
+          const e = variant4.val;
           dataView(memory0).setInt8(arg2 + 4, 0, true);
           if (!(e instanceof Error$1)) {
-            throw new Error('Not a valid "Error" resource.');
+            throw new Error('Resource error: Not a valid "Error" resource.');
           }
-          const handle2 = handleCnt1++;
-          handleTable1.set(handle2, { rep: e, own: true });
-          dataView(memory0).setInt32(arg2 + 8, handle2, true);
+          var handle3 = handleCnt0++;
+          handleTable0.set(handle3, { rep: e, own: true });
+          dataView(memory0).setInt32(arg2 + 8, handle3, true);
           break;
         }
         case 'closed': {
@@ -1880,7 +1880,7 @@ function trampoline21(arg0, arg1, arg2) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
         }
       }
       break;
@@ -1892,41 +1892,42 @@ function trampoline21(arg0, arg1, arg2) {
 }
 
 function trampoline22(arg0, arg1, arg2) {
-  const rsc0 = handleTable0.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable1.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: InputStream.prototype.blockingRead.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant4 = ret;
-  switch (variant4.tag) {
+  var variant5 = ret;
+  switch (variant5.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
-      const val1 = e;
-      const len1 = val1.byteLength;
-      const ptr1 = realloc0(0, 0, 1, len1 * 1);
-      const src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
-      (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
-      dataView(memory0).setInt32(arg2 + 8, len1, true);
-      dataView(memory0).setInt32(arg2 + 4, ptr1, true);
+      var val2 = e;
+      var len2 = val2.byteLength;
+      var ptr2 = realloc0(0, 0, 1, len2 * 1);
+      var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+      (new Uint8Array(memory0.buffer, ptr2, len2 * 1)).set(src2);
+      dataView(memory0).setInt32(arg2 + 8, len2, true);
+      dataView(memory0).setInt32(arg2 + 4, ptr2, true);
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const variant3 = e;
-      switch (variant3.tag) {
+      var variant4 = e;
+      switch (variant4.tag) {
         case 'last-operation-failed': {
-          const e = variant3.val;
+          const e = variant4.val;
           dataView(memory0).setInt8(arg2 + 4, 0, true);
           if (!(e instanceof Error$1)) {
-            throw new Error('Not a valid "Error" resource.');
+            throw new Error('Resource error: Not a valid "Error" resource.');
           }
-          const handle2 = handleCnt1++;
-          handleTable1.set(handle2, { rep: e, own: true });
-          dataView(memory0).setInt32(arg2 + 8, handle2, true);
+          var handle3 = handleCnt0++;
+          handleTable0.set(handle3, { rep: e, own: true });
+          dataView(memory0).setInt32(arg2 + 8, handle3, true);
           break;
         }
         case 'closed': {
@@ -1934,7 +1935,7 @@ function trampoline22(arg0, arg1, arg2) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
         }
       }
       break;
@@ -1946,35 +1947,36 @@ function trampoline22(arg0, arg1, arg2) {
 }
 
 function trampoline23(arg0, arg1) {
-  const rsc0 = handleTable2.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable2.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: OutputStream.prototype.checkWrite.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  var variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
       dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const variant2 = e;
-      switch (variant2.tag) {
+      var variant3 = e;
+      switch (variant3.tag) {
         case 'last-operation-failed': {
-          const e = variant2.val;
+          const e = variant3.val;
           dataView(memory0).setInt8(arg1 + 8, 0, true);
           if (!(e instanceof Error$1)) {
-            throw new Error('Not a valid "Error" resource.');
+            throw new Error('Resource error: Not a valid "Error" resource.');
           }
-          const handle1 = handleCnt1++;
-          handleTable1.set(handle1, { rep: e, own: true });
-          dataView(memory0).setInt32(arg1 + 12, handle1, true);
+          var handle2 = handleCnt0++;
+          handleTable0.set(handle2, { rep: e, own: true });
+          dataView(memory0).setInt32(arg1 + 12, handle2, true);
           break;
         }
         case 'closed': {
@@ -1982,7 +1984,7 @@ function trampoline23(arg0, arg1) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`StreamError\``);
         }
       }
       break;
@@ -1994,37 +1996,38 @@ function trampoline23(arg0, arg1) {
 }
 
 function trampoline24(arg0, arg1, arg2, arg3) {
-  const rsc0 = handleTable2.get(arg0).rep;
-  const ptr1 = arg1;
-  const len1 = arg2;
-  const result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
+  var handle1 = arg0;
+  var rsc0 = handleTable2.get(handle1).rep;
+  var ptr2 = arg1;
+  var len2 = arg2;
+  var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
   let ret;
   try {
-    ret = { tag: 'ok', val: OutputStream.prototype.write.call(rsc0, result1) };
+    ret = { tag: 'ok', val: OutputStream.prototype.write.call(rsc0, result2) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant4 = ret;
-  switch (variant4.tag) {
+  var variant5 = ret;
+  switch (variant5.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg3 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg3 + 0, 1, true);
-      const variant3 = e;
-      switch (variant3.tag) {
+      var variant4 = e;
+      switch (variant4.tag) {
         case 'last-operation-failed': {
-          const e = variant3.val;
+          const e = variant4.val;
           dataView(memory0).setInt8(arg3 + 4, 0, true);
           if (!(e instanceof Error$1)) {
-            throw new Error('Not a valid "Error" resource.');
+            throw new Error('Resource error: Not a valid "Error" resource.');
           }
-          const handle2 = handleCnt1++;
-          handleTable1.set(handle2, { rep: e, own: true });
-          dataView(memory0).setInt32(arg3 + 8, handle2, true);
+          var handle3 = handleCnt0++;
+          handleTable0.set(handle3, { rep: e, own: true });
+          dataView(memory0).setInt32(arg3 + 8, handle3, true);
           break;
         }
         case 'closed': {
@@ -2032,7 +2035,7 @@ function trampoline24(arg0, arg1, arg2, arg3) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
         }
       }
       break;
@@ -2044,37 +2047,38 @@ function trampoline24(arg0, arg1, arg2, arg3) {
 }
 
 function trampoline25(arg0, arg1, arg2, arg3) {
-  const rsc0 = handleTable2.get(arg0).rep;
-  const ptr1 = arg1;
-  const len1 = arg2;
-  const result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
+  var handle1 = arg0;
+  var rsc0 = handleTable2.get(handle1).rep;
+  var ptr2 = arg1;
+  var len2 = arg2;
+  var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
   let ret;
   try {
-    ret = { tag: 'ok', val: OutputStream.prototype.blockingWriteAndFlush.call(rsc0, result1) };
+    ret = { tag: 'ok', val: OutputStream.prototype.blockingWriteAndFlush.call(rsc0, result2) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant4 = ret;
-  switch (variant4.tag) {
+  var variant5 = ret;
+  switch (variant5.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg3 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg3 + 0, 1, true);
-      const variant3 = e;
-      switch (variant3.tag) {
+      var variant4 = e;
+      switch (variant4.tag) {
         case 'last-operation-failed': {
-          const e = variant3.val;
+          const e = variant4.val;
           dataView(memory0).setInt8(arg3 + 4, 0, true);
           if (!(e instanceof Error$1)) {
-            throw new Error('Not a valid "Error" resource.');
+            throw new Error('Resource error: Not a valid "Error" resource.');
           }
-          const handle2 = handleCnt1++;
-          handleTable1.set(handle2, { rep: e, own: true });
-          dataView(memory0).setInt32(arg3 + 8, handle2, true);
+          var handle3 = handleCnt0++;
+          handleTable0.set(handle3, { rep: e, own: true });
+          dataView(memory0).setInt32(arg3 + 8, handle3, true);
           break;
         }
         case 'closed': {
@@ -2082,7 +2086,7 @@ function trampoline25(arg0, arg1, arg2, arg3) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
         }
       }
       break;
@@ -2094,34 +2098,35 @@ function trampoline25(arg0, arg1, arg2, arg3) {
 }
 
 function trampoline26(arg0, arg1) {
-  const rsc0 = handleTable2.get(arg0).rep;
+  var handle1 = arg0;
+  var rsc0 = handleTable2.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: OutputStream.prototype.blockingFlush.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  var variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const variant2 = e;
-      switch (variant2.tag) {
+      var variant3 = e;
+      switch (variant3.tag) {
         case 'last-operation-failed': {
-          const e = variant2.val;
+          const e = variant3.val;
           dataView(memory0).setInt8(arg1 + 4, 0, true);
           if (!(e instanceof Error$1)) {
-            throw new Error('Not a valid "Error" resource.');
+            throw new Error('Resource error: Not a valid "Error" resource.');
           }
-          const handle1 = handleCnt1++;
-          handleTable1.set(handle1, { rep: e, own: true });
-          dataView(memory0).setInt32(arg1 + 8, handle1, true);
+          var handle2 = handleCnt0++;
+          handleTable0.set(handle2, { rep: e, own: true });
+          dataView(memory0).setInt32(arg1 + 8, handle2, true);
           break;
         }
         case 'closed': {
@@ -2129,7 +2134,7 @@ function trampoline26(arg0, arg1) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`StreamError\``);
         }
       }
       break;
@@ -2142,10 +2147,10 @@ function trampoline26(arg0, arg1) {
 
 function trampoline27(arg0, arg1) {
   const ret = getRandomBytes(BigInt.asUintN(64, arg0));
-  const val0 = ret;
-  const len0 = val0.byteLength;
-  const ptr0 = realloc0(0, 0, 1, len0 * 1);
-  const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+  var val0 = ret;
+  var len0 = val0.byteLength;
+  var ptr0 = realloc0(0, 0, 1, len0 * 1);
+  var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
   dataView(memory0).setInt32(arg1 + 4, len0, true);
   dataView(memory0).setInt32(arg1 + 0, ptr0, true);
@@ -2153,18 +2158,18 @@ function trampoline27(arg0, arg1) {
 
 function trampoline28(arg0) {
   const ret = getEnvironment();
-  const vec3 = ret;
-  const len3 = vec3.length;
-  const result3 = realloc0(0, 0, 4, len3 * 16);
+  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;const [tuple0_0, tuple0_1] = e;
-    const ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
-    const len1 = utf8EncodedLen;
+    const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
+    var ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
+    var len1 = utf8EncodedLen;
     dataView(memory0).setInt32(base + 4, len1, true);
     dataView(memory0).setInt32(base + 0, ptr1, true);
-    const ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
-    const len2 = utf8EncodedLen;
+    var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+    var len2 = utf8EncodedLen;
     dataView(memory0).setInt32(base + 12, len2, true);
     dataView(memory0).setInt32(base + 8, ptr2, true);
   }
@@ -2174,16 +2179,16 @@ function trampoline28(arg0) {
 
 function trampoline29(arg0) {
   const ret = getTerminalStdin();
-  const variant1 = ret;
+  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 Error('Not a valid "TerminalInput" resource.');
+      throw new Error('Resource error: Not a valid "TerminalInput" resource.');
     }
-    const handle0 = handleCnt6++;
+    var handle0 = handleCnt6++;
     handleTable6.set(handle0, { rep: e, own: true });
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
@@ -2191,16 +2196,16 @@ function trampoline29(arg0) {
 
 function trampoline30(arg0) {
   const ret = getTerminalStdout();
-  const variant1 = ret;
+  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 TerminalOutput)) {
-      throw new Error('Not a valid "TerminalOutput" resource.');
+      throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
     }
-    const handle0 = handleCnt7++;
+    var handle0 = handleCnt7++;
     handleTable7.set(handle0, { rep: e, own: true });
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
@@ -2208,16 +2213,16 @@ function trampoline30(arg0) {
 
 function trampoline31(arg0) {
   const ret = getTerminalStderr();
-  const variant1 = ret;
+  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 TerminalOutput)) {
-      throw new Error('Not a valid "TerminalOutput" resource.');
+      throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
     }
-    const handle0 = handleCnt7++;
+    var handle0 = handleCnt7++;
     handleTable7.set(handle0, { rep: e, own: true });
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
@@ -2226,90 +2231,98 @@ let exports3;
 let realloc1;
 let postReturn0;
 let postReturn1;
-const handleTable4= new Map();
-let handleCnt4 = 0;
 function trampoline0(handle) {
   const handleEntry = handleTable4.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable4.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
-const handleTable1= new Map();
-let handleCnt1 = 0;
 function trampoline1(handle) {
-  const handleEntry = handleTable1.get(handle);
+  const handleEntry = handleTable0.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
-  handleTable1.delete(handle);
+  handleTable0.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
-const handleTable0= new Map();
-let handleCnt0 = 0;
 function trampoline2(handle) {
-  const handleEntry = handleTable0.get(handle);
+  const handleEntry = handleTable1.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
-  handleTable0.delete(handle);
+  handleTable1.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
-const handleTable2= new Map();
-let handleCnt2 = 0;
 function trampoline3(handle) {
   const handleEntry = handleTable2.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable2.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
-const handleTable3= new Map();
-let handleCnt3 = 0;
 function trampoline4(handle) {
   const handleEntry = handleTable3.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable3.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
-const handleTable5= new Map();
-let handleCnt5 = 0;
 function trampoline5(handle) {
   const handleEntry = handleTable5.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable5.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
-const handleTable6= new Map();
-let handleCnt6 = 0;
 function trampoline6(handle) {
-  const handleEntry = handleTable6.get(handle);
+  const handleEntry = handleTable7.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
-  handleTable6.delete(handle);
+  handleTable7.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
-const handleTable7= new Map();
-let handleCnt7 = 0;
 function trampoline7(handle) {
-  const handleEntry = handleTable7.get(handle);
+  const handleEntry = handleTable6.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
-  handleTable7.delete(handle);
+  handleTable6.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 
 function parse(arg0) {
   if (!_initialized) throwUninitialized();
-  const ptr0 = utf8Encode(arg0, realloc1, memory0);
-  const len0 = utf8EncodedLen;
+  var ptr0 = utf8Encode(arg0, realloc1, memory0);
+  var len0 = utf8EncodedLen;
   const ret = exports1['local:wasm-tools/tools#parse'](ptr0, len0);
   let variant3;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      const ptr1 = dataView(memory0).getInt32(ret + 4, true);
-      const len1 = dataView(memory0).getInt32(ret + 8, true);
-      const result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
+      var ptr1 = dataView(memory0).getInt32(ret + 4, true);
+      var len1 = dataView(memory0).getInt32(ret + 8, true);
+      var result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
       variant3= {
         tag: 'ok',
         val: result1
@@ -2317,9 +2330,9 @@ function parse(arg0) {
       break;
     }
     case 1: {
-      const ptr2 = dataView(memory0).getInt32(ret + 4, true);
-      const len2 = dataView(memory0).getInt32(ret + 8, true);
-      const result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+      var ptr2 = dataView(memory0).getInt32(ret + 4, true);
+      var len2 = dataView(memory0).getInt32(ret + 8, true);
+      var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
       variant3= {
         tag: 'err',
         val: result2
@@ -2339,18 +2352,18 @@ function parse(arg0) {
 
 function print(arg0) {
   if (!_initialized) throwUninitialized();
-  const val0 = arg0;
-  const len0 = val0.byteLength;
-  const ptr0 = realloc1(0, 0, 1, len0 * 1);
-  const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+  var val0 = arg0;
+  var len0 = val0.byteLength;
+  var ptr0 = realloc1(0, 0, 1, len0 * 1);
+  var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
   const ret = exports1['local:wasm-tools/tools#print'](ptr0, len0);
   let variant3;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      const ptr1 = dataView(memory0).getInt32(ret + 4, true);
-      const len1 = dataView(memory0).getInt32(ret + 8, true);
-      const result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+      var ptr1 = dataView(memory0).getInt32(ret + 4, true);
+      var len1 = dataView(memory0).getInt32(ret + 8, true);
+      var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
       variant3= {
         tag: 'ok',
         val: result1
@@ -2358,9 +2371,9 @@ function print(arg0) {
       break;
     }
     case 1: {
-      const ptr2 = dataView(memory0).getInt32(ret + 4, true);
-      const len2 = dataView(memory0).getInt32(ret + 8, true);
-      const result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+      var ptr2 = dataView(memory0).getInt32(ret + 4, true);
+      var len2 = dataView(memory0).getInt32(ret + 8, true);
+      var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
       variant3= {
         tag: 'err',
         val: result2
@@ -2380,12 +2393,12 @@ function print(arg0) {
 
 function componentNew(arg0, arg1) {
   if (!_initialized) throwUninitialized();
-  const val0 = arg0;
-  const len0 = val0.byteLength;
-  const ptr0 = realloc1(0, 0, 1, len0 * 1);
-  const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+  var val0 = arg0;
+  var len0 = val0.byteLength;
+  var ptr0 = realloc1(0, 0, 1, len0 * 1);
+  var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
-  const variant5 = arg1;
+  var variant5 = arg1;
   let variant5_0;
   let variant5_1;
   let variant5_2;
@@ -2395,20 +2408,20 @@ function componentNew(arg0, arg1) {
     variant5_2 = 0;
   } else {
     const e = variant5;
-    const vec4 = e;
-    const len4 = vec4.length;
-    const result4 = realloc1(0, 0, 4, len4 * 16);
+    var vec4 = e;
+    var len4 = vec4.length;
+    var result4 = realloc1(0, 0, 4, len4 * 16);
     for (let i = 0; i < vec4.length; i++) {
       const e = vec4[i];
-      const base = result4 + i * 16;const [tuple1_0, tuple1_1] = e;
-      const ptr2 = utf8Encode(tuple1_0, realloc1, memory0);
-      const len2 = utf8EncodedLen;
+      const base = result4 + i * 16;var [tuple1_0, tuple1_1] = e;
+      var ptr2 = utf8Encode(tuple1_0, realloc1, memory0);
+      var len2 = utf8EncodedLen;
       dataView(memory0).setInt32(base + 4, len2, true);
       dataView(memory0).setInt32(base + 0, ptr2, true);
-      const val3 = tuple1_1;
-      const len3 = val3.byteLength;
-      const ptr3 = realloc1(0, 0, 1, len3 * 1);
-      const src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
+      var val3 = tuple1_1;
+      var len3 = val3.byteLength;
+      var ptr3 = realloc1(0, 0, 1, len3 * 1);
+      var src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
       (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
       dataView(memory0).setInt32(base + 12, len3, true);
       dataView(memory0).setInt32(base + 8, ptr3, true);
@@ -2421,9 +2434,9 @@ function componentNew(arg0, arg1) {
   let variant8;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      const ptr6 = dataView(memory0).getInt32(ret + 4, true);
-      const len6 = dataView(memory0).getInt32(ret + 8, true);
-      const result6 = new Uint8Array(memory0.buffer.slice(ptr6, ptr6 + len6 * 1));
+      var ptr6 = dataView(memory0).getInt32(ret + 4, true);
+      var len6 = dataView(memory0).getInt32(ret + 8, true);
+      var result6 = new Uint8Array(memory0.buffer.slice(ptr6, ptr6 + len6 * 1));
       variant8= {
         tag: 'ok',
         val: result6
@@ -2431,9 +2444,9 @@ function componentNew(arg0, arg1) {
       break;
     }
     case 1: {
-      const ptr7 = dataView(memory0).getInt32(ret + 4, true);
-      const len7 = dataView(memory0).getInt32(ret + 8, true);
-      const result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
+      var ptr7 = dataView(memory0).getInt32(ret + 4, true);
+      var len7 = dataView(memory0).getInt32(ret + 8, true);
+      var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
       variant8= {
         tag: 'err',
         val: result7
@@ -2453,18 +2466,18 @@ function componentNew(arg0, arg1) {
 
 function componentWit(arg0) {
   if (!_initialized) throwUninitialized();
-  const val0 = arg0;
-  const len0 = val0.byteLength;
-  const ptr0 = realloc1(0, 0, 1, len0 * 1);
-  const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+  var val0 = arg0;
+  var len0 = val0.byteLength;
+  var ptr0 = realloc1(0, 0, 1, len0 * 1);
+  var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
   const ret = exports1['local:wasm-tools/tools#component-wit'](ptr0, len0);
   let variant3;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      const ptr1 = dataView(memory0).getInt32(ret + 4, true);
-      const len1 = dataView(memory0).getInt32(ret + 8, true);
-      const result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+      var ptr1 = dataView(memory0).getInt32(ret + 4, true);
+      var len1 = dataView(memory0).getInt32(ret + 8, true);
+      var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
       variant3= {
         tag: 'ok',
         val: result1
@@ -2472,9 +2485,9 @@ function componentWit(arg0) {
       break;
     }
     case 1: {
-      const ptr2 = dataView(memory0).getInt32(ret + 4, true);
-      const len2 = dataView(memory0).getInt32(ret + 8, true);
-      const result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+      var ptr2 = dataView(memory0).getInt32(ret + 4, true);
+      var len2 = dataView(memory0).getInt32(ret + 8, true);
+      var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
       variant3= {
         tag: 'err',
         val: result2
@@ -2494,51 +2507,51 @@ function componentWit(arg0) {
 
 function componentEmbed(arg0) {
   if (!_initialized) throwUninitialized();
-  const ptr0 = realloc1(0, 0, 4, 64);
-  const {binary: v1_0, witSource: v1_1, witPath: v1_2, stringEncoding: v1_3, dummy: v1_4, world: v1_5, metadata: v1_6 } = arg0;
-  const variant3 = v1_0;
+  var ptr0 = realloc1(0, 0, 4, 64);
+  var {binary: v1_0, witSource: v1_1, witPath: v1_2, stringEncoding: v1_3, dummy: v1_4, world: v1_5, metadata: v1_6 } = arg0;
+  var variant3 = v1_0;
   if (variant3 === null || variant3=== undefined) {
     dataView(memory0).setInt8(ptr0 + 0, 0, true);
   } else {
     const e = variant3;
     dataView(memory0).setInt8(ptr0 + 0, 1, true);
-    const val2 = e;
-    const len2 = val2.byteLength;
-    const ptr2 = realloc1(0, 0, 1, len2 * 1);
-    const src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+    var val2 = e;
+    var len2 = val2.byteLength;
+    var ptr2 = realloc1(0, 0, 1, len2 * 1);
+    var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
     (new Uint8Array(memory0.buffer, ptr2, len2 * 1)).set(src2);
     dataView(memory0).setInt32(ptr0 + 8, len2, true);
     dataView(memory0).setInt32(ptr0 + 4, ptr2, true);
   }
-  const variant5 = v1_1;
+  var variant5 = v1_1;
   if (variant5 === null || variant5=== undefined) {
     dataView(memory0).setInt8(ptr0 + 12, 0, true);
   } else {
     const e = variant5;
     dataView(memory0).setInt8(ptr0 + 12, 1, true);
-    const ptr4 = utf8Encode(e, realloc1, memory0);
-    const len4 = utf8EncodedLen;
+    var ptr4 = utf8Encode(e, realloc1, memory0);
+    var len4 = utf8EncodedLen;
     dataView(memory0).setInt32(ptr0 + 20, len4, true);
     dataView(memory0).setInt32(ptr0 + 16, ptr4, true);
   }
-  const variant7 = v1_2;
+  var variant7 = v1_2;
   if (variant7 === null || variant7=== undefined) {
     dataView(memory0).setInt8(ptr0 + 24, 0, true);
   } else {
     const e = variant7;
     dataView(memory0).setInt8(ptr0 + 24, 1, true);
-    const ptr6 = utf8Encode(e, realloc1, memory0);
-    const len6 = utf8EncodedLen;
+    var ptr6 = utf8Encode(e, realloc1, memory0);
+    var len6 = utf8EncodedLen;
     dataView(memory0).setInt32(ptr0 + 32, len6, true);
     dataView(memory0).setInt32(ptr0 + 28, ptr6, true);
   }
-  const variant9 = v1_3;
+  var variant9 = v1_3;
   if (variant9 === null || variant9=== undefined) {
     dataView(memory0).setInt8(ptr0 + 36, 0, true);
   } else {
     const e = variant9;
     dataView(memory0).setInt8(ptr0 + 36, 1, true);
-    const val8 = e;
+    var val8 = e;
     let enum8;
     switch (val8) {
       case 'utf8': {
@@ -2563,7 +2576,7 @@ function componentEmbed(arg0) {
     }
     dataView(memory0).setInt8(ptr0 + 37, enum8, true);
   }
-  const variant10 = v1_4;
+  var variant10 = v1_4;
   if (variant10 === null || variant10=== undefined) {
     dataView(memory0).setInt8(ptr0 + 38, 0, true);
   } else {
@@ -2571,45 +2584,45 @@ function componentEmbed(arg0) {
     dataView(memory0).setInt8(ptr0 + 38, 1, true);
     dataView(memory0).setInt8(ptr0 + 39, e ? 1 : 0, true);
   }
-  const variant12 = v1_5;
+  var variant12 = v1_5;
   if (variant12 === null || variant12=== undefined) {
     dataView(memory0).setInt8(ptr0 + 40, 0, true);
   } else {
     const e = variant12;
     dataView(memory0).setInt8(ptr0 + 40, 1, true);
-    const ptr11 = utf8Encode(e, realloc1, memory0);
-    const len11 = utf8EncodedLen;
+    var ptr11 = utf8Encode(e, realloc1, memory0);
+    var len11 = utf8EncodedLen;
     dataView(memory0).setInt32(ptr0 + 48, len11, true);
     dataView(memory0).setInt32(ptr0 + 44, ptr11, true);
   }
-  const variant20 = v1_6;
+  var variant20 = v1_6;
   if (variant20 === null || variant20=== undefined) {
     dataView(memory0).setInt8(ptr0 + 52, 0, true);
   } else {
     const e = variant20;
     dataView(memory0).setInt8(ptr0 + 52, 1, true);
-    const vec19 = e;
-    const len19 = vec19.length;
-    const result19 = realloc1(0, 0, 4, len19 * 16);
+    var vec19 = e;
+    var len19 = vec19.length;
+    var result19 = realloc1(0, 0, 4, len19 * 16);
     for (let i = 0; i < vec19.length; i++) {
       const e = vec19[i];
-      const base = result19 + i * 16;const [tuple13_0, tuple13_1] = e;
-      const ptr14 = utf8Encode(tuple13_0, realloc1, memory0);
-      const len14 = utf8EncodedLen;
+      const base = result19 + i * 16;var [tuple13_0, tuple13_1] = e;
+      var ptr14 = utf8Encode(tuple13_0, realloc1, memory0);
+      var len14 = utf8EncodedLen;
       dataView(memory0).setInt32(base + 4, len14, true);
       dataView(memory0).setInt32(base + 0, ptr14, true);
-      const vec18 = tuple13_1;
-      const len18 = vec18.length;
-      const result18 = realloc1(0, 0, 4, len18 * 16);
+      var vec18 = tuple13_1;
+      var len18 = vec18.length;
+      var result18 = realloc1(0, 0, 4, len18 * 16);
       for (let i = 0; i < vec18.length; i++) {
         const e = vec18[i];
-        const base = result18 + i * 16;const [tuple15_0, tuple15_1] = e;
-        const ptr16 = utf8Encode(tuple15_0, realloc1, memory0);
-        const len16 = utf8EncodedLen;
+        const base = result18 + i * 16;var [tuple15_0, tuple15_1] = e;
+        var ptr16 = utf8Encode(tuple15_0, realloc1, memory0);
+        var len16 = utf8EncodedLen;
         dataView(memory0).setInt32(base + 4, len16, true);
         dataView(memory0).setInt32(base + 0, ptr16, true);
-        const ptr17 = utf8Encode(tuple15_1, realloc1, memory0);
-        const len17 = utf8EncodedLen;
+        var ptr17 = utf8Encode(tuple15_1, realloc1, memory0);
+        var len17 = utf8EncodedLen;
         dataView(memory0).setInt32(base + 12, len17, true);
         dataView(memory0).setInt32(base + 8, ptr17, true);
       }
@@ -2623,9 +2636,9 @@ function componentEmbed(arg0) {
   let variant23;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      const ptr21 = dataView(memory0).getInt32(ret + 4, true);
-      const len21 = dataView(memory0).getInt32(ret + 8, true);
-      const result21 = new Uint8Array(memory0.buffer.slice(ptr21, ptr21 + len21 * 1));
+      var ptr21 = dataView(memory0).getInt32(ret + 4, true);
+      var len21 = dataView(memory0).getInt32(ret + 8, true);
+      var result21 = new Uint8Array(memory0.buffer.slice(ptr21, ptr21 + len21 * 1));
       variant23= {
         tag: 'ok',
         val: result21
@@ -2633,9 +2646,9 @@ function componentEmbed(arg0) {
       break;
     }
     case 1: {
-      const ptr22 = dataView(memory0).getInt32(ret + 4, true);
-      const len22 = dataView(memory0).getInt32(ret + 8, true);
-      const result22 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr22, len22));
+      var ptr22 = dataView(memory0).getInt32(ret + 4, true);
+      var len22 = dataView(memory0).getInt32(ret + 8, true);
+      var result22 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr22, len22));
       variant23= {
         tag: 'err',
         val: result22
@@ -2655,18 +2668,18 @@ function componentEmbed(arg0) {
 
 function metadataShow(arg0) {
   if (!_initialized) throwUninitialized();
-  const val0 = arg0;
-  const len0 = val0.byteLength;
-  const ptr0 = realloc1(0, 0, 1, len0 * 1);
-  const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+  var val0 = arg0;
+  var len0 = val0.byteLength;
+  var ptr0 = realloc1(0, 0, 1, len0 * 1);
+  var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
   const ret = exports1['local:wasm-tools/tools#metadata-show'](ptr0, len0);
   let variant11;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      const len9 = dataView(memory0).getInt32(ret + 8, true);
-      const base9 = dataView(memory0).getInt32(ret + 4, true);
-      const result9 = [];
+      var len9 = dataView(memory0).getInt32(ret + 8, true);
+      var base9 = dataView(memory0).getInt32(ret + 4, true);
+      var result9 = [];
       for (let i = 0; i < len9; i++) {
         const base = base9 + i * 36;
         let variant2;
@@ -2676,9 +2689,9 @@ function metadataShow(arg0) {
             break;
           }
           case 1: {
-            const ptr1 = dataView(memory0).getInt32(base + 4, true);
-            const len1 = dataView(memory0).getInt32(base + 8, true);
-            const result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+            var ptr1 = dataView(memory0).getInt32(base + 4, true);
+            var len1 = dataView(memory0).getInt32(base + 8, true);
+            var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
             variant2 = result1;
             break;
           }
@@ -2705,25 +2718,25 @@ function metadataShow(arg0) {
             throw new TypeError('invalid variant discriminant for ModuleMetaType');
           }
         }
-        const len8 = dataView(memory0).getInt32(base + 32, true);
-        const base8 = dataView(memory0).getInt32(base + 28, true);
-        const result8 = [];
+        var len8 = dataView(memory0).getInt32(base + 32, true);
+        var base8 = dataView(memory0).getInt32(base + 28, true);
+        var result8 = [];
         for (let i = 0; i < len8; i++) {
           const base = base8 + i * 16;
-          const ptr4 = dataView(memory0).getInt32(base + 0, true);
-          const len4 = dataView(memory0).getInt32(base + 4, true);
-          const result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
-          const len7 = dataView(memory0).getInt32(base + 12, true);
-          const base7 = dataView(memory0).getInt32(base + 8, true);
-          const result7 = [];
+          var ptr4 = dataView(memory0).getInt32(base + 0, true);
+          var len4 = dataView(memory0).getInt32(base + 4, true);
+          var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+          var len7 = dataView(memory0).getInt32(base + 12, true);
+          var base7 = dataView(memory0).getInt32(base + 8, true);
+          var result7 = [];
           for (let i = 0; i < len7; i++) {
             const base = base7 + i * 16;
-            const ptr5 = dataView(memory0).getInt32(base + 0, true);
-            const len5 = dataView(memory0).getInt32(base + 4, true);
-            const result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
-            const ptr6 = dataView(memory0).getInt32(base + 8, true);
-            const len6 = dataView(memory0).getInt32(base + 12, true);
-            const result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+            var ptr5 = dataView(memory0).getInt32(base + 0, true);
+            var len5 = dataView(memory0).getInt32(base + 4, true);
+            var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+            var ptr6 = dataView(memory0).getInt32(base + 8, true);
+            var len6 = dataView(memory0).getInt32(base + 12, true);
+            var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
             result7.push([result5, result6]);
           }
           result8.push([result4, result7]);
@@ -2742,9 +2755,9 @@ function metadataShow(arg0) {
       break;
     }
     case 1: {
-      const ptr10 = dataView(memory0).getInt32(ret + 4, true);
-      const len10 = dataView(memory0).getInt32(ret + 8, true);
-      const result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+      var ptr10 = dataView(memory0).getInt32(ret + 4, true);
+      var len10 = dataView(memory0).getInt32(ret + 8, true);
+      var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
       variant11= {
         tag: 'err',
         val: result10
@@ -2764,33 +2777,33 @@ function metadataShow(arg0) {
 
 function metadataAdd(arg0, arg1) {
   if (!_initialized) throwUninitialized();
-  const val0 = arg0;
-  const len0 = val0.byteLength;
-  const ptr0 = realloc1(0, 0, 1, len0 * 1);
-  const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+  var val0 = arg0;
+  var len0 = val0.byteLength;
+  var ptr0 = realloc1(0, 0, 1, len0 * 1);
+  var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
   (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
-  const vec7 = arg1;
-  const len7 = vec7.length;
-  const result7 = realloc1(0, 0, 4, len7 * 16);
+  var vec7 = arg1;
+  var len7 = vec7.length;
+  var result7 = realloc1(0, 0, 4, len7 * 16);
   for (let i = 0; i < vec7.length; i++) {
     const e = vec7[i];
-    const base = result7 + i * 16;const [tuple1_0, tuple1_1] = e;
-    const ptr2 = utf8Encode(tuple1_0, realloc1, memory0);
-    const len2 = utf8EncodedLen;
+    const base = result7 + i * 16;var [tuple1_0, tuple1_1] = e;
+    var ptr2 = utf8Encode(tuple1_0, realloc1, memory0);
+    var len2 = utf8EncodedLen;
     dataView(memory0).setInt32(base + 4, len2, true);
     dataView(memory0).setInt32(base + 0, ptr2, true);
-    const vec6 = tuple1_1;
-    const len6 = vec6.length;
-    const result6 = realloc1(0, 0, 4, len6 * 16);
+    var vec6 = tuple1_1;
+    var len6 = vec6.length;
+    var result6 = realloc1(0, 0, 4, len6 * 16);
     for (let i = 0; i < vec6.length; i++) {
       const e = vec6[i];
-      const base = result6 + i * 16;const [tuple3_0, tuple3_1] = e;
-      const ptr4 = utf8Encode(tuple3_0, realloc1, memory0);
-      const len4 = utf8EncodedLen;
+      const base = result6 + i * 16;var [tuple3_0, tuple3_1] = e;
+      var ptr4 = utf8Encode(tuple3_0, realloc1, memory0);
+      var len4 = utf8EncodedLen;
       dataView(memory0).setInt32(base + 4, len4, true);
       dataView(memory0).setInt32(base + 0, ptr4, true);
-      const ptr5 = utf8Encode(tuple3_1, realloc1, memory0);
-      const len5 = utf8EncodedLen;
+      var ptr5 = utf8Encode(tuple3_1, realloc1, memory0);
+      var len5 = utf8EncodedLen;
       dataView(memory0).setInt32(base + 12, len5, true);
       dataView(memory0).setInt32(base + 8, ptr5, true);
     }
@@ -2801,9 +2814,9 @@ function metadataAdd(arg0, arg1) {
   let variant10;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      const ptr8 = dataView(memory0).getInt32(ret + 4, true);
-      const len8 = dataView(memory0).getInt32(ret + 8, true);
-      const result8 = new Uint8Array(memory0.buffer.slice(ptr8, ptr8 + len8 * 1));
+      var ptr8 = dataView(memory0).getInt32(ret + 4, true);
+      var len8 = dataView(memory0).getInt32(ret + 8, true);
+      var result8 = new Uint8Array(memory0.buffer.slice(ptr8, ptr8 + len8 * 1));
       variant10= {
         tag: 'ok',
         val: result8
@@ -2811,9 +2824,9 @@ function metadataAdd(arg0, arg1) {
       break;
     }
     case 1: {
-      const ptr9 = dataView(memory0).getInt32(ret + 4, true);
-      const len9 = dataView(memory0).getInt32(ret + 8, true);
-      const result9 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9));
+      var ptr9 = dataView(memory0).getInt32(ret + 4, true);
+      var len9 = dataView(memory0).getInt32(ret + 8, true);
+      var result9 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9));
       variant10= {
         tag: 'err',
         val: result9
@@ -2830,16 +2843,29 @@ function metadataAdd(arg0, arg1) {
   }
   return variant10.val;
 }
+const handleTable0= new Map();
+let handleCnt0 = 0;
+const handleTable1= new Map();
+let handleCnt1 = 0;
+const handleTable2= new Map();
+let handleCnt2 = 0;
+const handleTable3= new Map();
+let handleCnt3 = 0;
+const handleTable4= new Map();
+let handleCnt4 = 0;
+const handleTable5= new Map();
+let handleCnt5 = 0;
+const handleTable6= new Map();
+let handleCnt6 = 0;
+const handleTable7= new Map();
+let handleCnt7 = 0;
 
 let _initialized = false;
 export const $init = (async() => {
   const module0 = fetchCompile(new URL('./wasm-tools.core.wasm', import.meta.url));
   const module1 = fetchCompile(new URL('./wasm-tools.core2.wasm', import.meta.url));
-  const module2 = base64Compile('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');
-  const module3 = base64Compile('AGFzbQEAAAABUgxgAX8AYAN/fn8AYAJ/fwBgCH9/f39/f39/AGAEf39/fwBgAn5/AGACf38Bf2AEf39/fwF/YAl/f39/f35+f38Bf2ABfwF/YAN/f38Bf2ABfwACwAEgAAEwAAAAATEAAQABMgABAAEzAAIAATQAAgABNQACAAE2AAMAATcAAgABOAACAAE5AAEAAjEwAAEAAjExAAIAAjEyAAQAAjEzAAQAAjE0AAIAAjE1AAUAAjE2AAAAAjE3AAAAAjE4AAAAAjE5AAAAAjIwAAYAAjIxAAcAAjIyAAcAAjIzAAgAAjI0AAYAAjI1AAYAAjI2AAYAAjI3AAkAAjI4AAYAAjI5AAoAAjMwAAsACCRpbXBvcnRzAXABHx8JJQEAQQALHwABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4ALglwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAYwLjE2LjAAHARuYW1lABUUd2l0LWNvbXBvbmVudDpmaXh1cHM');
-  const instanceFlags0 = new WebAssembly.Global({ value: "i32", mutable: true }, 3);
-  const instanceFlags1 = new WebAssembly.Global({ value: "i32", mutable: true }, 3);
-  Promise.all([module0, module1, module2, module3]).catch(() => {});
+  const module2 = base64Compile('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');
+  const module3 = base64Compile('AGFzbQEAAAABUQxgAX8AYAN/fn8AYAJ/fwBgB39/f39/f38AYAR/f39/AGACfn8AYAJ/fwF/YAR/f39/AX9gCX9/f39/fn5/fwF/YAF/AX9gA39/fwF/YAF/AALAASAAATAAAAABMQABAAEyAAEAATMAAgABNAACAAE1AAIAATYAAwABNwACAAE4AAIAATkAAQACMTAAAQACMTEAAgACMTIABAACMTMABAACMTQAAgACMTUABQACMTYAAAACMTcAAAACMTgAAAACMTkAAAACMjAABgACMjEABwACMjIABwACMjMACAACMjQABgACMjUABgACMjYABgACMjcACQACMjgABgACMjkACgACMzAACwAIJGltcG9ydHMBcAEfHwklAQBBAAsfAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHgAuCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BjAuMTkuMAAcBG5hbWUAFRR3aXQtY29tcG9uZW50OmZpeHVwcw');
   ({ exports: exports0 } = await instantiateCore(await module2));
   ({ exports: exports1 } = await instantiateCore(await module0, {
     wasi_snapshot_preview1: {
@@ -2863,40 +2889,40 @@ export const $init = (async() => {
     env: {
       memory: exports1.memory,
     },
-    'wasi:cli/environment@0.2.0-rc-2023-11-05': {
+    'wasi:cli/environment@0.2.0-rc-2023-11-10': {
       'get-environment': exports0['16'],
     },
-    'wasi:cli/exit@0.2.0-rc-2023-11-05': {
+    'wasi:cli/exit@0.2.0-rc-2023-11-10': {
       exit: trampoline9,
     },
-    'wasi:cli/stderr@0.2.0-rc-2023-11-05': {
+    'wasi:cli/stderr@0.2.0-rc-2023-11-10': {
       'get-stderr': trampoline8,
     },
-    'wasi:cli/stdin@0.2.0-rc-2023-11-05': {
+    'wasi:cli/stdin@0.2.0-rc-2023-11-10': {
       'get-stdin': trampoline10,
     },
-    'wasi:cli/stdout@0.2.0-rc-2023-11-05': {
+    'wasi:cli/stdout@0.2.0-rc-2023-11-10': {
       'get-stdout': trampoline11,
     },
-    'wasi:cli/terminal-input@0.2.0-rc-2023-11-05': {
-      '[resource-drop]terminal-input': trampoline6,
+    'wasi:cli/terminal-input@0.2.0-rc-2023-11-10': {
+      '[resource-drop]terminal-input': trampoline7,
     },
-    'wasi:cli/terminal-output@0.2.0-rc-2023-11-05': {
-      '[resource-drop]terminal-output': trampoline7,
+    'wasi:cli/terminal-output@0.2.0-rc-2023-11-10': {
+      '[resource-drop]terminal-output': trampoline6,
     },
-    'wasi:cli/terminal-stderr@0.2.0-rc-2023-11-05': {
+    'wasi:cli/terminal-stderr@0.2.0-rc-2023-11-10': {
       'get-terminal-stderr': exports0['19'],
     },
-    'wasi:cli/terminal-stdin@0.2.0-rc-2023-11-05': {
+    'wasi:cli/terminal-stdin@0.2.0-rc-2023-11-10': {
       'get-terminal-stdin': exports0['17'],
     },
-    'wasi:cli/terminal-stdout@0.2.0-rc-2023-11-05': {
+    'wasi:cli/terminal-stdout@0.2.0-rc-2023-11-10': {
       'get-terminal-stdout': exports0['18'],
     },
-    'wasi:filesystem/preopens@0.2.0-rc-2023-11-05': {
+    'wasi:filesystem/preopens@0.2.0-rc-2023-11-10': {
       'get-directories': exports0['0'],
     },
-    'wasi:filesystem/types@0.2.0-rc-2023-11-05': {
+    'wasi:filesystem/types@0.2.0-rc-2023-11-10': {
       '[method]descriptor.append-via-stream': exports0['3'],
       '[method]descriptor.get-type': exports0['4'],
       '[method]descriptor.metadata-hash': exports0['7'],
@@ -2908,21 +2934,23 @@ export const $init = (async() => {
       '[resource-drop]directory-entry-stream': trampoline0,
       'filesystem-error-code': exports0['8'],
     },
-    'wasi:io/streams@0.2.0-rc-2023-11-05': {
+    'wasi:io/error@0.2.0-rc-2023-11-10': {
+      '[resource-drop]error': trampoline1,
+    },
+    'wasi:io/streams@0.2.0-rc-2023-11-10': {
       '[method]input-stream.blocking-read': exports0['10'],
       '[method]input-stream.read': exports0['9'],
       '[method]output-stream.blocking-flush': exports0['14'],
       '[method]output-stream.blocking-write-and-flush': exports0['13'],
       '[method]output-stream.check-write': exports0['11'],
       '[method]output-stream.write': exports0['12'],
-      '[resource-drop]error': trampoline1,
       '[resource-drop]input-stream': trampoline2,
       '[resource-drop]output-stream': trampoline3,
     },
-    'wasi:random/random@0.2.0-rc-2023-11-05': {
+    'wasi:random/random@0.2.0-rc-2023-11-10': {
       'get-random-bytes': exports0['15'],
     },
-    'wasi:sockets/tcp@0.2.0-rc-2023-11-05': {
+    'wasi:sockets/tcp@0.2.0-rc-2023-11-10': {
       '[resource-drop]tcp-socket': trampoline5,
     },
   }));
@@ -2980,4 +3008,4 @@ const tools = {
   
 };
 
-export { tools, tools as 'local:wasm-tools/tools' }
+export { tools,  }