@bytecodealliance/jco 1.17.3 → 1.17.5

package/obj/js-component-bindgen-component.js

@@ -1750,8 +1750,9 @@ class Waitable {
       
       const ready = readyFn();
       if (ready && ASYNC_DETERMINISM === 'random') {
-        const coinFlip = _coinFlip();
-        if (coinFlip) { return true }
+        // const coinFlip = _coinFlip();
+        // if (coinFlip) { return true }
+        return true;
       }
       
       const keepGoing = await this.immediateSuspend({ cancellable, readyFn });
@@ -2050,10 +2051,52 @@ function _lowerImportBackwardsCompat(args) {
     importFn,
   } = args;
   
-  const { taskID } = _getGlobalCurrentTaskMeta(componentIdx);
+  let meta = _getGlobalCurrentTaskMeta(componentIdx);
+  let createdTask;
+  
+  // Some components depend on initialization logic (i.e. `_initialize` or some such
+  // core wasm export) that is embedded in the component, but is not executed or wizer'd
+  // away before the transpiled component is attempted to be used.
+  //
+  // These components execut their initialization logic *when they are imported* in the
+  // transpiled context -- so we may get a call to an export that is lowered without going
+  // through `CallWasm` or `CallInterface`.
+  //
+  if (!meta) {
+    if (funcTypeIsAsync || (isAsync && !isManualAsync)) {
+      throw new Error('p3 async wasm exports cannot use backwards compat auto-task init');
+    }
+    
+    const [newTask, newTaskID] = createNewCurrentTask({
+      componentIdx,
+      isAsync,
+      isManualAsync,
+      callingWasmExport: false,
+    });
+    createdTask = newTask;
+    
+    // Since we're managing the task creation ourselves we must clear ourselves
+    createdTask.registerOnResolveHandler(() => {
+      _clearCurrentTask({
+        taskID: task.id(),
+        componentIdx: task.componentIdx(),
+      });
+    });
+    
+    _setGlobalCurrentTaskMeta({
+      componentIdx,
+      taskID: newTaskID,
+    });
+    
+    meta = _getGlobalCurrentTaskMeta(componentIdx);
+  }
+  
+  const { taskID } = meta;
   
   const taskMeta = getCurrentTask(componentIdx, taskID);
-  if (!taskMeta) { throw new Error('invalid/missing async task meta'); }
+  if (!taskMeta) {
+    throw new Error('invalid/missing async task meta');
+  }
   
   const task = taskMeta.task;
   if (!task) { throw new Error('invalid/missing async task'); }
@@ -2097,13 +2140,20 @@ function _lowerImportBackwardsCompat(args) {
     // TODO(breaking): remove once we get rid of manual async import specification,
     // as func types cannot be detected in that case only (and we don't need that w/ p3)
     if (!isManualAsync && !isAsync && !funcTypeIsAsync) {
+      if (createdTask) { createdTask.enterSync(); }
+      
       const res = importFn(...params);
+      
       // TODO(breaking): remove once we get rid of manual async import specification,
       // as func types cannot be detected in that case only (and we don't need that w/ p3)
       if (!funcTypeIsAsync && !subtask.isReturned()) {
         throw new Error('post-execution subtasks must either be async or returned');
       }
-      return subtask.getResult();
+      
+      const syncRes = subtask.getResult();
+      if (createdTask) { createdTask.resolve([syncRes]); }
+      
+      return syncRes;
     }
     
     // Sync-lowered async functions requires async behavior because the callee *can* block,
@@ -2172,10 +2222,16 @@ function _lowerImportBackwardsCompat(args) {
     queueMicrotask(async () => {
       try {
         _debugLog('[_lowerImportBackwardsCompat()] calling lowered import', { importFn, params });
-        const res = await importFn(...params);
+        if (createdTask) { await createdTask.enter(); }
+        
+        const asyncRes = await importFn(...params);
         if (requiresManualAsyncResult) {
           manualAsyncResult.resolve(subtask.getResult());
         }
+        
+        if (createdTask) { createdTask.resolve([asyncRes]); }
+        
+        
       } catch (err) {
         _debugLog("[_lowerImportBackwardsCompat()] import fn error:", err);
         if (requiresManualAsyncResult) {
@@ -2204,7 +2260,9 @@ function _lowerImportBackwardsCompat(args) {
     if (ctx.storageLen !== undefined && ctx.storageLen < ctx.storagePtr + 1) {
       throw new Error('not enough storage remaining for lift');
     }
+    
     val = new DataView(ctx.memory.buffer).getUint8(ctx.storagePtr, true);
+    
     ctx.storagePtr += 1;
     if (ctx.storageLen !== undefined) { ctx.storageLen -= 1; }
     
@@ -2361,47 +2419,11 @@ function _lowerImportBackwardsCompat(args) {
     }
   }
   
-  function _liftFlatList(elemLiftFn, align32, knownLen) {
-    function _liftFlatListInner(ctx) {
-      _debugLog('[_liftFlatList()] args', { ctx });
-      
-      let metaPtr;
-      let dataPtr;
-      let len;
-      if (ctx.useDirectParams) {
-        if (knownLen) {
-          dataPtr = _liftFlatU32(ctx);
-        } else {
-          metaPtr = _liftFlatU32(ctx);
-        }
-      } else {
-        if (knownLen) {
-          dataPtr = _liftFlatU32(ctx);
-        } else {
-          metaPtr = _liftFlatU32(ctx);
-        }
-      }
-      
-      if (metaPtr) {
-        if (dataPtr !== undefined) { throw new Error('both meta and data pointers should not be set yet'); }
-        
-        if (ctx.useDirectParams) {
-          ctx.useDirectParams = false;
-          ctx.storagePtr = metaPtr;
-          ctx.storageLen = 8;
-          
-          dataPtr = _liftFlatU32(ctx);
-          len = _liftFlatU32(ctx);
-          
-          ctx.useDirectParams = true;
-          ctx.storagePtr = null;
-          ctx.storageLen = null;
-        } else {
-          dataPtr = _liftFlatU32(ctx);
-          len = _liftFlatU32(ctx);
-        }
-      }
-      
+  function _liftFlatList(meta) {
+    const { elemLiftFn, align32, knownLen } = meta;
+    
+    const readValuesAndReset = (ctx, originalPtr, dataPtr, len) => {
+      ctx.storagePtr = dataPtr;
       const val = [];
       for (var i = 0; i < len; i++) {
         const [res, nextCtx] = elemLiftFn(ctx);
@@ -2409,1431 +2431,1530 @@ function _lowerImportBackwardsCompat(args) {
         ctx = nextCtx;
         
         const rem = ctx.storagePtr % align32;
-        if (rem !== 0) { newCtx.storagePtr += (align32 - rem); }
+        if (rem !== 0) { ctx.storagePtr += align32 - rem; }
       }
-      
+      if (originalPtr !== null) { ctx.storagePtr = originalPtr; }
       return [val, ctx];
+    };
+    
+    return function _liftFlatListInner(ctx) {
+      _debugLog('[_liftFlatList()] args', { ctx });
+      
+      let liftResults;
+      if (knownLen) { // list with known length
+      
+      if (ctx.useDirectParams) {
+        // list with known length w/ direct params
+        const dataPtr = ctx.params[0];
+        ctx.params = ctx.params.slice(1);
+        
+        // TODO: is it possible for all values to come in from params?
+        
+        ctx.useDirectParams = false;
+        const originalPtr = ctx.storagePtr;
+        ctx.storageLen = 8;
+        
+        liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, len);
+        
+        ctx.useDirectParams = true;
+        ctx.storagePtr = null;
+        ctx.storageLen = null;
+        
+      } else {
+        liftResults = readValuesAndReset(ctx, null, ctx.storagePtr, knownLen);
+      }
+      
+    } else { // unknown length list
+    
+    if (ctx.useDirectParams) {
+      // unknown length list ptr w/ direct params
+      const dataPtr = ctx.params[0];
+      const len = ctx.params[1];
+      ctx.params = ctx.params.slice(2);
+      
+      ctx.useDirectParams = false;
+      const originalPtr = ctx.storagePtr;
+      ctx.storageLen = 8;
+      
+      liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, len);
+      
+      ctx.useDirectParams = true;
+      ctx.storagePtr = null;
+      ctx.storageLen = null;
+      
+    } else {
+      // unknown length list ptr w/ in-memory params
+      const dataPtrLiftRes = _liftFlatU32(ctx);
+      const dataPtr = dataPtrLiftRes[0];
+      ctx = dataPtrLiftRes[1];
+      
+      const lenLiftRes = _liftFlatU32(ctx);
+      const len = lenLiftRes[0];
+      ctx = lenLiftRes[1];
+      
+      const originalPtr = ctx.storagePtr;
+      ctx.storagePtr = dataPtr;
+      
+      liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, len);
     }
   }
   
-  function _liftFlatFlags(cases) {
-    return function _liftFlatFlagsInner(ctx) {
-      _debugLog('[_liftFlatFlags()] args', { ctx });
-      throw new Error('flat lift for flags not yet implemented!');
-    }
-  }
-  
-  function _liftFlatResult(casesAndLiftFns) {
-    return function _liftFlatResultInner(ctx) {
-      _debugLog('[_liftFlatResult()] args', { ctx });
-      return _liftFlatVariant(casesAndLiftFns)(ctx);
-    }
-  }
-  
-  function _liftFlatBorrow(componentTableIdx, size, memory, vals, storagePtr, storageLen) {
-    _debugLog('[_liftFlatBorrow()] args', { size, memory, vals, storagePtr, storageLen });
-    throw new Error('flat lift for borrowed resources not yet implemented!');
-  }
+  return liftResults;
+}
+}
+
+function _liftFlatFlags(meta) {
+  const { names, size32, align32, intSize } = meta;
   
-  function _lowerFlatU8(ctx) {
-    _debugLog('[_lowerFlatU8()] args', ctx);
-    const { memory, realloc, vals, storagePtr, storageLen } = ctx;
-    if (vals.length !== 1) {
-      throw new Error('unexpected number (' + vals.length + ') of core vals (expected 1)');
-    }
-    if (vals[0] > 255 || vals[0] < 0) { throw new Error('invalid value for core value representing u8'); }
-    if (!memory) { throw new Error("missing memory for lower"); }
-    new DataView(memory.buffer).setUint32(storagePtr, vals[0], true);
+  return function _liftFlatFlagsInner(ctx) {
+    _debugLog('[_liftFlatFlags()] args', { ctx });
     
-    // TODO: ALIGNMENT IS WRONG?
+    const val = {};
     
-    return 1;
-  }
-  
-  function _lowerFlatU16(memory, vals, storagePtr, storageLen) {
-    _debugLog('[_lowerFlatU16()] args', { memory, vals, storagePtr, storageLen });
-    if (vals.length !== 1) {
-      throw new Error('unexpected number (' + vals.length + ') of core vals (expected 1)');
+    let liftRes;
+    let align;
+    switch (intSize) {
+      case 1:
+      liftRes = _liftFlatU8(ctx);
+      break;
+      case 2:
+      liftRes = _liftFlatU16(ctx);
+      break;
+      case 4:
+      liftRes = _liftFlatU32(ctx);
+      break;
+      default:
+      throw new Error('invalid flags size');
     }
-    if (vals[0] > 65_535 || vals[0] < 0) { throw new Error('invalid value for core value representing u16'); }
-    new DataView(memory.buffer).setUint16(storagePtr, vals[0], true);
-    return 2;
-  }
-  
-  function _lowerFlatU32(ctx) {
-    _debugLog('[_lowerFlatU32()] args', { ctx });
-    const { memory, realloc, vals, storagePtr, storageLen } = ctx;
-    if (vals.length !== 1) { throw new Error('expected single value to lower, got (' + vals.length + ')'); }
-    if (vals[0] > 4_294_967_295 || vals[0] < 0) { throw new Error('invalid value for core value representing u32'); }
+    let bits = liftRes[0];
+    ctx = liftRes[1];
     
-    // TODO(refactor): fail loudly on misaligned flat lowers?
-    const rem = ctx.storagePtr % 4;
-    if (rem !== 0) { ctx.storagePtr += (4 - rem); }
+    for (const name of names) {
+      val[name] = (bits & 1) === 1;
+      bits >>>= 1;
+    }
     
-    new DataView(memory.buffer).setUint32(storagePtr, vals[0], true);
+    const rem = ctx.storagePtr % align32;
+    if (rem !== 0) { ctx.storagePtr += align32 - rem; }
     
-    return 4;
+    return [val, ctx];
   }
-  
-  function _lowerFlatU64(memory, vals, storagePtr, storageLen) {
-    _debugLog('[_lowerFlatU64()] args', { memory, vals, storagePtr, storageLen });
-    if (vals.length !== 1) { throw new Error('unexpected number of core vals'); }
-    if (vals[0] > 18_446_744_073_709_551_615n || vals[0] < 0n) { throw new Error('invalid value for core value representing u64'); }
-    new DataView(memory.buffer).setBigUint64(storagePtr, vals[0], true);
-    return 8;
+}
+
+function _liftFlatResult(casesAndLiftFns) {
+  return function _liftFlatResultInner(ctx) {
+    _debugLog('[_liftFlatResult()] args', { ctx });
+    return _liftFlatVariant(casesAndLiftFns)(ctx);
+  }
+}
+
+function _liftFlatBorrow(componentTableIdx, size, memory, vals, storagePtr, storageLen) {
+  _debugLog('[_liftFlatBorrow()] args', { size, memory, vals, storagePtr, storageLen });
+  throw new Error('flat lift for borrowed resources not yet implemented!');
+}
+
+function _lowerFlatU8(ctx) {
+  _debugLog('[_lowerFlatU8()] args', ctx);
+  const { memory, realloc, vals, storagePtr, storageLen } = ctx;
+  if (vals.length !== 1) {
+    throw new Error('unexpected number (' + vals.length + ') of core vals (expected 1)');
   }
+  if (vals[0] > 255 || vals[0] < 0) { throw new Error('invalid value for core value representing u8'); }
+  if (!memory) { throw new Error("missing memory for lower"); }
+  new DataView(memory.buffer).setUint32(storagePtr, vals[0], true);
+  
+  // TODO: ALIGNMENT IS WRONG?
+  
+  return 1;
+}
+
+function _lowerFlatU16(memory, vals, storagePtr, storageLen) {
+  _debugLog('[_lowerFlatU16()] args', { memory, vals, storagePtr, storageLen });
+  if (vals.length !== 1) {
+    throw new Error('unexpected number (' + vals.length + ') of core vals (expected 1)');
+  }
+  if (vals[0] > 65_535 || vals[0] < 0) { throw new Error('invalid value for core value representing u16'); }
+  new DataView(memory.buffer).setUint16(storagePtr, vals[0], true);
+  return 2;
+}
+
+function _lowerFlatU32(ctx) {
+  _debugLog('[_lowerFlatU32()] args', { ctx });
+  const { memory, realloc, vals, storagePtr, storageLen } = ctx;
+  if (vals.length !== 1) { throw new Error('expected single value to lower, got (' + vals.length + ')'); }
+  if (vals[0] > 4_294_967_295 || vals[0] < 0) { throw new Error('invalid value for core value representing u32'); }
+  
+  // TODO(refactor): fail loudly on misaligned flat lowers?
+  const rem = ctx.storagePtr % 4;
+  if (rem !== 0) { ctx.storagePtr += (4 - rem); }
+  
+  new DataView(memory.buffer).setUint32(storagePtr, vals[0], true);
+  
+  return 4;
+}
+
+function _lowerFlatU64(memory, vals, storagePtr, storageLen) {
+  _debugLog('[_lowerFlatU64()] args', { memory, vals, storagePtr, storageLen });
+  if (vals.length !== 1) { throw new Error('unexpected number of core vals'); }
+  if (vals[0] > 18_446_744_073_709_551_615n || vals[0] < 0n) { throw new Error('invalid value for core value representing u64'); }
+  new DataView(memory.buffer).setBigUint64(storagePtr, vals[0], true);
+  return 8;
+}
+
+function _lowerFlatStringUTF8(ctx) {
+  _debugLog('[_lowerFlatStringUTF8()] args', ctx);
+  
+  const { memory, realloc, vals, storagePtr, storageLen } = ctx;
+  
+  const s = vals[0];
+  const { ptr, len, codepoints } = _utf8AllocateAndEncode(vals[0], realloc, memory);
+  
+  const view = new DataView(memory.buffer);
+  view.setUint32(storagePtr, ptr, true);
+  view.setUint32(storagePtr + 4, codepoints, true);
   
-  function _lowerFlatStringUTF8(ctx) {
-    _debugLog('[_lowerFlatStringUTF8()] args', ctx);
+  return len;
+}
+
+function _lowerFlatRecord(fieldMetas) {
+  return (size, memory, vals, storagePtr, storageLen) => {
+    const params = [...arguments].slice(5);
+    _debugLog('[_lowerFlatRecord()] args', {
+      size,
+      memory,
+      vals,
+      storagePtr,
+      storageLen,
+      params,
+      fieldMetas
+    });
     
-    const { memory, realloc, vals, storagePtr, storageLen } = ctx;
+    const [start] = vals;
+    if (storageLen !== undefined && size !== undefined && size > storageLen) {
+      throw new Error('not enough storage remaining for record flat lower');
+    }
+    const data = new Uint8Array(memory.buffer, start, size);
+    new Uint8Array(memory.buffer, storagePtr, size).set(data);
+    return data.byteLength;
+  }
+}
+
+function _lowerFlatVariant(lowerMetas) {
+  return function _lowerFlatVariantInner(ctx) {
+    _debugLog('[_lowerFlatVariant()] args', ctx);
+    
+    const { memory, realloc, vals, storageLen, componentIdx } = ctx;
+    let storagePtr = ctx.storagePtr;
+    
+    const { tag, val } = vals[0];
+    const disc = lowerMetas.findIndex(m => m[0] === tag);
+    if (disc === -1) {
+      throw new Error(`invalid variant tag/discriminant [${tag}] (valid tags: ${variantMetas.map(m => m[0])})`);
+    }
+    
+    const [ _tag, lowerFn, size32, align32, payloadOffset32 ] = lowerMetas[disc];
+    
+    const originalPtr = ctx.resultPtr;
+    ctx.vals = [disc];
+    let discLowerRes;
+    if (lowerMetas.length < 256) {
+      discLowerRes = _lowerFlatU8(ctx);
+    } else if (lowerMetas.length >= 256 && lowerMetas.length < 65536) {
+      discLowerRes = _lowerFlatU16(ctx);
+    } else if (lowerMetas.length >= 65536 && lowerMetas.length < 4_294_967_296) {
+      discLowerRes = _lowerFlatU32(ctx);
+    } else {
+      throw new Error('unsupported number of cases [' + lowerMetas.legnth + ']');
+    }
     
-    const s = vals[0];
-    const { ptr, len, codepoints } = _utf8AllocateAndEncode(vals[0], realloc, memory);
+    ctx.resultPtr = originalPtr + payloadOffset32;
     
-    const view = new DataView(memory.buffer);
-    view.setUint32(storagePtr, ptr, true);
-    view.setUint32(storagePtr + 4, codepoints, true);
+    const payloadBytesWritten = lowerFn({
+      memory,
+      realloc,
+      vals: [val],
+      storagePtr,
+      storageLen,
+      componentIdx,
+    });
+    let bytesWritten = payloadOffset + payloadBytesWritten;
     
-    return len;
-  }
-  
-  function _lowerFlatRecord(fieldMetas) {
-    return (size, memory, vals, storagePtr, storageLen) => {
-      const params = [...arguments].slice(5);
-      _debugLog('[_lowerFlatRecord()] args', {
-        size,
-        memory,
-        vals,
-        storagePtr,
-        storageLen,
-        params,
-        fieldMetas
-      });
-      
-      const [start] = vals;
-      if (storageLen !== undefined && size !== undefined && size > storageLen) {
-        throw new Error('not enough storage remaining for record flat lower');
-      }
-      const data = new Uint8Array(memory.buffer, start, size);
-      new Uint8Array(memory.buffer, storagePtr, size).set(data);
-      return data.byteLength;
+    const rem = ctx.storagePtr % align32;
+    if (rem !== 0) {
+      const pad = align32 - rem;
+      ctx.storagePtr += pad;
+      bytesWritten += pad;
     }
+    
+    return bytesWritten;
   }
+}
+
+function _lowerFlatList(args) {
+  const { elemLowerFn } = args;
+  if (!elemLowerFn) { throw new TypeError("missing/invalid element lower fn for list"); }
   
-  function _lowerFlatVariant(lowerMetas) {
-    return function _lowerFlatVariantInner(ctx) {
-      _debugLog('[_lowerFlatVariant()] args', ctx);
-      
-      const { memory, realloc, vals, storageLen, componentIdx } = ctx;
-      let storagePtr = ctx.storagePtr;
-      
-      const { tag, val } = vals[0];
-      const disc = lowerMetas.findIndex(m => m[0] === tag);
-      if (disc === -1) {
-        throw new Error(`invalid variant tag/discriminant [${tag}] (valid tags: ${variantMetas.map(m => m[0])})`);
-      }
-      
-      const [ _tag, lowerFn, size32, align32, payloadOffset32 ] = lowerMetas[disc];
-      
-      const originalPtr = ctx.resultPtr;
-      ctx.vals = [disc];
-      let discLowerRes;
-      if (lowerMetas.length < 256) {
-        discLowerRes = _lowerFlatU8(ctx);
-      } else if (lowerMetas.length >= 256 && lowerMetas.length < 65536) {
-        discLowerRes = _lowerFlatU16(ctx);
-      } else if (lowerMetas.length >= 65536 && lowerMetas.length < 4_294_967_296) {
-        discLowerRes = _lowerFlatU32(ctx);
-      } else {
-        throw new Error('unsupported number of cases [' + lowerMetas.legnth + ']');
-      }
-      
-      ctx.resultPtr = originalPtr + payloadOffset32;
-      
-      const payloadBytesWritten = lowerFn({
-        memory,
-        realloc,
-        vals: [val],
-        storagePtr,
-        storageLen,
-        componentIdx,
-      });
-      let bytesWritten = payloadOffset + payloadBytesWritten;
+  return function _lowerFlatListInner(ctx) {
+    _debugLog('[_lowerFlatList()] args', { ctx });
+    
+    if (ctx.params.length < 2) { throw new Error('insufficient params left to lower list'); }
+    const storagePtr = ctx.params[0];
+    const elemCount = ctx.params[1];
+    ctx.params = ctx.params.slice(2);
+    
+    if (ctx.useDirectParams) {
+      const list = ctx.vals[0];
+      if (!list) { throw new Error("missing direct param value"); }
       
-      const rem = ctx.storagePtr % align32;
-      if (rem !== 0) {
-        const pad = align32 - rem;
-        ctx.storagePtr += pad;
-        bytesWritten += pad;
+      const elemLowerCtx = { storagePtr, memory: ctx.memory };
+      for (let idx = 0; idx < list.length; idx++) {
+        elemLowerCtx.vals = list.slice(idx, idx+1);
+        elemLowerCtx.storagePtr += elemLowerFn(elemLowerCtx);
       }
       
-      return bytesWritten;
+      const bytesLowered = elemLowerCtx.storagePtr - ctx.storagePtr;
+      ctx.storagePtr = elemLowerCtx.storagePtr;
+      return bytesLowered;
     }
-  }
-  
-  function _lowerFlatList(args) {
-    const { elemLowerFn } = args;
-    if (!elemLowerFn) { throw new TypeError("missing/invalid element lower fn for list"); }
     
-    return function _lowerFlatListInner(ctx) {
-      _debugLog('[_lowerFlatList()] args', { ctx });
-      
-      if (ctx.params.length < 2) { throw new Error('insufficient params left to lower list'); }
-      const storagePtr = ctx.params[0];
-      const elemCount = ctx.params[1];
-      ctx.params = ctx.params.slice(2);
-      
-      if (ctx.useDirectParams) {
-        const list = ctx.vals[0];
-        if (!list) { throw new Error("missing direct param value"); }
-        
-        const elemLowerCtx = { storagePtr, memory: ctx.memory };
-        for (let idx = 0; idx < list.length; idx++) {
-          elemLowerCtx.vals = list.slice(idx, idx+1);
-          elemLowerCtx.storagePtr += elemLowerFn(elemLowerCtx);
-        }
-        
-        const bytesLowered = elemLowerCtx.storagePtr - ctx.storagePtr;
-        ctx.storagePtr = elemLowerCtx.storagePtr;
-        return bytesLowered;
-      }
-      
-      if (ctx.vals.length !== 2) {
-        throw new Error('indirect parameter loading must have a pointer and length as vals');
-      }
-      let [valStartPtr, valLen] = ctx.vals;
-      const totalSizeBytes = valLen * size;
-      if (ctx.storageLen !== undefined && totalSizeBytes > ctx.storageLen) {
-        throw new Error('not enough storage remaining for list flat lower');
-      }
-      
-      const data = new Uint8Array(memory.buffer, valStartPtr, totalSizeBytes);
-      new Uint8Array(memory.buffer, storagePtr, totalSizeBytes).set(data);
-      
-      return totalSizeBytes;
+    if (ctx.vals.length !== 2) {
+      throw new Error('indirect parameter loading must have a pointer and length as vals');
     }
-  }
-  
-  function _lowerFlatTuple(size, memory, vals, storagePtr, storageLen) {
-    _debugLog('[_lowerFlatTuple()] args', { size, memory, vals, storagePtr, storageLen });
-    let [start, len] = vals;
-    if (storageLen !== undefined && len > storageLen) {
-      throw new Error('not enough storage remaining for tuple flat lower');
+    let [valStartPtr, valLen] = ctx.vals;
+    const totalSizeBytes = valLen * size;
+    if (ctx.storageLen !== undefined && totalSizeBytes > ctx.storageLen) {
+      throw new Error('not enough storage remaining for list flat lower');
     }
-    const data = new Uint8Array(memory.buffer, start, len);
-    new Uint8Array(memory.buffer, storagePtr, len).set(data);
-    return data.byteLength;
+    
+    const data = new Uint8Array(memory.buffer, valStartPtr, totalSizeBytes);
+    new Uint8Array(memory.buffer, storagePtr, totalSizeBytes).set(data);
+    
+    return totalSizeBytes;
   }
-  
-  function _lowerFlatFlags(memory, vals, storagePtr, storageLen) {
-    _debugLog('[_lowerFlatFlags()] args', { size, memory, vals, storagePtr, storageLen });
-    if (vals.length !== 1) { throw new Error('unexpected number of core vals'); }
-    new DataView(memory.buffer).setInt32(storagePtr, vals[0], true);
-    return 4;
+}
+
+function _lowerFlatTuple(size, memory, vals, storagePtr, storageLen) {
+  _debugLog('[_lowerFlatTuple()] args', { size, memory, vals, storagePtr, storageLen });
+  let [start, len] = vals;
+  if (storageLen !== undefined && len > storageLen) {
+    throw new Error('not enough storage remaining for tuple flat lower');
+  }
+  const data = new Uint8Array(memory.buffer, start, len);
+  new Uint8Array(memory.buffer, storagePtr, len).set(data);
+  return data.byteLength;
+}
+
+function _lowerFlatFlags(memory, vals, storagePtr, storageLen) {
+  _debugLog('[_lowerFlatFlags()] args', { size, memory, vals, storagePtr, storageLen });
+  if (vals.length !== 1) { throw new Error('unexpected number of core vals'); }
+  new DataView(memory.buffer).setInt32(storagePtr, vals[0], true);
+  return 4;
+}
+
+function _lowerFlatEnum(size, memory, vals, storagePtr, storageLen) {
+  _debugLog('[_lowerFlatEnum()] args', { size, memory, vals, storagePtr, storageLen });
+  let [start] = vals;
+  if (storageLen !== undefined && size !== undefined && size > storageLen) {
+    throw new Error('not enough storage remaining for enum flat lower');
+  }
+  const data = new Uint8Array(memory.buffer, start, size);
+  new Uint8Array(memory.buffer, storagePtr, size).set(data);
+  return data.byteLength;
+}
+
+function _lowerFlatOption(lowerMetas) {
+  function _lowerFlatOptionInner(ctx) {
+    _debugLog('[_lowerFlatOption()] args', { ctx });
+    return _lowerFlatVariant(lowerMetas)(ctx);
   }
+}
+
+function _lowerFlatResult(lowerMetas) {
+  return function _lowerFlatResultInner(ctx) {
+    _debugLog('[_lowerFlatResult()] args', { lowerMetas });
+    return _lowerFlatVariant(lowerMetas)(ctx);
+  };
+}
+
+function _lowerFlatOwn(size, memory, vals, storagePtr, storageLen) {
+  _debugLog('[_lowerFlatOwn()] args', { size, memory, vals, storagePtr, storageLen });
+  throw new Error('flat lower for owned resources not yet implemented!');
+}
+
+const STREAMS = new RepTable({ target: 'global stream map' });
+const ASYNC_STATE = new Map();
+
+function getOrCreateAsyncState(componentIdx, init) {
+  if (!ASYNC_STATE.has(componentIdx)) {
+    const newState = new ComponentAsyncState({ componentIdx });
+    ASYNC_STATE.set(componentIdx, newState);
+  }
+  return ASYNC_STATE.get(componentIdx);
+}
+
+class ComponentAsyncState {
+  static EVENT_HANDLER_EVENTS = [ 'backpressure-change' ];
   
-  function _lowerFlatEnum(size, memory, vals, storagePtr, storageLen) {
-    _debugLog('[_lowerFlatEnum()] args', { size, memory, vals, storagePtr, storageLen });
-    let [start] = vals;
-    if (storageLen !== undefined && size !== undefined && size > storageLen) {
-      throw new Error('not enough storage remaining for enum flat lower');
+  #componentIdx;
+  #callingAsyncImport = false;
+  #syncImportWait = promiseWithResolvers();
+  #locked = false;
+  #parkedTasks = new Map();
+  #suspendedTasksByTaskID = new Map();
+  #suspendedTaskIDs = [];
+  #errored = null;
+  
+  #backpressure = 0;
+  #backpressureWaiters = 0n;
+  
+  #handlerMap = new Map();
+  #nextHandlerID = 0n;
+  
+  #tickLoop = null;
+  #tickLoopInterval = null;
+  
+  #onExclusiveReleaseHandlers = [];
+  
+  mayLeave = true;
+  
+  handles;
+  subtasks;
+  
+  constructor(args) {
+    this.#componentIdx = args.componentIdx;
+    this.handles = new RepTable({ target: `component [${this.#componentIdx}] handles (waitable objects)` });
+    this.subtasks = new RepTable({ target: `component [${this.#componentIdx}] subtasks` });
+  };
+  
+  componentIdx() { return this.#componentIdx; }
+  
+  errored() { return this.#errored !== null; }
+  setErrored(err) {
+    _debugLog('[ComponentAsyncState#setErrored()] component errored', { err, componentIdx: this.#componentIdx });
+    if (this.#errored) { return; }
+    if (!err) {
+      err = new Error('error elswehere (see other component instance error)')
+      err.componentIdx = this.#componentIdx;
     }
-    const data = new Uint8Array(memory.buffer, start, size);
-    new Uint8Array(memory.buffer, storagePtr, size).set(data);
-    return data.byteLength;
+    this.#errored = err;
   }
   
-  function _lowerFlatOption(lowerMetas) {
-    function _lowerFlatOptionInner(ctx) {
-      _debugLog('[_lowerFlatOption()] args', { ctx });
-      return _lowerFlatVariant(lowerMetas)(ctx);
+  callingSyncImport(val) {
+    if (val === undefined) { return this.#callingAsyncImport; }
+    if (typeof val !== 'boolean') { throw new TypeError('invalid setting for async import'); }
+    const prev = this.#callingAsyncImport;
+    this.#callingAsyncImport = val;
+    if (prev === true && this.#callingAsyncImport === false) {
+      this.#notifySyncImportEnd();
     }
   }
   
-  function _lowerFlatResult(lowerMetas) {
-    return function _lowerFlatResultInner(ctx) {
-      _debugLog('[_lowerFlatResult()] args', { lowerMetas });
-      return _lowerFlatVariant(lowerMetas)(ctx);
-    };
+  #notifySyncImportEnd() {
+    const existing = this.#syncImportWait;
+    this.#syncImportWait = promiseWithResolvers();
+    existing.resolve();
   }
   
-  function _lowerFlatOwn(size, memory, vals, storagePtr, storageLen) {
-    _debugLog('[_lowerFlatOwn()] args', { size, memory, vals, storagePtr, storageLen });
-    throw new Error('flat lower for owned resources not yet implemented!');
+  async waitForSyncImportCallEnd() {
+    await this.#syncImportWait.promise;
   }
   
-  const STREAMS = new RepTable({ target: 'global stream map' });
-  const ASYNC_STATE = new Map();
+  setBackpressure(v) {
+    this.#backpressure = v;
+    return this.#backpressure
+  }
+  getBackpressure() { return this.#backpressure; }
   
-  function getOrCreateAsyncState(componentIdx, init) {
-    if (!ASYNC_STATE.has(componentIdx)) {
-      const newState = new ComponentAsyncState({ componentIdx });
-      ASYNC_STATE.set(componentIdx, newState);
+  incrementBackpressure() {
+    const current = this.#backpressure;
+    if (current < 0 || current > 2**16) {
+      throw new Error(`invalid current backpressure value [${current}]`);
+    }
+    const newValue = this.getBackpressure() + 1;
+    if (newValue >= 2**16) {
+      throw new Error(`invalid new backpressure value [${newValue}], overflow`);
     }
-    return ASYNC_STATE.get(componentIdx);
+    return this.setBackpressure(newValue);
   }
   
-  class ComponentAsyncState {
-    static EVENT_HANDLER_EVENTS = [ 'backpressure-change' ];
-    
-    #componentIdx;
-    #callingAsyncImport = false;
-    #syncImportWait = promiseWithResolvers();
-    #locked = false;
-    #parkedTasks = new Map();
-    #suspendedTasksByTaskID = new Map();
-    #suspendedTaskIDs = [];
-    #errored = null;
-    
-    #backpressure = 0;
-    #backpressureWaiters = 0n;
-    
-    #handlerMap = new Map();
-    #nextHandlerID = 0n;
-    
-    #tickLoop = null;
-    #tickLoopInterval = null;
-    
-    #onExclusiveReleaseHandlers = [];
-    
-    mayLeave = true;
-    
-    handles;
-    subtasks;
-    
-    constructor(args) {
-      this.#componentIdx = args.componentIdx;
-      this.handles = new RepTable({ target: `component [${this.#componentIdx}] handles (waitable objects)` });
-      this.subtasks = new RepTable({ target: `component [${this.#componentIdx}] subtasks` });
-    };
-    
-    componentIdx() { return this.#componentIdx; }
-    
-    errored() { return this.#errored !== null; }
-    setErrored(err) {
-      _debugLog('[ComponentAsyncState#setErrored()] component errored', { err, componentIdx: this.#componentIdx });
-      if (this.#errored) { return; }
-      if (!err) {
-        err = new Error('error elswehere (see other component instance error)')
-        err.componentIdx = this.#componentIdx;
-      }
-      this.#errored = err;
-    }
-    
-    callingSyncImport(val) {
-      if (val === undefined) { return this.#callingAsyncImport; }
-      if (typeof val !== 'boolean') { throw new TypeError('invalid setting for async import'); }
-      const prev = this.#callingAsyncImport;
-      this.#callingAsyncImport = val;
-      if (prev === true && this.#callingAsyncImport === false) {
-        this.#notifySyncImportEnd();
-      }
+  decrementBackpressure() {
+    const current = this.#backpressure;
+    if (current < 0 || current > 2**16) {
+      throw new Error(`invalid current backpressure value [${current}]`);
     }
-    
-    #notifySyncImportEnd() {
-      const existing = this.#syncImportWait;
-      this.#syncImportWait = promiseWithResolvers();
-      existing.resolve();
+    const newValue = Math.max(0, current - 1);
+    if (newValue < 0) {
+      throw new Error(`invalid new backpressure value [${newValue}], underflow`);
     }
+    return this.setBackpressure(newValue);
+  }
+  hasBackpressure() { return this.#backpressure > 0; }
+  
+  waitForBackpressure() {
+    let backpressureCleared = false;
+    const cstate = this;
+    cstate.addBackpressureWaiter();
+    const handlerID = this.registerHandler({
+      event: 'backpressure-change',
+      fn: (bp) => {
+        if (bp === 0) {
+          cstate.removeHandler(handlerID);
+          backpressureCleared = true;
+        }
+      }
+    });
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        if (backpressureCleared) { return; }
+        clearInterval(interval);
+        cstate.removeBackpressureWaiter();
+        resolve(null);
+      }, 0);
+    });
+  }
+  
+  registerHandler(args) {
+    const { event, fn } = args;
+    if (!event) { throw new Error("missing handler event"); }
+    if (!fn) { throw new Error("missing handler fn"); }
     
-    async waitForSyncImportCallEnd() {
-      await this.#syncImportWait.promise;
+    if (!ComponentAsyncState.EVENT_HANDLER_EVENTS.includes(event)) {
+      throw new Error(`unrecognized event handler [${event}]`);
     }
     
-    setBackpressure(v) {
-      this.#backpressure = v;
-      return this.#backpressure
+    const handlerID = this.#nextHandlerID++;
+    let handlers = this.#handlerMap.get(event);
+    if (!handlers) {
+      handlers = [];
+      this.#handlerMap.set(event, handlers)
     }
-    getBackpressure() { return this.#backpressure; }
     
-    incrementBackpressure() {
-      const current = this.#backpressure;
-      if (current < 0 || current > 2**16) {
-        throw new Error(`invalid current backpressure value [${current}]`);
-      }
-      const newValue = this.getBackpressure() + 1;
-      if (newValue >= 2**16) {
-        throw new Error(`invalid new backpressure value [${newValue}], overflow`);
-      }
-      return this.setBackpressure(newValue);
+    handlers.push({ id: handlerID, fn, event });
+    return handlerID;
+  }
+  
+  removeHandler(args) {
+    const { event, handlerID } = args;
+    const registeredHandlers = this.#handlerMap.get(event);
+    if (!registeredHandlers) { return; }
+    const found = registeredHandlers.find(h => h.id === handlerID);
+    if (!found) { return; }
+    this.#handlerMap.set(event, this.#handlerMap.get(event).filter(h => h.id !== handlerID));
+  }
+  
+  getBackpressureWaiters() { return this.#backpressureWaiters; }
+  addBackpressureWaiter() { this.#backpressureWaiters++; }
+  removeBackpressureWaiter() {
+    this.#backpressureWaiters--;
+    if (this.#backpressureWaiters < 0) {
+      throw new Error("unexepctedly negative number of backpressure waiters");
     }
+  }
+  
+  isExclusivelyLocked() { return this.#locked === true; }
+  setLocked(locked) {
+    this.#locked = locked;
+  }
+  
+  // TODO(fix): we might want to check for pre-locked status here, we should be deterministically
+  // going from locked -> unlocked and vice versa
+  exclusiveLock() {
+    _debugLog('[ComponentAsyncState#exclusiveLock()]', {
+      locked: this.#locked,
+      componentIdx: this.#componentIdx,
+    });
+    this.setLocked(true);
+  }
+  
+  exclusiveRelease() {
+    _debugLog('[ComponentAsyncState#exclusiveRelease()] args', {
+      locked: this.#locked,
+      componentIdx: this.#componentIdx,
+    });
+    this.setLocked(false);
     
-    decrementBackpressure() {
-      const current = this.#backpressure;
-      if (current < 0 || current > 2**16) {
-        throw new Error(`invalid current backpressure value [${current}]`);
-      }
-      const newValue = Math.max(0, current - 1);
-      if (newValue < 0) {
-        throw new Error(`invalid new backpressure value [${newValue}], underflow`);
+    this.#onExclusiveReleaseHandlers = this.#onExclusiveReleaseHandlers.filter(v => !!v);
+    for (const [idx, f] of this.#onExclusiveReleaseHandlers.entries()) {
+      try {
+        this.#onExclusiveReleaseHandlers[idx] = null;
+        f();
+      } catch (err) {
+        _debugLog("error while executing handler for next exclusive release", err);
+        throw err;
       }
-      return this.setBackpressure(newValue);
     }
-    hasBackpressure() { return this.#backpressure > 0; }
+  }
+  
+  onNextExclusiveRelease(fn) {
+    _debugLog('[ComponentAsyncState#()onNextExclusiveRelease] registering');
+    this.#onExclusiveReleaseHandlers.push(fn);
+  }
+  
+  #getSuspendedTaskMeta(taskID) {
+    return this.#suspendedTasksByTaskID.get(taskID);
+  }
+  
+  #removeSuspendedTaskMeta(taskID) {
+    _debugLog('[ComponentAsyncState#removeSuspendedTaskMeta()] removing suspended task', { taskID });
+    const idx = this.#suspendedTaskIDs.findIndex(t => t === taskID);
+    const meta = this.#suspendedTasksByTaskID.get(taskID);
+    this.#suspendedTaskIDs[idx] = null;
+    this.#suspendedTasksByTaskID.delete(taskID);
+    return meta;
+  }
+  
+  #addSuspendedTaskMeta(meta) {
+    if (!meta) { throw new Error('missing task meta'); }
+    const taskID = meta.taskID;
+    this.#suspendedTasksByTaskID.set(taskID, meta);
+    this.#suspendedTaskIDs.push(taskID);
+    if (this.#suspendedTasksByTaskID.size < this.#suspendedTaskIDs.length - 10) {
+      this.#suspendedTaskIDs = this.#suspendedTaskIDs.filter(t => t !== null);
+    }
+  }
+  
+  // TODO(threads): readyFn is normally on the thread
+  suspendTask(args) {
+    const { task, readyFn } = args;
+    const taskID = task.id();
+    _debugLog('[ComponentAsyncState#suspendTask()]', {
+      taskID,
+      componentIdx: this.#componentIdx,
+      taskEntryFnName: task.entryFnName(),
+      subtask: task.getParentSubtask(),
+    });
     
-    waitForBackpressure() {
-      let backpressureCleared = false;
-      const cstate = this;
-      cstate.addBackpressureWaiter();
-      const handlerID = this.registerHandler({
-        event: 'backpressure-change',
-        fn: (bp) => {
-          if (bp === 0) {
-            cstate.removeHandler(handlerID);
-            backpressureCleared = true;
-          }
-        }
-      });
-      return new Promise((resolve) => {
-        const interval = setInterval(() => {
-          if (backpressureCleared) { return; }
-          clearInterval(interval);
-          cstate.removeBackpressureWaiter();
-          resolve(null);
-        }, 0);
-      });
+    if (this.#getSuspendedTaskMeta(taskID)) {
+      throw new Error(`task [${taskID}] already suspended`);
     }
     
-    registerHandler(args) {
-      const { event, fn } = args;
-      if (!event) { throw new Error("missing handler event"); }
-      if (!fn) { throw new Error("missing handler fn"); }
-      
-      if (!ComponentAsyncState.EVENT_HANDLER_EVENTS.includes(event)) {
-        throw new Error(`unrecognized event handler [${event}]`);
+    const { promise, resolve, reject } = promiseWithResolvers();
+    this.#addSuspendedTaskMeta({
+      task,
+      taskID,
+      readyFn,
+      resume: () => {
+        _debugLog('[ComponentAsyncState#suspendTask()] resuming suspended task', { taskID });
+        // TODO(threads): it's thread cancellation we should be checking for below, not task
+        resolve(!task.isCancelled());
+      },
+    });
+    
+    this.runTickLoop();
+    
+    return promise;
+  }
+  
+  resumeTaskByID(taskID) {
+    const meta = this.#removeSuspendedTaskMeta(taskID);
+    if (!meta) { return; }
+    if (meta.taskID !== taskID) { throw new Error('task ID does not match'); }
+    meta.resume();
+  }
+  
+  async runTickLoop() {
+    if (this.#tickLoop !== null) { return; }
+    this.#tickLoop = 1;
+    setTimeout(async () => {
+      let done = this.tick();
+      while (!done) {
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        done = this.tick();
+      }
+      this.#tickLoop = null;
+    }, 10);
+  }
+  
+  tick() {
+    // _debugLog('[ComponentAsyncState#tick()]', { suspendedTaskIDs: this.#suspendedTaskIDs });
+    
+    const resumableTasks = this.#suspendedTaskIDs.filter(t => t !== null);
+    for (const taskID of resumableTasks) {
+      const meta = this.#suspendedTasksByTaskID.get(taskID);
+      if (!meta || !meta.readyFn) {
+        throw new Error(`missing/invalid task despite ID [${taskID}] being present`);
       }
       
-      const handlerID = this.#nextHandlerID++;
-      let handlers = this.#handlerMap.get(event);
-      if (!handlers) {
-        handlers = [];
-        this.#handlerMap.set(event, handlers)
+      // If the task failed via any means, allow the task to resume because
+      // it's been cancelled -- the callback should immediately exit as well
+      if (meta.task.isRejected()) {
+        _debugLog('[ComponentAsyncState#suspendTask()] detected task rejection, leaving early', { meta });
+        this.resumeTaskByID(taskID);
+        return;
       }
       
-      handlers.push({ id: handlerID, fn, event });
-      return handlerID;
+      const isReady = meta.readyFn();
+      if (!isReady) { continue; }
+      
+      this.resumeTaskByID(taskID);
     }
     
-    removeHandler(args) {
-      const { event, handlerID } = args;
-      const registeredHandlers = this.#handlerMap.get(event);
-      if (!registeredHandlers) { return; }
-      const found = registeredHandlers.find(h => h.id === handlerID);
-      if (!found) { return; }
-      this.#handlerMap.set(event, this.#handlerMap.get(event).filter(h => h.id !== handlerID));
-    }
+    return this.#suspendedTaskIDs.filter(t => t !== null).length === 0;
+  }
+  
+  addStreamEndToTable(args) {
+    _debugLog('[ComponentAsyncState#addStreamEnd()] args', args);
+    const { tableIdx, streamEnd } = args;
+    if (typeof streamEnd === 'number') { throw new Error("INSERTING BAD STREAMEND"); }
     
-    getBackpressureWaiters() { return this.#backpressureWaiters; }
-    addBackpressureWaiter() { this.#backpressureWaiters++; }
-    removeBackpressureWaiter() {
-      this.#backpressureWaiters--;
-      if (this.#backpressureWaiters < 0) {
-        throw new Error("unexepctedly negative number of backpressure waiters");
-      }
+    let { table, componentIdx } = STREAM_TABLES[tableIdx];
+    if (componentIdx === undefined || !table) {
+      throw new Error(`invalid global stream table state for table [${tableIdx}]`);
     }
     
-    isExclusivelyLocked() { return this.#locked === true; }
-    setLocked(locked) {
-      this.#locked = locked;
-    }
+    const handle = table.insert(streamEnd);
+    streamEnd.setHandle(handle);
+    streamEnd.setStreamTableIdx(tableIdx);
     
-    // TODO(fix): we might want to check for pre-locked status here, we should be deterministically
-    // going from locked -> unlocked and vice versa
-    exclusiveLock() {
-      _debugLog('[ComponentAsyncState#exclusiveLock()]', {
-        locked: this.#locked,
-        componentIdx: this.#componentIdx,
-      });
-      this.setLocked(true);
-    }
+    const cstate = getOrCreateAsyncState(componentIdx);
+    const waitableIdx = cstate.handles.insert(streamEnd);
+    streamEnd.setWaitableIdx(waitableIdx);
     
-    exclusiveRelease() {
-      _debugLog('[ComponentAsyncState#exclusiveRelease()] args', {
-        locked: this.#locked,
-        componentIdx: this.#componentIdx,
-      });
-      this.setLocked(false);
-      
-      this.#onExclusiveReleaseHandlers = this.#onExclusiveReleaseHandlers.filter(v => !!v);
-      for (const [idx, f] of this.#onExclusiveReleaseHandlers.entries()) {
-        try {
-          this.#onExclusiveReleaseHandlers[idx] = null;
-          f();
-        } catch (err) {
-          _debugLog("error while executing handler for next exclusive release", err);
-          throw err;
-        }
-      }
-    }
+    _debugLog('[ComponentAsyncState#addStreamEnd()] added stream end', {
+      tableIdx,
+      table,
+      handle,
+      streamEnd,
+      destComponentIdx: componentIdx,
+    });
     
-    onNextExclusiveRelease(fn) {
-      _debugLog('[ComponentAsyncState#()onNextExclusiveRelease] registering');
-      this.#onExclusiveReleaseHandlers.push(fn);
-    }
+    return { handle, waitableIdx };
+  }
+  
+  createWaitable(args) {
+    return new Waitable({ target: args?.target, });
+  }
+  
+  createStream(args) {
+    _debugLog('[ComponentAsyncState#createStream()] args', args);
+    const { tableIdx, elemMeta } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while adding stream"); }
+    if (elemMeta === undefined) { throw new Error("missing element metadata while adding stream"); }
     
-    #getSuspendedTaskMeta(taskID) {
-      return this.#suspendedTasksByTaskID.get(taskID);
+    const { table: localStreamTable, componentIdx } = STREAM_TABLES[tableIdx];
+    if (!localStreamTable) {
+      throw new Error(`missing global stream table lookup for table [${tableIdx}] while creating stream`);
     }
-    
-    #removeSuspendedTaskMeta(taskID) {
-      _debugLog('[ComponentAsyncState#removeSuspendedTaskMeta()] removing suspended task', { taskID });
-      const idx = this.#suspendedTaskIDs.findIndex(t => t === taskID);
-      const meta = this.#suspendedTasksByTaskID.get(taskID);
-      this.#suspendedTaskIDs[idx] = null;
-      this.#suspendedTasksByTaskID.delete(taskID);
-      return meta;
+    if (componentIdx !== this.#componentIdx) {
+      throw new Error('component idx mismatch while creating stream');
     }
     
-    #addSuspendedTaskMeta(meta) {
-      if (!meta) { throw new Error('missing task meta'); }
-      const taskID = meta.taskID;
-      this.#suspendedTasksByTaskID.set(taskID, meta);
-      this.#suspendedTaskIDs.push(taskID);
-      if (this.#suspendedTasksByTaskID.size < this.#suspendedTaskIDs.length - 10) {
-        this.#suspendedTaskIDs = this.#suspendedTaskIDs.filter(t => t !== null);
-      }
-    }
+    const readWaitable = this.createWaitable();
+    const writeWaitable = this.createWaitable();
     
-    // TODO(threads): readyFn is normally on the thread
-    suspendTask(args) {
-      const { task, readyFn } = args;
-      const taskID = task.id();
-      _debugLog('[ComponentAsyncState#suspendTask()]', {
-        taskID,
-        componentIdx: this.#componentIdx,
-        taskEntryFnName: task.entryFnName(),
-        subtask: task.getParentSubtask(),
-      });
-      
-      if (this.#getSuspendedTaskMeta(taskID)) {
-        throw new Error(`task [${taskID}] already suspended`);
-      }
-      
-      const { promise, resolve, reject } = promiseWithResolvers();
-      this.#addSuspendedTaskMeta({
-        task,
-        taskID,
-        readyFn,
-        resume: () => {
-          _debugLog('[ComponentAsyncState#suspendTask()] resuming suspended task', { taskID });
-          // TODO(threads): it's thread cancellation we should be checking for below, not task
-          resolve(!task.isCancelled());
-        },
-      });
-      
-      this.runTickLoop();
-      
-      return promise;
-    }
+    const stream = new InternalStream({
+      tableIdx,
+      componentIdx: this.#componentIdx,
+      elemMeta,
+      readWaitable,
+      writeWaitable,
+    });
+    stream.setGlobalStreamMapRep(STREAMS.insert(stream));
+    
+    const writeEnd = stream.writeEnd();
+    writeEnd.setWaitableIdx(this.handles.insert(writeEnd));
+    writeEnd.setHandle(localStreamTable.insert(writeEnd));
+    if (writeEnd.streamTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched stream table"); }
+    
+    const writeEndWaitableIdx = writeEnd.waitableIdx();
+    const writeEndHandle = writeEnd.handle();
+    writeWaitable.setTarget(`waitable for stream write end (waitable [${writeEndWaitableIdx}])`);
+    writeEnd.setTarget(`stream write end (waitable [${writeEndWaitableIdx}])`);
+    
+    const readEnd = stream.readEnd();
+    readEnd.setWaitableIdx(this.handles.insert(readEnd));
+    readEnd.setHandle(localStreamTable.insert(readEnd));
+    if (readEnd.streamTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched stream table"); }
+    
+    const readEndWaitableIdx = readEnd.waitableIdx();
+    const readEndHandle = readEnd.handle();
+    readWaitable.setTarget(`waitable for read end (waitable [${readEndWaitableIdx}])`);
+    readEnd.setTarget(`stream read end (waitable [${readEndWaitableIdx}])`);
+    
+    return {
+      writeEndWaitableIdx,
+      writeEndHandle,
+      readEndWaitableIdx,
+      readEndHandle,
+    };
+  }
+  
+  getStreamEnd(args) {
+    _debugLog('[ComponentAsyncState#getStreamEnd()] args', args);
+    const { tableIdx, streamEndHandle, streamEndWaitableIdx } = args;
+    if (tableIdx === undefined) { throw new Error('missing table idx while getting stream end'); }
     
-    resumeTaskByID(taskID) {
-      const meta = this.#removeSuspendedTaskMeta(taskID);
-      if (!meta) { return; }
-      if (meta.taskID !== taskID) { throw new Error('task ID does not match'); }
-      meta.resume();
+    const { table, componentIdx } = STREAM_TABLES[tableIdx];
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    let streamEnd;
+    if (streamEndWaitableIdx !== undefined) {
+      streamEnd = cstate.handles.get(streamEndWaitableIdx);
+    } else if (streamEndHandle !== undefined) {
+      if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while getting stream end`); }
+      streamEnd = table.get(streamEndHandle);
+    } else {
+      throw new TypeError("must specify either waitable idx or handle to retrieve stream");
     }
     
-    async runTickLoop() {
-      if (this.#tickLoop !== null) { return; }
-      this.#tickLoop = 1;
-      setTimeout(async () => {
-        let done = this.tick();
-        while (!done) {
-          await new Promise((resolve) => setTimeout(resolve, 30));
-          done = this.tick();
-        }
-        this.#tickLoop = null;
-      }, 10);
+    if (!streamEnd) {
+      throw new Error(`missing stream end (tableIdx [${tableIdx}], handle [${streamEndHandle}], waitableIdx [${streamEndWaitableIdx}])`);
+    }
+    if (tableIdx && streamEnd.streamTableIdx() !== tableIdx) {
+      throw new Error(`stream end table idx [${streamEnd.streamTableIdx()}] does not match [${tableIdx}]`);
     }
     
-    tick() {
-      // _debugLog('[ComponentAsyncState#tick()]', { suspendedTaskIDs: this.#suspendedTaskIDs });
-      
-      const resumableTasks = this.#suspendedTaskIDs.filter(t => t !== null);
-      for (const taskID of resumableTasks) {
-        const meta = this.#suspendedTasksByTaskID.get(taskID);
-        if (!meta || !meta.readyFn) {
-          throw new Error(`missing/invalid task despite ID [${taskID}] being present`);
-        }
-        
-        // If the task failed via any means, allow the task to resume because
-        // it's been cancelled -- the callback should immediately exit as well
-        if (meta.task.isRejected()) {
-          _debugLog('[ComponentAsyncState#suspendTask()] detected task rejection, leaving early', { meta });
-          this.resumeTaskByID(taskID);
-          return;
-        }
-        
-        const isReady = meta.readyFn();
-        if (!isReady) { continue; }
-        
-        this.resumeTaskByID(taskID);
-      }
-      
-      return this.#suspendedTaskIDs.filter(t => t !== null).length === 0;
+    return streamEnd;
+  }
+  
+  deleteStreamEnd(args) {
+    _debugLog('[ComponentAsyncState#deleteStreamEnd()] args', args);
+    const { tableIdx, streamEndWaitableIdx } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while removing stream end"); }
+    if (streamEndWaitableIdx === undefined) { throw new Error("missing stream idx while removing stream end"); }
+    
+    const { table, componentIdx } = STREAM_TABLES[tableIdx];
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    const streamEnd = cstate.handles.get(streamEndWaitableIdx);
+    if (!streamEnd) {
+      throw new Error(`missing stream end [${streamEndWaitableIdx}] in component handles while deleting stream`);
+    }
+    if (streamEnd.streamTableIdx() !== tableIdx) {
+      throw new Error(`stream end table idx [${streamEnd.streamTableIdx()}] does not match [${tableIdx}]`);
     }
     
-    addStreamEndToTable(args) {
-      _debugLog('[ComponentAsyncState#addStreamEnd()] args', args);
-      const { tableIdx, streamEnd } = args;
-      if (typeof streamEnd === 'number') { throw new Error("INSERTING BAD STREAMEND"); }
-      
-      let { table, componentIdx } = STREAM_TABLES[tableIdx];
-      if (componentIdx === undefined || !table) {
-        throw new Error(`invalid global stream table state for table [${tableIdx}]`);
-      }
-      
-      const handle = table.insert(streamEnd);
-      streamEnd.setHandle(handle);
-      streamEnd.setStreamTableIdx(tableIdx);
-      
-      const cstate = getOrCreateAsyncState(componentIdx);
-      const waitableIdx = cstate.handles.insert(streamEnd);
-      streamEnd.setWaitableIdx(waitableIdx);
-      
-      _debugLog('[ComponentAsyncState#addStreamEnd()] added stream end', {
-        tableIdx,
-        table,
-        handle,
-        streamEnd,
-        destComponentIdx: componentIdx,
-      });
-      
-      return { handle, waitableIdx };
+    let removed = cstate.handles.remove(streamEnd.waitableIdx());
+    if (!removed) {
+      throw new Error(`failed to remove stream end [${streamEndWaitableIdx}] waitable obj in component [${componentIdx}]`);
     }
     
-    createWaitable(args) {
-      return new Waitable({ target: args?.target, });
+    removed = table.remove(streamEnd.handle());
+    if (!removed) {
+      throw new Error(`failed to remove stream end with handle [${streamEnd.handle()}] from stream table [${tableIdx}] in component [${componentIdx}]`);
     }
     
-    createStream(args) {
-      _debugLog('[ComponentAsyncState#createStream()] args', args);
-      const { tableIdx, elemMeta } = args;
-      if (tableIdx === undefined) { throw new Error("missing table idx while adding stream"); }
-      if (elemMeta === undefined) { throw new Error("missing element metadata while adding stream"); }
-      
-      const { table: localStreamTable, componentIdx } = STREAM_TABLES[tableIdx];
-      if (!localStreamTable) {
-        throw new Error(`missing global stream table lookup for table [${tableIdx}] while creating stream`);
-      }
-      if (componentIdx !== this.#componentIdx) {
-        throw new Error('component idx mismatch while creating stream');
-      }
-      
-      const readWaitable = this.createWaitable();
-      const writeWaitable = this.createWaitable();
-      
-      const stream = new InternalStream({
-        tableIdx,
-        componentIdx: this.#componentIdx,
-        elemMeta,
-        readWaitable,
-        writeWaitable,
-      });
-      stream.setGlobalStreamMapRep(STREAMS.insert(stream));
-      
-      const writeEnd = stream.writeEnd();
-      writeEnd.setWaitableIdx(this.handles.insert(writeEnd));
-      writeEnd.setHandle(localStreamTable.insert(writeEnd));
-      if (writeEnd.streamTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched stream table"); }
-      
-      const writeEndWaitableIdx = writeEnd.waitableIdx();
-      const writeEndHandle = writeEnd.handle();
-      writeWaitable.setTarget(`waitable for stream write end (waitable [${writeEndWaitableIdx}])`);
-      writeEnd.setTarget(`stream write end (waitable [${writeEndWaitableIdx}])`);
-      
-      const readEnd = stream.readEnd();
-      readEnd.setWaitableIdx(this.handles.insert(readEnd));
-      readEnd.setHandle(localStreamTable.insert(readEnd));
-      if (readEnd.streamTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched stream table"); }
-      
-      const readEndWaitableIdx = readEnd.waitableIdx();
-      const readEndHandle = readEnd.handle();
-      readWaitable.setTarget(`waitable for read end (waitable [${readEndWaitableIdx}])`);
-      readEnd.setTarget(`stream read end (waitable [${readEndWaitableIdx}])`);
-      
-      return {
-        writeEndWaitableIdx,
-        writeEndHandle,
-        readEndWaitableIdx,
-        readEndHandle,
-      };
+    return streamEnd;
+  }
+  
+  removeStreamEndFromTable(args) {
+    _debugLog('[ComponentAsyncState#removeStreamEndFromTable()] args', args);
+    
+    const { tableIdx, streamWaitableIdx } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while removing stream end"); }
+    if (streamWaitableIdx === undefined) {
+      throw new Error("missing stream end waitable idx while removing stream end");
     }
     
-    getStreamEnd(args) {
-      _debugLog('[ComponentAsyncState#getStreamEnd()] args', args);
-      const { tableIdx, streamEndHandle, streamEndWaitableIdx } = args;
-      if (tableIdx === undefined) { throw new Error('missing table idx while getting stream end'); }
-      
-      const { table, componentIdx } = STREAM_TABLES[tableIdx];
-      const cstate = getOrCreateAsyncState(componentIdx);
-      
-      let streamEnd;
-      if (streamEndWaitableIdx !== undefined) {
-        streamEnd = cstate.handles.get(streamEndWaitableIdx);
-      } else if (streamEndHandle !== undefined) {
-        if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while getting stream end`); }
-        streamEnd = table.get(streamEndHandle);
-      } else {
-        throw new TypeError("must specify either waitable idx or handle to retrieve stream");
-      }
-      
-      if (!streamEnd) {
-        throw new Error(`missing stream end (tableIdx [${tableIdx}], handle [${streamEndHandle}], waitableIdx [${streamEndWaitableIdx}])`);
-      }
-      if (tableIdx && streamEnd.streamTableIdx() !== tableIdx) {
-        throw new Error(`stream end table idx [${streamEnd.streamTableIdx()}] does not match [${tableIdx}]`);
-      }
-      
-      return streamEnd;
+    const { table, componentIdx } = STREAM_TABLES[tableIdx];
+    if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while removing stream end`); }
+    
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    const streamEnd = cstate.handles.get(streamWaitableIdx);
+    if (!streamEnd) {
+      throw new Error(`missing stream end (handle [${streamWaitableIdx}], table [${tableIdx}])`);
     }
+    const handle = streamEnd.handle();
     
-    deleteStreamEnd(args) {
-      _debugLog('[ComponentAsyncState#deleteStreamEnd()] args', args);
-      const { tableIdx, streamEndWaitableIdx } = args;
-      if (tableIdx === undefined) { throw new Error("missing table idx while removing stream end"); }
-      if (streamEndWaitableIdx === undefined) { throw new Error("missing stream idx while removing stream end"); }
-      
-      const { table, componentIdx } = STREAM_TABLES[tableIdx];
-      const cstate = getOrCreateAsyncState(componentIdx);
-      
-      const streamEnd = cstate.handles.get(streamEndWaitableIdx);
-      if (!streamEnd) {
-        throw new Error(`missing stream end [${streamEndWaitableIdx}] in component handles while deleting stream`);
-      }
-      if (streamEnd.streamTableIdx() !== tableIdx) {
-        throw new Error(`stream end table idx [${streamEnd.streamTableIdx()}] does not match [${tableIdx}]`);
-      }
-      
-      let removed = cstate.handles.remove(streamEnd.waitableIdx());
-      if (!removed) {
-        throw new Error(`failed to remove stream end [${streamEndWaitableIdx}] waitable obj in component [${componentIdx}]`);
-      }
-      
-      removed = table.remove(streamEnd.handle());
-      if (!removed) {
-        throw new Error(`failed to remove stream end with handle [${streamEnd.handle()}] from stream table [${tableIdx}] in component [${componentIdx}]`);
-      }
-      
-      return streamEnd;
+    let removed = cstate.handles.remove(streamWaitableIdx);
+    if (!removed) {
+      throw new Error(`failed to remove streamEnd from handles (waitable idx [${streamWaitableIdx}]), component [${componentIdx}])`);
     }
     
-    removeStreamEndFromTable(args) {
-      _debugLog('[ComponentAsyncState#removeStreamEndFromTable()] args', args);
-      
-      const { tableIdx, streamWaitableIdx } = args;
-      if (tableIdx === undefined) { throw new Error("missing table idx while removing stream end"); }
-      if (streamWaitableIdx === undefined) {
-        throw new Error("missing stream end waitable idx while removing stream end");
-      }
-      
-      const { table, componentIdx } = STREAM_TABLES[tableIdx];
-      if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while removing stream end`); }
-      
-      const cstate = getOrCreateAsyncState(componentIdx);
-      
-      const streamEnd = cstate.handles.get(streamWaitableIdx);
-      if (!streamEnd) {
-        throw new Error(`missing stream end (handle [${streamWaitableIdx}], table [${tableIdx}])`);
-      }
-      const handle = streamEnd.handle();
-      
-      let removed = cstate.handles.remove(streamWaitableIdx);
-      if (!removed) {
-        throw new Error(`failed to remove streamEnd from handles (waitable idx [${streamWaitableIdx}]), component [${componentIdx}])`);
-      }
-      
-      removed = table.remove(handle);
-      if (!removed) {
-        throw new Error(`failed to remove streamEnd from table (handle [${handle}]), table [${tableIdx}], component [${componentIdx}])`);
-      }
-      
-      return streamEnd;
+    removed = table.remove(handle);
+    if (!removed) {
+      throw new Error(`failed to remove streamEnd from table (handle [${handle}]), table [${tableIdx}], component [${componentIdx}])`);
     }
+    
+    return streamEnd;
   }
-  
-  const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
-  
-  const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
-  let _fs;
-  async function fetchCompile (url) {
-    if (isNode) {
-      _fs = _fs || await import('node:fs/promises');
-      return WebAssembly.compile(await _fs.readFile(url));
-    }
-    return fetch(url).then(WebAssembly.compileStreaming);
+}
+
+const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
+
+const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+let _fs;
+async function fetchCompile (url) {
+  if (isNode) {
+    _fs = _fs || await import('node:fs/promises');
+    return WebAssembly.compile(await _fs.readFile(url));
+  }
+  return fetch(url).then(WebAssembly.compileStreaming);
+}
+
+const symbolCabiDispose = Symbol.for('cabiDispose');
+
+const symbolRscHandle = Symbol('handle');
+
+const symbolRscRep = Symbol.for('cabiRep');
+
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+
+const handleTables = [];
+
+class ComponentError extends Error {
+  constructor (value) {
+    const enumerable = typeof value !== 'string';
+    super(enumerable ? `${String(value)} (see error.payload)` : value);
+    Object.defineProperty(this, 'payload', { value, enumerable });
   }
+}
+
+function getErrorPayload(e) {
+  if (e && hasOwnProperty.call(e, 'payload')) return e.payload;
+  if (e instanceof Error) throw e;
+  return e;
+}
+
+function throwUninitialized() {
+  throw new TypeError('Wasm uninitialized use `await $init` first');
+}
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const instantiateCore = WebAssembly.instantiate;
+
+
+let exports0;
+let exports1;
+const handleTable2 = [T_FLAG, 0];
+const captureTable2= new Map();
+let captureCnt2 = 0;
+handleTables[2] = handleTable2;
+
+const _trampoline5 = function() {
+  _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"] [Instruction::CallInterface] (sync, @ enter)');
+  let hostProvided = true;
   
-  const symbolCabiDispose = Symbol.for('cabiDispose');
-  
-  const symbolRscHandle = Symbol('handle');
-  
-  const symbolRscRep = Symbol.for('cabiRep');
-  
-  const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+  let parentTask;
+  let task;
+  let subtask;
   
-  const handleTables = [];
+  const createTask = () => {
+    const results = createNewCurrentTask({
+      componentIdx: -1, // 0,
+      isAsync: false,
+      entryFnName: 'getStderr',
+      getCallbackFn: () => null,
+      callbackFnName: 'null',
+      errHandling: 'none',
+      callingWasmExport: false,
+    });
+    task = results[0];
+  };
   
-  class ComponentError extends Error {
-    constructor (value) {
-      const enumerable = typeof value !== 'string';
-      super(enumerable ? `${String(value)} (see error.payload)` : value);
-      Object.defineProperty(this, 'payload', { value, enumerable });
+  taskCreation: {
+    parentTask = getCurrentTask(0)?.task;
+    if (!parentTask) {
+      createTask();
+      break taskCreation;
+    }
+    
+    createTask();
+    
+    if (hostProvided) {
+      subtask = parentTask.getLatestSubtask();
+      if (!subtask) {
+        throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
+      }
+      task.setParentSubtask(subtask);
     }
   }
   
-  function getErrorPayload(e) {
-    if (e && hasOwnProperty.call(e, 'payload')) return e.payload;
-    if (e instanceof Error) throw e;
-    return e;
+  const started = task.enterSync();
+  let ret = _withGlobalCurrentTaskMeta({
+    componentIdx: task.componentIdx(),
+    taskID: task.id(),
+    fn: () => getStderr()
+  })
+  ;
+  if (!(ret instanceof OutputStream)) {
+    throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
   }
-  
-  function throwUninitialized() {
-    throw new TypeError('Wasm uninitialized use `await $init` first');
+  var handle0 = ret[symbolRscHandle];
+  if (!handle0) {
+    const rep = ret[symbolRscRep] || ++captureCnt2;
+    captureTable2.set(rep, ret);
+    handle0 = rscTableCreateOwn(handleTable2, rep);
   }
+  _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"][Instruction::Return]', {
+    funcName: 'get-stderr',
+    paramCount: 1,
+    async: false,
+    postReturn: false
+  });
+  task.resolve([handle0]);
+  task.exit();
+  return handle0;
+}
+_trampoline5.fnName = 'wasi:cli/stderr@0.2.3#getStderr';
+const handleTable1 = [T_FLAG, 0];
+const captureTable1= new Map();
+let captureCnt1 = 0;
+handleTables[1] = handleTable1;
+
+const _trampoline8 = function() {
+  _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"] [Instruction::CallInterface] (sync, @ enter)');
+  let hostProvided = true;
   
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  
-  const instantiateCore = WebAssembly.instantiate;
-  
+  let parentTask;
+  let task;
+  let subtask;
   
-  let exports0;
-  let exports1;
-  const handleTable2 = [T_FLAG, 0];
-  const captureTable2= new Map();
-  let captureCnt2 = 0;
-  handleTables[2] = handleTable2;
+  const createTask = () => {
+    const results = createNewCurrentTask({
+      componentIdx: -1, // 0,
+      isAsync: false,
+      entryFnName: 'getStdin',
+      getCallbackFn: () => null,
+      callbackFnName: 'null',
+      errHandling: 'none',
+      callingWasmExport: false,
+    });
+    task = results[0];
+  };
   
-  const _trampoline5 = function() {
-    _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"] [Instruction::CallInterface] (sync, @ enter)');
-    let hostProvided = true;
-    
-    let parentTask;
-    let task;
-    let subtask;
+  taskCreation: {
+    parentTask = getCurrentTask(0)?.task;
+    if (!parentTask) {
+      createTask();
+      break taskCreation;
+    }
     
-    const createTask = () => {
-      const results = createNewCurrentTask({
-        componentIdx: -1, // 0,
-        isAsync: false,
-        entryFnName: 'getStderr',
-        getCallbackFn: () => null,
-        callbackFnName: 'null',
-        errHandling: 'none',
-        callingWasmExport: false,
-      });
-      task = results[0];
-    };
+    createTask();
     
-    taskCreation: {
-      parentTask = getCurrentTask(0)?.task;
-      if (!parentTask) {
-        createTask();
-        break taskCreation;
+    if (hostProvided) {
+      subtask = parentTask.getLatestSubtask();
+      if (!subtask) {
+        throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
       }
-      
+      task.setParentSubtask(subtask);
+    }
+  }
+  
+  const started = task.enterSync();
+  let ret = _withGlobalCurrentTaskMeta({
+    componentIdx: task.componentIdx(),
+    taskID: task.id(),
+    fn: () => getStdin()
+  })
+  ;
+  if (!(ret instanceof InputStream)) {
+    throw new TypeError('Resource error: Not a valid "InputStream" resource.');
+  }
+  var handle0 = ret[symbolRscHandle];
+  if (!handle0) {
+    const rep = ret[symbolRscRep] || ++captureCnt1;
+    captureTable1.set(rep, ret);
+    handle0 = rscTableCreateOwn(handleTable1, rep);
+  }
+  _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"][Instruction::Return]', {
+    funcName: 'get-stdin',
+    paramCount: 1,
+    async: false,
+    postReturn: false
+  });
+  task.resolve([handle0]);
+  task.exit();
+  return handle0;
+}
+_trampoline8.fnName = 'wasi:cli/stdin@0.2.3#getStdin';
+
+const _trampoline9 = function() {
+  _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"] [Instruction::CallInterface] (sync, @ enter)');
+  let hostProvided = true;
+  
+  let parentTask;
+  let task;
+  let subtask;
+  
+  const createTask = () => {
+    const results = createNewCurrentTask({
+      componentIdx: -1, // 0,
+      isAsync: false,
+      entryFnName: 'getStdout',
+      getCallbackFn: () => null,
+      callbackFnName: 'null',
+      errHandling: 'none',
+      callingWasmExport: false,
+    });
+    task = results[0];
+  };
+  
+  taskCreation: {
+    parentTask = getCurrentTask(0)?.task;
+    if (!parentTask) {
       createTask();
-      
-      if (hostProvided) {
-        subtask = parentTask.getLatestSubtask();
-        if (!subtask) {
-          throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
-        }
-        task.setParentSubtask(subtask);
-      }
+      break taskCreation;
     }
     
-    const started = task.enterSync();
-    let ret = _withGlobalCurrentTaskMeta({
-      componentIdx: task.componentIdx(),
-      taskID: task.id(),
-      fn: () => getStderr()
-    })
-    ;
-    if (!(ret instanceof OutputStream)) {
-      throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+    createTask();
+    
+    if (hostProvided) {
+      subtask = parentTask.getLatestSubtask();
+      if (!subtask) {
+        throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
+      }
+      task.setParentSubtask(subtask);
     }
-    var handle0 = ret[symbolRscHandle];
-    if (!handle0) {
-      const rep = ret[symbolRscRep] || ++captureCnt2;
-      captureTable2.set(rep, ret);
-      handle0 = rscTableCreateOwn(handleTable2, rep);
-    }
-    _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"][Instruction::Return]', {
-      funcName: 'get-stderr',
-      paramCount: 1,
-      async: false,
-      postReturn: false
+  }
+  
+  const started = task.enterSync();
+  let ret = _withGlobalCurrentTaskMeta({
+    componentIdx: task.componentIdx(),
+    taskID: task.id(),
+    fn: () => getStdout()
+  })
+  ;
+  if (!(ret instanceof OutputStream)) {
+    throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+  }
+  var handle0 = ret[symbolRscHandle];
+  if (!handle0) {
+    const rep = ret[symbolRscRep] || ++captureCnt2;
+    captureTable2.set(rep, ret);
+    handle0 = rscTableCreateOwn(handleTable2, rep);
+  }
+  _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"][Instruction::Return]', {
+    funcName: 'get-stdout',
+    paramCount: 1,
+    async: false,
+    postReturn: false
+  });
+  task.resolve([handle0]);
+  task.exit();
+  return handle0;
+}
+_trampoline9.fnName = 'wasi:cli/stdout@0.2.3#getStdout';
+
+const _trampoline10 = function(arg0) {
+  let variant0;
+  switch (arg0) {
+    case 0: {
+      variant0= {
+        tag: 'ok',
+        val: undefined
+      };
+      break;
+    }
+    case 1: {
+      variant0= {
+        tag: 'err',
+        val: undefined
+      };
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant discriminant for expected');
+    }
+  }
+  _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"] [Instruction::CallInterface] (sync, @ enter)');
+  let hostProvided = true;
+  
+  let parentTask;
+  let task;
+  let subtask;
+  
+  const createTask = () => {
+    const results = createNewCurrentTask({
+      componentIdx: -1, // 0,
+      isAsync: false,
+      entryFnName: 'exit',
+      getCallbackFn: () => null,
+      callbackFnName: 'null',
+      errHandling: 'none',
+      callingWasmExport: false,
     });
-    task.resolve([handle0]);
-    task.exit();
-    return handle0;
-  }
-  _trampoline5.fnName = 'wasi:cli/stderr@0.2.3#getStderr';
-  const handleTable1 = [T_FLAG, 0];
-  const captureTable1= new Map();
-  let captureCnt1 = 0;
-  handleTables[1] = handleTable1;
-  
-  const _trampoline8 = function() {
-    _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"] [Instruction::CallInterface] (sync, @ enter)');
-    let hostProvided = true;
-    
-    let parentTask;
-    let task;
-    let subtask;
-    
-    const createTask = () => {
-      const results = createNewCurrentTask({
-        componentIdx: -1, // 0,
-        isAsync: false,
-        entryFnName: 'getStdin',
-        getCallbackFn: () => null,
-        callbackFnName: 'null',
-        errHandling: 'none',
-        callingWasmExport: false,
-      });
-      task = results[0];
-    };
+    task = results[0];
+  };
+  
+  taskCreation: {
+    parentTask = getCurrentTask(0)?.task;
+    if (!parentTask) {
+      createTask();
+      break taskCreation;
+    }
+    
+    createTask();
     
-    taskCreation: {
-      parentTask = getCurrentTask(0)?.task;
-      if (!parentTask) {
-        createTask();
-        break taskCreation;
+    if (hostProvided) {
+      subtask = parentTask.getLatestSubtask();
+      if (!subtask) {
+        throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
       }
-      
+      task.setParentSubtask(subtask);
+    }
+  }
+  
+  const started = task.enterSync();
+  let ret;_withGlobalCurrentTaskMeta({
+    componentIdx: task.componentIdx(),
+    taskID: task.id(),
+    fn: () => exit(variant0)
+  })
+  ;
+  _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"][Instruction::Return]', {
+    funcName: 'exit',
+    paramCount: 0,
+    async: false,
+    postReturn: false
+  });
+  task.resolve([ret]);
+  task.exit();
+}
+_trampoline10.fnName = 'wasi:cli/exit@0.2.3#exit';
+let exports2;
+let memory0;
+let realloc0;
+let realloc0Async;
+
+const _trampoline11 = function(arg0) {
+  _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"] [Instruction::CallInterface] (sync, @ enter)');
+  let hostProvided = true;
+  
+  let parentTask;
+  let task;
+  let subtask;
+  
+  const createTask = () => {
+    const results = createNewCurrentTask({
+      componentIdx: -1, // 0,
+      isAsync: false,
+      entryFnName: 'getEnvironment',
+      getCallbackFn: () => null,
+      callbackFnName: 'null',
+      errHandling: 'none',
+      callingWasmExport: false,
+    });
+    task = results[0];
+  };
+  
+  taskCreation: {
+    parentTask = getCurrentTask(0)?.task;
+    if (!parentTask) {
       createTask();
-      
-      if (hostProvided) {
-        subtask = parentTask.getLatestSubtask();
-        if (!subtask) {
-          throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
-        }
-        task.setParentSubtask(subtask);
+      break taskCreation;
+    }
+    
+    createTask();
+    
+    if (hostProvided) {
+      subtask = parentTask.getLatestSubtask();
+      if (!subtask) {
+        throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
       }
+      task.setParentSubtask(subtask);
     }
+  }
+  
+  const started = task.enterSync();
+  let ret = _withGlobalCurrentTaskMeta({
+    componentIdx: task.componentIdx(),
+    taskID: task.id(),
+    fn: () => getEnvironment()
+  })
+  ;
+  var vec3 = ret;
+  var len3 = vec3.length;
+  var result3 = realloc0(0, 0, 4, len3 * 16);
+  for (let i = 0; i < vec3.length; i++) {
+    const e = vec3[i];
+    const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
+    
+    var encodeRes = _utf8AllocateAndEncode(tuple0_0, realloc0, memory0);
+    var ptr1= encodeRes.ptr;
+    var len1 = encodeRes.len;
+    
+    dataView(memory0).setUint32(base + 4, len1, true);
+    dataView(memory0).setUint32(base + 0, ptr1, true);
+    
+    var encodeRes = _utf8AllocateAndEncode(tuple0_1, realloc0, memory0);
+    var ptr2= encodeRes.ptr;
+    var len2 = encodeRes.len;
     
-    const started = task.enterSync();
-    let ret = _withGlobalCurrentTaskMeta({
+    dataView(memory0).setUint32(base + 12, len2, true);
+    dataView(memory0).setUint32(base + 8, ptr2, true);
+  }
+  dataView(memory0).setUint32(arg0 + 4, len3, true);
+  dataView(memory0).setUint32(arg0 + 0, result3, true);
+  _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"][Instruction::Return]', {
+    funcName: 'get-environment',
+    paramCount: 0,
+    async: false,
+    postReturn: false
+  });
+  task.resolve([ret]);
+  task.exit();
+}
+_trampoline11.fnName = 'wasi:cli/environment@0.2.3#getEnvironment';
+const handleTable6 = [T_FLAG, 0];
+const captureTable6= new Map();
+let captureCnt6 = 0;
+handleTables[6] = handleTable6;
+
+const _trampoline12 = function(arg0, arg1) {
+  var handle1 = arg0;
+  
+  var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
+  var rsc0 = captureTable6.get(rep2);
+  if (!rsc0) {
+    rsc0 = Object.create(Descriptor.prototype);
+    Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
+    Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
+  }
+  
+  curResourceBorrows.push(rsc0);
+  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-flags"] [Instruction::CallInterface] (sync, @ enter)');
+  let hostProvided = true;
+  
+  let parentTask;
+  let task;
+  let subtask;
+  
+  const createTask = () => {
+    const results = createNewCurrentTask({
+      componentIdx: -1, // 0,
+      isAsync: false,
+      entryFnName: 'getFlags',
+      getCallbackFn: () => null,
+      callbackFnName: 'null',
+      errHandling: 'result-catch-handler',
+      callingWasmExport: false,
+    });
+    task = results[0];
+  };
+  
+  taskCreation: {
+    parentTask = getCurrentTask(0)?.task;
+    if (!parentTask) {
+      createTask();
+      break taskCreation;
+    }
+    
+    createTask();
+    
+    if (hostProvided) {
+      subtask = parentTask.getLatestSubtask();
+      if (!subtask) {
+        throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
+      }
+      task.setParentSubtask(subtask);
+    }
+  }
+  
+  const started = task.enterSync();
+  
+  let ret;
+  try {
+    ret = { tag: 'ok', val: _withGlobalCurrentTaskMeta({
       componentIdx: task.componentIdx(),
       taskID: task.id(),
-      fn: () => getStdin()
+      fn: () => rsc0.getFlags()
     })
-    ;
-    if (!(ret instanceof InputStream)) {
-      throw new TypeError('Resource error: Not a valid "InputStream" resource.');
+  };
+} catch (e) {
+  ret = { tag: 'err', val: getErrorPayload(e) };
+}
+
+for (const rsc of curResourceBorrows) {
+  rsc[symbolRscHandle] = undefined;
+}
+curResourceBorrows = [];
+var variant5 = ret;
+switch (variant5.tag) {
+  case 'ok': {
+    const e = variant5.val;
+    dataView(memory0).setInt8(arg1 + 0, 0, true);
+    let flags3 = 0;
+    if (typeof e === 'object' && e !== null) {
+      flags3 = Boolean(e.read) << 0 | Boolean(e.write) << 1 | Boolean(e.fileIntegritySync) << 2 | Boolean(e.dataIntegritySync) << 3 | Boolean(e.requestedWriteSync) << 4 | Boolean(e.mutateDirectory) << 5;
+    } else if (e !== null && e!== undefined) {
+      throw new TypeError('only an object, undefined or null can be converted to flags');
     }
-    var handle0 = ret[symbolRscHandle];
-    if (!handle0) {
-      const rep = ret[symbolRscRep] || ++captureCnt1;
-      captureTable1.set(rep, ret);
-      handle0 = rscTableCreateOwn(handleTable1, rep);
-    }
-    _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"][Instruction::Return]', {
-      funcName: 'get-stdin',
-      paramCount: 1,
-      async: false,
-      postReturn: false
-    });
-    task.resolve([handle0]);
-    task.exit();
-    return handle0;
-  }
-  _trampoline8.fnName = 'wasi:cli/stdin@0.2.3#getStdin';
-  
-  const _trampoline9 = function() {
-    _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"] [Instruction::CallInterface] (sync, @ enter)');
-    let hostProvided = true;
-    
-    let parentTask;
-    let task;
-    let subtask;
-    
-    const createTask = () => {
-      const results = createNewCurrentTask({
-        componentIdx: -1, // 0,
-        isAsync: false,
-        entryFnName: 'getStdout',
-        getCallbackFn: () => null,
-        callbackFnName: 'null',
-        errHandling: 'none',
-        callingWasmExport: false,
-      });
-      task = results[0];
-    };
+    dataView(memory0).setInt8(arg1 + 1, flags3, true);
     
-    taskCreation: {
-      parentTask = getCurrentTask(0)?.task;
-      if (!parentTask) {
-        createTask();
-        break taskCreation;
+    break;
+  }
+  case 'err': {
+    const e = variant5.val;
+    dataView(memory0).setInt8(arg1 + 0, 1, true);
+    var val4 = e;
+    let enum4;
+    switch (val4) {
+      case 'access': {
+        enum4 = 0;
+        break;
+      }
+      case 'would-block': {
+        enum4 = 1;
+        break;
+      }
+      case 'already': {
+        enum4 = 2;
+        break;
+      }
+      case 'bad-descriptor': {
+        enum4 = 3;
+        break;
+      }
+      case 'busy': {
+        enum4 = 4;
+        break;
+      }
+      case 'deadlock': {
+        enum4 = 5;
+        break;
+      }
+      case 'quota': {
+        enum4 = 6;
+        break;
+      }
+      case 'exist': {
+        enum4 = 7;
+        break;
+      }
+      case 'file-too-large': {
+        enum4 = 8;
+        break;
+      }
+      case 'illegal-byte-sequence': {
+        enum4 = 9;
+        break;
+      }
+      case 'in-progress': {
+        enum4 = 10;
+        break;
+      }
+      case 'interrupted': {
+        enum4 = 11;
+        break;
+      }
+      case 'invalid': {
+        enum4 = 12;
+        break;
+      }
+      case 'io': {
+        enum4 = 13;
+        break;
+      }
+      case 'is-directory': {
+        enum4 = 14;
+        break;
+      }
+      case 'loop': {
+        enum4 = 15;
+        break;
+      }
+      case 'too-many-links': {
+        enum4 = 16;
+        break;
+      }
+      case 'message-size': {
+        enum4 = 17;
+        break;
+      }
+      case 'name-too-long': {
+        enum4 = 18;
+        break;
+      }
+      case 'no-device': {
+        enum4 = 19;
+        break;
+      }
+      case 'no-entry': {
+        enum4 = 20;
+        break;
+      }
+      case 'no-lock': {
+        enum4 = 21;
+        break;
+      }
+      case 'insufficient-memory': {
+        enum4 = 22;
+        break;
+      }
+      case 'insufficient-space': {
+        enum4 = 23;
+        break;
+      }
+      case 'not-directory': {
+        enum4 = 24;
+        break;
       }
-      
-      createTask();
-      
-      if (hostProvided) {
-        subtask = parentTask.getLatestSubtask();
-        if (!subtask) {
-          throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
-        }
-        task.setParentSubtask(subtask);
+      case 'not-empty': {
+        enum4 = 25;
+        break;
       }
-    }
-    
-    const started = task.enterSync();
-    let ret = _withGlobalCurrentTaskMeta({
-      componentIdx: task.componentIdx(),
-      taskID: task.id(),
-      fn: () => getStdout()
-    })
-    ;
-    if (!(ret instanceof OutputStream)) {
-      throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
-    }
-    var handle0 = ret[symbolRscHandle];
-    if (!handle0) {
-      const rep = ret[symbolRscRep] || ++captureCnt2;
-      captureTable2.set(rep, ret);
-      handle0 = rscTableCreateOwn(handleTable2, rep);
-    }
-    _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"][Instruction::Return]', {
-      funcName: 'get-stdout',
-      paramCount: 1,
-      async: false,
-      postReturn: false
-    });
-    task.resolve([handle0]);
-    task.exit();
-    return handle0;
-  }
-  _trampoline9.fnName = 'wasi:cli/stdout@0.2.3#getStdout';
-  
-  const _trampoline10 = function(arg0) {
-    let variant0;
-    switch (arg0) {
-      case 0: {
-        variant0= {
-          tag: 'ok',
-          val: undefined
-        };
+      case 'not-recoverable': {
+        enum4 = 26;
         break;
       }
-      case 1: {
-        variant0= {
-          tag: 'err',
-          val: undefined
-        };
+      case 'unsupported': {
+        enum4 = 27;
         break;
       }
-      default: {
-        throw new TypeError('invalid variant discriminant for expected');
+      case 'no-tty': {
+        enum4 = 28;
+        break;
       }
-    }
-    _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"] [Instruction::CallInterface] (sync, @ enter)');
-    let hostProvided = true;
-    
-    let parentTask;
-    let task;
-    let subtask;
-    
-    const createTask = () => {
-      const results = createNewCurrentTask({
-        componentIdx: -1, // 0,
-        isAsync: false,
-        entryFnName: 'exit',
-        getCallbackFn: () => null,
-        callbackFnName: 'null',
-        errHandling: 'none',
-        callingWasmExport: false,
-      });
-      task = results[0];
-    };
-    
-    taskCreation: {
-      parentTask = getCurrentTask(0)?.task;
-      if (!parentTask) {
-        createTask();
-        break taskCreation;
+      case 'no-such-device': {
+        enum4 = 29;
+        break;
       }
-      
-      createTask();
-      
-      if (hostProvided) {
-        subtask = parentTask.getLatestSubtask();
-        if (!subtask) {
-          throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
-        }
-        task.setParentSubtask(subtask);
+      case 'overflow': {
+        enum4 = 30;
+        break;
       }
-    }
-    
-    const started = task.enterSync();
-    let ret;_withGlobalCurrentTaskMeta({
-      componentIdx: task.componentIdx(),
-      taskID: task.id(),
-      fn: () => exit(variant0)
-    })
-    ;
-    _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"][Instruction::Return]', {
-      funcName: 'exit',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-    task.resolve([ret]);
-    task.exit();
-  }
-  _trampoline10.fnName = 'wasi:cli/exit@0.2.3#exit';
-  let exports2;
-  let memory0;
-  let realloc0;
-  let realloc0Async;
-  
-  const _trampoline11 = function(arg0) {
-    _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"] [Instruction::CallInterface] (sync, @ enter)');
-    let hostProvided = true;
-    
-    let parentTask;
-    let task;
-    let subtask;
-    
-    const createTask = () => {
-      const results = createNewCurrentTask({
-        componentIdx: -1, // 0,
-        isAsync: false,
-        entryFnName: 'getEnvironment',
-        getCallbackFn: () => null,
-        callbackFnName: 'null',
-        errHandling: 'none',
-        callingWasmExport: false,
-      });
-      task = results[0];
-    };
-    
-    taskCreation: {
-      parentTask = getCurrentTask(0)?.task;
-      if (!parentTask) {
-        createTask();
-        break taskCreation;
+      case 'not-permitted': {
+        enum4 = 31;
+        break;
       }
-      
-      createTask();
-      
-      if (hostProvided) {
-        subtask = parentTask.getLatestSubtask();
-        if (!subtask) {
-          throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
-        }
-        task.setParentSubtask(subtask);
+      case 'pipe': {
+        enum4 = 32;
+        break;
       }
-    }
-    
-    const started = task.enterSync();
-    let ret = _withGlobalCurrentTaskMeta({
-      componentIdx: task.componentIdx(),
-      taskID: task.id(),
-      fn: () => getEnvironment()
-    })
-    ;
-    var vec3 = ret;
-    var len3 = vec3.length;
-    var result3 = realloc0(0, 0, 4, len3 * 16);
-    for (let i = 0; i < vec3.length; i++) {
-      const e = vec3[i];
-      const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
-      
-      var encodeRes = _utf8AllocateAndEncode(tuple0_0, realloc0, memory0);
-      var ptr1= encodeRes.ptr;
-      var len1 = encodeRes.len;
-      
-      dataView(memory0).setUint32(base + 4, len1, true);
-      dataView(memory0).setUint32(base + 0, ptr1, true);
-      
-      var encodeRes = _utf8AllocateAndEncode(tuple0_1, realloc0, memory0);
-      var ptr2= encodeRes.ptr;
-      var len2 = encodeRes.len;
-      
-      dataView(memory0).setUint32(base + 12, len2, true);
-      dataView(memory0).setUint32(base + 8, ptr2, true);
-    }
-    dataView(memory0).setUint32(arg0 + 4, len3, true);
-    dataView(memory0).setUint32(arg0 + 0, result3, true);
-    _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"][Instruction::Return]', {
-      funcName: 'get-environment',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-    task.resolve([ret]);
-    task.exit();
-  }
-  _trampoline11.fnName = 'wasi:cli/environment@0.2.3#getEnvironment';
-  const handleTable6 = [T_FLAG, 0];
-  const captureTable6= new Map();
-  let captureCnt6 = 0;
-  handleTables[6] = handleTable6;
-  
-  const _trampoline12 = function(arg0, arg1) {
-    var handle1 = arg0;
-    
-    var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable6.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(Descriptor.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    
-    curResourceBorrows.push(rsc0);
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-flags"] [Instruction::CallInterface] (sync, @ enter)');
-    let hostProvided = true;
-    
-    let parentTask;
-    let task;
-    let subtask;
-    
-    const createTask = () => {
-      const results = createNewCurrentTask({
-        componentIdx: -1, // 0,
-        isAsync: false,
-        entryFnName: 'getFlags',
-        getCallbackFn: () => null,
-        callbackFnName: 'null',
-        errHandling: 'result-catch-handler',
-        callingWasmExport: false,
-      });
-      task = results[0];
-    };
-    
-    taskCreation: {
-      parentTask = getCurrentTask(0)?.task;
-      if (!parentTask) {
-        createTask();
-        break taskCreation;
+      case 'read-only': {
+        enum4 = 33;
+        break;
       }
-      
-      createTask();
-      
-      if (hostProvided) {
-        subtask = parentTask.getLatestSubtask();
-        if (!subtask) {
-          throw new Error(`Missing subtask (in parent task [${parentTask.id()}]) for host import, has the import been lowered? (ensure asyncImports are set properly)`);
+      case 'invalid-seek': {
+        enum4 = 34;
+        break;
+      }
+      case 'text-file-busy': {
+        enum4 = 35;
+        break;
+      }
+      case 'cross-device': {
+        enum4 = 36;
+        break;
+      }
+      default: {
+        if ((e) instanceof Error) {
+          console.error(e);
         }
-        task.setParentSubtask(subtask);
+        
+        throw new TypeError(`"${val4}" is not one of the cases of error-code`);
       }
     }
+    dataView(memory0).setInt8(arg1 + 1, enum4, true);
     
-    const started = task.enterSync();
-    
-    let ret;
-    try {
-      ret = { tag: 'ok', val: _withGlobalCurrentTaskMeta({
-        componentIdx: task.componentIdx(),
-        taskID: task.id(),
-        fn: () => rsc0.getFlags()
-      })
-    };
-  } catch (e) {
-    ret = { tag: 'err', val: getErrorPayload(e) };
-  }
-  
-  for (const rsc of curResourceBorrows) {
-    rsc[symbolRscHandle] = undefined;
+    break;
   }
-  curResourceBorrows = [];
-  var variant5 = ret;
-  switch (variant5.tag) {
-    case 'ok': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 0, true);
-      let flags3 = 0;
-      if (typeof e === 'object' && e !== null) {
-        flags3 = Boolean(e.read) << 0 | Boolean(e.write) << 1 | Boolean(e.fileIntegritySync) << 2 | Boolean(e.dataIntegritySync) << 3 | Boolean(e.requestedWriteSync) << 4 | Boolean(e.mutateDirectory) << 5;
-      } else if (e !== null && e!== undefined) {
-        throw new TypeError('only an object, undefined or null can be converted to flags');
-      }
-      dataView(memory0).setInt8(arg1 + 1, flags3, true);
-      break;
-    }
-    case 'err': {
-      const e = variant5.val;
-      dataView(memory0).setInt8(arg1 + 0, 1, true);
-      var val4 = e;
-      let enum4;
-      switch (val4) {
-        case 'access': {
-          enum4 = 0;
-          break;
-        }
-        case 'would-block': {
-          enum4 = 1;
-          break;
-        }
-        case 'already': {
-          enum4 = 2;
-          break;
-        }
-        case 'bad-descriptor': {
-          enum4 = 3;
-          break;
-        }
-        case 'busy': {
-          enum4 = 4;
-          break;
-        }
-        case 'deadlock': {
-          enum4 = 5;
-          break;
-        }
-        case 'quota': {
-          enum4 = 6;
-          break;
-        }
-        case 'exist': {
-          enum4 = 7;
-          break;
-        }
-        case 'file-too-large': {
-          enum4 = 8;
-          break;
-        }
-        case 'illegal-byte-sequence': {
-          enum4 = 9;
-          break;
-        }
-        case 'in-progress': {
-          enum4 = 10;
-          break;
-        }
-        case 'interrupted': {
-          enum4 = 11;
-          break;
-        }
-        case 'invalid': {
-          enum4 = 12;
-          break;
-        }
-        case 'io': {
-          enum4 = 13;
-          break;
-        }
-        case 'is-directory': {
-          enum4 = 14;
-          break;
-        }
-        case 'loop': {
-          enum4 = 15;
-          break;
-        }
-        case 'too-many-links': {
-          enum4 = 16;
-          break;
-        }
-        case 'message-size': {
-          enum4 = 17;
-          break;
-        }
-        case 'name-too-long': {
-          enum4 = 18;
-          break;
-        }
-        case 'no-device': {
-          enum4 = 19;
-          break;
-        }
-        case 'no-entry': {
-          enum4 = 20;
-          break;
-        }
-        case 'no-lock': {
-          enum4 = 21;
-          break;
-        }
-        case 'insufficient-memory': {
-          enum4 = 22;
-          break;
-        }
-        case 'insufficient-space': {
-          enum4 = 23;
-          break;
-        }
-        case 'not-directory': {
-          enum4 = 24;
-          break;
-        }
-        case 'not-empty': {
-          enum4 = 25;
-          break;
-        }
-        case 'not-recoverable': {
-          enum4 = 26;
-          break;
-        }
-        case 'unsupported': {
-          enum4 = 27;
-          break;
-        }
-        case 'no-tty': {
-          enum4 = 28;
-          break;
-        }
-        case 'no-such-device': {
-          enum4 = 29;
-          break;
-        }
-        case 'overflow': {
-          enum4 = 30;
-          break;
-        }
-        case 'not-permitted': {
-          enum4 = 31;
-          break;
-        }
-        case 'pipe': {
-          enum4 = 32;
-          break;
-        }
-        case 'read-only': {
-          enum4 = 33;
-          break;
-        }
-        case 'invalid-seek': {
-          enum4 = 34;
-          break;
-        }
-        case 'text-file-busy': {
-          enum4 = 35;
-          break;
-        }
-        case 'cross-device': {
-          enum4 = 36;
-          break;
-        }
-        default: {
-          if ((e) instanceof Error) {
-            console.error(e);
-          }
-          
-          throw new TypeError(`"${val4}" is not one of the cases of error-code`);
-        }
-      }
-      dataView(memory0).setInt8(arg1 + 1, enum4, true);
-      break;
-    }
-    default: {
-      throw new TypeError('invalid variant specified for result');
-    }
+  default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
+    throw new TypeError('invalid variant specified for result');
   }
-  _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-flags"][Instruction::Return]', {
-    funcName: '[method]descriptor.get-flags',
-    paramCount: 0,
-    async: false,
-    postReturn: false
-  });
-  task.resolve([ret]);
-  task.exit();
+}
+_debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-flags"][Instruction::Return]', {
+  funcName: '[method]descriptor.get-flags',
+  paramCount: 0,
+  async: false,
+  postReturn: false
+});
+task.resolve([ret]);
+task.exit();
 }
 _trampoline12.fnName = 'wasi:filesystem/types@0.2.3#getFlags';
 
@@ -3954,6 +4075,7 @@ switch (variant5.tag) {
       }
     }
     dataView(memory0).setInt8(arg1 + 1, enum3, true);
+    
     break;
   }
   case 'err': {
@@ -4119,9 +4241,11 @@ switch (variant5.tag) {
       }
     }
     dataView(memory0).setInt8(arg1 + 1, enum4, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -4212,6 +4336,7 @@ switch (variant5.tag) {
     var {lower: v3_0, upper: v3_1 } = e;
     dataView(memory0).setBigInt64(arg1 + 8, toUint64(v3_0), true);
     dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
+    
     break;
   }
   case 'err': {
@@ -4377,9 +4502,11 @@ switch (variant5.tag) {
       }
     }
     dataView(memory0).setInt8(arg1 + 8, enum4, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -4722,6 +4849,7 @@ switch (variant7.tag) {
     var {lower: v5_0, upper: v5_1 } = e;
     dataView(memory0).setBigInt64(arg4 + 8, toUint64(v5_0), true);
     dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
+    
     break;
   }
   case 'err': {
@@ -4887,9 +5015,11 @@ switch (variant7.tag) {
       }
     }
     dataView(memory0).setInt8(arg4 + 8, enum6, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant7, valueType: typeof variant7});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -4987,6 +5117,7 @@ switch (variant5.tag) {
       handle3 = rscTableCreateOwn(handleTable1, rep);
     }
     dataView(memory0).setInt32(arg2 + 4, handle3, true);
+    
     break;
   }
   case 'err': {
@@ -5152,9 +5283,11 @@ switch (variant5.tag) {
       }
     }
     dataView(memory0).setInt8(arg2 + 4, enum4, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -5252,6 +5385,7 @@ switch (variant5.tag) {
       handle3 = rscTableCreateOwn(handleTable2, rep);
     }
     dataView(memory0).setInt32(arg2 + 4, handle3, true);
+    
     break;
   }
   case 'err': {
@@ -5417,9 +5551,11 @@ switch (variant5.tag) {
       }
     }
     dataView(memory0).setInt8(arg2 + 4, enum4, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -5517,6 +5653,7 @@ switch (variant5.tag) {
       handle3 = rscTableCreateOwn(handleTable2, rep);
     }
     dataView(memory0).setInt32(arg1 + 4, handle3, true);
+    
     break;
   }
   case 'err': {
@@ -5682,9 +5819,11 @@ switch (variant5.tag) {
       }
     }
     dataView(memory0).setInt8(arg1 + 4, enum4, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -5786,6 +5925,7 @@ switch (variant5.tag) {
       handle3 = rscTableCreateOwn(handleTable5, rep);
     }
     dataView(memory0).setInt32(arg1 + 4, handle3, true);
+    
     break;
   }
   case 'err': {
@@ -5951,9 +6091,11 @@ switch (variant5.tag) {
       }
     }
     dataView(memory0).setInt8(arg1 + 4, enum4, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -6118,6 +6260,7 @@ switch (variant12.tag) {
       dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
       dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
     }
+    
     break;
   }
   case 'err': {
@@ -6283,9 +6426,11 @@ switch (variant12.tag) {
       }
     }
     dataView(memory0).setInt8(arg1 + 8, enum11, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant12, valueType: typeof variant12});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -6459,6 +6604,7 @@ switch (variant14.tag) {
       dataView(memory0).setBigInt64(arg4 + 88, toUint64(v11_0), true);
       dataView(memory0).setInt32(arg4 + 96, toUint32(v11_1), true);
     }
+    
     break;
   }
   case 'err': {
@@ -6624,9 +6770,11 @@ switch (variant14.tag) {
       }
     }
     dataView(memory0).setInt8(arg4 + 8, enum13, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant14, valueType: typeof variant14});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -6753,6 +6901,7 @@ switch (variant9.tag) {
       handle7 = rscTableCreateOwn(handleTable6, rep);
     }
     dataView(memory0).setInt32(arg6 + 4, handle7, true);
+    
     break;
   }
   case 'err': {
@@ -6918,9 +7067,11 @@ switch (variant9.tag) {
       }
     }
     dataView(memory0).setInt8(arg6 + 4, enum8, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant9, valueType: typeof variant9});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -7067,6 +7218,7 @@ switch (variant8.tag) {
       dataView(memory0).setUint32(arg1 + 16, len5, true);
       dataView(memory0).setUint32(arg1 + 12, ptr5, true);
     }
+    
     break;
   }
   case 'err': {
@@ -7232,9 +7384,11 @@ switch (variant8.tag) {
       }
     }
     dataView(memory0).setInt8(arg1 + 4, enum7, true);
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant8, valueType: typeof variant8});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -7323,7 +7477,7 @@ switch (variant6.tag) {
     const e = variant6.val;
     dataView(memory0).setInt8(arg2 + 0, 0, true);
     var val3 = e;
-    var len3 = val3.byteLength;
+    var len3 = Array.isArray(val3) ? val3.length : val3.byteLength;
     var ptr3 = realloc0(0, 0, 1, len3 * 1);
     
     let valData3;
@@ -7345,6 +7499,7 @@ switch (variant6.tag) {
     
     dataView(memory0).setUint32(arg2 + 8, len3, true);
     dataView(memory0).setUint32(arg2 + 4, ptr3, true);
+    
     break;
   }
   case 'err': {
@@ -7375,9 +7530,11 @@ switch (variant6.tag) {
         throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
       }
     }
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant6, valueType: typeof variant6});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -7466,7 +7623,7 @@ switch (variant6.tag) {
     const e = variant6.val;
     dataView(memory0).setInt8(arg2 + 0, 0, true);
     var val3 = e;
-    var len3 = val3.byteLength;
+    var len3 = Array.isArray(val3) ? val3.length : val3.byteLength;
     var ptr3 = realloc0(0, 0, 1, len3 * 1);
     
     let valData3;
@@ -7488,6 +7645,7 @@ switch (variant6.tag) {
     
     dataView(memory0).setUint32(arg2 + 8, len3, true);
     dataView(memory0).setUint32(arg2 + 4, ptr3, true);
+    
     break;
   }
   case 'err': {
@@ -7518,9 +7676,11 @@ switch (variant6.tag) {
         throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
       }
     }
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant6, valueType: typeof variant6});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -7609,6 +7769,7 @@ switch (variant5.tag) {
     const e = variant5.val;
     dataView(memory0).setInt8(arg1 + 0, 0, true);
     dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
+    
     break;
   }
   case 'err': {
@@ -7639,9 +7800,11 @@ switch (variant5.tag) {
         throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
       }
     }
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -7732,6 +7895,7 @@ switch (variant6.tag) {
   case 'ok': {
     const e = variant6.val;
     dataView(memory0).setInt8(arg3 + 0, 0, true);
+    
     break;
   }
   case 'err': {
@@ -7762,9 +7926,11 @@ switch (variant6.tag) {
         throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
       }
     }
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant6, valueType: typeof variant6});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -7855,6 +8021,7 @@ switch (variant6.tag) {
   case 'ok': {
     const e = variant6.val;
     dataView(memory0).setInt8(arg3 + 0, 0, true);
+    
     break;
   }
   case 'err': {
@@ -7885,9 +8052,11 @@ switch (variant6.tag) {
         throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
       }
     }
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant6, valueType: typeof variant6});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -7975,6 +8144,7 @@ switch (variant5.tag) {
   case 'ok': {
     const e = variant5.val;
     dataView(memory0).setInt8(arg1 + 0, 0, true);
+    
     break;
   }
   case 'err': {
@@ -8005,9 +8175,11 @@ switch (variant5.tag) {
         throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
       }
     }
+    
     break;
   }
   default: {
+    _debugLog("ERROR: invalid value (expected result as object with 'tag' member)", { value: variant5, valueType: typeof variant5});
     throw new TypeError('invalid variant specified for result');
   }
 }
@@ -8069,7 +8241,7 @@ const _trampoline31 = function(arg0, arg1) {
   })
   ;
   var val0 = ret;
-  var len0 = val0.byteLength;
+  var len0 = Array.isArray(val0) ? val0.length : val0.byteLength;
   var ptr0 = realloc0(0, 0, 1, len0 * 1);
   
   let valData0;
@@ -8852,7 +9024,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline16.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 1),_liftFlatStringUTF8],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags({ names: ['symlink-follow'], size32: 1, align32: 1, intSize: 1 }),_liftFlatStringUTF8],
   resultLowerFns: [_lowerFlatResult([[ 'ok', _lowerFlatRecord.bind(null, [['lower', _lowerFlatU64, 16, 8 ],['upper', _lowerFlatU64, 16, 8 ],]), 24, 8, 8 ],[ 'err', _lowerFlatEnum.bind(null, 0), 24, 8, 8 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -8870,7 +9042,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline16.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 1),_liftFlatStringUTF8],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags({ names: ['symlink-follow'], size32: 1, align32: 1, intSize: 1 }),_liftFlatStringUTF8],
   resultLowerFns: [_lowerFlatResult([[ 'ok', _lowerFlatRecord.bind(null, [['lower', _lowerFlatU64, 16, 8 ],['upper', _lowerFlatU64, 16, 8 ],]), 24, 8, 8 ],[ 'err', _lowerFlatEnum.bind(null, 0), 24, 8, 8 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9074,7 +9246,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline22.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 1),_liftFlatStringUTF8],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags({ names: ['symlink-follow'], size32: 1, align32: 1, intSize: 1 }),_liftFlatStringUTF8],
   resultLowerFns: [_lowerFlatResult([[ 'ok', _lowerFlatRecord.bind(null, [['type', _lowerFlatEnum.bind(null, 1), 96, 8 ],['linkCount', _lowerFlatU64, 96, 8 ],['size', _lowerFlatU64, 96, 8 ],['dataAccessTimestamp', _lowerFlatOption([[ 'some', _lowerFlatRecord.bind(null, [['seconds', _lowerFlatU64, 16, 8 ],['nanoseconds', _lowerFlatU32, 16, 8 ],]), 24, 8, 8 ],[ 'none', null, 24, 8, 8 ],]), 96, 8 ],['dataModificationTimestamp', _lowerFlatOption([[ 'some', _lowerFlatRecord.bind(null, [['seconds', _lowerFlatU64, 16, 8 ],['nanoseconds', _lowerFlatU32, 16, 8 ],]), 24, 8, 8 ],[ 'none', null, 24, 8, 8 ],]), 96, 8 ],['statusChangeTimestamp', _lowerFlatOption([[ 'some', _lowerFlatRecord.bind(null, [['seconds', _lowerFlatU64, 16, 8 ],['nanoseconds', _lowerFlatU32, 16, 8 ],]), 24, 8, 8 ],[ 'none', null, 24, 8, 8 ],]), 96, 8 ],]), 104, 8, 8 ],[ 'err', _lowerFlatEnum.bind(null, 0), 104, 8, 8 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9092,7 +9264,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline22.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 1),_liftFlatStringUTF8],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags({ names: ['symlink-follow'], size32: 1, align32: 1, intSize: 1 }),_liftFlatStringUTF8],
   resultLowerFns: [_lowerFlatResult([[ 'ok', _lowerFlatRecord.bind(null, [['type', _lowerFlatEnum.bind(null, 1), 96, 8 ],['linkCount', _lowerFlatU64, 96, 8 ],['size', _lowerFlatU64, 96, 8 ],['dataAccessTimestamp', _lowerFlatOption([[ 'some', _lowerFlatRecord.bind(null, [['seconds', _lowerFlatU64, 16, 8 ],['nanoseconds', _lowerFlatU32, 16, 8 ],]), 24, 8, 8 ],[ 'none', null, 24, 8, 8 ],]), 96, 8 ],['dataModificationTimestamp', _lowerFlatOption([[ 'some', _lowerFlatRecord.bind(null, [['seconds', _lowerFlatU64, 16, 8 ],['nanoseconds', _lowerFlatU32, 16, 8 ],]), 24, 8, 8 ],[ 'none', null, 24, 8, 8 ],]), 96, 8 ],['statusChangeTimestamp', _lowerFlatOption([[ 'some', _lowerFlatRecord.bind(null, [['seconds', _lowerFlatU64, 16, 8 ],['nanoseconds', _lowerFlatU32, 16, 8 ],]), 24, 8, 8 ],[ 'none', null, 24, 8, 8 ],]), 96, 8 ],]), 104, 8, 8 ],[ 'err', _lowerFlatEnum.bind(null, 0), 104, 8, 8 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9111,7 +9283,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline23.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 1),_liftFlatStringUTF8,_liftFlatFlags.bind(null, 2),_liftFlatFlags.bind(null, 0)],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags({ names: ['symlink-follow'], size32: 1, align32: 1, intSize: 1 }),_liftFlatStringUTF8,_liftFlatFlags({ names: ['create','directory','exclusive','truncate'], size32: 1, align32: 1, intSize: 1 }),_liftFlatFlags({ names: ['read','write','file-integrity-sync','data-integrity-sync','requested-write-sync','mutate-directory'], size32: 1, align32: 1, intSize: 1 })],
   resultLowerFns: [_lowerFlatResult([[ 'ok', _lowerFlatOwn.bind(null, 6), 8, 4, 4 ],[ 'err', _lowerFlatEnum.bind(null, 0), 8, 4, 4 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9129,7 +9301,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline23.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags.bind(null, 1),_liftFlatStringUTF8,_liftFlatFlags.bind(null, 2),_liftFlatFlags.bind(null, 0)],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 6),_liftFlatFlags({ names: ['symlink-follow'], size32: 1, align32: 1, intSize: 1 }),_liftFlatStringUTF8,_liftFlatFlags({ names: ['create','directory','exclusive','truncate'], size32: 1, align32: 1, intSize: 1 }),_liftFlatFlags({ names: ['read','write','file-integrity-sync','data-integrity-sync','requested-write-sync','mutate-directory'], size32: 1, align32: 1, intSize: 1 })],
   resultLowerFns: [_lowerFlatResult([[ 'ok', _lowerFlatOwn.bind(null, 6), 8, 4, 4 ],[ 'err', _lowerFlatEnum.bind(null, 0), 8, 4, 4 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9296,7 +9468,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline28.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList.bind(null, 1)],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList({ elemLiftFn: _liftFlatU8, align32: 1, size32: 1 })],
   resultLowerFns: [_lowerFlatResult([[ 'ok', null, 12, 4, 4 ],[ 'err', _lowerFlatVariant([[ 'last-operation-failed', _lowerFlatOwn.bind(null, 0), 8, 4, 4 ],[ 'closed', null, 8, 4, 4 ],]), 12, 4, 4 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9314,7 +9486,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline28.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList.bind(null, 1)],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList({ elemLiftFn: _liftFlatU8, align32: 1, size32: 1 })],
   resultLowerFns: [_lowerFlatResult([[ 'ok', null, 12, 4, 4 ],[ 'err', _lowerFlatVariant([[ 'last-operation-failed', _lowerFlatOwn.bind(null, 0), 8, 4, 4 ],[ 'closed', null, 8, 4, 4 ],]), 12, 4, 4 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9333,7 +9505,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline29.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList.bind(null, 1)],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList({ elemLiftFn: _liftFlatU8, align32: 1, size32: 1 })],
   resultLowerFns: [_lowerFlatResult([[ 'ok', null, 12, 4, 4 ],[ 'err', _lowerFlatVariant([[ 'last-operation-failed', _lowerFlatOwn.bind(null, 0), 8, 4, 4 ],[ 'closed', null, 8, 4, 4 ],]), 12, 4, 4 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9351,7 +9523,7 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline29.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList.bind(null, 1)],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 2),_liftFlatList({ elemLiftFn: _liftFlatU8, align32: 1, size32: 1 })],
   resultLowerFns: [_lowerFlatResult([[ 'ok', null, 12, 4, 4 ],[ 'err', _lowerFlatVariant([[ 'last-operation-failed', _lowerFlatOwn.bind(null, 0), 8, 4, 4 ],[ 'closed', null, 8, 4, 4 ],]), 12, 4, 4 ],])],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
@@ -9591,7 +9763,7 @@ function generate(arg0, arg1) {
   if (!_initialized) throwUninitialized();
   var ptr0 = realloc1(0, 0, 4, 84);
   var val1 = arg0;
-  var len1 = val1.byteLength;
+  var len1 = Array.isArray(val1) ? val1.length : val1.byteLength;
   var ptr1 = realloc1(0, 0, 1, len1 * 1);
   
   let valData1;
@@ -9990,7 +10162,7 @@ function generateTypes(arg0, arg1) {
       const e = variant6.val;
       dataView(memory0).setInt8(ptr0 + 8, 1, true);
       var val4 = e;
-      var len4 = val4.byteLength;
+      var len4 = Array.isArray(val4) ? val4.length : val4.byteLength;
       var ptr4 = realloc1(0, 0, 1, len4 * 1);
       
       let valData4;