@bytecodealliance/jco 0.12.2 → 0.13.0

package/obj/wasm-tools.js

@@ -7,29 +7,18 @@ const { exit } = exit$1;
 const { getStderr } = stderr;
 const { getStdin } = stdin;
 const { getStdout } = stdout;
-const { dropTerminalInput } = terminalInput;
-const { dropTerminalOutput } = terminalOutput;
+const { TerminalInput } = terminalInput;
+const { TerminalOutput } = terminalOutput;
 const { getTerminalStderr } = terminalStderr;
 const { getTerminalStdin } = terminalStdin;
 const { getTerminalStdout } = terminalStdout;
 const { getDirectories } = preopens;
-const { appendViaStream,
-  dropDescriptor,
-  dropDirectoryEntryStream,
-  getType,
-  metadataHash,
-  openAt,
-  readViaStream,
-  stat,
-  writeViaStream } = types;
-const { blockingFlush,
-  blockingRead,
-  blockingWriteAndFlush,
-  checkWrite,
-  dropInputStream,
-  dropOutputStream,
-  read,
-  write } = streams;
+const { Descriptor,
+  DirectoryEntryStream,
+  filesystemErrorCode } = types;
+const { Error: Error$1,
+  InputStream,
+  OutputStream } = streams;
 const { getRandomBytes } = random;
 
 const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
@@ -64,6 +53,8 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 const instantiateCore = WebAssembly.instantiate;
 
+const resourceHandleSymbol = Symbol();
+
 function throwUninitialized() {
   throw new TypeError('Wasm uninitialized use `await $init` first');
 }
@@ -107,43 +98,14 @@ function utf8Encode(s, realloc, memory) {
 let exports0;
 let exports1;
 
-function trampoline0(arg0) {
-  dropDirectoryEntryStream(arg0 >>> 0);
-}
-
-function trampoline1(arg0) {
-  dropInputStream(arg0 >>> 0);
-}
-
-function trampoline2(arg0) {
-  dropOutputStream(arg0 >>> 0);
-}
-
-function trampoline3(arg0) {
-  dropDescriptor(arg0 >>> 0);
-}
-
-function trampoline4() {
-  const ret = getStdin();
-  return toUint32(ret);
-}
-
-function trampoline5(arg0) {
-  dropTerminalInput(arg0 >>> 0);
-}
-
-function trampoline6() {
-  const ret = getStdout();
-  return toUint32(ret);
-}
-
-function trampoline7(arg0) {
-  dropTerminalOutput(arg0 >>> 0);
-}
-
 function trampoline8() {
   const ret = getStderr();
-  return toUint32(ret);
+  if (!(ret instanceof OutputStream)) {
+    throw new Error('Not a valid "OutputStream" resource.');
+  }
+  const handle0 = handleCnt2++;
+  handleTable2.set(handle0, { rep: ret, own: true });
+  return handle0;
 }
 
 function trampoline9(arg0) {
@@ -169,195 +131,226 @@ function trampoline9(arg0) {
   }
   exit(variant0);
 }
+
+function trampoline10() {
+  const ret = getStdin();
+  if (!(ret instanceof InputStream)) {
+    throw new Error('Not a valid "InputStream" resource.');
+  }
+  const handle0 = handleCnt0++;
+  handleTable0.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.');
+  }
+  const handle0 = handleCnt2++;
+  handleTable2.set(handle0, { rep: ret, own: true });
+  return handle0;
+}
 let exports2;
 
-function trampoline10(arg0) {
+function trampoline12(arg0) {
   const ret = getDirectories();
-  const vec2 = ret;
-  const len2 = vec2.length;
-  const result2 = realloc0(0, 0, 4, len2 * 12);
-  for (let i = 0; i < vec2.length; i++) {
-    const e = vec2[i];
-    const base = result2 + i * 12;const [tuple0_0, tuple0_1] = e;
-    dataView(memory0).setInt32(base + 0, toUint32(tuple0_0), true);
-    const ptr1 = utf8Encode(tuple0_1, realloc0, memory0);
-    const len1 = utf8EncodedLen;
-    dataView(memory0).setInt32(base + 8, len1, true);
-    dataView(memory0).setInt32(base + 4, ptr1, true);
+  const vec3 = ret;
+  const len3 = vec3.length;
+  const 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;
+    if (!(tuple0_0 instanceof Descriptor)) {
+      throw new Error('Not a valid "Descriptor" resource.');
+    }
+    const 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;
+    dataView(memory0).setInt32(base + 8, len2, true);
+    dataView(memory0).setInt32(base + 4, ptr2, true);
   }
-  dataView(memory0).setInt32(arg0 + 4, len2, true);
-  dataView(memory0).setInt32(arg0 + 0, result2, true);
+  dataView(memory0).setInt32(arg0 + 4, len3, true);
+  dataView(memory0).setInt32(arg0 + 0, result3, true);
 }
 let memory0;
 let realloc0;
 
-function trampoline11(arg0, arg1, arg2) {
+function trampoline13(arg0, arg1, arg2) {
+  const rsc0 = handleTable3.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: readViaStream(arg0 >>> 0, BigInt.asUintN(64, arg1)) };
+    ret = { tag: 'ok', val: Descriptor.prototype.readViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant1 = ret;
-  switch (variant1.tag) {
+  const variant3 = ret;
+  switch (variant3.tag) {
     case 'ok': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
-      dataView(memory0).setInt32(arg2 + 4, toUint32(e), true);
+      if (!(e instanceof InputStream)) {
+        throw new Error('Not a valid "InputStream" resource.');
+      }
+      const handle1 = handleCnt0++;
+      handleTable0.set(handle1, { rep: e, own: true });
+      dataView(memory0).setInt32(arg2 + 4, handle1, true);
       break;
     }
     case 'err': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const val0 = e;
-      let enum0;
-      switch (val0) {
+      const val2 = e;
+      let enum2;
+      switch (val2) {
         case 'access': {
-          enum0 = 0;
+          enum2 = 0;
           break;
         }
         case 'would-block': {
-          enum0 = 1;
+          enum2 = 1;
           break;
         }
         case 'already': {
-          enum0 = 2;
+          enum2 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum0 = 3;
+          enum2 = 3;
           break;
         }
         case 'busy': {
-          enum0 = 4;
+          enum2 = 4;
           break;
         }
         case 'deadlock': {
-          enum0 = 5;
+          enum2 = 5;
           break;
         }
         case 'quota': {
-          enum0 = 6;
+          enum2 = 6;
           break;
         }
         case 'exist': {
-          enum0 = 7;
+          enum2 = 7;
           break;
         }
         case 'file-too-large': {
-          enum0 = 8;
+          enum2 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum0 = 9;
+          enum2 = 9;
           break;
         }
         case 'in-progress': {
-          enum0 = 10;
+          enum2 = 10;
           break;
         }
         case 'interrupted': {
-          enum0 = 11;
+          enum2 = 11;
           break;
         }
         case 'invalid': {
-          enum0 = 12;
+          enum2 = 12;
           break;
         }
         case 'io': {
-          enum0 = 13;
+          enum2 = 13;
           break;
         }
         case 'is-directory': {
-          enum0 = 14;
+          enum2 = 14;
           break;
         }
         case 'loop': {
-          enum0 = 15;
+          enum2 = 15;
           break;
         }
         case 'too-many-links': {
-          enum0 = 16;
+          enum2 = 16;
           break;
         }
         case 'message-size': {
-          enum0 = 17;
+          enum2 = 17;
           break;
         }
         case 'name-too-long': {
-          enum0 = 18;
+          enum2 = 18;
           break;
         }
         case 'no-device': {
-          enum0 = 19;
+          enum2 = 19;
           break;
         }
         case 'no-entry': {
-          enum0 = 20;
+          enum2 = 20;
           break;
         }
         case 'no-lock': {
-          enum0 = 21;
+          enum2 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum0 = 22;
+          enum2 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum0 = 23;
+          enum2 = 23;
           break;
         }
         case 'not-directory': {
-          enum0 = 24;
+          enum2 = 24;
           break;
         }
         case 'not-empty': {
-          enum0 = 25;
+          enum2 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum0 = 26;
+          enum2 = 26;
           break;
         }
         case 'unsupported': {
-          enum0 = 27;
+          enum2 = 27;
           break;
         }
         case 'no-tty': {
-          enum0 = 28;
+          enum2 = 28;
           break;
         }
         case 'no-such-device': {
-          enum0 = 29;
+          enum2 = 29;
           break;
         }
         case 'overflow': {
-          enum0 = 30;
+          enum2 = 30;
           break;
         }
         case 'not-permitted': {
-          enum0 = 31;
+          enum2 = 31;
           break;
         }
         case 'pipe': {
-          enum0 = 32;
+          enum2 = 32;
           break;
         }
         case 'read-only': {
-          enum0 = 33;
+          enum2 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum0 = 34;
+          enum2 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum0 = 35;
+          enum2 = 35;
           break;
         }
         case 'cross-device': {
-          enum0 = 36;
+          enum2 = 36;
           break;
         }
         default: {
@@ -365,10 +358,10 @@ function trampoline11(arg0, arg1, arg2) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val0}" 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(arg2 + 4, enum0, true);
+      dataView(memory0).setInt8(arg2 + 4, enum2, true);
       break;
     }
     default: {
@@ -377,173 +370,179 @@ function trampoline11(arg0, arg1, arg2) {
   }
 }
 
-function trampoline12(arg0, arg1, arg2) {
+function trampoline14(arg0, arg1, arg2) {
+  const rsc0 = handleTable3.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: writeViaStream(arg0 >>> 0, BigInt.asUintN(64, arg1)) };
+    ret = { tag: 'ok', val: Descriptor.prototype.writeViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant1 = ret;
-  switch (variant1.tag) {
+  const variant3 = ret;
+  switch (variant3.tag) {
     case 'ok': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
-      dataView(memory0).setInt32(arg2 + 4, toUint32(e), true);
+      if (!(e instanceof OutputStream)) {
+        throw new Error('Not a valid "OutputStream" resource.');
+      }
+      const handle1 = handleCnt2++;
+      handleTable2.set(handle1, { rep: e, own: true });
+      dataView(memory0).setInt32(arg2 + 4, handle1, true);
       break;
     }
     case 'err': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const val0 = e;
-      let enum0;
-      switch (val0) {
+      const val2 = e;
+      let enum2;
+      switch (val2) {
         case 'access': {
-          enum0 = 0;
+          enum2 = 0;
           break;
         }
         case 'would-block': {
-          enum0 = 1;
+          enum2 = 1;
           break;
         }
         case 'already': {
-          enum0 = 2;
+          enum2 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum0 = 3;
+          enum2 = 3;
           break;
         }
         case 'busy': {
-          enum0 = 4;
+          enum2 = 4;
           break;
         }
         case 'deadlock': {
-          enum0 = 5;
+          enum2 = 5;
           break;
         }
         case 'quota': {
-          enum0 = 6;
+          enum2 = 6;
           break;
         }
         case 'exist': {
-          enum0 = 7;
+          enum2 = 7;
           break;
         }
         case 'file-too-large': {
-          enum0 = 8;
+          enum2 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum0 = 9;
+          enum2 = 9;
           break;
         }
         case 'in-progress': {
-          enum0 = 10;
+          enum2 = 10;
           break;
         }
         case 'interrupted': {
-          enum0 = 11;
+          enum2 = 11;
           break;
         }
         case 'invalid': {
-          enum0 = 12;
+          enum2 = 12;
           break;
         }
         case 'io': {
-          enum0 = 13;
+          enum2 = 13;
           break;
         }
         case 'is-directory': {
-          enum0 = 14;
+          enum2 = 14;
           break;
         }
         case 'loop': {
-          enum0 = 15;
+          enum2 = 15;
           break;
         }
         case 'too-many-links': {
-          enum0 = 16;
+          enum2 = 16;
           break;
         }
         case 'message-size': {
-          enum0 = 17;
+          enum2 = 17;
           break;
         }
         case 'name-too-long': {
-          enum0 = 18;
+          enum2 = 18;
           break;
         }
         case 'no-device': {
-          enum0 = 19;
+          enum2 = 19;
           break;
         }
         case 'no-entry': {
-          enum0 = 20;
+          enum2 = 20;
           break;
         }
         case 'no-lock': {
-          enum0 = 21;
+          enum2 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum0 = 22;
+          enum2 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum0 = 23;
+          enum2 = 23;
           break;
         }
         case 'not-directory': {
-          enum0 = 24;
+          enum2 = 24;
           break;
         }
         case 'not-empty': {
-          enum0 = 25;
+          enum2 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum0 = 26;
+          enum2 = 26;
           break;
         }
         case 'unsupported': {
-          enum0 = 27;
+          enum2 = 27;
           break;
         }
         case 'no-tty': {
-          enum0 = 28;
+          enum2 = 28;
           break;
         }
         case 'no-such-device': {
-          enum0 = 29;
+          enum2 = 29;
           break;
         }
         case 'overflow': {
-          enum0 = 30;
+          enum2 = 30;
           break;
         }
         case 'not-permitted': {
-          enum0 = 31;
+          enum2 = 31;
           break;
         }
         case 'pipe': {
-          enum0 = 32;
+          enum2 = 32;
           break;
         }
         case 'read-only': {
-          enum0 = 33;
+          enum2 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum0 = 34;
+          enum2 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum0 = 35;
+          enum2 = 35;
           break;
         }
         case 'cross-device': {
-          enum0 = 36;
+          enum2 = 36;
           break;
         }
         default: {
@@ -551,10 +550,10 @@ function trampoline12(arg0, arg1, arg2) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val0}" 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(arg2 + 4, enum0, true);
+      dataView(memory0).setInt8(arg2 + 4, enum2, true);
       break;
     }
     default: {
@@ -563,173 +562,179 @@ function trampoline12(arg0, arg1, arg2) {
   }
 }
 
-function trampoline13(arg0, arg1) {
+function trampoline15(arg0, arg1) {
+  const rsc0 = handleTable3.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: appendViaStream(arg0 >>> 0) };
+    ret = { tag: 'ok', val: Descriptor.prototype.appendViaStream.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant1 = ret;
-  switch (variant1.tag) {
+  const variant3 = ret;
+  switch (variant3.tag) {
     case 'ok': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      dataView(memory0).setInt32(arg1 + 4, toUint32(e), true);
+      if (!(e instanceof OutputStream)) {
+        throw new Error('Not a valid "OutputStream" resource.');
+      }
+      const handle1 = handleCnt2++;
+      handleTable2.set(handle1, { rep: e, own: true });
+      dataView(memory0).setInt32(arg1 + 4, handle1, true);
       break;
     }
     case 'err': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val0 = e;
-      let enum0;
-      switch (val0) {
+      const val2 = e;
+      let enum2;
+      switch (val2) {
         case 'access': {
-          enum0 = 0;
+          enum2 = 0;
           break;
         }
         case 'would-block': {
-          enum0 = 1;
+          enum2 = 1;
           break;
         }
         case 'already': {
-          enum0 = 2;
+          enum2 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum0 = 3;
+          enum2 = 3;
           break;
         }
         case 'busy': {
-          enum0 = 4;
+          enum2 = 4;
           break;
         }
         case 'deadlock': {
-          enum0 = 5;
+          enum2 = 5;
           break;
         }
         case 'quota': {
-          enum0 = 6;
+          enum2 = 6;
           break;
         }
         case 'exist': {
-          enum0 = 7;
+          enum2 = 7;
           break;
         }
         case 'file-too-large': {
-          enum0 = 8;
+          enum2 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum0 = 9;
+          enum2 = 9;
           break;
         }
         case 'in-progress': {
-          enum0 = 10;
+          enum2 = 10;
           break;
         }
         case 'interrupted': {
-          enum0 = 11;
+          enum2 = 11;
           break;
         }
         case 'invalid': {
-          enum0 = 12;
+          enum2 = 12;
           break;
         }
         case 'io': {
-          enum0 = 13;
+          enum2 = 13;
           break;
         }
         case 'is-directory': {
-          enum0 = 14;
+          enum2 = 14;
           break;
         }
         case 'loop': {
-          enum0 = 15;
+          enum2 = 15;
           break;
         }
         case 'too-many-links': {
-          enum0 = 16;
+          enum2 = 16;
           break;
         }
         case 'message-size': {
-          enum0 = 17;
+          enum2 = 17;
           break;
         }
         case 'name-too-long': {
-          enum0 = 18;
+          enum2 = 18;
           break;
         }
         case 'no-device': {
-          enum0 = 19;
+          enum2 = 19;
           break;
         }
         case 'no-entry': {
-          enum0 = 20;
+          enum2 = 20;
           break;
         }
         case 'no-lock': {
-          enum0 = 21;
+          enum2 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum0 = 22;
+          enum2 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum0 = 23;
+          enum2 = 23;
           break;
         }
         case 'not-directory': {
-          enum0 = 24;
+          enum2 = 24;
           break;
         }
         case 'not-empty': {
-          enum0 = 25;
+          enum2 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum0 = 26;
+          enum2 = 26;
           break;
         }
         case 'unsupported': {
-          enum0 = 27;
+          enum2 = 27;
           break;
         }
         case 'no-tty': {
-          enum0 = 28;
+          enum2 = 28;
           break;
         }
         case 'no-such-device': {
-          enum0 = 29;
+          enum2 = 29;
           break;
         }
         case 'overflow': {
-          enum0 = 30;
+          enum2 = 30;
           break;
         }
         case 'not-permitted': {
-          enum0 = 31;
+          enum2 = 31;
           break;
         }
         case 'pipe': {
-          enum0 = 32;
+          enum2 = 32;
           break;
         }
         case 'read-only': {
-          enum0 = 33;
+          enum2 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum0 = 34;
+          enum2 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum0 = 35;
+          enum2 = 35;
           break;
         }
         case 'cross-device': {
-          enum0 = 36;
+          enum2 = 36;
           break;
         }
         default: {
@@ -737,10 +742,10 @@ function trampoline13(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val0}" 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 + 4, enum0, true);
+      dataView(memory0).setInt8(arg1 + 4, enum2, true);
       break;
     }
     default: {
@@ -749,51 +754,52 @@ function trampoline13(arg0, arg1) {
   }
 }
 
-function trampoline14(arg0, arg1) {
+function trampoline16(arg0, arg1) {
+  const rsc0 = handleTable3.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: getType(arg0 >>> 0) };
+    ret = { tag: 'ok', val: Descriptor.prototype.getType.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant2 = ret;
-  switch (variant2.tag) {
+  const variant3 = ret;
+  switch (variant3.tag) {
     case 'ok': {
-      const e = variant2.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const val0 = e;
-      let enum0;
-      switch (val0) {
+      const val1 = e;
+      let enum1;
+      switch (val1) {
         case 'unknown': {
-          enum0 = 0;
+          enum1 = 0;
           break;
         }
         case 'block-device': {
-          enum0 = 1;
+          enum1 = 1;
           break;
         }
         case 'character-device': {
-          enum0 = 2;
+          enum1 = 2;
           break;
         }
         case 'directory': {
-          enum0 = 3;
+          enum1 = 3;
           break;
         }
         case 'fifo': {
-          enum0 = 4;
+          enum1 = 4;
           break;
         }
         case 'symbolic-link': {
-          enum0 = 5;
+          enum1 = 5;
           break;
         }
         case 'regular-file': {
-          enum0 = 6;
+          enum1 = 6;
           break;
         }
         case 'socket': {
-          enum0 = 7;
+          enum1 = 7;
           break;
         }
         default: {
@@ -801,164 +807,164 @@ function trampoline14(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val0}" is not one of the cases of descriptor-type`);
+          throw new TypeError(`"${val1}" is not one of the cases of descriptor-type`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 1, enum0, true);
+      dataView(memory0).setInt8(arg1 + 1, enum1, true);
       break;
     }
     case 'err': {
-      const e = variant2.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val1 = e;
-      let enum1;
-      switch (val1) {
+      const 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: {
@@ -966,10 +972,10 @@ function trampoline14(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);
       break;
     }
     default: {
@@ -978,228 +984,250 @@ function trampoline14(arg0, arg1) {
   }
 }
 
-function trampoline15(arg0, arg1) {
+function trampoline17(arg0, arg1) {
+  const rsc0 = handleTable3.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: stat(arg0 >>> 0) };
+    ret = { tag: 'ok', val: Descriptor.prototype.stat.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant6 = ret;
-  switch (variant6.tag) {
+  const variant10 = ret;
+  switch (variant10.tag) {
     case 'ok': {
-      const e = variant6.val;
+      const e = variant10.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const {type: v0_0, linkCount: v0_1, size: v0_2, dataAccessTimestamp: v0_3, dataModificationTimestamp: v0_4, statusChangeTimestamp: v0_5 } = e;
-      const val1 = v0_0;
-      let enum1;
-      switch (val1) {
+      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) {
         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: {
-          if ((v0_0) instanceof Error) {
-            console.error(v0_0);
+          if ((v1_0) instanceof Error) {
+            console.error(v1_0);
           }
           
-          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 + 8, enum1, true);
-      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v0_1), true);
-      dataView(memory0).setBigInt64(arg1 + 24, toUint64(v0_2), true);
-      const {seconds: v2_0, nanoseconds: v2_1 } = v0_3;
-      dataView(memory0).setBigInt64(arg1 + 32, toUint64(v2_0), true);
-      dataView(memory0).setInt32(arg1 + 40, toUint32(v2_1), true);
-      const {seconds: v3_0, nanoseconds: v3_1 } = v0_4;
-      dataView(memory0).setBigInt64(arg1 + 48, toUint64(v3_0), true);
-      dataView(memory0).setInt32(arg1 + 56, toUint32(v3_1), true);
-      const {seconds: v4_0, nanoseconds: v4_1 } = v0_5;
-      dataView(memory0).setBigInt64(arg1 + 64, toUint64(v4_0), true);
-      dataView(memory0).setInt32(arg1 + 72, toUint32(v4_1), true);
+      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 + 32, 0, true);
+      } else {
+        const e = variant4;
+        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);
+      }
+      const variant6 = v1_4;
+      if (variant6 === null || variant6=== undefined) {
+        dataView(memory0).setInt8(arg1 + 56, 0, true);
+      } else {
+        const e = variant6;
+        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);
+      }
+      const variant8 = v1_5;
+      if (variant8 === null || variant8=== undefined) {
+        dataView(memory0).setInt8(arg1 + 80, 0, true);
+      } else {
+        const e = variant8;
+        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);
+      }
       break;
     }
     case 'err': {
-      const e = variant6.val;
+      const e = variant10.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val5 = e;
-      let enum5;
-      switch (val5) {
+      const val9 = e;
+      let enum9;
+      switch (val9) {
         case 'access': {
-          enum5 = 0;
+          enum9 = 0;
           break;
         }
         case 'would-block': {
-          enum5 = 1;
+          enum9 = 1;
           break;
         }
         case 'already': {
-          enum5 = 2;
+          enum9 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum5 = 3;
+          enum9 = 3;
           break;
         }
         case 'busy': {
-          enum5 = 4;
+          enum9 = 4;
           break;
         }
         case 'deadlock': {
-          enum5 = 5;
+          enum9 = 5;
           break;
         }
         case 'quota': {
-          enum5 = 6;
+          enum9 = 6;
           break;
         }
         case 'exist': {
-          enum5 = 7;
+          enum9 = 7;
           break;
         }
         case 'file-too-large': {
-          enum5 = 8;
+          enum9 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum5 = 9;
+          enum9 = 9;
           break;
         }
         case 'in-progress': {
-          enum5 = 10;
+          enum9 = 10;
           break;
         }
         case 'interrupted': {
-          enum5 = 11;
+          enum9 = 11;
           break;
         }
         case 'invalid': {
-          enum5 = 12;
+          enum9 = 12;
           break;
         }
         case 'io': {
-          enum5 = 13;
+          enum9 = 13;
           break;
         }
         case 'is-directory': {
-          enum5 = 14;
+          enum9 = 14;
           break;
         }
         case 'loop': {
-          enum5 = 15;
+          enum9 = 15;
           break;
         }
         case 'too-many-links': {
-          enum5 = 16;
+          enum9 = 16;
           break;
         }
         case 'message-size': {
-          enum5 = 17;
+          enum9 = 17;
           break;
         }
         case 'name-too-long': {
-          enum5 = 18;
+          enum9 = 18;
           break;
         }
         case 'no-device': {
-          enum5 = 19;
+          enum9 = 19;
           break;
         }
         case 'no-entry': {
-          enum5 = 20;
+          enum9 = 20;
           break;
         }
         case 'no-lock': {
-          enum5 = 21;
+          enum9 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum5 = 22;
+          enum9 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum5 = 23;
+          enum9 = 23;
           break;
         }
         case 'not-directory': {
-          enum5 = 24;
+          enum9 = 24;
           break;
         }
         case 'not-empty': {
-          enum5 = 25;
+          enum9 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum5 = 26;
+          enum9 = 26;
           break;
         }
         case 'unsupported': {
-          enum5 = 27;
+          enum9 = 27;
           break;
         }
         case 'no-tty': {
-          enum5 = 28;
+          enum9 = 28;
           break;
         }
         case 'no-such-device': {
-          enum5 = 29;
+          enum9 = 29;
           break;
         }
         case 'overflow': {
-          enum5 = 30;
+          enum9 = 30;
           break;
         }
         case 'not-permitted': {
-          enum5 = 31;
+          enum9 = 31;
           break;
         }
         case 'pipe': {
-          enum5 = 32;
+          enum9 = 32;
           break;
         }
         case 'read-only': {
-          enum5 = 33;
+          enum9 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum5 = 34;
+          enum9 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum5 = 35;
+          enum9 = 35;
           break;
         }
         case 'cross-device': {
-          enum5 = 36;
+          enum9 = 36;
           break;
         }
         default: {
@@ -1207,10 +1235,10 @@ function trampoline15(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val5}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val9}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum5, true);
+      dataView(memory0).setInt8(arg1 + 8, enum9, true);
       break;
     }
     default: {
@@ -1219,20 +1247,21 @@ function trampoline15(arg0, arg1) {
   }
 }
 
-function trampoline16(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+  const rsc0 = handleTable3.get(arg0).rep;
   if ((arg1 & 4294967294) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags0 = {
+  const flags1 = {
     symlinkFollow: Boolean(arg1 & 1),
   };
-  const ptr1 = arg2;
-  const len1 = arg3;
-  const result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+  const ptr2 = arg2;
+  const len2 = arg3;
+  const result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
   if ((arg4 & 4294967280) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags2 = {
+  const flags3 = {
     create: Boolean(arg4 & 1),
     directory: Boolean(arg4 & 2),
     exclusive: Boolean(arg4 & 4),
@@ -1241,7 +1270,7 @@ function trampoline16(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
   if ((arg5 & 4294967232) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags3 = {
+  const flags4 = {
     read: Boolean(arg5 & 1),
     write: Boolean(arg5 & 2),
     fileIntegritySync: Boolean(arg5 & 4),
@@ -1252,177 +1281,182 @@ function trampoline16(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
   if ((arg6 & 4294967288) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags4 = {
+  const flags5 = {
     readable: Boolean(arg6 & 1),
     writable: Boolean(arg6 & 2),
     executable: Boolean(arg6 & 4),
   };
   let ret;
   try {
-    ret = { tag: 'ok', val: openAt(arg0 >>> 0, flags0, result1, flags2, flags3, flags4) };
+    ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags1, result2, flags3, flags4, flags5) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant6 = ret;
-  switch (variant6.tag) {
+  const variant8 = ret;
+  switch (variant8.tag) {
     case 'ok': {
-      const e = variant6.val;
+      const e = variant8.val;
       dataView(memory0).setInt8(arg7 + 0, 0, true);
-      dataView(memory0).setInt32(arg7 + 4, toUint32(e), true);
+      if (!(e instanceof Descriptor)) {
+        throw new Error('Not a valid "Descriptor" resource.');
+      }
+      const handle6 = handleCnt3++;
+      handleTable3.set(handle6, { rep: e, own: true });
+      dataView(memory0).setInt32(arg7 + 4, handle6, true);
       break;
     }
     case 'err': {
-      const e = variant6.val;
+      const e = variant8.val;
       dataView(memory0).setInt8(arg7 + 0, 1, true);
-      const val5 = e;
-      let enum5;
-      switch (val5) {
+      const val7 = e;
+      let enum7;
+      switch (val7) {
         case 'access': {
-          enum5 = 0;
+          enum7 = 0;
           break;
         }
         case 'would-block': {
-          enum5 = 1;
+          enum7 = 1;
           break;
         }
         case 'already': {
-          enum5 = 2;
+          enum7 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum5 = 3;
+          enum7 = 3;
           break;
         }
         case 'busy': {
-          enum5 = 4;
+          enum7 = 4;
           break;
         }
         case 'deadlock': {
-          enum5 = 5;
+          enum7 = 5;
           break;
         }
         case 'quota': {
-          enum5 = 6;
+          enum7 = 6;
           break;
         }
         case 'exist': {
-          enum5 = 7;
+          enum7 = 7;
           break;
         }
         case 'file-too-large': {
-          enum5 = 8;
+          enum7 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum5 = 9;
+          enum7 = 9;
           break;
         }
         case 'in-progress': {
-          enum5 = 10;
+          enum7 = 10;
           break;
         }
         case 'interrupted': {
-          enum5 = 11;
+          enum7 = 11;
           break;
         }
         case 'invalid': {
-          enum5 = 12;
+          enum7 = 12;
           break;
         }
         case 'io': {
-          enum5 = 13;
+          enum7 = 13;
           break;
         }
         case 'is-directory': {
-          enum5 = 14;
+          enum7 = 14;
           break;
         }
         case 'loop': {
-          enum5 = 15;
+          enum7 = 15;
           break;
         }
         case 'too-many-links': {
-          enum5 = 16;
+          enum7 = 16;
           break;
         }
         case 'message-size': {
-          enum5 = 17;
+          enum7 = 17;
           break;
         }
         case 'name-too-long': {
-          enum5 = 18;
+          enum7 = 18;
           break;
         }
         case 'no-device': {
-          enum5 = 19;
+          enum7 = 19;
           break;
         }
         case 'no-entry': {
-          enum5 = 20;
+          enum7 = 20;
           break;
         }
         case 'no-lock': {
-          enum5 = 21;
+          enum7 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum5 = 22;
+          enum7 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum5 = 23;
+          enum7 = 23;
           break;
         }
         case 'not-directory': {
-          enum5 = 24;
+          enum7 = 24;
           break;
         }
         case 'not-empty': {
-          enum5 = 25;
+          enum7 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum5 = 26;
+          enum7 = 26;
           break;
         }
         case 'unsupported': {
-          enum5 = 27;
+          enum7 = 27;
           break;
         }
         case 'no-tty': {
-          enum5 = 28;
+          enum7 = 28;
           break;
         }
         case 'no-such-device': {
-          enum5 = 29;
+          enum7 = 29;
           break;
         }
         case 'overflow': {
-          enum5 = 30;
+          enum7 = 30;
           break;
         }
         case 'not-permitted': {
-          enum5 = 31;
+          enum7 = 31;
           break;
         }
         case 'pipe': {
-          enum5 = 32;
+          enum7 = 32;
           break;
         }
         case 'read-only': {
-          enum5 = 33;
+          enum7 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum5 = 34;
+          enum7 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum5 = 35;
+          enum7 = 35;
           break;
         }
         case 'cross-device': {
-          enum5 = 36;
+          enum7 = 36;
           break;
         }
         default: {
@@ -1430,10 +1464,10 @@ function trampoline16(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val5}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val7}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg7 + 4, enum5, true);
+      dataView(memory0).setInt8(arg7 + 4, enum7, true);
       break;
     }
     default: {
@@ -1442,175 +1476,176 @@ function trampoline16(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
   }
 }
 
-function trampoline17(arg0, arg1) {
+function trampoline19(arg0, arg1) {
+  const rsc0 = handleTable3.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: metadataHash(arg0 >>> 0) };
+    ret = { tag: 'ok', val: Descriptor.prototype.metadataHash.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant2 = ret;
-  switch (variant2.tag) {
+  const variant3 = ret;
+  switch (variant3.tag) {
     case 'ok': {
-      const e = variant2.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const {lower: v0_0, upper: v0_1 } = e;
-      dataView(memory0).setBigInt64(arg1 + 8, toUint64(v0_0), true);
-      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v0_1), 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);
       break;
     }
     case 'err': {
-      const e = variant2.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val1 = e;
-      let enum1;
-      switch (val1) {
+      const 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: {
@@ -1618,10 +1653,10 @@ function trampoline17(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 + 8, enum1, true);
+      dataView(memory0).setInt8(arg1 + 8, enum2, true);
       break;
     }
     default: {
@@ -1630,51 +1665,224 @@ function trampoline17(arg0, arg1) {
   }
 }
 
-function trampoline18(arg0, arg1, arg2) {
+function trampoline20(arg0, arg1) {
+  const rsc0 = handleTable1.get(arg0).rep;
+  const ret = filesystemErrorCode(rsc0);
+  const variant2 = ret;
+  if (variant2 === null || variant2=== undefined) {
+    dataView(memory0).setInt8(arg1 + 0, 0, true);
+  } else {
+    const e = variant2;
+    dataView(memory0).setInt8(arg1 + 0, 1, true);
+    const val1 = e;
+    let enum1;
+    switch (val1) {
+      case 'access': {
+        enum1 = 0;
+        break;
+      }
+      case 'would-block': {
+        enum1 = 1;
+        break;
+      }
+      case 'already': {
+        enum1 = 2;
+        break;
+      }
+      case 'bad-descriptor': {
+        enum1 = 3;
+        break;
+      }
+      case 'busy': {
+        enum1 = 4;
+        break;
+      }
+      case 'deadlock': {
+        enum1 = 5;
+        break;
+      }
+      case 'quota': {
+        enum1 = 6;
+        break;
+      }
+      case 'exist': {
+        enum1 = 7;
+        break;
+      }
+      case 'file-too-large': {
+        enum1 = 8;
+        break;
+      }
+      case 'illegal-byte-sequence': {
+        enum1 = 9;
+        break;
+      }
+      case 'in-progress': {
+        enum1 = 10;
+        break;
+      }
+      case 'interrupted': {
+        enum1 = 11;
+        break;
+      }
+      case 'invalid': {
+        enum1 = 12;
+        break;
+      }
+      case 'io': {
+        enum1 = 13;
+        break;
+      }
+      case 'is-directory': {
+        enum1 = 14;
+        break;
+      }
+      case 'loop': {
+        enum1 = 15;
+        break;
+      }
+      case 'too-many-links': {
+        enum1 = 16;
+        break;
+      }
+      case 'message-size': {
+        enum1 = 17;
+        break;
+      }
+      case 'name-too-long': {
+        enum1 = 18;
+        break;
+      }
+      case 'no-device': {
+        enum1 = 19;
+        break;
+      }
+      case 'no-entry': {
+        enum1 = 20;
+        break;
+      }
+      case 'no-lock': {
+        enum1 = 21;
+        break;
+      }
+      case 'insufficient-memory': {
+        enum1 = 22;
+        break;
+      }
+      case 'insufficient-space': {
+        enum1 = 23;
+        break;
+      }
+      case 'not-directory': {
+        enum1 = 24;
+        break;
+      }
+      case 'not-empty': {
+        enum1 = 25;
+        break;
+      }
+      case 'not-recoverable': {
+        enum1 = 26;
+        break;
+      }
+      case 'unsupported': {
+        enum1 = 27;
+        break;
+      }
+      case 'no-tty': {
+        enum1 = 28;
+        break;
+      }
+      case 'no-such-device': {
+        enum1 = 29;
+        break;
+      }
+      case 'overflow': {
+        enum1 = 30;
+        break;
+      }
+      case 'not-permitted': {
+        enum1 = 31;
+        break;
+      }
+      case 'pipe': {
+        enum1 = 32;
+        break;
+      }
+      case 'read-only': {
+        enum1 = 33;
+        break;
+      }
+      case 'invalid-seek': {
+        enum1 = 34;
+        break;
+      }
+      case 'text-file-busy': {
+        enum1 = 35;
+        break;
+      }
+      case 'cross-device': {
+        enum1 = 36;
+        break;
+      }
+      default: {
+        if ((e) instanceof Error) {
+          console.error(e);
+        }
+        
+        throw new TypeError(`"${val1}" is not one of the cases of error-code`);
+      }
+    }
+    dataView(memory0).setInt8(arg1 + 1, enum1, true);
+  }
+}
+
+function trampoline21(arg0, arg1, arg2) {
+  const rsc0 = handleTable0.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: read(arg0 >>> 0, BigInt.asUintN(64, arg1)) };
+    ret = { tag: 'ok', val: InputStream.prototype.read.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
-      const [tuple0_0, tuple0_1] = e;
-      const val1 = tuple0_0;
+      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);
-      const val2 = tuple0_1;
-      let enum2;
-      switch (val2) {
-        case 'open': {
-          enum2 = 0;
+      break;
+    }
+    case 'err': {
+      const e = variant4.val;
+      dataView(memory0).setInt8(arg2 + 0, 1, true);
+      const variant3 = e;
+      switch (variant3.tag) {
+        case 'last-operation-failed': {
+          const e = variant3.val;
+          dataView(memory0).setInt8(arg2 + 4, 0, true);
+          if (!(e instanceof Error$1)) {
+            throw new Error('Not a valid "Error" resource.');
+          }
+          const handle2 = handleCnt1++;
+          handleTable1.set(handle2, { rep: e, own: true });
+          dataView(memory0).setInt32(arg2 + 8, handle2, true);
           break;
         }
-        case 'ended': {
-          enum2 = 1;
+        case 'closed': {
+          dataView(memory0).setInt8(arg2 + 4, 1, true);
           break;
         }
         default: {
-          if ((tuple0_1) instanceof Error) {
-            console.error(tuple0_1);
-          }
-          
-          throw new TypeError(`"${val2}" is not one of the cases of stream-status`);
+          throw new TypeError('invalid variant specified for StreamError');
         }
       }
-      dataView(memory0).setInt8(arg2 + 12, enum2, true);
-      break;
-    }
-    case 'err': {
-      const e = variant3.val;
-      dataView(memory0).setInt8(arg2 + 0, 1, true);
       break;
     }
     default: {
@@ -1683,51 +1891,52 @@ function trampoline18(arg0, arg1, arg2) {
   }
 }
 
-function trampoline19(arg0, arg1, arg2) {
+function trampoline22(arg0, arg1, arg2) {
+  const rsc0 = handleTable0.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: blockingRead(arg0 >>> 0, BigInt.asUintN(64, arg1)) };
+    ret = { tag: 'ok', val: InputStream.prototype.blockingRead.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
-      const [tuple0_0, tuple0_1] = e;
-      const val1 = tuple0_0;
+      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);
-      const val2 = tuple0_1;
-      let enum2;
-      switch (val2) {
-        case 'open': {
-          enum2 = 0;
+      break;
+    }
+    case 'err': {
+      const e = variant4.val;
+      dataView(memory0).setInt8(arg2 + 0, 1, true);
+      const variant3 = e;
+      switch (variant3.tag) {
+        case 'last-operation-failed': {
+          const e = variant3.val;
+          dataView(memory0).setInt8(arg2 + 4, 0, true);
+          if (!(e instanceof Error$1)) {
+            throw new Error('Not a valid "Error" resource.');
+          }
+          const handle2 = handleCnt1++;
+          handleTable1.set(handle2, { rep: e, own: true });
+          dataView(memory0).setInt32(arg2 + 8, handle2, true);
           break;
         }
-        case 'ended': {
-          enum2 = 1;
+        case 'closed': {
+          dataView(memory0).setInt8(arg2 + 4, 1, true);
           break;
         }
         default: {
-          if ((tuple0_1) instanceof Error) {
-            console.error(tuple0_1);
-          }
-          
-          throw new TypeError(`"${val2}" is not one of the cases of stream-status`);
+          throw new TypeError('invalid variant specified for StreamError');
         }
       }
-      dataView(memory0).setInt8(arg2 + 12, enum2, true);
-      break;
-    }
-    case 'err': {
-      const e = variant3.val;
-      dataView(memory0).setInt8(arg2 + 0, 1, true);
       break;
     }
     default: {
@@ -1736,44 +1945,46 @@ function trampoline19(arg0, arg1, arg2) {
   }
 }
 
-function trampoline20(arg0, arg1) {
+function trampoline23(arg0, arg1) {
+  const rsc0 = handleTable2.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: checkWrite(arg0 >>> 0) };
+    ret = { tag: 'ok', val: OutputStream.prototype.checkWrite.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant1 = ret;
-  switch (variant1.tag) {
+  const variant3 = ret;
+  switch (variant3.tag) {
     case 'ok': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
       dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
       break;
     }
     case 'err': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val0 = e;
-      let enum0;
-      switch (val0) {
+      const variant2 = e;
+      switch (variant2.tag) {
         case 'last-operation-failed': {
-          enum0 = 0;
+          const e = variant2.val;
+          dataView(memory0).setInt8(arg1 + 8, 0, true);
+          if (!(e instanceof Error$1)) {
+            throw new Error('Not a valid "Error" resource.');
+          }
+          const handle1 = handleCnt1++;
+          handleTable1.set(handle1, { rep: e, own: true });
+          dataView(memory0).setInt32(arg1 + 12, handle1, true);
           break;
         }
         case 'closed': {
-          enum0 = 1;
+          dataView(memory0).setInt8(arg1 + 8, 1, true);
           break;
         }
         default: {
-          if ((e) instanceof Error) {
-            console.error(e);
-          }
-          
-          throw new TypeError(`"${val0}" is not one of the cases of write-error`);
+          throw new TypeError('invalid variant specified for StreamError');
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum0, true);
       break;
     }
     default: {
@@ -1782,46 +1993,48 @@ function trampoline20(arg0, arg1) {
   }
 }
 
-function trampoline21(arg0, arg1, arg2, arg3) {
-  const ptr0 = arg1;
-  const len0 = arg2;
-  const result0 = new Uint8Array(memory0.buffer.slice(ptr0, ptr0 + len0 * 1));
+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));
   let ret;
   try {
-    ret = { tag: 'ok', val: write(arg0 >>> 0, result0) };
+    ret = { tag: 'ok', val: OutputStream.prototype.write.call(rsc0, result1) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant2 = ret;
-  switch (variant2.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant2.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg3 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant2.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg3 + 0, 1, true);
-      const val1 = e;
-      let enum1;
-      switch (val1) {
+      const variant3 = e;
+      switch (variant3.tag) {
         case 'last-operation-failed': {
-          enum1 = 0;
+          const e = variant3.val;
+          dataView(memory0).setInt8(arg3 + 4, 0, true);
+          if (!(e instanceof Error$1)) {
+            throw new Error('Not a valid "Error" resource.');
+          }
+          const handle2 = handleCnt1++;
+          handleTable1.set(handle2, { rep: e, own: true });
+          dataView(memory0).setInt32(arg3 + 8, handle2, true);
           break;
         }
         case 'closed': {
-          enum1 = 1;
+          dataView(memory0).setInt8(arg3 + 4, 1, true);
           break;
         }
         default: {
-          if ((e) instanceof Error) {
-            console.error(e);
-          }
-          
-          throw new TypeError(`"${val1}" is not one of the cases of write-error`);
+          throw new TypeError('invalid variant specified for StreamError');
         }
       }
-      dataView(memory0).setInt8(arg3 + 1, enum1, true);
       break;
     }
     default: {
@@ -1830,46 +2043,48 @@ function trampoline21(arg0, arg1, arg2, arg3) {
   }
 }
 
-function trampoline22(arg0, arg1, arg2, arg3) {
-  const ptr0 = arg1;
-  const len0 = arg2;
-  const result0 = new Uint8Array(memory0.buffer.slice(ptr0, ptr0 + len0 * 1));
+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));
   let ret;
   try {
-    ret = { tag: 'ok', val: blockingWriteAndFlush(arg0 >>> 0, result0) };
+    ret = { tag: 'ok', val: OutputStream.prototype.blockingWriteAndFlush.call(rsc0, result1) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant2 = ret;
-  switch (variant2.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant2.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg3 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant2.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg3 + 0, 1, true);
-      const val1 = e;
-      let enum1;
-      switch (val1) {
+      const variant3 = e;
+      switch (variant3.tag) {
         case 'last-operation-failed': {
-          enum1 = 0;
+          const e = variant3.val;
+          dataView(memory0).setInt8(arg3 + 4, 0, true);
+          if (!(e instanceof Error$1)) {
+            throw new Error('Not a valid "Error" resource.');
+          }
+          const handle2 = handleCnt1++;
+          handleTable1.set(handle2, { rep: e, own: true });
+          dataView(memory0).setInt32(arg3 + 8, handle2, true);
           break;
         }
         case 'closed': {
-          enum1 = 1;
+          dataView(memory0).setInt8(arg3 + 4, 1, true);
           break;
         }
         default: {
-          if ((e) instanceof Error) {
-            console.error(e);
-          }
-          
-          throw new TypeError(`"${val1}" is not one of the cases of write-error`);
+          throw new TypeError('invalid variant specified for StreamError');
         }
       }
-      dataView(memory0).setInt8(arg3 + 1, enum1, true);
       break;
     }
     default: {
@@ -1878,43 +2093,45 @@ function trampoline22(arg0, arg1, arg2, arg3) {
   }
 }
 
-function trampoline23(arg0, arg1) {
+function trampoline26(arg0, arg1) {
+  const rsc0 = handleTable2.get(arg0).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: blockingFlush(arg0 >>> 0) };
+    ret = { tag: 'ok', val: OutputStream.prototype.blockingFlush.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant1 = ret;
-  switch (variant1.tag) {
+  const variant3 = ret;
+  switch (variant3.tag) {
     case 'ok': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant1.val;
+      const e = variant3.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val0 = e;
-      let enum0;
-      switch (val0) {
+      const variant2 = e;
+      switch (variant2.tag) {
         case 'last-operation-failed': {
-          enum0 = 0;
+          const e = variant2.val;
+          dataView(memory0).setInt8(arg1 + 4, 0, true);
+          if (!(e instanceof Error$1)) {
+            throw new Error('Not a valid "Error" resource.');
+          }
+          const handle1 = handleCnt1++;
+          handleTable1.set(handle1, { rep: e, own: true });
+          dataView(memory0).setInt32(arg1 + 8, handle1, true);
           break;
         }
         case 'closed': {
-          enum0 = 1;
+          dataView(memory0).setInt8(arg1 + 4, 1, true);
           break;
         }
         default: {
-          if ((e) instanceof Error) {
-            console.error(e);
-          }
-          
-          throw new TypeError(`"${val0}" is not one of the cases of write-error`);
+          throw new TypeError('invalid variant specified for StreamError');
         }
       }
-      dataView(memory0).setInt8(arg1 + 1, enum0, true);
       break;
     }
     default: {
@@ -1923,7 +2140,7 @@ function trampoline23(arg0, arg1) {
   }
 }
 
-function trampoline24(arg0, arg1) {
+function trampoline27(arg0, arg1) {
   const ret = getRandomBytes(BigInt.asUintN(64, arg0));
   const val0 = ret;
   const len0 = val0.byteLength;
@@ -1934,7 +2151,7 @@ function trampoline24(arg0, arg1) {
   dataView(memory0).setInt32(arg1 + 0, ptr0, true);
 }
 
-function trampoline25(arg0) {
+function trampoline28(arg0) {
   const ret = getEnvironment();
   const vec3 = ret;
   const len3 = vec3.length;
@@ -1955,45 +2172,132 @@ function trampoline25(arg0) {
   dataView(memory0).setInt32(arg0 + 0, result3, true);
 }
 
-function trampoline26(arg0) {
+function trampoline29(arg0) {
   const ret = getTerminalStdin();
-  const variant0 = ret;
-  if (variant0 === null || variant0=== undefined) {
+  const variant1 = ret;
+  if (variant1 === null || variant1=== undefined) {
     dataView(memory0).setInt8(arg0 + 0, 0, true);
   } else {
-    const e = variant0;
+    const e = variant1;
     dataView(memory0).setInt8(arg0 + 0, 1, true);
-    dataView(memory0).setInt32(arg0 + 4, toUint32(e), true);
+    if (!(e instanceof TerminalInput)) {
+      throw new Error('Not a valid "TerminalInput" resource.');
+    }
+    const handle0 = handleCnt6++;
+    handleTable6.set(handle0, { rep: e, own: true });
+    dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
 }
 
-function trampoline27(arg0) {
+function trampoline30(arg0) {
   const ret = getTerminalStdout();
-  const variant0 = ret;
-  if (variant0 === null || variant0=== undefined) {
+  const variant1 = ret;
+  if (variant1 === null || variant1=== undefined) {
     dataView(memory0).setInt8(arg0 + 0, 0, true);
   } else {
-    const e = variant0;
+    const e = variant1;
     dataView(memory0).setInt8(arg0 + 0, 1, true);
-    dataView(memory0).setInt32(arg0 + 4, toUint32(e), true);
+    if (!(e instanceof TerminalOutput)) {
+      throw new Error('Not a valid "TerminalOutput" resource.');
+    }
+    const handle0 = handleCnt7++;
+    handleTable7.set(handle0, { rep: e, own: true });
+    dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
 }
 
-function trampoline28(arg0) {
+function trampoline31(arg0) {
   const ret = getTerminalStderr();
-  const variant0 = ret;
-  if (variant0 === null || variant0=== undefined) {
+  const variant1 = ret;
+  if (variant1 === null || variant1=== undefined) {
     dataView(memory0).setInt8(arg0 + 0, 0, true);
   } else {
-    const e = variant0;
+    const e = variant1;
     dataView(memory0).setInt8(arg0 + 0, 1, true);
-    dataView(memory0).setInt32(arg0 + 4, toUint32(e), true);
+    if (!(e instanceof TerminalOutput)) {
+      throw new Error('Not a valid "TerminalOutput" resource.');
+    }
+    const handle0 = handleCnt7++;
+    handleTable7.set(handle0, { rep: e, own: true });
+    dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
 }
 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);
+}
+const handleTable1= new Map();
+let handleCnt1 = 0;
+function trampoline1(handle) {
+  const handleEntry = handleTable1.get(handle);
+  if (!handleEntry) {
+    throw new Error(`Resource error: Invalid handle ${handle}`);
+  }
+  handleTable1.delete(handle);
+}
+const handleTable0= new Map();
+let handleCnt0 = 0;
+function trampoline2(handle) {
+  const handleEntry = handleTable0.get(handle);
+  if (!handleEntry) {
+    throw new Error(`Resource error: Invalid handle ${handle}`);
+  }
+  handleTable0.delete(handle);
+}
+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);
+}
+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);
+}
+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);
+}
+const handleTable6= new Map();
+let handleCnt6 = 0;
+function trampoline6(handle) {
+  const handleEntry = handleTable6.get(handle);
+  if (!handleEntry) {
+    throw new Error(`Resource error: Invalid handle ${handle}`);
+  }
+  handleTable6.delete(handle);
+}
+const handleTable7= new Map();
+let handleCnt7 = 0;
+function trampoline7(handle) {
+  const handleEntry = handleTable7.get(handle);
+  if (!handleEntry) {
+    throw new Error(`Resource error: Invalid handle ${handle}`);
+  }
+  handleTable7.delete(handle);
+}
 
 function parse(arg0) {
   if (!_initialized) throwUninitialized();
@@ -2531,25 +2835,25 @@ 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/f38Bf2ABfwACugEfAAEwAAAAATEAAQABMgABAAEzAAIAATQAAgABNQACAAE2AAMAATcAAgABOAABAAE5AAEAAjEwAAIAAjExAAQAAjEyAAQAAjEzAAIAAjE0AAUAAjE1AAAAAjE2AAAAAjE3AAAAAjE4AAAAAjE5AAYAAjIwAAcAAjIxAAcAAjIyAAgAAjIzAAYAAjI0AAYAAjI1AAYAAjI2AAkAAjI3AAYAAjI4AAoAAjI5AAsACCRpbXBvcnRzAXABHh4JJAEAQQALHgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHQAuCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BjAuMTUuMAAcBG5hbWUAFRR3aXQtY29tcG9uZW50OmZpeHVwcw');
+  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(() => {});
   ({ exports: exports0 } = await instantiateCore(await module2));
   ({ exports: exports1 } = await instantiateCore(await module0, {
     wasi_snapshot_preview1: {
-      environ_get: exports0['24'],
-      environ_sizes_get: exports0['25'],
-      fd_close: exports0['26'],
-      fd_filestat_get: exports0['19'],
-      fd_prestat_dir_name: exports0['28'],
-      fd_prestat_get: exports0['27'],
-      fd_read: exports0['20'],
-      fd_write: exports0['21'],
-      path_open: exports0['22'],
-      proc_exit: exports0['29'],
-      random_get: exports0['23'],
+      environ_get: exports0['25'],
+      environ_sizes_get: exports0['26'],
+      fd_close: exports0['27'],
+      fd_filestat_get: exports0['20'],
+      fd_prestat_dir_name: exports0['29'],
+      fd_prestat_get: exports0['28'],
+      fd_read: exports0['21'],
+      fd_write: exports0['22'],
+      path_open: exports0['23'],
+      proc_exit: exports0['30'],
+      random_get: exports0['24'],
     },
   }));
   ({ exports: exports2 } = await instantiateCore(await module1, {
@@ -2559,62 +2863,67 @@ export const $init = (async() => {
     env: {
       memory: exports1.memory,
     },
-    'wasi:cli/environment': {
-      'get-environment': exports0['15'],
+    'wasi:cli/environment@0.2.0-rc-2023-11-05': {
+      'get-environment': exports0['16'],
     },
-    'wasi:cli/exit': {
+    'wasi:cli/exit@0.2.0-rc-2023-11-05': {
       exit: trampoline9,
     },
-    'wasi:cli/stderr': {
+    'wasi:cli/stderr@0.2.0-rc-2023-11-05': {
       'get-stderr': trampoline8,
     },
-    'wasi:cli/stdin': {
-      'get-stdin': trampoline4,
+    'wasi:cli/stdin@0.2.0-rc-2023-11-05': {
+      'get-stdin': trampoline10,
     },
-    'wasi:cli/stdout': {
-      'get-stdout': trampoline6,
+    'wasi:cli/stdout@0.2.0-rc-2023-11-05': {
+      'get-stdout': trampoline11,
     },
-    'wasi:cli/terminal-input': {
-      'drop-terminal-input': trampoline5,
+    'wasi:cli/terminal-input@0.2.0-rc-2023-11-05': {
+      '[resource-drop]terminal-input': trampoline6,
     },
-    'wasi:cli/terminal-output': {
-      'drop-terminal-output': trampoline7,
+    'wasi:cli/terminal-output@0.2.0-rc-2023-11-05': {
+      '[resource-drop]terminal-output': trampoline7,
     },
-    'wasi:cli/terminal-stderr': {
-      'get-terminal-stderr': exports0['18'],
+    'wasi:cli/terminal-stderr@0.2.0-rc-2023-11-05': {
+      'get-terminal-stderr': exports0['19'],
     },
-    'wasi:cli/terminal-stdin': {
-      'get-terminal-stdin': exports0['16'],
+    'wasi:cli/terminal-stdin@0.2.0-rc-2023-11-05': {
+      'get-terminal-stdin': exports0['17'],
     },
-    'wasi:cli/terminal-stdout': {
-      'get-terminal-stdout': exports0['17'],
+    'wasi:cli/terminal-stdout@0.2.0-rc-2023-11-05': {
+      'get-terminal-stdout': exports0['18'],
     },
-    'wasi:filesystem/preopens': {
+    'wasi:filesystem/preopens@0.2.0-rc-2023-11-05': {
       'get-directories': exports0['0'],
     },
-    'wasi:filesystem/types': {
-      'append-via-stream': exports0['3'],
-      'drop-descriptor': trampoline3,
-      'drop-directory-entry-stream': trampoline0,
-      'get-type': exports0['4'],
-      'metadata-hash': exports0['7'],
-      'open-at': exports0['6'],
-      'read-via-stream': exports0['1'],
-      stat: exports0['5'],
-      'write-via-stream': exports0['2'],
+    'wasi:filesystem/types@0.2.0-rc-2023-11-05': {
+      '[method]descriptor.append-via-stream': exports0['3'],
+      '[method]descriptor.get-type': exports0['4'],
+      '[method]descriptor.metadata-hash': exports0['7'],
+      '[method]descriptor.open-at': exports0['6'],
+      '[method]descriptor.read-via-stream': exports0['1'],
+      '[method]descriptor.stat': exports0['5'],
+      '[method]descriptor.write-via-stream': exports0['2'],
+      '[resource-drop]descriptor': trampoline4,
+      '[resource-drop]directory-entry-stream': trampoline0,
+      'filesystem-error-code': exports0['8'],
+    },
+    'wasi:io/streams@0.2.0-rc-2023-11-05': {
+      '[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:io/streams': {
-      'blocking-flush': exports0['13'],
-      'blocking-read': exports0['9'],
-      'blocking-write-and-flush': exports0['12'],
-      'check-write': exports0['10'],
-      'drop-input-stream': trampoline1,
-      'drop-output-stream': trampoline2,
-      read: exports0['8'],
-      write: exports0['11'],
+    'wasi:random/random@0.2.0-rc-2023-11-05': {
+      'get-random-bytes': exports0['15'],
     },
-    'wasi:random/random': {
-      'get-random-bytes': exports0['14'],
+    'wasi:sockets/tcp@0.2.0-rc-2023-11-05': {
+      '[resource-drop]tcp-socket': trampoline5,
     },
   }));
   memory0 = exports1.memory;
@@ -2622,36 +2931,37 @@ export const $init = (async() => {
   ({ exports: exports3 } = await instantiateCore(await module3, {
     '': {
       $imports: exports0.$imports,
-      '0': trampoline10,
-      '1': trampoline11,
-      '10': trampoline20,
-      '11': trampoline21,
-      '12': trampoline22,
-      '13': trampoline23,
-      '14': trampoline24,
-      '15': trampoline25,
-      '16': trampoline26,
-      '17': trampoline27,
-      '18': trampoline28,
-      '19': exports2.fd_filestat_get,
-      '2': trampoline12,
-      '20': exports2.fd_read,
-      '21': exports2.fd_write,
-      '22': exports2.path_open,
-      '23': exports2.random_get,
-      '24': exports2.environ_get,
-      '25': exports2.environ_sizes_get,
-      '26': exports2.fd_close,
-      '27': exports2.fd_prestat_get,
-      '28': exports2.fd_prestat_dir_name,
-      '29': exports2.proc_exit,
-      '3': trampoline13,
-      '4': trampoline14,
-      '5': trampoline15,
-      '6': trampoline16,
-      '7': trampoline17,
-      '8': trampoline18,
-      '9': trampoline19,
+      '0': trampoline12,
+      '1': trampoline13,
+      '10': trampoline22,
+      '11': trampoline23,
+      '12': trampoline24,
+      '13': trampoline25,
+      '14': trampoline26,
+      '15': trampoline27,
+      '16': trampoline28,
+      '17': trampoline29,
+      '18': trampoline30,
+      '19': trampoline31,
+      '2': trampoline14,
+      '20': exports2.fd_filestat_get,
+      '21': exports2.fd_read,
+      '22': exports2.fd_write,
+      '23': exports2.path_open,
+      '24': exports2.random_get,
+      '25': exports2.environ_get,
+      '26': exports2.environ_sizes_get,
+      '27': exports2.fd_close,
+      '28': exports2.fd_prestat_get,
+      '29': exports2.fd_prestat_dir_name,
+      '3': trampoline15,
+      '30': exports2.proc_exit,
+      '4': trampoline16,
+      '5': trampoline17,
+      '6': trampoline18,
+      '7': trampoline19,
+      '8': trampoline20,
+      '9': trampoline21,
     },
   }));
   realloc1 = exports1.cabi_realloc;