@bytecodealliance/jco 0.14.1 → 1.0.0

package/obj/wasm-tools.js

@@ -97,7 +97,7 @@ function utf8Encode(s, realloc, memory) {
 let exports0;
 let exports1;
 
-function trampoline8() {
+function trampoline7() {
   const ret = getStderr();
   if (!(ret instanceof OutputStream)) {
     throw new Error('Resource error: Not a valid "OutputStream" resource.');
@@ -107,7 +107,7 @@ function trampoline8() {
   return handle0;
 }
 
-function trampoline9(arg0) {
+function trampoline8(arg0) {
   let variant0;
   switch (arg0) {
     case 0: {
@@ -131,7 +131,7 @@ function trampoline9(arg0) {
   exit(variant0);
 }
 
-function trampoline10() {
+function trampoline9() {
   const ret = getStdin();
   if (!(ret instanceof InputStream)) {
     throw new Error('Resource error: Not a valid "InputStream" resource.');
@@ -141,7 +141,7 @@ function trampoline10() {
   return handle0;
 }
 
-function trampoline11() {
+function trampoline10() {
   const ret = getStdout();
   if (!(ret instanceof OutputStream)) {
     throw new Error('Resource error: Not a valid "OutputStream" resource.');
@@ -152,7 +152,7 @@ function trampoline11() {
 }
 let exports2;
 
-function trampoline12(arg0) {
+function trampoline11(arg0) {
   const ret = getDirectories();
   var vec3 = ret;
   var len3 = vec3.length;
@@ -163,8 +163,8 @@ function trampoline12(arg0) {
     if (!(tuple0_0 instanceof Descriptor)) {
       throw new Error('Resource error: Not a valid "Descriptor" resource.');
     }
-    var handle1 = handleCnt3++;
-    handleTable3.set(handle1, { rep: tuple0_0, own: true });
+    var handle1 = handleCnt5++;
+    handleTable5.set(handle1, { rep: tuple0_0, own: true });
     dataView(memory0).setInt32(base + 0, handle1, true);
     var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
     var len2 = utf8EncodedLen;
@@ -177,9 +177,9 @@ function trampoline12(arg0) {
 let memory0;
 let realloc0;
 
-function trampoline13(arg0, arg1, arg2) {
+function trampoline12(arg0, arg1, arg2) {
   var handle1 = arg0;
-  var rsc0 = handleTable3.get(handle1).rep;
+  var rsc0 = handleTable5.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.readViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
@@ -370,9 +370,9 @@ function trampoline13(arg0, arg1, arg2) {
   }
 }
 
-function trampoline14(arg0, arg1, arg2) {
+function trampoline13(arg0, arg1, arg2) {
   var handle1 = arg0;
-  var rsc0 = handleTable3.get(handle1).rep;
+  var rsc0 = handleTable5.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.writeViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
@@ -563,9 +563,9 @@ function trampoline14(arg0, arg1, arg2) {
   }
 }
 
-function trampoline15(arg0, arg1) {
+function trampoline14(arg0, arg1) {
   var handle1 = arg0;
-  var rsc0 = handleTable3.get(handle1).rep;
+  var rsc0 = handleTable5.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.appendViaStream.call(rsc0) };
@@ -756,9 +756,9 @@ function trampoline15(arg0, arg1) {
   }
 }
 
-function trampoline16(arg0, arg1) {
+function trampoline15(arg0, arg1) {
   var handle1 = arg0;
-  var rsc0 = handleTable3.get(handle1).rep;
+  var rsc0 = handleTable5.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.getType.call(rsc0) };
@@ -987,9 +987,202 @@ function trampoline16(arg0, arg1) {
   }
 }
 
+function trampoline16(arg0, arg1) {
+  var handle1 = arg0;
+  var rsc0 = handleTable5.get(handle1).rep;
+  let ret;
+  try {
+    ret = { tag: 'ok', val: Descriptor.prototype.readDirectory.call(rsc0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  var variant4 = ret;
+  switch (variant4.tag) {
+    case 'ok': {
+      const e = variant4.val;
+      dataView(memory0).setInt8(arg1 + 0, 0, true);
+      if (!(e instanceof DirectoryEntryStream)) {
+        throw new Error('Resource error: Not a valid "DirectoryEntryStream" resource.');
+      }
+      var handle2 = handleCnt6++;
+      handleTable6.set(handle2, { rep: e, own: true });
+      dataView(memory0).setInt32(arg1 + 4, handle2, true);
+      break;
+    }
+    case 'err': {
+      const e = variant4.val;
+      dataView(memory0).setInt8(arg1 + 0, 1, true);
+      var val3 = e;
+      let enum3;
+      switch (val3) {
+        case 'access': {
+          enum3 = 0;
+          break;
+        }
+        case 'would-block': {
+          enum3 = 1;
+          break;
+        }
+        case 'already': {
+          enum3 = 2;
+          break;
+        }
+        case 'bad-descriptor': {
+          enum3 = 3;
+          break;
+        }
+        case 'busy': {
+          enum3 = 4;
+          break;
+        }
+        case 'deadlock': {
+          enum3 = 5;
+          break;
+        }
+        case 'quota': {
+          enum3 = 6;
+          break;
+        }
+        case 'exist': {
+          enum3 = 7;
+          break;
+        }
+        case 'file-too-large': {
+          enum3 = 8;
+          break;
+        }
+        case 'illegal-byte-sequence': {
+          enum3 = 9;
+          break;
+        }
+        case 'in-progress': {
+          enum3 = 10;
+          break;
+        }
+        case 'interrupted': {
+          enum3 = 11;
+          break;
+        }
+        case 'invalid': {
+          enum3 = 12;
+          break;
+        }
+        case 'io': {
+          enum3 = 13;
+          break;
+        }
+        case 'is-directory': {
+          enum3 = 14;
+          break;
+        }
+        case 'loop': {
+          enum3 = 15;
+          break;
+        }
+        case 'too-many-links': {
+          enum3 = 16;
+          break;
+        }
+        case 'message-size': {
+          enum3 = 17;
+          break;
+        }
+        case 'name-too-long': {
+          enum3 = 18;
+          break;
+        }
+        case 'no-device': {
+          enum3 = 19;
+          break;
+        }
+        case 'no-entry': {
+          enum3 = 20;
+          break;
+        }
+        case 'no-lock': {
+          enum3 = 21;
+          break;
+        }
+        case 'insufficient-memory': {
+          enum3 = 22;
+          break;
+        }
+        case 'insufficient-space': {
+          enum3 = 23;
+          break;
+        }
+        case 'not-directory': {
+          enum3 = 24;
+          break;
+        }
+        case 'not-empty': {
+          enum3 = 25;
+          break;
+        }
+        case 'not-recoverable': {
+          enum3 = 26;
+          break;
+        }
+        case 'unsupported': {
+          enum3 = 27;
+          break;
+        }
+        case 'no-tty': {
+          enum3 = 28;
+          break;
+        }
+        case 'no-such-device': {
+          enum3 = 29;
+          break;
+        }
+        case 'overflow': {
+          enum3 = 30;
+          break;
+        }
+        case 'not-permitted': {
+          enum3 = 31;
+          break;
+        }
+        case 'pipe': {
+          enum3 = 32;
+          break;
+        }
+        case 'read-only': {
+          enum3 = 33;
+          break;
+        }
+        case 'invalid-seek': {
+          enum3 = 34;
+          break;
+        }
+        case 'text-file-busy': {
+          enum3 = 35;
+          break;
+        }
+        case 'cross-device': {
+          enum3 = 36;
+          break;
+        }
+        default: {
+          if ((e) instanceof Error) {
+            console.error(e);
+          }
+          
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 4, enum3, true);
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
 function trampoline17(arg0, arg1) {
   var handle1 = arg0;
-  var rsc0 = handleTable3.get(handle1).rep;
+  var rsc0 = handleTable5.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.stat.call(rsc0) };
@@ -1087,151 +1280,836 @@ function trampoline17(arg0, arg1) {
       let enum10;
       switch (val10) {
         case 'access': {
-          enum10 = 0;
+          enum10 = 0;
+          break;
+        }
+        case 'would-block': {
+          enum10 = 1;
+          break;
+        }
+        case 'already': {
+          enum10 = 2;
+          break;
+        }
+        case 'bad-descriptor': {
+          enum10 = 3;
+          break;
+        }
+        case 'busy': {
+          enum10 = 4;
+          break;
+        }
+        case 'deadlock': {
+          enum10 = 5;
+          break;
+        }
+        case 'quota': {
+          enum10 = 6;
+          break;
+        }
+        case 'exist': {
+          enum10 = 7;
+          break;
+        }
+        case 'file-too-large': {
+          enum10 = 8;
+          break;
+        }
+        case 'illegal-byte-sequence': {
+          enum10 = 9;
+          break;
+        }
+        case 'in-progress': {
+          enum10 = 10;
+          break;
+        }
+        case 'interrupted': {
+          enum10 = 11;
+          break;
+        }
+        case 'invalid': {
+          enum10 = 12;
+          break;
+        }
+        case 'io': {
+          enum10 = 13;
+          break;
+        }
+        case 'is-directory': {
+          enum10 = 14;
+          break;
+        }
+        case 'loop': {
+          enum10 = 15;
+          break;
+        }
+        case 'too-many-links': {
+          enum10 = 16;
+          break;
+        }
+        case 'message-size': {
+          enum10 = 17;
+          break;
+        }
+        case 'name-too-long': {
+          enum10 = 18;
+          break;
+        }
+        case 'no-device': {
+          enum10 = 19;
+          break;
+        }
+        case 'no-entry': {
+          enum10 = 20;
+          break;
+        }
+        case 'no-lock': {
+          enum10 = 21;
+          break;
+        }
+        case 'insufficient-memory': {
+          enum10 = 22;
+          break;
+        }
+        case 'insufficient-space': {
+          enum10 = 23;
+          break;
+        }
+        case 'not-directory': {
+          enum10 = 24;
+          break;
+        }
+        case 'not-empty': {
+          enum10 = 25;
+          break;
+        }
+        case 'not-recoverable': {
+          enum10 = 26;
+          break;
+        }
+        case 'unsupported': {
+          enum10 = 27;
+          break;
+        }
+        case 'no-tty': {
+          enum10 = 28;
+          break;
+        }
+        case 'no-such-device': {
+          enum10 = 29;
+          break;
+        }
+        case 'overflow': {
+          enum10 = 30;
+          break;
+        }
+        case 'not-permitted': {
+          enum10 = 31;
+          break;
+        }
+        case 'pipe': {
+          enum10 = 32;
+          break;
+        }
+        case 'read-only': {
+          enum10 = 33;
+          break;
+        }
+        case 'invalid-seek': {
+          enum10 = 34;
+          break;
+        }
+        case 'text-file-busy': {
+          enum10 = 35;
+          break;
+        }
+        case 'cross-device': {
+          enum10 = 36;
+          break;
+        }
+        default: {
+          if ((e) instanceof Error) {
+            console.error(e);
+          }
+          
+          throw new TypeError(`"${val10}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 8, enum10, true);
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function trampoline18(arg0, arg1, arg2, arg3, arg4) {
+  var handle1 = arg0;
+  var rsc0 = handleTable5.get(handle1).rep;
+  if ((arg1 & 4294967294) !== 0) {
+    throw new TypeError('flags have extraneous bits set');
+  }
+  var flags2 = {
+    symlinkFollow: Boolean(arg1 & 1),
+  };
+  var ptr3 = arg2;
+  var len3 = arg3;
+  var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+  let ret;
+  try {
+    ret = { tag: 'ok', val: Descriptor.prototype.statAt.call(rsc0, flags2, result3) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  var variant13 = ret;
+  switch (variant13.tag) {
+    case 'ok': {
+      const e = variant13.val;
+      dataView(memory0).setInt8(arg4 + 0, 0, true);
+      var {type: v4_0, linkCount: v4_1, size: v4_2, dataAccessTimestamp: v4_3, dataModificationTimestamp: v4_4, statusChangeTimestamp: v4_5 } = e;
+      var val5 = v4_0;
+      let enum5;
+      switch (val5) {
+        case 'unknown': {
+          enum5 = 0;
+          break;
+        }
+        case 'block-device': {
+          enum5 = 1;
+          break;
+        }
+        case 'character-device': {
+          enum5 = 2;
+          break;
+        }
+        case 'directory': {
+          enum5 = 3;
+          break;
+        }
+        case 'fifo': {
+          enum5 = 4;
+          break;
+        }
+        case 'symbolic-link': {
+          enum5 = 5;
+          break;
+        }
+        case 'regular-file': {
+          enum5 = 6;
+          break;
+        }
+        case 'socket': {
+          enum5 = 7;
+          break;
+        }
+        default: {
+          if ((v4_0) instanceof Error) {
+            console.error(v4_0);
+          }
+          
+          throw new TypeError(`"${val5}" is not one of the cases of descriptor-type`);
+        }
+      }
+      dataView(memory0).setInt8(arg4 + 8, enum5, true);
+      dataView(memory0).setBigInt64(arg4 + 16, toUint64(v4_1), true);
+      dataView(memory0).setBigInt64(arg4 + 24, toUint64(v4_2), true);
+      var variant7 = v4_3;
+      if (variant7 === null || variant7=== undefined) {
+        dataView(memory0).setInt8(arg4 + 32, 0, true);
+      } else {
+        const e = variant7;
+        dataView(memory0).setInt8(arg4 + 32, 1, true);
+        var {seconds: v6_0, nanoseconds: v6_1 } = e;
+        dataView(memory0).setBigInt64(arg4 + 40, toUint64(v6_0), true);
+        dataView(memory0).setInt32(arg4 + 48, toUint32(v6_1), true);
+      }
+      var variant9 = v4_4;
+      if (variant9 === null || variant9=== undefined) {
+        dataView(memory0).setInt8(arg4 + 56, 0, true);
+      } else {
+        const e = variant9;
+        dataView(memory0).setInt8(arg4 + 56, 1, true);
+        var {seconds: v8_0, nanoseconds: v8_1 } = e;
+        dataView(memory0).setBigInt64(arg4 + 64, toUint64(v8_0), true);
+        dataView(memory0).setInt32(arg4 + 72, toUint32(v8_1), true);
+      }
+      var variant11 = v4_5;
+      if (variant11 === null || variant11=== undefined) {
+        dataView(memory0).setInt8(arg4 + 80, 0, true);
+      } else {
+        const e = variant11;
+        dataView(memory0).setInt8(arg4 + 80, 1, true);
+        var {seconds: v10_0, nanoseconds: v10_1 } = e;
+        dataView(memory0).setBigInt64(arg4 + 88, toUint64(v10_0), true);
+        dataView(memory0).setInt32(arg4 + 96, toUint32(v10_1), true);
+      }
+      break;
+    }
+    case 'err': {
+      const e = variant13.val;
+      dataView(memory0).setInt8(arg4 + 0, 1, true);
+      var val12 = e;
+      let enum12;
+      switch (val12) {
+        case 'access': {
+          enum12 = 0;
+          break;
+        }
+        case 'would-block': {
+          enum12 = 1;
+          break;
+        }
+        case 'already': {
+          enum12 = 2;
+          break;
+        }
+        case 'bad-descriptor': {
+          enum12 = 3;
+          break;
+        }
+        case 'busy': {
+          enum12 = 4;
+          break;
+        }
+        case 'deadlock': {
+          enum12 = 5;
+          break;
+        }
+        case 'quota': {
+          enum12 = 6;
+          break;
+        }
+        case 'exist': {
+          enum12 = 7;
+          break;
+        }
+        case 'file-too-large': {
+          enum12 = 8;
+          break;
+        }
+        case 'illegal-byte-sequence': {
+          enum12 = 9;
+          break;
+        }
+        case 'in-progress': {
+          enum12 = 10;
+          break;
+        }
+        case 'interrupted': {
+          enum12 = 11;
+          break;
+        }
+        case 'invalid': {
+          enum12 = 12;
+          break;
+        }
+        case 'io': {
+          enum12 = 13;
+          break;
+        }
+        case 'is-directory': {
+          enum12 = 14;
+          break;
+        }
+        case 'loop': {
+          enum12 = 15;
+          break;
+        }
+        case 'too-many-links': {
+          enum12 = 16;
+          break;
+        }
+        case 'message-size': {
+          enum12 = 17;
+          break;
+        }
+        case 'name-too-long': {
+          enum12 = 18;
+          break;
+        }
+        case 'no-device': {
+          enum12 = 19;
+          break;
+        }
+        case 'no-entry': {
+          enum12 = 20;
+          break;
+        }
+        case 'no-lock': {
+          enum12 = 21;
+          break;
+        }
+        case 'insufficient-memory': {
+          enum12 = 22;
+          break;
+        }
+        case 'insufficient-space': {
+          enum12 = 23;
+          break;
+        }
+        case 'not-directory': {
+          enum12 = 24;
+          break;
+        }
+        case 'not-empty': {
+          enum12 = 25;
+          break;
+        }
+        case 'not-recoverable': {
+          enum12 = 26;
+          break;
+        }
+        case 'unsupported': {
+          enum12 = 27;
+          break;
+        }
+        case 'no-tty': {
+          enum12 = 28;
+          break;
+        }
+        case 'no-such-device': {
+          enum12 = 29;
+          break;
+        }
+        case 'overflow': {
+          enum12 = 30;
+          break;
+        }
+        case 'not-permitted': {
+          enum12 = 31;
+          break;
+        }
+        case 'pipe': {
+          enum12 = 32;
+          break;
+        }
+        case 'read-only': {
+          enum12 = 33;
+          break;
+        }
+        case 'invalid-seek': {
+          enum12 = 34;
+          break;
+        }
+        case 'text-file-busy': {
+          enum12 = 35;
+          break;
+        }
+        case 'cross-device': {
+          enum12 = 36;
+          break;
+        }
+        default: {
+          if ((e) instanceof Error) {
+            console.error(e);
+          }
+          
+          throw new TypeError(`"${val12}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg4 + 8, enum12, true);
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function trampoline19(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+  var handle1 = arg0;
+  var rsc0 = handleTable5.get(handle1).rep;
+  if ((arg1 & 4294967294) !== 0) {
+    throw new TypeError('flags have extraneous bits set');
+  }
+  var flags2 = {
+    symlinkFollow: Boolean(arg1 & 1),
+  };
+  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');
+  }
+  var flags4 = {
+    create: Boolean(arg4 & 1),
+    directory: Boolean(arg4 & 2),
+    exclusive: Boolean(arg4 & 4),
+    truncate: Boolean(arg4 & 8),
+  };
+  if ((arg5 & 4294967232) !== 0) {
+    throw new TypeError('flags have extraneous bits set');
+  }
+  var flags5 = {
+    read: Boolean(arg5 & 1),
+    write: Boolean(arg5 & 2),
+    fileIntegritySync: Boolean(arg5 & 4),
+    dataIntegritySync: Boolean(arg5 & 8),
+    requestedWriteSync: Boolean(arg5 & 16),
+    mutateDirectory: Boolean(arg5 & 32),
+  };
+  let ret;
+  try {
+    ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags2, result3, flags4, flags5) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  var variant8 = ret;
+  switch (variant8.tag) {
+    case 'ok': {
+      const e = variant8.val;
+      dataView(memory0).setInt8(arg6 + 0, 0, true);
+      if (!(e instanceof Descriptor)) {
+        throw new Error('Resource error: Not a valid "Descriptor" resource.');
+      }
+      var handle6 = handleCnt5++;
+      handleTable5.set(handle6, { rep: e, own: true });
+      dataView(memory0).setInt32(arg6 + 4, handle6, true);
+      break;
+    }
+    case 'err': {
+      const e = variant8.val;
+      dataView(memory0).setInt8(arg6 + 0, 1, true);
+      var val7 = e;
+      let enum7;
+      switch (val7) {
+        case 'access': {
+          enum7 = 0;
+          break;
+        }
+        case 'would-block': {
+          enum7 = 1;
+          break;
+        }
+        case 'already': {
+          enum7 = 2;
+          break;
+        }
+        case 'bad-descriptor': {
+          enum7 = 3;
+          break;
+        }
+        case 'busy': {
+          enum7 = 4;
+          break;
+        }
+        case 'deadlock': {
+          enum7 = 5;
+          break;
+        }
+        case 'quota': {
+          enum7 = 6;
+          break;
+        }
+        case 'exist': {
+          enum7 = 7;
+          break;
+        }
+        case 'file-too-large': {
+          enum7 = 8;
+          break;
+        }
+        case 'illegal-byte-sequence': {
+          enum7 = 9;
+          break;
+        }
+        case 'in-progress': {
+          enum7 = 10;
+          break;
+        }
+        case 'interrupted': {
+          enum7 = 11;
+          break;
+        }
+        case 'invalid': {
+          enum7 = 12;
+          break;
+        }
+        case 'io': {
+          enum7 = 13;
+          break;
+        }
+        case 'is-directory': {
+          enum7 = 14;
+          break;
+        }
+        case 'loop': {
+          enum7 = 15;
+          break;
+        }
+        case 'too-many-links': {
+          enum7 = 16;
+          break;
+        }
+        case 'message-size': {
+          enum7 = 17;
+          break;
+        }
+        case 'name-too-long': {
+          enum7 = 18;
+          break;
+        }
+        case 'no-device': {
+          enum7 = 19;
+          break;
+        }
+        case 'no-entry': {
+          enum7 = 20;
+          break;
+        }
+        case 'no-lock': {
+          enum7 = 21;
+          break;
+        }
+        case 'insufficient-memory': {
+          enum7 = 22;
+          break;
+        }
+        case 'insufficient-space': {
+          enum7 = 23;
+          break;
+        }
+        case 'not-directory': {
+          enum7 = 24;
+          break;
+        }
+        case 'not-empty': {
+          enum7 = 25;
+          break;
+        }
+        case 'not-recoverable': {
+          enum7 = 26;
+          break;
+        }
+        case 'unsupported': {
+          enum7 = 27;
+          break;
+        }
+        case 'no-tty': {
+          enum7 = 28;
+          break;
+        }
+        case 'no-such-device': {
+          enum7 = 29;
+          break;
+        }
+        case 'overflow': {
+          enum7 = 30;
+          break;
+        }
+        case 'not-permitted': {
+          enum7 = 31;
+          break;
+        }
+        case 'pipe': {
+          enum7 = 32;
+          break;
+        }
+        case 'read-only': {
+          enum7 = 33;
+          break;
+        }
+        case 'invalid-seek': {
+          enum7 = 34;
+          break;
+        }
+        case 'text-file-busy': {
+          enum7 = 35;
+          break;
+        }
+        case 'cross-device': {
+          enum7 = 36;
+          break;
+        }
+        default: {
+          if ((e) instanceof Error) {
+            console.error(e);
+          }
+          
+          throw new TypeError(`"${val7}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg6 + 4, enum7, true);
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function trampoline20(arg0, arg1) {
+  var handle1 = arg0;
+  var rsc0 = handleTable5.get(handle1).rep;
+  let ret;
+  try {
+    ret = { tag: 'ok', val: Descriptor.prototype.metadataHash.call(rsc0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  var variant4 = ret;
+  switch (variant4.tag) {
+    case 'ok': {
+      const e = variant4.val;
+      dataView(memory0).setInt8(arg1 + 0, 0, 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 = variant4.val;
+      dataView(memory0).setInt8(arg1 + 0, 1, true);
+      var val3 = e;
+      let enum3;
+      switch (val3) {
+        case 'access': {
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum10 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum10 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum10 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum10 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum10 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum10 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum10 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum10 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum10 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum10 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum10 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum10 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum10 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum10 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum10 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum10 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum10 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum10 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum10 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum10 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum10 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum10 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum10 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum10 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum10 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum10 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum10 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum10 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum10 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum10 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum10 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum10 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum10 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum10 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum10 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum10 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -1239,10 +2117,10 @@ function trampoline17(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val10}" 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, enum10, true);
+      dataView(memory0).setInt8(arg1 + 8, enum3, true);
       break;
     }
     default: {
@@ -1251,9 +2129,9 @@ function trampoline17(arg0, arg1) {
   }
 }
 
-function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+function trampoline21(arg0, arg1, arg2, arg3, arg4) {
   var handle1 = arg0;
-  var rsc0 = handleTable3.get(handle1).rep;
+  var rsc0 = handleTable5.get(handle1).rep;
   if ((arg1 & 4294967294) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
@@ -1263,197 +2141,174 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
   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');
-  }
-  var flags4 = {
-    create: Boolean(arg4 & 1),
-    directory: Boolean(arg4 & 2),
-    exclusive: Boolean(arg4 & 4),
-    truncate: Boolean(arg4 & 8),
-  };
-  if ((arg5 & 4294967232) !== 0) {
-    throw new TypeError('flags have extraneous bits set');
-  }
-  var flags5 = {
-    read: Boolean(arg5 & 1),
-    write: Boolean(arg5 & 2),
-    fileIntegritySync: Boolean(arg5 & 4),
-    dataIntegritySync: Boolean(arg5 & 8),
-    requestedWriteSync: Boolean(arg5 & 16),
-    mutateDirectory: Boolean(arg5 & 32),
-  };
   let ret;
   try {
-    ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags2, result3, flags4, flags5) };
+    ret = { tag: 'ok', val: Descriptor.prototype.metadataHashAt.call(rsc0, flags2, result3) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  var variant8 = ret;
-  switch (variant8.tag) {
+  var variant6 = ret;
+  switch (variant6.tag) {
     case 'ok': {
-      const e = variant8.val;
-      dataView(memory0).setInt8(arg6 + 0, 0, true);
-      if (!(e instanceof Descriptor)) {
-        throw new Error('Resource error: Not a valid "Descriptor" resource.');
-      }
-      var handle6 = handleCnt3++;
-      handleTable3.set(handle6, { rep: e, own: true });
-      dataView(memory0).setInt32(arg6 + 4, handle6, true);
+      const e = variant6.val;
+      dataView(memory0).setInt8(arg4 + 0, 0, true);
+      var {lower: v4_0, upper: v4_1 } = e;
+      dataView(memory0).setBigInt64(arg4 + 8, toUint64(v4_0), true);
+      dataView(memory0).setBigInt64(arg4 + 16, toUint64(v4_1), true);
       break;
     }
     case 'err': {
-      const e = variant8.val;
-      dataView(memory0).setInt8(arg6 + 0, 1, true);
-      var val7 = e;
-      let enum7;
-      switch (val7) {
+      const e = variant6.val;
+      dataView(memory0).setInt8(arg4 + 0, 1, true);
+      var val5 = e;
+      let enum5;
+      switch (val5) {
         case 'access': {
-          enum7 = 0;
+          enum5 = 0;
           break;
         }
         case 'would-block': {
-          enum7 = 1;
+          enum5 = 1;
           break;
         }
         case 'already': {
-          enum7 = 2;
+          enum5 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum7 = 3;
+          enum5 = 3;
           break;
         }
         case 'busy': {
-          enum7 = 4;
+          enum5 = 4;
           break;
         }
         case 'deadlock': {
-          enum7 = 5;
+          enum5 = 5;
           break;
         }
         case 'quota': {
-          enum7 = 6;
+          enum5 = 6;
           break;
         }
         case 'exist': {
-          enum7 = 7;
+          enum5 = 7;
           break;
         }
         case 'file-too-large': {
-          enum7 = 8;
+          enum5 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum7 = 9;
+          enum5 = 9;
           break;
         }
         case 'in-progress': {
-          enum7 = 10;
+          enum5 = 10;
           break;
         }
         case 'interrupted': {
-          enum7 = 11;
+          enum5 = 11;
           break;
         }
         case 'invalid': {
-          enum7 = 12;
+          enum5 = 12;
           break;
         }
         case 'io': {
-          enum7 = 13;
+          enum5 = 13;
           break;
         }
         case 'is-directory': {
-          enum7 = 14;
+          enum5 = 14;
           break;
         }
         case 'loop': {
-          enum7 = 15;
+          enum5 = 15;
           break;
         }
         case 'too-many-links': {
-          enum7 = 16;
+          enum5 = 16;
           break;
         }
         case 'message-size': {
-          enum7 = 17;
+          enum5 = 17;
           break;
         }
         case 'name-too-long': {
-          enum7 = 18;
+          enum5 = 18;
           break;
         }
         case 'no-device': {
-          enum7 = 19;
+          enum5 = 19;
           break;
         }
         case 'no-entry': {
-          enum7 = 20;
+          enum5 = 20;
           break;
         }
         case 'no-lock': {
-          enum7 = 21;
+          enum5 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum7 = 22;
+          enum5 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum7 = 23;
+          enum5 = 23;
           break;
         }
         case 'not-directory': {
-          enum7 = 24;
+          enum5 = 24;
           break;
         }
         case 'not-empty': {
-          enum7 = 25;
+          enum5 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum7 = 26;
+          enum5 = 26;
           break;
         }
         case 'unsupported': {
-          enum7 = 27;
+          enum5 = 27;
           break;
         }
         case 'no-tty': {
-          enum7 = 28;
+          enum5 = 28;
           break;
         }
         case 'no-such-device': {
-          enum7 = 29;
+          enum5 = 29;
           break;
         }
         case 'overflow': {
-          enum7 = 30;
+          enum5 = 30;
           break;
         }
         case 'not-permitted': {
-          enum7 = 31;
+          enum5 = 31;
           break;
         }
         case 'pipe': {
-          enum7 = 32;
+          enum5 = 32;
           break;
         }
         case 'read-only': {
-          enum7 = 33;
+          enum5 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum7 = 34;
+          enum5 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum7 = 35;
+          enum5 = 35;
           break;
         }
         case 'cross-device': {
-          enum7 = 36;
+          enum5 = 36;
           break;
         }
         default: {
@@ -1461,10 +2316,10 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val7}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val5}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg6 + 4, enum7, true);
+      dataView(memory0).setInt8(arg4 + 8, enum5, true);
       break;
     }
     default: {
@@ -1473,177 +2328,230 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
   }
 }
 
-function trampoline19(arg0, arg1) {
+function trampoline22(arg0, arg1) {
   var handle1 = arg0;
-  var rsc0 = handleTable3.get(handle1).rep;
+  var rsc0 = handleTable6.get(handle1).rep;
   let ret;
   try {
-    ret = { tag: 'ok', val: Descriptor.prototype.metadataHash.call(rsc0) };
+    ret = { tag: 'ok', val: DirectoryEntryStream.prototype.readDirectoryEntry.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  var variant4 = ret;
-  switch (variant4.tag) {
+  var variant7 = ret;
+  switch (variant7.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant7.val;
       dataView(memory0).setInt8(arg1 + 0, 0, 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);
+      var variant5 = e;
+      if (variant5 === null || variant5=== undefined) {
+        dataView(memory0).setInt8(arg1 + 4, 0, true);
+      } else {
+        const e = variant5;
+        dataView(memory0).setInt8(arg1 + 4, 1, true);
+        var {type: v2_0, name: v2_1 } = e;
+        var val3 = v2_0;
+        let enum3;
+        switch (val3) {
+          case 'unknown': {
+            enum3 = 0;
+            break;
+          }
+          case 'block-device': {
+            enum3 = 1;
+            break;
+          }
+          case 'character-device': {
+            enum3 = 2;
+            break;
+          }
+          case 'directory': {
+            enum3 = 3;
+            break;
+          }
+          case 'fifo': {
+            enum3 = 4;
+            break;
+          }
+          case 'symbolic-link': {
+            enum3 = 5;
+            break;
+          }
+          case 'regular-file': {
+            enum3 = 6;
+            break;
+          }
+          case 'socket': {
+            enum3 = 7;
+            break;
+          }
+          default: {
+            if ((v2_0) instanceof Error) {
+              console.error(v2_0);
+            }
+            
+            throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum3, true);
+        var ptr4 = utf8Encode(v2_1, realloc0, memory0);
+        var len4 = utf8EncodedLen;
+        dataView(memory0).setInt32(arg1 + 16, len4, true);
+        dataView(memory0).setInt32(arg1 + 12, ptr4, true);
+      }
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant7.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      var val3 = e;
-      let enum3;
-      switch (val3) {
+      var val6 = e;
+      let enum6;
+      switch (val6) {
         case 'access': {
-          enum3 = 0;
+          enum6 = 0;
           break;
         }
         case 'would-block': {
-          enum3 = 1;
+          enum6 = 1;
           break;
         }
         case 'already': {
-          enum3 = 2;
+          enum6 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum3 = 3;
+          enum6 = 3;
           break;
         }
         case 'busy': {
-          enum3 = 4;
+          enum6 = 4;
           break;
         }
         case 'deadlock': {
-          enum3 = 5;
+          enum6 = 5;
           break;
         }
         case 'quota': {
-          enum3 = 6;
+          enum6 = 6;
           break;
         }
         case 'exist': {
-          enum3 = 7;
+          enum6 = 7;
           break;
         }
         case 'file-too-large': {
-          enum3 = 8;
+          enum6 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum3 = 9;
+          enum6 = 9;
           break;
         }
         case 'in-progress': {
-          enum3 = 10;
+          enum6 = 10;
           break;
         }
         case 'interrupted': {
-          enum3 = 11;
+          enum6 = 11;
           break;
         }
         case 'invalid': {
-          enum3 = 12;
+          enum6 = 12;
           break;
         }
         case 'io': {
-          enum3 = 13;
+          enum6 = 13;
           break;
         }
         case 'is-directory': {
-          enum3 = 14;
+          enum6 = 14;
           break;
         }
         case 'loop': {
-          enum3 = 15;
+          enum6 = 15;
           break;
         }
         case 'too-many-links': {
-          enum3 = 16;
+          enum6 = 16;
           break;
         }
         case 'message-size': {
-          enum3 = 17;
+          enum6 = 17;
           break;
         }
         case 'name-too-long': {
-          enum3 = 18;
+          enum6 = 18;
           break;
         }
         case 'no-device': {
-          enum3 = 19;
+          enum6 = 19;
           break;
         }
         case 'no-entry': {
-          enum3 = 20;
+          enum6 = 20;
           break;
         }
         case 'no-lock': {
-          enum3 = 21;
+          enum6 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum3 = 22;
+          enum6 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum3 = 23;
+          enum6 = 23;
           break;
         }
         case 'not-directory': {
-          enum3 = 24;
+          enum6 = 24;
           break;
         }
         case 'not-empty': {
-          enum3 = 25;
+          enum6 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum3 = 26;
+          enum6 = 26;
           break;
         }
         case 'unsupported': {
-          enum3 = 27;
+          enum6 = 27;
           break;
         }
         case 'no-tty': {
-          enum3 = 28;
+          enum6 = 28;
           break;
         }
         case 'no-such-device': {
-          enum3 = 29;
+          enum6 = 29;
           break;
         }
         case 'overflow': {
-          enum3 = 30;
+          enum6 = 30;
           break;
         }
         case 'not-permitted': {
-          enum3 = 31;
+          enum6 = 31;
           break;
         }
         case 'pipe': {
-          enum3 = 32;
+          enum6 = 32;
           break;
         }
         case 'read-only': {
-          enum3 = 33;
+          enum6 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum3 = 34;
+          enum6 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum3 = 35;
+          enum6 = 35;
           break;
         }
         case 'cross-device': {
-          enum3 = 36;
+          enum6 = 36;
           break;
         }
         default: {
@@ -1651,10 +2559,10 @@ function trampoline19(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val6}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum3, true);
+      dataView(memory0).setInt8(arg1 + 4, enum6, true);
       break;
     }
     default: {
@@ -1663,7 +2571,7 @@ function trampoline19(arg0, arg1) {
   }
 }
 
-function trampoline20(arg0, arg1) {
+function trampoline23(arg0, arg1) {
   var handle1 = arg0;
   var rsc0 = handleTable0.get(handle1).rep;
   const ret = filesystemErrorCode(rsc0);
@@ -1836,7 +2744,7 @@ function trampoline20(arg0, arg1) {
   }
 }
 
-function trampoline21(arg0, arg1, arg2) {
+function trampoline24(arg0, arg1, arg2) {
   var handle1 = arg0;
   var rsc0 = handleTable1.get(handle1).rep;
   let ret;
@@ -1891,7 +2799,7 @@ function trampoline21(arg0, arg1, arg2) {
   }
 }
 
-function trampoline22(arg0, arg1, arg2) {
+function trampoline25(arg0, arg1, arg2) {
   var handle1 = arg0;
   var rsc0 = handleTable1.get(handle1).rep;
   let ret;
@@ -1946,7 +2854,7 @@ function trampoline22(arg0, arg1, arg2) {
   }
 }
 
-function trampoline23(arg0, arg1) {
+function trampoline26(arg0, arg1) {
   var handle1 = arg0;
   var rsc0 = handleTable2.get(handle1).rep;
   let ret;
@@ -1995,7 +2903,7 @@ function trampoline23(arg0, arg1) {
   }
 }
 
-function trampoline24(arg0, arg1, arg2, arg3) {
+function trampoline27(arg0, arg1, arg2, arg3) {
   var handle1 = arg0;
   var rsc0 = handleTable2.get(handle1).rep;
   var ptr2 = arg1;
@@ -2046,7 +2954,7 @@ function trampoline24(arg0, arg1, arg2, arg3) {
   }
 }
 
-function trampoline25(arg0, arg1, arg2, arg3) {
+function trampoline28(arg0, arg1, arg2, arg3) {
   var handle1 = arg0;
   var rsc0 = handleTable2.get(handle1).rep;
   var ptr2 = arg1;
@@ -2097,7 +3005,7 @@ function trampoline25(arg0, arg1, arg2, arg3) {
   }
 }
 
-function trampoline26(arg0, arg1) {
+function trampoline29(arg0, arg1) {
   var handle1 = arg0;
   var rsc0 = handleTable2.get(handle1).rep;
   let ret;
@@ -2145,7 +3053,7 @@ function trampoline26(arg0, arg1) {
   }
 }
 
-function trampoline27(arg0, arg1) {
+function trampoline30(arg0, arg1) {
   const ret = getRandomBytes(BigInt.asUintN(64, arg0));
   var val0 = ret;
   var len0 = val0.byteLength;
@@ -2156,7 +3064,7 @@ function trampoline27(arg0, arg1) {
   dataView(memory0).setInt32(arg1 + 0, ptr0, true);
 }
 
-function trampoline28(arg0) {
+function trampoline31(arg0) {
   const ret = getEnvironment();
   var vec3 = ret;
   var len3 = vec3.length;
@@ -2177,7 +3085,7 @@ function trampoline28(arg0) {
   dataView(memory0).setInt32(arg0 + 0, result3, true);
 }
 
-function trampoline29(arg0) {
+function trampoline32(arg0) {
   const ret = getTerminalStdin();
   var variant1 = ret;
   if (variant1 === null || variant1=== undefined) {
@@ -2188,13 +3096,13 @@ function trampoline29(arg0) {
     if (!(e instanceof TerminalInput)) {
       throw new Error('Resource error: Not a valid "TerminalInput" resource.');
     }
-    var handle0 = handleCnt6++;
-    handleTable6.set(handle0, { rep: e, own: true });
+    var handle0 = handleCnt3++;
+    handleTable3.set(handle0, { rep: e, own: true });
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
 }
 
-function trampoline30(arg0) {
+function trampoline33(arg0) {
   const ret = getTerminalStdout();
   var variant1 = ret;
   if (variant1 === null || variant1=== undefined) {
@@ -2205,13 +3113,13 @@ function trampoline30(arg0) {
     if (!(e instanceof TerminalOutput)) {
       throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
     }
-    var handle0 = handleCnt7++;
-    handleTable7.set(handle0, { rep: e, own: true });
+    var handle0 = handleCnt4++;
+    handleTable4.set(handle0, { rep: e, own: true });
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
 }
 
-function trampoline31(arg0) {
+function trampoline34(arg0) {
   const ret = getTerminalStderr();
   var variant1 = ret;
   if (variant1 === null || variant1=== undefined) {
@@ -2222,8 +3130,8 @@ function trampoline31(arg0) {
     if (!(e instanceof TerminalOutput)) {
       throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
     }
-    var handle0 = handleCnt7++;
-    handleTable7.set(handle0, { rep: e, own: true });
+    var handle0 = handleCnt4++;
+    handleTable4.set(handle0, { rep: e, own: true });
     dataView(memory0).setInt32(arg0 + 4, handle0, true);
   }
 }
@@ -2232,11 +3140,11 @@ let realloc1;
 let postReturn0;
 let postReturn1;
 function trampoline0(handle) {
-  const handleEntry = handleTable4.get(handle);
+  const handleEntry = handleTable6.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
-  handleTable4.delete(handle);
+  handleTable6.delete(handle);
   if (handleEntry.own && handleEntry.rep[symbolDispose]) {
     handleEntry.rep[symbolDispose]();
   }
@@ -2272,16 +3180,6 @@ function trampoline3(handle) {
   }
 }
 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]();
-  }
-}
-function trampoline5(handle) {
   const handleEntry = handleTable5.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
@@ -2291,22 +3189,22 @@ function trampoline5(handle) {
     handleEntry.rep[symbolDispose]();
   }
 }
-function trampoline6(handle) {
-  const handleEntry = handleTable7.get(handle);
+function trampoline5(handle) {
+  const handleEntry = handleTable3.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
-  handleTable7.delete(handle);
+  handleTable3.delete(handle);
   if (handleEntry.own && handleEntry.rep[symbolDispose]) {
     handleEntry.rep[symbolDispose]();
   }
 }
-function trampoline7(handle) {
-  const handleEntry = handleTable6.get(handle);
+function trampoline6(handle) {
+  const handleEntry = handleTable4.get(handle);
   if (!handleEntry) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
-  handleTable6.delete(handle);
+  handleTable4.delete(handle);
   if (handleEntry.own && handleEntry.rep[symbolDispose]) {
     handleEntry.rep[symbolDispose]();
   }
@@ -2857,29 +3755,29 @@ 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('AGFzbQEAAAABUQxgAX8AYAN/fn8AYAJ/fwBgB39/f39/f38AYAR/f39/AGACfn8AYAl/f39/f35+f38Bf2ACf38Bf2AEf39/fwF/YAF/AX9gA39/fwF/YAF/AALAASAAATAAAAABMQABAAEyAAEAATMAAgABNAACAAE1AAIAATYAAwABNwACAAE4AAIAATkAAQACMTAAAQACMTEAAgACMTIABAACMTMABAACMTQAAgACMTUABQACMTYAAAACMTcAAAACMTgAAAACMTkAAAACMjAABgACMjEABwACMjIABwACMjMACAACMjQACAACMjUABwACMjYABwACMjcACQACMjgABwACMjkACgACMzAACwAIJGltcG9ydHMBcAEfHwklAQBBAAsfAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHgAuCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BjAuMTkuMAAcBG5hbWUAFRR3aXQtY29tcG9uZW50OmZpeHVwcw');
+  const module2 = base64Compile('AGFzbQEAAAABaw9gAX8AYAN/fn8AYAJ/fwBgBX9/f39/AGAHf39/f39/fwBgBH9/f38AYAJ+fwBgCX9/f39/fn5/fwF/YAJ/fwF/YAV/f39+fwF/YAV/f39/fwF/YAR/f39/AX9gAX8Bf2ADf39/AX9gAX8AAyYlAAEBAgICAgMEAgMCAgEBAgUFAgYAAAAABwgJCggLCwgIDAgNDgQFAXABJSUHuwEmATAAAAExAAEBMgACATMAAwE0AAQBNQAFATYABgE3AAcBOAAIATkACQIxMAAKAjExAAsCMTIADAIxMwANAjE0AA4CMTUADwIxNgAQAjE3ABECMTgAEgIxOQATAjIwABQCMjEAFQIyMgAWAjIzABcCMjQAGAIyNQAZAjI2ABoCMjcAGwIyOAAcAjI5AB0CMzAAHgIzMQAfAjMyACACMzMAIQIzNAAiAjM1ACMCMzYAJAgkaW1wb3J0cwEACvkDJQkAIABBABEAAAsNACAAIAEgAkEBEQEACw0AIAAgASACQQIRAQALCwAgACABQQMRAgALCwAgACABQQQRAgALCwAgACABQQURAgALCwAgACABQQYRAgALEQAgACABIAIgAyAEQQcRAwALFQAgACABIAIgAyAEIAUgBkEIEQQACwsAIAAgAUEJEQIACxEAIAAgASACIAMgBEEKEQMACwsAIAAgAUELEQIACwsAIAAgAUEMEQIACw0AIAAgASACQQ0RAQALDQAgACABIAJBDhEBAAsLACAAIAFBDxECAAsPACAAIAEgAiADQRARBQALDwAgACABIAIgA0EREQUACwsAIAAgAUESEQIACwsAIAAgAUETEQYACwkAIABBFBEAAAsJACAAQRURAAALCQAgAEEWEQAACwkAIABBFxEAAAsZACAAIAEgAiADIAQgBSAGIAcgCEEYEQcACwsAIAAgAUEZEQgACxEAIAAgASACIAMgBEEaEQkACxEAIAAgASACIAMgBEEbEQoACwsAIAAgAUEcEQgACw8AIAAgASACIANBHRELAAsPACAAIAEgAiADQR4RCwALCwAgACABQR8RCAALCwAgACABQSARCAALCQAgAEEhEQwACwsAIAAgAUEiEQgACw0AIAAgASACQSMRDQALCQAgAEEkEQ4ACwAuCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BjAuMjAuMACAEQRuYW1lABMSd2l0LWNvbXBvbmVudDpzaGltAeMQJQA3aW5kaXJlY3Qtd2FzaTpmaWxlc3lzdGVtL3ByZW9wZW5zQDAuMi4wLWdldC1kaXJlY3RvcmllcwFHaW5kaXJlY3Qtd2FzaTpmaWxlc3lzdGVtL3R5cGVzQDAuMi4wLVttZXRob2RdZGVzY3JpcHRvci5yZWFkLXZpYS1zdHJlYW0CSGluZGlyZWN0LXdhc2k6ZmlsZXN5c3RlbS90eXBlc0AwLjIuMC1bbWV0aG9kXWRlc2NyaXB0b3Iud3JpdGUtdmlhLXN0cmVhbQNJaW5kaXJlY3Qtd2FzaTpmaWxlc3lzdGVtL3R5cGVzQDAuMi4wLVttZXRob2RdZGVzY3JpcHRvci5hcHBlbmQtdmlhLXN0cmVhbQRAaW5kaXJlY3Qtd2FzaTpmaWxlc3lzdGVtL3R5cGVzQDAuMi4wLVttZXRob2RdZGVzY3JpcHRvci5nZXQtdHlwZQVGaW5kaXJlY3Qtd2FzaTpmaWxlc3lzdGVtL3R5cGVzQDAuMi4wLVttZXRob2RdZGVzY3JpcHRvci5yZWFkLWRpcmVjdG9yeQY8aW5kaXJlY3Qtd2FzaTpmaWxlc3lzdGVtL3R5cGVzQDAuMi4wLVttZXRob2RdZGVzY3JpcHRvci5zdGF0Bz9pbmRpcmVjdC13YXNpOmZpbGVzeXN0ZW0vdHlwZXNAMC4yLjAtW21ldGhvZF1kZXNjcmlwdG9yLnN0YXQtYXQIP2luZGlyZWN0LXdhc2k6ZmlsZXN5c3RlbS90eXBlc0AwLjIuMC1bbWV0aG9kXWRlc2NyaXB0b3Iub3Blbi1hdAlFaW5kaXJlY3Qtd2FzaTpmaWxlc3lzdGVtL3R5cGVzQDAuMi4wLVttZXRob2RdZGVzY3JpcHRvci5tZXRhZGF0YS1oYXNoCkhpbmRpcmVjdC13YXNpOmZpbGVzeXN0ZW0vdHlwZXNAMC4yLjAtW21ldGhvZF1kZXNjcmlwdG9yLm1ldGFkYXRhLWhhc2gtYXQLWGluZGlyZWN0LXdhc2k6ZmlsZXN5c3RlbS90eXBlc0AwLjIuMC1bbWV0aG9kXWRpcmVjdG9yeS1lbnRyeS1zdHJlYW0ucmVhZC1kaXJlY3RvcnktZW50cnkMOmluZGlyZWN0LXdhc2k6ZmlsZXN5c3RlbS90eXBlc0AwLjIuMC1maWxlc3lzdGVtLWVycm9yLWNvZGUNOGluZGlyZWN0LXdhc2k6aW8vc3RyZWFtc0AwLjIuMC1bbWV0aG9kXWlucHV0LXN0cmVhbS5yZWFkDkFpbmRpcmVjdC13YXNpOmlvL3N0cmVhbXNAMC4yLjAtW21ldGhvZF1pbnB1dC1zdHJlYW0uYmxvY2tpbmctcmVhZA9AaW5kaXJlY3Qtd2FzaTppby9zdHJlYW1zQDAuMi4wLVttZXRob2Rdb3V0cHV0LXN0cmVhbS5jaGVjay13cml0ZRA6aW5kaXJlY3Qtd2FzaTppby9zdHJlYW1zQDAuMi4wLVttZXRob2Rdb3V0cHV0LXN0cmVhbS53cml0ZRFNaW5kaXJlY3Qtd2FzaTppby9zdHJlYW1zQDAuMi4wLVttZXRob2Rdb3V0cHV0LXN0cmVhbS5ibG9ja2luZy13cml0ZS1hbmQtZmx1c2gSQ2luZGlyZWN0LXdhc2k6aW8vc3RyZWFtc0AwLjIuMC1bbWV0aG9kXW91dHB1dC1zdHJlYW0uYmxvY2tpbmctZmx1c2gTMmluZGlyZWN0LXdhc2k6cmFuZG9tL3JhbmRvbUAwLjIuMC1nZXQtcmFuZG9tLWJ5dGVzFDNpbmRpcmVjdC13YXNpOmNsaS9lbnZpcm9ubWVudEAwLjIuMC1nZXQtZW52aXJvbm1lbnQVOWluZGlyZWN0LXdhc2k6Y2xpL3Rlcm1pbmFsLXN0ZGluQDAuMi4wLWdldC10ZXJtaW5hbC1zdGRpbhY7aW5kaXJlY3Qtd2FzaTpjbGkvdGVybWluYWwtc3Rkb3V0QDAuMi4wLWdldC10ZXJtaW5hbC1zdGRvdXQXO2luZGlyZWN0LXdhc2k6Y2xpL3Rlcm1pbmFsLXN0ZGVyckAwLjIuMC1nZXQtdGVybWluYWwtc3RkZXJyGCZhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLXBhdGhfb3BlbhksYWRhcHQtd2FzaV9zbmFwc2hvdF9wcmV2aWV3MS1mZF9maWxlc3RhdF9nZXQaJ2FkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZmRfcmVhZGRpchsuYWRhcHQtd2FzaV9zbmFwc2hvdF9wcmV2aWV3MS1wYXRoX2ZpbGVzdGF0X2dldBwnYWRhcHQtd2FzaV9zbmFwc2hvdF9wcmV2aWV3MS1yYW5kb21fZ2V0HSRhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWZkX3JlYWQeJWFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZmRfd3JpdGUfKGFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZW52aXJvbl9nZXQgLmFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZW52aXJvbl9zaXplc19nZXQhJWFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZmRfY2xvc2UiK2FkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZmRfcHJlc3RhdF9nZXQjMGFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZmRfcHJlc3RhdF9kaXJfbmFtZSQmYWRhcHQtd2FzaV9zbmFwc2hvdF9wcmV2aWV3MS1wcm9jX2V4aXQ');
+  const module3 = base64Compile('AGFzbQEAAAABaw9gAX8AYAN/fn8AYAJ/fwBgBX9/f39/AGAHf39/f39/fwBgBH9/f38AYAJ+fwBgCX9/f39/fn5/fwF/YAJ/fwF/YAV/f39+fwF/YAV/f39/fwF/YAR/f39/AX9gAX8Bf2ADf39/AX9gAX8AAuQBJgABMAAAAAExAAEAATIAAQABMwACAAE0AAIAATUAAgABNgACAAE3AAMAATgABAABOQACAAIxMAADAAIxMQACAAIxMgACAAIxMwABAAIxNAABAAIxNQACAAIxNgAFAAIxNwAFAAIxOAACAAIxOQAGAAIyMAAAAAIyMQAAAAIyMgAAAAIyMwAAAAIyNAAHAAIyNQAIAAIyNgAJAAIyNwAKAAIyOAAIAAIyOQALAAIzMAALAAIzMQAIAAIzMgAIAAIzMwAMAAIzNAAIAAIzNQANAAIzNgAOAAgkaW1wb3J0cwFwASUlCSsBAEEACyUAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkAC4JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQGMC4yMC4wABwEbmFtZQAVFHdpdC1jb21wb25lbnQ6Zml4dXBz');
   ({ exports: exports0 } = await instantiateCore(await module2));
   ({ exports: exports1 } = await instantiateCore(await module0, {
     wasi_snapshot_preview1: {
-      environ_get: exports0['25'],
-      environ_sizes_get: exports0['26'],
-      fd_close: exports0['27'],
-      fd_filestat_get: exports0['21'],
-      fd_prestat_dir_name: exports0['29'],
-      fd_prestat_get: exports0['28'],
-      fd_read: exports0['23'],
-      fd_write: exports0['24'],
-      path_open: exports0['20'],
-      proc_exit: exports0['30'],
-      random_get: exports0['22'],
+      environ_get: exports0['31'],
+      environ_sizes_get: exports0['32'],
+      fd_close: exports0['33'],
+      fd_filestat_get: exports0['25'],
+      fd_prestat_dir_name: exports0['35'],
+      fd_prestat_get: exports0['34'],
+      fd_read: exports0['29'],
+      fd_readdir: exports0['26'],
+      fd_write: exports0['30'],
+      path_filestat_get: exports0['27'],
+      path_open: exports0['24'],
+      proc_exit: exports0['36'],
+      random_get: exports0['28'],
     },
   }));
   ({ exports: exports2 } = await instantiateCore(await module1, {
@@ -2889,69 +3787,70 @@ export const $init = (async() => {
     env: {
       memory: exports1.memory,
     },
-    'wasi:cli/environment@0.2.0-rc-2023-11-10': {
-      'get-environment': exports0['16'],
+    'wasi:cli/environment@0.2.0': {
+      'get-environment': exports0['20'],
     },
-    'wasi:cli/exit@0.2.0-rc-2023-11-10': {
-      exit: trampoline9,
+    'wasi:cli/exit@0.2.0': {
+      exit: trampoline8,
     },
-    'wasi:cli/stderr@0.2.0-rc-2023-11-10': {
-      'get-stderr': trampoline8,
+    'wasi:cli/stderr@0.2.0': {
+      'get-stderr': trampoline7,
     },
-    'wasi:cli/stdin@0.2.0-rc-2023-11-10': {
-      'get-stdin': trampoline10,
+    'wasi:cli/stdin@0.2.0': {
+      'get-stdin': trampoline9,
     },
-    'wasi:cli/stdout@0.2.0-rc-2023-11-10': {
-      'get-stdout': trampoline11,
+    'wasi:cli/stdout@0.2.0': {
+      'get-stdout': trampoline10,
     },
-    'wasi:cli/terminal-input@0.2.0-rc-2023-11-10': {
-      '[resource-drop]terminal-input': trampoline7,
+    'wasi:cli/terminal-input@0.2.0': {
+      '[resource-drop]terminal-input': trampoline5,
     },
-    'wasi:cli/terminal-output@0.2.0-rc-2023-11-10': {
+    'wasi:cli/terminal-output@0.2.0': {
       '[resource-drop]terminal-output': trampoline6,
     },
-    'wasi:cli/terminal-stderr@0.2.0-rc-2023-11-10': {
-      'get-terminal-stderr': exports0['19'],
+    'wasi:cli/terminal-stderr@0.2.0': {
+      'get-terminal-stderr': exports0['23'],
     },
-    'wasi:cli/terminal-stdin@0.2.0-rc-2023-11-10': {
-      'get-terminal-stdin': exports0['17'],
+    'wasi:cli/terminal-stdin@0.2.0': {
+      'get-terminal-stdin': exports0['21'],
     },
-    'wasi:cli/terminal-stdout@0.2.0-rc-2023-11-10': {
-      'get-terminal-stdout': exports0['18'],
+    'wasi:cli/terminal-stdout@0.2.0': {
+      'get-terminal-stdout': exports0['22'],
     },
-    'wasi:filesystem/preopens@0.2.0-rc-2023-11-10': {
+    'wasi:filesystem/preopens@0.2.0': {
       'get-directories': exports0['0'],
     },
-    'wasi:filesystem/types@0.2.0-rc-2023-11-10': {
+    'wasi:filesystem/types@0.2.0': {
       '[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.metadata-hash': exports0['9'],
+      '[method]descriptor.metadata-hash-at': exports0['10'],
+      '[method]descriptor.open-at': exports0['8'],
+      '[method]descriptor.read-directory': exports0['5'],
       '[method]descriptor.read-via-stream': exports0['1'],
-      '[method]descriptor.stat': exports0['5'],
+      '[method]descriptor.stat': exports0['6'],
+      '[method]descriptor.stat-at': exports0['7'],
       '[method]descriptor.write-via-stream': exports0['2'],
+      '[method]directory-entry-stream.read-directory-entry': exports0['11'],
       '[resource-drop]descriptor': trampoline4,
       '[resource-drop]directory-entry-stream': trampoline0,
-      'filesystem-error-code': exports0['8'],
+      'filesystem-error-code': exports0['12'],
     },
-    'wasi:io/error@0.2.0-rc-2023-11-10': {
+    'wasi:io/error@0.2.0': {
       '[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'],
+    'wasi:io/streams@0.2.0': {
+      '[method]input-stream.blocking-read': exports0['14'],
+      '[method]input-stream.read': exports0['13'],
+      '[method]output-stream.blocking-flush': exports0['18'],
+      '[method]output-stream.blocking-write-and-flush': exports0['17'],
+      '[method]output-stream.check-write': exports0['15'],
+      '[method]output-stream.write': exports0['16'],
       '[resource-drop]input-stream': trampoline2,
       '[resource-drop]output-stream': trampoline3,
     },
-    'wasi:random/random@0.2.0-rc-2023-11-10': {
-      'get-random-bytes': exports0['15'],
-    },
-    'wasi:sockets/tcp@0.2.0-rc-2023-11-10': {
-      '[resource-drop]tcp-socket': trampoline5,
+    'wasi:random/random@0.2.0': {
+      'get-random-bytes': exports0['19'],
     },
   }));
   memory0 = exports1.memory;
@@ -2959,37 +3858,43 @@ export const $init = (async() => {
   ({ exports: exports3 } = await instantiateCore(await module3, {
     '': {
       $imports: exports0.$imports,
-      '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.path_open,
-      '21': exports2.fd_filestat_get,
-      '22': exports2.random_get,
-      '23': exports2.fd_read,
-      '24': exports2.fd_write,
-      '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,
+      '0': trampoline11,
+      '1': trampoline12,
+      '10': trampoline21,
+      '11': trampoline22,
+      '12': trampoline23,
+      '13': trampoline24,
+      '14': trampoline25,
+      '15': trampoline26,
+      '16': trampoline27,
+      '17': trampoline28,
+      '18': trampoline29,
+      '19': trampoline30,
+      '2': trampoline13,
+      '20': trampoline31,
+      '21': trampoline32,
+      '22': trampoline33,
+      '23': trampoline34,
+      '24': exports2.path_open,
+      '25': exports2.fd_filestat_get,
+      '26': exports2.fd_readdir,
+      '27': exports2.path_filestat_get,
+      '28': exports2.random_get,
+      '29': exports2.fd_read,
+      '3': trampoline14,
+      '30': exports2.fd_write,
+      '31': exports2.environ_get,
+      '32': exports2.environ_sizes_get,
+      '33': exports2.fd_close,
+      '34': exports2.fd_prestat_get,
+      '35': exports2.fd_prestat_dir_name,
+      '36': exports2.proc_exit,
+      '4': trampoline15,
+      '5': trampoline16,
+      '6': trampoline17,
+      '7': trampoline18,
+      '8': trampoline19,
+      '9': trampoline20,
     },
   }));
   realloc1 = exports1.cabi_realloc;