@terminal3/t3n-sdk 3.1.0 → 3.3.0

package/dist/wasm/generated/session.js

@@ -1,9 +1,8 @@
-"use jco";
+"use components";
 import { environment, exit as exit$1, stderr } from '@bytecodealliance/preview2-shim/cli';
 import { error, streams } from '@bytecodealliance/preview2-shim/io';
 import { random } from '@bytecodealliance/preview2-shim/random';
 const { getEnvironment } = environment;
-getEnvironment._isHostProvided = true;
 
 if (getEnvironment=== undefined) {
   const err = new Error("unexpectedly undefined local import 'getEnvironment', was 'getEnvironment' available at instantiation?");
@@ -11,8 +10,8 @@ if (getEnvironment=== undefined) {
   throw err;
 }
 
+getEnvironment._isHostProvided = true;
 const { exit } = exit$1;
-exit._isHostProvided = true;
 
 if (exit=== undefined) {
   const err = new Error("unexpectedly undefined local import 'exit', was 'exit' available at instantiation?");
@@ -20,8 +19,8 @@ if (exit=== undefined) {
   throw err;
 }
 
+exit._isHostProvided = true;
 const { getStderr } = stderr;
-getStderr._isHostProvided = true;
 
 if (getStderr=== undefined) {
   const err = new Error("unexpectedly undefined local import 'getStderr', was 'getStderr' available at instantiation?");
@@ -29,8 +28,8 @@ if (getStderr=== undefined) {
   throw err;
 }
 
+getStderr._isHostProvided = true;
 const { Error: Error$1 } = error;
-Error$1._isHostProvided = true;
 
 if (Error$1=== undefined) {
   const err = new Error("unexpectedly undefined local import 'Error$1', was 'Error' available at instantiation?");
@@ -38,8 +37,8 @@ if (Error$1=== undefined) {
   throw err;
 }
 
+Error$1._isHostProvided = true;
 const { OutputStream } = streams;
-OutputStream._isHostProvided = true;
 
 if (OutputStream=== undefined) {
   const err = new Error("unexpectedly undefined local import 'OutputStream', was 'OutputStream' available at instantiation?");
@@ -47,8 +46,8 @@ if (OutputStream=== undefined) {
   throw err;
 }
 
+OutputStream._isHostProvided = true;
 const { getRandomU64 } = random;
-getRandomU64._isHostProvided = true;
 
 if (getRandomU64=== undefined) {
   const err = new Error("unexpectedly undefined local import 'getRandomU64', was 'getRandomU64' available at instantiation?");
@@ -56,6 +55,7 @@ if (getRandomU64=== undefined) {
   throw err;
 }
 
+getRandomU64._isHostProvided = true;
 
 function promiseWithResolvers() {
   if (Promise.withResolvers) {
@@ -70,8 +70,9 @@ function promiseWithResolvers() {
     return { promise, resolve, reject };
   }
 }
-
 const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+const symbolAsyncIterator = Symbol.asyncIterator;
+const symbolIterator = Symbol.iterator;
 
 const _debugLog = (...args) => {
   if (!globalThis?.process?.env?.JCO_DEBUG) { return; }
@@ -166,7 +167,7 @@ async function _clearCurrentTask(args) {
   const { taskID, componentIdx } = args;
   
   const meta = CURRENT_TASK_META[componentIdx];
-  if (!meta) { throw new Error(`missing current task meta for component idx [${componentIdx}]`); }
+  if (!meta) { throw new Error(`missing current task meta for component idx [${componentIdx}]n`); }
   
   if (meta.taskID !== taskID) {
     throw new Error(`task ID [${meta.taskID}] != requested ID [${taskID}]`);
@@ -274,13 +275,54 @@ const _coinFlip = () => { return Math.random() > 0.5; };
 let SCOPE_ID = 0;
 const I32_MIN = -2_147_483_648;
 const I32_MAX = 2_147_483_647;
+
+function _isValidNumericPrimitive(ty, v) {
+  if (v === undefined || v === null) { return false; }
+  switch (ty) {
+    case 'bool':
+    return v === 0 || v === 1;
+    break;
+    case 'u8':
+    return v >= 0 && v <= 255;
+    break;
+    case 's8':
+    return v >= -128 && v <= 127;
+    break;
+    case 'u16':
+    return v >= 0 && v <= 65535;
+    break;
+    case 's16':
+    return v >= -32768 && v <= 32767;
+    case 'u32':
+    return v >= 0 && v <= 4_294_967_295;
+    case 's32':
+    return v >= -2_147_483_648 && v <= 2_147_483_647;
+    case 'u64':
+    return typeof v === 'bigint' && v >= 0 && v <= 18_446_744_073_709_551_615n;
+    case 's64':
+    return typeof v === 'bigint' && v >= -9223372036854775808n && v <= 9223372036854775807n;
+    break;
+    case 'f32':
+    case 'f64': return typeof v === 'number';
+    default:
+    return false;
+  }
+  return true;
+}
+
+function _requireValidNumericPrimitive(ty, v) {
+  if (v === undefined  || v === null || !_isValidNumericPrimitive(ty, v)) {
+    throw new TypeError(`invalid ${ty} value [${v}]`);
+  }
+  return true;
+}
 const _typeCheckValidI32 = (n) => typeof n === 'number' && n >= I32_MIN && n <= I32_MAX;
 
 const _typeCheckAsyncFn= (f) => {
   return f instanceof ASYNC_FN_CTOR;
 };
 
-const ASYNC_FN_CTOR = (async () => {}).constructor;
+let RESOURCE_CALL_BORROWS = [];const ASYNC_FN_CTOR = (async () => {}).constructor;
 
 function clearCurrentTask(componentIdx, taskID) {
   _debugLog('[clearCurrentTask()] args', { componentIdx, taskID });
@@ -569,6 +611,7 @@ class AsyncSubtask {
           realloc,
           vals: [subtaskValue],
           storagePtr: resultPtr,
+          stringEncoding: callMetadata.stringEncoding,
         });
       }
     }
@@ -758,6 +801,7 @@ resultCountOrAsync,
       resultPtr,
       returnFn,
       startFn,
+      stringEncoding,
     }
   });
   
@@ -923,7 +967,8 @@ function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
       memory: callerMemory,
       vals: [res],
       storagePtr: subtaskCallMeta.resultPtr,
-      componentIdx: callerComponentIdx
+      componentIdx: callerComponentIdx,
+      stringEncoding: subtaskCallMeta.stringEncoding,
     });
     
   });
@@ -1161,7 +1206,12 @@ class Waitable {
   let dv = new DataView(new ArrayBuffer());
   const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
   
-  const toUint64 = val => BigInt.asUintN(64, BigInt(val));
+  function toUint64(val) {
+    const converted = BigInt(val)
+    
+    return BigInt.asUintN(64, converted);
+  }
+  
   const TEXT_DECODER_UTF8 = new TextDecoder();
   const TEXT_ENCODER_UTF8 = new TextEncoder();
   
@@ -1350,6 +1400,8 @@ class Waitable {
     storage = [0, 0];
     borrowedHandles = {};
     
+    tmpRetI64HighBits = 0|0;
+    
     constructor(opts) {
       this.#id = ++AsyncTask._ID;
       
@@ -1938,6 +1990,7 @@ function _lowerImportBackwardsCompat(args) {
     getMemoryFn,
     getReallocFn,
     importFn,
+    stringEncoding,
   } = args;
   
   let meta = _getGlobalCurrentTaskMeta(componentIdx);
@@ -2017,6 +2070,7 @@ function _lowerImportBackwardsCompat(args) {
         realloc: getReallocFn(),
         resultPtr: params[0],
         lowers: resultLowerFns,
+        stringEncoding,
       }
     });
     task.setReturnMemoryIdx(memoryIdx);
@@ -2146,8 +2200,8 @@ function _lowerImportBackwardsCompat(args) {
       return [val, ctx];
     }
     
-    if (ctx.storageLen !== undefined && ctx.storageLen < ctx.storagePtr + 1) {
-      throw new Error('not enough storage remaining for lift');
+    if (ctx.storageLen !== undefined && ctx.storageLen < 1) {
+      throw new Error(`insufficient storage ([${ctx.storageLen}] bytes) for lift (u8 requires 1 byte)`);
     }
     
     val = new DataView(ctx.memory.buffer).getUint8(ctx.storagePtr, true);
@@ -2158,6 +2212,7 @@ function _lowerImportBackwardsCompat(args) {
     return [val, ctx];
   }
   
+  
   function _liftFlatU16(ctx) {
     _debugLog('[_liftFlatU16()] args', { ctx });
     let val;
@@ -2169,8 +2224,8 @@ function _lowerImportBackwardsCompat(args) {
       return [val, ctx];
     }
     
-    if (ctx.storageLen !== undefined && ctx.storageLen < ctx.storagePtr + 2) {
-      throw new Error('not enough storage remaining for lift');
+    if (ctx.storageLen !== undefined && ctx.storageLen < 2) {
+      throw new Error(`insufficient storage ([${ctx.storageLen}] bytes) for lift (u16 requires 2 bytes)`);
     }
     
     val = new DataView(ctx.memory.buffer).getUint16(ctx.storagePtr, true);
@@ -2184,6 +2239,7 @@ function _lowerImportBackwardsCompat(args) {
     return [val, ctx];
   }
   
+  
   function _liftFlatU32(ctx) {
     _debugLog('[_liftFlatU32()] args', { ctx });
     let val;
@@ -2195,8 +2251,8 @@ function _lowerImportBackwardsCompat(args) {
       return [val, ctx];
     }
     
-    if (ctx.storageLen !== undefined && ctx.storageLen < ctx.storagePtr + 4) {
-      throw new Error('not enough storage remaining for lift');
+    if (ctx.storageLen !== undefined && ctx.storageLen < 4) {
+      throw new Error(`insufficient storage ([${ctx.storageLen}] bytes) for lift (u32 requires 4 bytes)`);
     }
     val = new DataView(ctx.memory.buffer).getUint32(ctx.storagePtr, true);
     ctx.storagePtr += 4;
@@ -2205,6 +2261,7 @@ function _lowerImportBackwardsCompat(args) {
     return [val, ctx];
   }
   
+  
   function _liftFlatVariant(casesAndLiftFns) {
     return function _liftFlatVariantInner(ctx) {
       _debugLog('[_liftFlatVariant()] args', { ctx });
@@ -2260,7 +2317,7 @@ function _lowerImportBackwardsCompat(args) {
   }
   
   function _liftFlatList(meta) {
-    const { elemLiftFn, align32, knownLen } = meta;
+    const { elemLiftFn, elemSize32, elemAlign32, knownLen } = meta;
     
     const readValuesAndReset = (ctx, originalPtr, dataPtr, len) => {
       ctx.storagePtr = dataPtr;
@@ -2270,37 +2327,40 @@ function _lowerImportBackwardsCompat(args) {
         val.push(res);
         ctx = nextCtx;
         
-        const rem = ctx.storagePtr % align32;
-        if (rem !== 0) { ctx.storagePtr += align32 - rem; }
+        const rem = ctx.storagePtr % elemAlign32;
+        if (rem !== 0) { ctx.storagePtr += elemAlign32 - rem; }
       }
       if (originalPtr !== null) { ctx.storagePtr = originalPtr; }
       return [val, ctx];
     };
     
+    // TODO(fix): special case for u8/u16/etc into appropriate type
+    
     return function _liftFlatListInner(ctx) {
       _debugLog('[_liftFlatList()] args', { ctx });
       
       let liftResults;
-      if (knownLen) { // list with known length
+      if (knownLen !== undefined) { // 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?
+        // TODO(???): is it possible for all values to come in from params?
         
         ctx.useDirectParams = false;
         const originalPtr = ctx.storagePtr;
-        ctx.storageLen = 8;
+        ctx.storageLen = knownLen * elemSize32;
         
-        liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, len);
+        liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, knownLen);
         
         ctx.useDirectParams = true;
         ctx.storagePtr = null;
         ctx.storageLen = null;
         
       } else {
+        ctx.storageLen = knownLen * elemSize32;
         liftResults = readValuesAndReset(ctx, null, ctx.storagePtr, knownLen);
       }
       
@@ -2314,7 +2374,7 @@ function _lowerImportBackwardsCompat(args) {
       
       ctx.useDirectParams = false;
       const originalPtr = ctx.storagePtr;
-      ctx.storageLen = 8;
+      ctx.storageLen = len * elemSize32;
       
       liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, len);
       
@@ -2324,6 +2384,8 @@ function _lowerImportBackwardsCompat(args) {
       
     } else {
       // unknown length list ptr w/ in-memory params
+      ctx.storageLen = 8;
+      
       const dataPtrLiftRes = _liftFlatU32(ctx);
       const dataPtr = dataPtrLiftRes[0];
       ctx = dataPtrLiftRes[1];
@@ -2335,6 +2397,7 @@ function _lowerImportBackwardsCompat(args) {
       const originalPtr = ctx.storagePtr;
       ctx.storagePtr = dataPtr;
       
+      ctx.storageLen = len * elemSize32;
       liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, len);
     }
   }
@@ -2355,86 +2418,137 @@ function _liftFlatBorrow(componentTableIdx, size, memory, vals, storagePtr, stor
   throw new Error('flat lift for borrowed resources is not supported!');
 }
 
+
 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 (ctx.vals.length !== 1) {
+    throw new Error(`unexpected number [${ctx.vals.length}] of 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?
+  _requireValidNumericPrimitive.bind('u8', ctx.vals[0]);
   
-  return 1;
+  if (!ctx.memory) { throw new Error("missing memory for lower"); }
+  new DataView(ctx.memory.buffer).setUint32(ctx.storagePtr, ctx.vals[0], true);
+  
+  ctx.storagePtr += 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 _lowerFlatU16(ctx) {
+  _debugLog('[_lowerFlatU16()] args', { ctx });
+  
+  if (!ctx.memory) { throw new Error("missing memory for lower"); }
+  if (ctx.vals.length !== 1) {
+    throw new Error(`unexpected number [${ctx.vals.length}] of vals (expected 1)`);
+  }
+  
+  const rem = ctx.storagePtr % 2;
+  if (rem !== 0) { ctx.storagePtr += (2 - rem); }
+  
+  _requireValidNumericPrimitive.bind('u16', ctx.vals[0]);
+  new DataView(ctx.memory.buffer).setUint16(ctx.storagePtr, ctx.vals[0], true);
+  
+  ctx.storagePtr += 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?
+  if (ctx.vals.length !== 1) {
+    throw new Error(`expected single value to lower, got [${ctx.vals.length}]`);
+  }
+  
   const rem = ctx.storagePtr % 4;
   if (rem !== 0) { ctx.storagePtr += (4 - rem); }
   
-  new DataView(memory.buffer).setUint32(storagePtr, vals[0], true);
+  _requireValidNumericPrimitive.bind('u32', ctx.vals[0]);
+  new DataView(ctx.memory.buffer).setUint32(ctx.storagePtr, ctx.vals[0], true);
+  
+  ctx.storagePtr += 4;
+}
+
+function _lowerFlatU64(ctx) {
+  _debugLog('[_lowerFlatU64()] args', { ctx });
+  
+  if (ctx.vals.length !== 1) { throw new Error('unexpected number of vals'); }
+  
+  const rem = ctx.storagePtr % 8;
+  if (rem !== 0) { ctx.storagePtr += (8 - rem); }
   
-  return 4;
+  _requireValidNumericPrimitive.bind('u64', ctx.vals[0]);
+  new DataView(ctx.memory.buffer).setBigUint64(ctx.storagePtr, ctx.vals[0], true);
+  
+  ctx.storagePtr += 8;
 }
 
-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 _lowerFlatStringAny(ctx) {
+  switch (ctx.stringEncoding) {
+    case 'utf8':
+    return _lowerFlatStringUTF8(ctx);
+    case 'utf16':
+    return _lowerFlatStringUTF16(ctx);
+    default:
+    throw new Error(`missing/unrecognized/unsupported string encoding [${ctx.stringEncoding}]`);
+  }
 }
 
 function _lowerFlatStringUTF8(ctx) {
   _debugLog('[_lowerFlatStringUTF8()] args', ctx);
+  if (!ctx.realloc) { throw new Error('missing realloc during flat string lower'); }
   
-  const { memory, realloc, vals, storagePtr, storageLen } = ctx;
+  const s = ctx.vals[0];
+  const { ptr, codepoints } = _utf8AllocateAndEncode(ctx.vals[0], ctx.realloc, ctx.memory);
   
-  const s = vals[0];
-  const { ptr, len, codepoints } = _utf8AllocateAndEncode(vals[0], realloc, memory);
+  const view = new DataView(ctx.memory.buffer);
+  view.setUint32(ctx.storagePtr, ptr, true);
+  view.setUint32(ctx.storagePtr + 4, codepoints, true);
   
-  const view = new DataView(memory.buffer);
-  view.setUint32(storagePtr, ptr, true);
-  view.setUint32(storagePtr + 4, codepoints, true);
+  ctx.storagePtr += 8;
+}
+
+function _lowerFlatStringUTF16(ctx) {
+  _debugLog('[_lowerFlatStringUTF16()] args', { ctx });
+  if (!ctx.realloc) { throw new Error('missing realloc during flat string lower'); }
   
-  return len;
+  const s = ctx.vals[0];
+  const { ptr, len, codepoints } = _utf16AllocateAndEncode(ctx.vals[0], ctx.realloc, ctx.memory);
+  
+  const view = new DataView(ctx.memory.buffer);
+  view.setUint32(ctx.storagePtr, ptr, true);
+  view.setUint32(ctx.storagePtr + 4, codepoints, true);
+  
+  const bytes = new Uint16Array(ctx.memory.buffer, start, codeUnits);
+  if (ctx.memory.buffer.byteLength < start + bytes.byteLength) {
+    throw new Error('memory out of bounds');
+  }
+  if (ctx.storageLen !== undefined && ctx.storageLen !== bytes.byteLength) {
+    throw new Error(`storage length [${ctx.storageLen}] != [${bytes.byteLength}])`);
+  }
+  new Uint16Array(ctx.memory.buffer, ctx.storagePtr).set(bytes);
+  
+  ctx.storagePtr += len;
 }
 
 function _lowerFlatVariant(lowerMetas) {
+  let caseLookup = {};
+  for (const [idx, meta] of lowerMetas.entries()) {
+    let tag = meta[0];
+    caseLookup[tag] = { discriminant: idx, meta };
+  }
+  
   return function _lowerFlatVariantInner(ctx) {
-    _debugLog('[_lowerFlatVariant()] args', ctx);
-    
-    const { memory, realloc, vals, storageLen, componentIdx } = ctx;
-    let storagePtr = ctx.storagePtr;
+    _debugLog('[_lowerFlatVariant()] args', { ctx });
     
-    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, val } = ctx.vals[0];
+    const variantCase = caseLookup[tag];
+    if (!variantCase) {
+      throw new Error(`missing tag [${tag}] (valid tags: ${Object.keys(caseLookup)})`);
     }
     
-    const [ _tag, lowerFn, size32, align32, payloadOffset32 ] = lowerMetas[disc];
+    const [ _tag, lowerFn, size32, align32, payloadOffset32 ] = variantCase.meta;
     
-    const originalPtr = ctx.resultPtr;
-    ctx.vals = [disc];
+    const originalPtr = ctx.storagePtr;
+    ctx.vals = [variantCase.discriminant];
     let discLowerRes;
     if (lowerMetas.length < 256) {
       discLowerRes = _lowerFlatU8(ctx);
@@ -2443,23 +2557,15 @@ function _lowerFlatVariant(lowerMetas) {
     } else if (lowerMetas.length >= 65536 && lowerMetas.length < 4_294_967_296) {
       discLowerRes = _lowerFlatU32(ctx);
     } else {
-      throw new Error('unsupported number of cases [' + lowerMetas.legnth + ']');
+      throw new Error(`unsupported number of cases [${lowerMetas.length}]`);
     }
     
-    ctx.resultPtr = originalPtr + payloadOffset32;
+    const payloadOffsetPtr = originalPtr + payloadOffset32;
+    ctx.storagePtr = payloadOffsetPtr;
+    ctx.vals = [val];
+    if (lowerFn) { lowerFn(ctx); }
     
-    let payloadBytesWritten = 0;
-    if (lowerFn) {
-      lowerFn({
-        memory,
-        realloc,
-        vals: [val],
-        storagePtr,
-        storageLen,
-        componentIdx,
-      });
-    }
-    let bytesWritten = payloadOffset + payloadBytesWritten;
+    let bytesWritten = ctx.storagePtr - payloadOffsetPtr;
     
     const rem = ctx.storagePtr % align32;
     if (rem !== 0) {
@@ -2468,74 +2574,148 @@ function _lowerFlatVariant(lowerMetas) {
       bytesWritten += pad;
     }
     
-    return bytesWritten;
+    ctx.storagePtr += bytesWritten;
   }
 }
 
-function _lowerFlatList(args) {
-  const { elemLowerFn } = args;
+function _lowerFlatList(meta) {
+  const {
+    elemLowerFn,
+    knownLen,
+    size32,
+    align32,
+    elemSize32,
+    elemAlign32,
+  } = meta;
+  
   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) {
+      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);
+      
       const list = ctx.vals[0];
       if (!list) { throw new Error("missing direct param value"); }
       
-      const elemLowerCtx = { storagePtr, memory: ctx.memory };
+      const lowerCtx = {
+        storagePtr,
+        memory: ctx.memory,
+        stringEncoding: ctx.stringEncoding,
+      };
       for (let idx = 0; idx < list.length; idx++) {
-        elemLowerCtx.vals = list.slice(idx, idx+1);
-        elemLowerCtx.storagePtr += elemLowerFn(elemLowerCtx);
+        lowerCtx.vals = list.slice(idx, idx+1);
+        elemLowerFn(lowerCtx);
       }
       
-      const bytesLowered = elemLowerCtx.storagePtr - ctx.storagePtr;
-      ctx.storagePtr = elemLowerCtx.storagePtr;
-      return bytesLowered;
+      const bytesLowered = lowerCtx.storagePtr - ctx.storagePtr;
+      ctx.storagePtr = lowerCtx.storagePtr;
+      
+      // TODO: implement parma-only known-length processing
+      
+      ctx.storagePtr += bytesLowered;
+      return;
     }
     
-    if (ctx.vals.length !== 2) {
-      throw new Error('indirect parameter loading must have a pointer and length as vals');
+    // TODO(fix): is it possible to get a vals that are a addr and length here from
+    // a component lower?
+    
+    const elems = ctx.vals[0];
+    if (knownLen === undefined) {
+      // unknown length
+      if (!ctx.realloc) { throw new Error('missing realloc during flat string lower'); }
+      const dataPtr = ctx.realloc(0, 0, elemAlign32, elemSize32 * elems.length);
+      
+      ctx.vals[0] = dataPtr;
+      _lowerFlatU32(ctx);
+      
+      ctx.vals[0] = elems.length;
+      _lowerFlatU32(ctx);
+      
+      const origPtr = ctx.storagePtr;
+      ctx.storagePtr = dataPtr;
+      
+      ctx.storagePtr = dataPtr;
+      for (const elem of elems) {
+        ctx.vals = [elem];
+        elemLowerFn(ctx);
+      }
+      
+      ctx.storagePtr = origPtr;
+      
+    } else {
+      // known length
+      
+      if (elems.length !== knownLen) {
+        throw new TypeError(`invalid list input of length [${elems.length}], must be length [${knownLen}]`);
+      }
+      
+      for (const elem of elems) {
+        ctx.vals = [elem];
+        elemLowerFn(ctx);
+      }
     }
-    let [valStartPtr, valLen] = ctx.vals;
-    const totalSizeBytes = valLen * size;
+    
+    // TODO(fix): special case for u8/u16/etc, we can do a direct copy
+    
+    const totalSizeBytes = elems.length * size32;
     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;
   }
 }
 
-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 _lowerFlatTuple(elemLowerMetas) {
+  return function _lowerFlatTupleInner(ctx) {
+    _debugLog('[_lowerFlatTuple()] args', { ctx });
+    const tuple = ctx.vals[0];
+    for (const [idx, [ lowerFn, size32, align32 ]]  of elemLowerMetas.entries()) {
+      ctx.vals = [tuple[idx]];
+      lowerFn(ctx);
+    }
+  }
 }
 
 function _lowerFlatResult(lowerMetas) {
   return function _lowerFlatResultInner(ctx) {
     _debugLog('[_lowerFlatResult()] args', { lowerMetas });
-    return _lowerFlatVariant(lowerMetas)(ctx);
+    
+    const v = ctx.vals[0];
+    const isNotResultObject = typeof v !== 'object'
+    || Object.keys(v).length !== 2
+    || !('tag' in v)
+    || !('ok' === v.tag || 'err' === v.tag)
+    || !('val' in v);
+    if (isNotResultObject) {
+      ctx.vals[0] = { tag: 'ok', val: v };
+    }
+    
+    _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!');
+function _lowerFlatOwn(meta) {
+  const { lowerFn, componentIdx } = meta;
+  
+  return function _lowerFlatOwnInner(ctx) {
+    _debugLog('[_lowerFlatOwn()] args', { ctx });
+    const { createFn } = ctx;
+    
+    if (ctx.componentIdx !== componentIdx) {
+      throw new Error(`component index mismatch (expected [${componentIdx}], lift called from [${ctx.componentIdx}])`);
+    }
+    
+    const obj = ctx.vals[0];
+    if (obj === undefined || obj === null) { throw new Error('missing resource'); }
+    const handle = lowerFn(obj);
+    
+    ctx.vals[0] = handle;
+    _lowerFlatU32(ctx);
+  };
 }
 
 const STREAMS = new RepTable({ target: 'global stream map' });
@@ -2882,9 +3062,48 @@ class ComponentAsyncState {
     return new Waitable({ target: args?.target, });
   }
   
+  createReadableStreamEnd(args) {
+    _debugLog('[ComponentAsyncState#createStreamEnd()] args', args);
+    const { tableIdx, elemMeta, hostInjectFn } = args;
+    
+    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 waitable = this.createWaitable();
+    const streamEnd = new StreamReadableEnd({
+      tableIdx,
+      elemMeta,
+      hostInjectFn,
+      pendingBufferMeta: {},
+      target: `stream read end (lowered, @init)`,
+      waitable,
+    });
+    
+    streamEnd.setWaitableIdx(this.handles.insert(streamEnd));
+    streamEnd.setHandle(localStreamTable.insert(streamEnd));
+    if (streamEnd.streamTableIdx() !== tableIdx) {
+      throw new Error("unexpectedly mismatched stream table");
+    }
+    const streamEndWaitableIdx = streamEnd.waitableIdx();
+    const streamEndHandle = streamEnd.handle();
+    waitable.setTarget(`waitable for stream read end (lowered, waitable [${streamEndWaitableIdx}])`);
+    streamEnd.setTarget(`stream read end (lowered, waitable [${streamEndWaitableIdx}])`);
+    
+    return {
+      waitableIdx: streamEndWaitableIdx,
+      handle: streamEndHandle,
+      streamEnd,
+    };
+  }
+  
   createStream(args) {
     _debugLog('[ComponentAsyncState#createStream()] args', args);
-    const { tableIdx, elemMeta } = args;
+    const { tableIdx, elemMeta, hostInjectFn } = 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"); }
     
@@ -2901,10 +3120,10 @@ class ComponentAsyncState {
     
     const stream = new InternalStream({
       tableIdx,
-      componentIdx: this.#componentIdx,
       elemMeta,
       readWaitable,
       writeWaitable,
+      hostInjectFn,
     });
     stream.setGlobalStreamMapRep(STREAMS.insert(stream));
     
@@ -2929,17 +3148,21 @@ class ComponentAsyncState {
     readEnd.setTarget(`stream read end (waitable [${readEndWaitableIdx}])`);
     
     return {
+      writeEnd,
       writeEndWaitableIdx,
       writeEndHandle,
       readEndWaitableIdx,
       readEndHandle,
+      readEnd,
     };
   }
   
   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'); }
+    if (tableIdx === undefined) {
+      throw new Error('missing table idx while getting stream end');
+    }
     
     const { table, componentIdx } = STREAM_TABLES[tableIdx];
     const cstate = getOrCreateAsyncState(componentIdx);
@@ -3026,6 +3249,127 @@ class ComponentAsyncState {
     
     return streamEnd;
   }
+  
+  createFuture(args) {
+    _debugLog('[ComponentAsyncState#createFuture()] args', args);
+    const { tableIdx, elemMeta, hostInjectFn } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while adding future"); }
+    if (elemMeta === undefined) { throw new Error("missing element metadata while adding future"); }
+    
+    const { table: futureTable, componentIdx } = FUTURE_TABLES[tableIdx];
+    if (!futureTable) {
+      throw new Error(`missing global future table lookup for table [${tableIdx}] while creating future`);
+    }
+    if (componentIdx !== this.#componentIdx) {
+      throw new Error('component idx mismatch while creating future');
+    }
+    
+    const readWaitable = this.createWaitable();
+    const writeWaitable = this.createWaitable();
+    
+    const future = new InternalFuture({
+      tableIdx,
+      componentIdx: this.#componentIdx,
+      elemMeta,
+      readWaitable,
+      writeWaitable,
+      hostInjectFn,
+    });
+    future.setGlobalFutureMapRep(FUTURES.insert(future));
+    
+    const writeEnd = future.writeEnd();
+    writeEnd.setWaitableIdx(this.handles.insert(writeEnd));
+    writeEnd.setHandle(futureTable.insert(writeEnd));
+    if (writeEnd.futureTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched future table"); }
+    
+    const writeEndWaitableIdx = writeEnd.waitableIdx();
+    const writeEndHandle = writeEnd.handle();
+    writeWaitable.setTarget(`waitable for future write end (waitable [${writeEndWaitableIdx}])`);
+    writeEnd.setTarget(`future write end (waitable [${writeEndWaitableIdx}])`);
+    
+    const readEnd = future.readEnd();
+    readEnd.setWaitableIdx(this.handles.insert(readEnd));
+    readEnd.setHandle(futureTable.insert(readEnd));
+    if (readEnd.futureTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched future table"); }
+    
+    const readEndWaitableIdx = readEnd.waitableIdx();
+    const readEndHandle = readEnd.handle();
+    readWaitable.setTarget(`waitable for read end (waitable [${readEndWaitableIdx}])`);
+    readEnd.setTarget(`future read end (waitable [${readEndWaitableIdx}])`);
+    
+    return {
+      writeEnd,
+      writeEndWaitableIdx,
+      writeEndHandle,
+      readEndWaitableIdx,
+      readEndHandle,
+      readEnd,
+    };
+  }
+  
+  getFutureEnd(args) {
+    _debugLog('[ComponentAsyncState#getFutureEnd()] args', args);
+    const { tableIdx, futureEndHandle, futureEndWaitableIdx } = args;
+    if (tableIdx === undefined) {
+      throw new Error('missing table idx while getting future end');
+    }
+    
+    const { table, componentIdx } = FUTURE_TABLES[tableIdx];
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    let futureEnd;
+    if (futureEndWaitableIdx !== undefined) {
+      futureEnd = cstate.handles.get(futureEndWaitableIdx);
+    } else if (futureEndHandle !== undefined) {
+      if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while getting future end`); }
+      futureEnd = table.get(futureEndHandle);
+    } else {
+      throw new TypeError("must specify either waitable idx or handle to retrieve future");
+    }
+    
+    if (!futureEnd) {
+      throw new Error(`missing future end (tableIdx [${tableIdx}], handle [${futureEndHandle}], waitableIdx [${futureEndWaitableIdx}])`);
+    }
+    if (tableIdx && futureEnd.futureTableIdx() !== tableIdx) {
+      throw new Error(`future end table idx [${futureEnd.futureTableIdx()}] does not match [${tableIdx}]`);
+    }
+    
+    return futureEnd;
+  }
+  
+  removeFutureEndFromTable(args) {
+    _debugLog('[ComponentAsyncState#removeFutureEndFromTable()] args', args);
+    
+    const { tableIdx, futureWaitableIdx } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while removing future end"); }
+    if (futureWaitableIdx === undefined) {
+      throw new Error("missing future end waitable idx while removing future end");
+    }
+    
+    const { table, componentIdx } = FUTURE_TABLES[tableIdx];
+    if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while removing future end`); }
+    
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    const futureEnd = cstate.handles.get(futureWaitableIdx);
+    if (!futureEnd) {
+      throw new Error(`missing future end (handle [${futureWaitableIdx}], table [${tableIdx}])`);
+    }
+    const handle = futureEnd.handle();
+    
+    let removed = cstate.handles.remove(futureWaitableIdx);
+    if (!removed) {
+      throw new Error(`failed to remove futureEnd from handles (waitable idx [${futureWaitableIdx}]), component [${componentIdx}])`);
+    }
+    
+    removed = table.remove(handle);
+    if (!removed) {
+      throw new Error(`failed to remove futureEnd from table (handle [${handle}]), table [${tableIdx}], component [${componentIdx}])`);
+    }
+    
+    return futureEnd;
+  }
+  
 }
 
 const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
@@ -3062,6 +3406,8 @@ function getErrorPayload(e) {
   return e;
 }
 
+const isLE = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+
 function throwInvalidBool() {
   throw new TypeError('invalid variant discriminant for bool');
 }
@@ -3181,8 +3527,9 @@ const _trampoline2 = function() {
     fn: () => getStderr()
   })
   ;
+  
   if (!(ret instanceof OutputStream)) {
-    throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
+    throw new TypeError('Resource error: Not a valid \"OutputStream\" resource.');
   }
   var handle0 = ret[symbolRscHandle];
   if (!handle0) {
@@ -3190,6 +3537,7 @@ const _trampoline2 = function() {
     captureTable1.set(rep, ret);
     handle0 = rscTableCreateOwn(handleTable1, rep);
   }
+  
   _debugLog('[iface="wasi:cli/stderr@0.2.9", function="get-stderr"][Instruction::Return]', {
     funcName: 'get-stderr',
     paramCount: 1,
@@ -3374,8 +3722,9 @@ switch (variant6.tag) {
       case 'last-operation-failed': {
         const e = variant5.val;
         dataView(memory0).setInt8(arg3 + 4, 0, true);
+        
         if (!(e instanceof Error$1)) {
-          throw new TypeError('Resource error: Not a valid "Error" resource.');
+          throw new TypeError('Resource error: Not a valid \"Error\" resource.');
         }
         var handle4 = e[symbolRscHandle];
         if (!handle4) {
@@ -3383,6 +3732,7 @@ switch (variant6.tag) {
           captureTable0.set(rep, e);
           handle4 = rscTableCreateOwn(handleTable0, rep);
         }
+        
         dataView(memory0).setInt32(arg3 + 8, handle4, true);
         break;
       }
@@ -3602,13 +3952,14 @@ function next(arg0, arg1) {
       let offset = 0;
       const dv0 = new DataView(memory0.buffer);
       for (const v of val0) {
+        _requireValidNumericPrimitive.bind(null, 'u8')(v);
         dv0.setUint8(ptr0+ offset, v, true);
         offset += 1;
       }
     } else {
       // TypedArray / ArrayBuffer-like, direct copy
       valData0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, valLenBytes0);
-      const out0 = new Uint8Array(memory0.buffer, ptr0,valLenBytes0);
+      const out0 = new Uint8Array(memory0.buffer, ptr0, valLenBytes0);
       out0.set(valData0);
     }
     
@@ -3627,13 +3978,14 @@ function next(arg0, arg1) {
     let offset = 0;
     const dv2 = new DataView(memory0.buffer);
     for (const v of val2) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv2.setUint8(ptr2+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, valLenBytes2);
-    const out2 = new Uint8Array(memory0.buffer, ptr2,valLenBytes2);
+    const out2 = new Uint8Array(memory0.buffer, ptr2, valLenBytes2);
     out2.set(valData2);
   }
   
@@ -3734,13 +4086,14 @@ function finish(arg0) {
     let offset = 0;
     const dv0 = new DataView(memory0.buffer);
     for (const v of val0) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv0.setUint8(ptr0+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, valLenBytes0);
-    const out0 = new Uint8Array(memory0.buffer, ptr0,valLenBytes0);
+    const out0 = new Uint8Array(memory0.buffer, ptr0, valLenBytes0);
     out0.set(valData0);
   }
   
@@ -3845,13 +4198,14 @@ function next$1(arg0, arg1) {
       let offset = 0;
       const dv0 = new DataView(memory0.buffer);
       for (const v of val0) {
+        _requireValidNumericPrimitive.bind(null, 'u8')(v);
         dv0.setUint8(ptr0+ offset, v, true);
         offset += 1;
       }
     } else {
       // TypedArray / ArrayBuffer-like, direct copy
       valData0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, valLenBytes0);
-      const out0 = new Uint8Array(memory0.buffer, ptr0,valLenBytes0);
+      const out0 = new Uint8Array(memory0.buffer, ptr0, valLenBytes0);
       out0.set(valData0);
     }
     
@@ -3870,13 +4224,14 @@ function next$1(arg0, arg1) {
     let offset = 0;
     const dv2 = new DataView(memory0.buffer);
     for (const v of val2) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv2.setUint8(ptr2+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, valLenBytes2);
-    const out2 = new Uint8Array(memory0.buffer, ptr2,valLenBytes2);
+    const out2 = new Uint8Array(memory0.buffer, ptr2, valLenBytes2);
     out2.set(valData2);
   }
   
@@ -3977,13 +4332,14 @@ function finish$1(arg0) {
     let offset = 0;
     const dv0 = new DataView(memory0.buffer);
     for (const v of val0) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv0.setUint8(ptr0+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, valLenBytes0);
-    const out0 = new Uint8Array(memory0.buffer, ptr0,valLenBytes0);
+    const out0 = new Uint8Array(memory0.buffer, ptr0, valLenBytes0);
     out0.set(valData0);
   }
   
@@ -4078,13 +4434,14 @@ function encrypt(arg0, arg1) {
     let offset = 0;
     const dv0 = new DataView(memory0.buffer);
     for (const v of val0) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv0.setUint8(ptr0+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, valLenBytes0);
-    const out0 = new Uint8Array(memory0.buffer, ptr0,valLenBytes0);
+    const out0 = new Uint8Array(memory0.buffer, ptr0, valLenBytes0);
     out0.set(valData0);
   }
   
@@ -4099,13 +4456,14 @@ function encrypt(arg0, arg1) {
     let offset = 0;
     const dv1 = new DataView(memory0.buffer);
     for (const v of val1) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv1.setUint8(ptr1+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, valLenBytes1);
-    const out1 = new Uint8Array(memory0.buffer, ptr1,valLenBytes1);
+    const out1 = new Uint8Array(memory0.buffer, ptr1, valLenBytes1);
     out1.set(valData1);
   }
   
@@ -4200,13 +4558,14 @@ function decrypt(arg0, arg1) {
     let offset = 0;
     const dv0 = new DataView(memory0.buffer);
     for (const v of val0) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv0.setUint8(ptr0+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, valLenBytes0);
-    const out0 = new Uint8Array(memory0.buffer, ptr0,valLenBytes0);
+    const out0 = new Uint8Array(memory0.buffer, ptr0, valLenBytes0);
     out0.set(valData0);
   }
   
@@ -4221,13 +4580,14 @@ function decrypt(arg0, arg1) {
     let offset = 0;
     const dv1 = new DataView(memory0.buffer);
     for (const v of val1) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv1.setUint8(ptr1+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, valLenBytes1);
-    const out1 = new Uint8Array(memory0.buffer, ptr1,valLenBytes1);
+    const out1 = new Uint8Array(memory0.buffer, ptr1, valLenBytes1);
     out1.set(valData1);
   }
   
@@ -4327,13 +4687,14 @@ function validate(arg0, arg1, arg2) {
     let offset = 0;
     const dv1 = new DataView(memory0.buffer);
     for (const v of val1) {
+      _requireValidNumericPrimitive.bind(null, 'u8')(v);
       dv1.setUint8(ptr1+ offset, v, true);
       offset += 1;
     }
   } else {
     // TypedArray / ArrayBuffer-like, direct copy
     valData1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, valLenBytes1);
-    const out1 = new Uint8Array(memory0.buffer, ptr1,valLenBytes1);
+    const out1 = new Uint8Array(memory0.buffer, ptr1, valLenBytes1);
     out1.set(valData1);
   }
   
@@ -4447,6 +4808,7 @@ null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: null,
+  stringEncoding: 'utf8',
   getMemoryFn: () => null,
   getReallocFn: () => null,
   importFn: _trampoline0,
@@ -4465,6 +4827,7 @@ null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: null,
+  stringEncoding: 'utf8',
   getMemoryFn: () => null,
   getReallocFn: () => null,
   importFn: _trampoline0,
@@ -4491,12 +4854,16 @@ null,
   isAsync: false,
   isManualAsync: _trampoline2.manuallyAsync,
   paramLiftFns: [],
-  resultLowerFns: [_lowerFlatOwn.bind(null, 1)],
+  resultLowerFns: [_lowerFlatOwn({
+    componentIdx: 0,
+    lowerFn: () => { throw new Error('missing/invalid resource metadata'); }
+  })],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: null,
+  stringEncoding: 'utf8',
   getMemoryFn: () => null,
   getReallocFn: () => null,
   importFn: _trampoline2,
@@ -4509,12 +4876,16 @@ null,
   isAsync: false,
   isManualAsync: _trampoline2.manuallyAsync,
   paramLiftFns: [],
-  resultLowerFns: [_lowerFlatOwn.bind(null, 1)],
+  resultLowerFns: [_lowerFlatOwn({
+    componentIdx: 0,
+    lowerFn: () => { throw new Error('missing/invalid resource metadata'); }
+  })],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: null,
+  stringEncoding: 'utf8',
   getMemoryFn: () => null,
   getReallocFn: () => null,
   importFn: _trampoline2,
@@ -4547,6 +4918,7 @@ null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: null,
+  stringEncoding: 'utf8',
   getMemoryFn: () => null,
   getReallocFn: () => null,
   importFn: _trampoline4,
@@ -4565,6 +4937,7 @@ null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: null,
+  stringEncoding: 'utf8',
   getMemoryFn: () => null,
   getReallocFn: () => null,
   importFn: _trampoline4,
@@ -4577,13 +4950,25 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline5.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 1),_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 ],])],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 1),_liftFlatList({
+    elemLiftFn: _liftFlatU8,
+    elemAlign32: 1,
+    elemSize32: 1,
+  })],
+  resultLowerFns: [_lowerFlatResult([
+  [ 'ok', null, 12, 4, 4 ],
+  [ 'err', _lowerFlatVariant([[ 'last-operation-failed', _lowerFlatOwn({
+    componentIdx: 0,
+    lowerFn: () => { throw new Error('missing/invalid resource metadata'); }
+  }), 8, 4, 4 ],[ 'closed', null, 8, 4, 4 ],]), 12, 4, 4 ],
+  ])
+  ],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: 0,
+  stringEncoding: 'utf8',
   getMemoryFn: () => memory0,
   getReallocFn: () => null,
   importFn: _trampoline5,
@@ -4595,13 +4980,25 @@ null,
   componentIdx: 0,
   isAsync: false,
   isManualAsync: _trampoline5.manuallyAsync,
-  paramLiftFns: [_liftFlatBorrow.bind(null, 1),_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 ],])],
+  paramLiftFns: [_liftFlatBorrow.bind(null, 1),_liftFlatList({
+    elemLiftFn: _liftFlatU8,
+    elemAlign32: 1,
+    elemSize32: 1,
+  })],
+  resultLowerFns: [_lowerFlatResult([
+  [ 'ok', null, 12, 4, 4 ],
+  [ 'err', _lowerFlatVariant([[ 'last-operation-failed', _lowerFlatOwn({
+    componentIdx: 0,
+    lowerFn: () => { throw new Error('missing/invalid resource metadata'); }
+  }), 8, 4, 4 ],[ 'closed', null, 8, 4, 4 ],]), 12, 4, 4 ],
+  ])
+  ],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: 0,
+  stringEncoding: 'utf8',
   getMemoryFn: () => memory0,
   getReallocFn: () => null,
   importFn: _trampoline5,
@@ -4615,12 +5012,13 @@ null,
   isAsync: false,
   isManualAsync: _trampoline6.manuallyAsync,
   paramLiftFns: [_liftFlatBorrow.bind(null, 0)],
-  resultLowerFns: [_lowerFlatStringUTF8],
+  resultLowerFns: [_lowerFlatStringAny],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: 0,
+  stringEncoding: 'utf8',
   getMemoryFn: () => memory0,
   getReallocFn: () => realloc0,
   importFn: _trampoline6,
@@ -4633,12 +5031,13 @@ null,
   isAsync: false,
   isManualAsync: _trampoline6.manuallyAsync,
   paramLiftFns: [_liftFlatBorrow.bind(null, 0)],
-  resultLowerFns: [_lowerFlatStringUTF8],
+  resultLowerFns: [_lowerFlatStringAny],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: 0,
+  stringEncoding: 'utf8',
   getMemoryFn: () => memory0,
   getReallocFn: () => realloc0,
   importFn: _trampoline6,
@@ -4652,12 +5051,17 @@ null,
   isAsync: false,
   isManualAsync: _trampoline7.manuallyAsync,
   paramLiftFns: [],
-  resultLowerFns: [_lowerFlatList({ elemLowerFn: _lowerFlatTuple.bind(null, 7), typeIdx: 1 })],
+  resultLowerFns: [_lowerFlatList({
+    elemLowerFn: _lowerFlatTuple([[_lowerFlatStringAny, 16, 4],[_lowerFlatStringAny, 16, 4],]),
+    elemSize32: 16,
+    elemAlign32: 4,
+  })],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: 0,
+  stringEncoding: 'utf8',
   getMemoryFn: () => memory0,
   getReallocFn: () => realloc0,
   importFn: _trampoline7,
@@ -4670,12 +5074,17 @@ null,
   isAsync: false,
   isManualAsync: _trampoline7.manuallyAsync,
   paramLiftFns: [],
-  resultLowerFns: [_lowerFlatList({ elemLowerFn: _lowerFlatTuple.bind(null, 7), typeIdx: 1 })],
+  resultLowerFns: [_lowerFlatList({
+    elemLowerFn: _lowerFlatTuple([[_lowerFlatStringAny, 16, 4],[_lowerFlatStringAny, 16, 4],]),
+    elemSize32: 16,
+    elemAlign32: 4,
+  })],
   funcTypeIsAsync: false,
   getCallbackFn: () => null,
   getPostReturnFn: () => null,
   isCancellable: false,
   memoryIdx: 0,
+  stringEncoding: 'utf8',
   getMemoryFn: () => memory0,
   getReallocFn: () => realloc0,
   importFn: _trampoline7,